Transaction rolled back because it has been marked as rollback-only 原因和解决方案

产生原因，

1 serviceA 调用 serviceB 然后 B 抛出异常，B 所在的事物回滚，B 把当前可写事物标记成只读事物，

2 如果 A 和B 是在同一个事物环境，并且 A 抓了 B 抛出的异常，没有和 B 一起回滚，

3 然后 A 方法完成，把当前事物当成写事物提交。就会出上面的问题。

上代码：

解释：可以看出上面代码问题有点多，方法 A 是没有事物环境的，也就是说调用方法A 的前面的方法如果有事物环境，方法A 就依赖前面的事物环境，没有方法A 就是以非事物的方式执行（级联操作，如果在非事物环境执行，就不能级联回滚，正常必须要在事物环境），然后就是随意的抓异常，让本来应该回滚的事物没有回滚，依旧在向下执行。

正确的处理方法：如果是级联操作，那么应该处于同一个事物环境，并且不应该随意的抓异常，只有自己能处理，并且不影响事物回滚的异常才能抓，别的异常统统不允许抓。并且默认的回滚需要 runtimexception ，所以只能抛出这个异常的子类，如果出现别的异常，非 runtimexception 那么应该抓了抛出 runtimexception 。

另外说一句 spring有完善的全局异常处理体系，正常来说不需要随意的 try 异常。我们需要处理的只有非 runtimexception ，别的异常直接跑就是了。

推荐的异常处理方法：

1 定义全局异常处理，然后根据不同异常，返回不同的提示信息。

全局异常处理类：

package com.hs.backend.controller.exception;

import java.util.Map;

import java.util.Set;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Component;

import org.springframework.web.method.HandlerMethod;

import org.springframework.web.servlet.HandlerExceptionResolver;

import org.springframework.web.servlet.ModelAndView;

import org.springframework.web.servlet.mvc.method.RequestMappingInfo;

import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping;

import com.hs.commons.exception.CanRedirectExcetion;

import com.hs.commons.utils.ClassUtils;

/**

 * 统一异常处理

 *

 * @author ZHANGYUKUN

 *

 */

@Component

public class GlobalExceptionResolver implements HandlerExceptionResolver {

    Logger logger = LoggerFactory.getLogger(GlobalExceptionResolver.class);

    @Autowired

    RequestMappingHandlerMapping requestMappingHandlerMapping;

    /**

     * 异常前缀

     */

    private String prefix = "/global/exception/";

    /**

     * 异常后缀

     */

    private String suffix = "Result";

    /**

     * 自定义异常列表

     *

     */

    //private List<Class<?>> exceptionClsList = new ArrayList<>();

    /**

     * 子包名

     */

    //private String subPackage = "exception";

    /**

     * 默认的处理结果

     */

    private String defaultResult = "unknownException";

    @Override

    public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, Object handler,

                                         Exception exception) {

        ModelAndView mv = new ModelAndView();

        mv.setViewName(getForwardViewName(getViewName(defaultResult)));

        mv.addObject("exception", exception);

        Class<?> cls = exception.getClass();

        String viewName = getViewName(ClassUtils.getObjectName(cls.getSimpleName()));

        if (CanRedirectExcetion.class.isInstance(exception)) {

            Map<RequestMappingInfo, HandlerMethod> map = requestMappingHandlerMapping.getHandlerMethods();

            Set<RequestMappingInfo> set = map.keySet();

            for (RequestMappingInfo requestMappingInfo : set) {

                if (!requestMappingInfo.getPatternsCondition().getMatchingPatterns( viewName ).isEmpty()) {

                    mv.setViewName(getForwardViewName(getViewName(ClassUtils.getObjectName(cls.getSimpleName()))));

                    return mv;

                }

            }

        }

        System.out.println( exception.toString() );

        return mv;

    }

    /**

     * 通过 异常对象名 得到 异常视图名

     * @param exceptionObjectName

     * @return

     */

    private String getViewName(String exceptionObjectName) {

        return prefix + exceptionObjectName + suffix;

    }

    /**

     * 得到 forward 格式 的viewName

     * @param viewName

     * @return

     */

    private String getForwardViewName(String viewName) {

        return "forward:" + viewName;

    }

}

异常信息返回：上面的异常处理类会调用下面这个类的不同方法返回前端不同错误码，并且统一格式的信息。

package com.hs.backend.controller.exception;

import javax.servlet.http.HttpServletRequest;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RestController;

import org.springframework.web.context.request.RequestContextHolder;

import org.springframework.web.context.request.ServletRequestAttributes;

import com.hs.backend.exception.GlobalExceptionResolver;

import com.hs.common.result.CommonErrorInfo;

import com.hs.common.result.CommonResult;

import com.hs.commons.exception.AlreadyExistRecord;

import com.hs.commons.exception.ApiInvokingException;

import com.hs.commons.exception.DataErrorException;

import com.hs.commons.exception.NoPermissionException;

import com.hs.commons.exception.NoTokenErrorException;

import com.hs.commons.exception.ParameterErrorException;

import com.hs.commons.exception.TokenExpiredException;

import com.hs.commons.exception.UnLoginException;

import springfox.documentation.annotations.ApiIgnore;

/**

 * 定义异常的返回处理策略，这个路劲不应该添加热河权限限制

 *

 * @author ZHANGYUKUN

 */

@ApiIgnore

@RestController

@RequestMapping("global")

public class GlobalController {

    private static Logger logger = LoggerFactory.getLogger(GlobalExceptionResolver.class);

    /**

     * 未知异统一处理

     *

     * @return

     */

    @RequestMapping("exception/unknownExceptionResult")

    public CommonResult<Void> unknownExceptionResult() {

        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();

        Exception exception =  (Exception) request.getAttribute("exception");

        Throwable throwable = null;

        if (logger.isErrorEnabled()) {

            logger.error("未知异常发生了:", exception);

            throwable =  findFinalCause( exception );;

        }

        //如果取不到异常堆站里面的 信息 ，就向前端提示未知异常

        String message = "未知的异常";

        if( throwable.getMessage() != null ) {

            message = throwable.getMessage();

        }

        return CommonResult.getFaiInstance(CommonErrorInfo.code_3001, message);

    }

    /**

     * 参错误统一返回

     *

     * @return

     */

    @RequestMapping("exception/parameterErrorExceptionResult")

    public CommonResult<Void> parameterErrorExceptionResult() {

         HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();

         ParameterErrorException exception =  (ParameterErrorException)request.getAttribute("exception");

        return CommonResult.getFaiInstance(CommonErrorInfo.code_1001,  exception.getMessage() );

    }

    /**

     * 没有权限统一返回

     * @return

     */

    @RequestMapping("exception/noPermissionExceptionResult")

    public  CommonResult<Void>  noPermissionException() {

        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();

        NoPermissionException exception =  (NoPermissionException)request.getAttribute("exception");

        return CommonResult.getFaiInstance( CommonErrorInfo.code_2001 , exception.getMessage() == null ? "没有权限" : exception.getMessage());

    }

    /**

     * 未登录统一返回

     *

     * @return

     */

    @RequestMapping("exception/unLoginExceptionResult")

    public CommonResult<Void> unLoginExceptionResult() {

        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();

        UnLoginException exception =  (UnLoginException)request.getAttribute("exception");

        return CommonResult.getFaiInstance(CommonErrorInfo.code_4001, exception.getMessage());

    }

   /**

    * 已存在的记录错误

    * @return

    */

    @RequestMapping("exception/alreadyExistRecordResult")

    public CommonResult<Void> alreadyExistRecordResult() {

        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();

        AlreadyExistRecord exception =  (AlreadyExistRecord)request.getAttribute("exception");

        return CommonResult.getFaiInstance(CommonErrorInfo.code_5001,  exception.getMessage() );

    }

    /**

     * 没有token

     * @return

     */

    @RequestMapping("exception/noTokenErrorExceptionResult")

    public CommonResult<Void> noTokenErrorExceptionResult() {

        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();

        NoTokenErrorException exception =  (NoTokenErrorException)request.getAttribute("exception");

        return CommonResult.getFaiInstance(CommonErrorInfo.code_2101,  exception.getMessage() );

    }

    /**

     * token过期

     * @return

     */

    @RequestMapping("exception/tokenExpiredExceptionResult")

    public CommonResult<Void> tokenExpiredExceptionResult() {

        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();

        TokenExpiredException exception =  (TokenExpiredException)request.getAttribute("exception");

        return CommonResult.getFaiInstance(CommonErrorInfo.code_2102,  exception.getMessage() );

    }

    /**

     * 数据错误

     * @return

     */

    @RequestMapping("exception/dataErrorExceptionResult")

    public CommonResult<Void> dataErrorException() {

        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();

        DataErrorException exception =  (DataErrorException)request.getAttribute("exception");

        return CommonResult.getFaiInstance(CommonErrorInfo.code_6001,  exception.getMessage() );

    }

    /**

     * 访问频率过高

     * @return

     */

    @RequestMapping("exception/requestFrequencyExceptionResult")

    public CommonResult<Void> requestFrequencyException() {

        return CommonResult.getFaiInstance(CommonErrorInfo.code_8001,  "访问频率过高" );

    }

    /**

     * api调用异常错误

     * @return

     */

    @RequestMapping("exception/apiInvokingExceptionResult")

    public CommonResult<Void> apiInvokingException() {

        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();

        ApiInvokingException exception =  (ApiInvokingException)request.getAttribute("exception");

        return CommonResult.getFaiInstance(CommonErrorInfo.code_9001,  exception.getMessage() );

    }

    /**

     * 得到最根上的异常

     *

     * @param throwable

     * @return

     */

    private Throwable findFinalCause(Throwable throwable) {

        Throwable rootThrowable = null;

        String msg = null;

        if( throwable.getCause() == null ) {

            rootThrowable =  throwable;

        }else {

            rootThrowable = findFinalCause( throwable.getCause() );

        }

        msg = rootThrowable.getMessage();

        System.out.println( msg );

        return rootThrowable;

    }

}

正常的方法调用：保持事物环境，不管是注解还是 aop ，然后不合理的操作，直接抛出异常，让整个事物环境回滚。（这里只有单个方法，如果 A 调用B ，B 里面抛出异常，B 的事物传播参数指定的是 REQUIRED（默认的），那么就可以正常回滚）

Transaction rolled back because it has been marked as rollback-only 原因和解决方案

Transaction rolled back because it has been marked as rollback-only 原因和解决方案的相关教程结束。

相关推荐

Kurator，你的分布式云原生解决方案

Unity TextMeshPro 添加中文字体遇见的问题以及解决方案

Node.js安装中出现的问题及其解决方案

基于 Rainbond 的混合云管理解决方案

分布式 ID 解决方案之美团 Leaf

svn is already locked 最终解决方案

vue一直处在2.9.6版本卸载不了升级不了解决方案

WPF中Popup控件在Win7以及Win10等中的对齐点方式不一样的解决方案 - 简书

Transaction rolled back because it has been marked as rollback-only 原因 和解决方案

Transaction rolled back because it has been marked as rollback-only 原因 和解决方案的相关教程结束。

相关推荐

Kurator，你的分布式云原生解决方案

Unity TextMeshPro 添加中文字体遇见的问题以及解决方案

Node.js安装中出现的问题及其解决方案

基于 Rainbond 的混合云管理解决方案

分布式 ID 解决方案之美团 Leaf

svn is already locked 最终解决方案

vue一直处在2.9.6版本卸载不了升级不了解决方案

WPF中Popup控件在Win7以及Win10等中的对齐点方式不一样的解决方案 - 简书

Transaction rolled back because it has been marked as rollback-only 原因和解决方案

Transaction rolled back because it has been marked as rollback-only 原因和解决方案的相关教程结束。