探索spring事务失效之谜

1. spring 事务失效 描述

工作中经常使用spring声明式事务，使用起来很方便，只需要在需要添加事务的方法上面添加一个@Transaction注解即可，对开发人员来说完全是透明的实现。spring使用AOP来支持声明式事务，会根据事务属性，自动在方法调用之前决定是否开启一个事务，并在方法执行之后决定事务提交或回滚事务。在使用过程中，遇到过一种情况：就是同一个类中无事务方法调用有事务方法会导致有事务方法不生效,起始不仅仅是spring事务这种情况会失效，Spring AOP 这种情况下也是不起作用的，下面就来探索下这种情况的原因。

事务实效情况图示.png

2 动态代理模拟spring 事务实现

spring 的声明式事务，其根本实现原理就是动态代理的方式,下面采用java JDK动态代理的方式来模拟spring 事务的实现，然后展示spring 事务失效的现象。

2.1 定义接口

Tx 是 Transaction的缩写。

public interface TxService {
 /**
  * 事务方法
  */
 void txM();
 /**
  * 无事务方法
  */
 void noTxM();
}

2.2 模拟事务失效

  @Test
    public void testTx(){
        //被代理对象
        TxServiceImpl target = new TxServiceImpl();
        //代理对象
        TxService proxyInstance =(TxService) Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(), new TxInvocationHandler(target));
        System.out.println("测试1:执行无事务方法调用有事务方法");
        proxyInstance.noTxM();
        System.out.println("-------------分割线------------");
        System.out.println("测试2:执行有事务方法");
        proxyInstance.txM();
    }

    /**
     * 拦截 目标方法，进行事务管理
     */
    class TxInvocationHandler implements InvocationHandler{
        /**
         * 被代理类实列
         */
        private Object target;

        public TxInvocationHandler(Object target){
            this.target = target;
        }
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            //判断是否是事务方法
            boolean isTxMethod = isTxMethod(method,target);
            //获取数据库连接
            System.out.println("获取数据库连接");
            //事务开启
            startTx(isTxMethod);
            Object result ;
            try {
                //执行被代理类对象方法
                result = method.invoke(target, args);
                //事务提交
                commitTx(isTxMethod);
                return result;
            }catch (Exception e){
                //事务回滚
                rollBack(isTxMethod);
                throw new Exception(e);
            }finally {
                //关闭数据库连接
                closeConnection();
            }
        }

        /**
         * 关闭数据库连接
         */
        private void closeConnection() {
            System.out.println("关闭数据库连接");
        }

        /**
         * 判断是否是 一个事务方法
         */
        private boolean isTxMethod(Method method,Object target) {
            try {
                Transactional annotation = AnnotationUtils.findAnnotation(method, Transactional.class);
                if(annotation == null){
                    Method tagetMethod = target.getClass().getMethod(method.getName(), method.getParameterTypes());
                    annotation = AnnotationUtils.findAnnotation(tagetMethod, Transactional.class);
                }
                return annotation != null;
            } catch (NoSuchMethodException e) {
                e.printStackTrace();
            }
            return false;
        }
        /**
         * 提交事务
         */
        private void commitTx(boolean isTxMethod) {
            if(isTxMethod){
                System.out.println(":事务提交");
            }
        }
        /**
         * 回滚事务
         */
        private void rollBack(boolean isTxMethod) {
            if(isTxMethod){
                System.out.println(":事务回滚");
            }
        }
        /**
         * 根据条件事务开启
         */
        private void startTx(boolean isTxMethod) {
            if(isTxMethod){
                System.out.println(":开启事务");
            }
        }
    }

2.3 执行testTx()结果

从结果可以看出测试1 在执行有事务方法是并没有开启事务。

***测试1:执行无事务方法调用有事务方法:
获取数据库连接
执行无事务方法调用有事务方法->(
执行事务方法
)
关闭数据库连接
----------------------分割线-----------------------
***测试2:执行有事务方法:
获取数据库连接
:开启事务
执行事务方法
:事务提交
关闭数据库连接

3 查看动态代理字节码文件

按照保存java 动态代理生成的字节码文件介绍的方法获取到动态代理生成的字节码文件。

3.1 动态代理类中noTxM方法的实现

1.生成的动态代理类继承了 Proxy 类 并且实现了TxService接口
2.Proxy的h属性 就是 InvacationHandler实现类,既是我们的TxInvocationHandler
3.接口方法的实现都是 调用了 InvocationHandler 的invoke方法。invoke方法的实现就是实现事务管理的地方。

public final class $Proxy extends Proxy implements TxService { 
 //省略 属性 其他方法
  public final void noTxM() throws  {
        try {
            super.h.invoke(this, m4, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }
}

3.2 代理类UML图

JDK动态代理UML图.jpg

3.3 绘制调用时序图

通过 字节码文件可以绘制一下调用时序图(无事务方法调用有事务方法)：

无事务方法调用有事务方法.png

4 事务失效原因分析

1. 项目中，通过spring的 自动注入 获取到 TxService类型的对象，其实是一个动态代理类增强对象$Proxy。
2. 在执行TxService.noTxM()方法时，实际执行的$Proxy.noTxM(),接着会执行InvocationHandler.invoke 方法。
3. 在invoke方法内判断noTxM()并不是一个事务方法，所以事务并没有开启。
4. 在事务没有开启的情况下,执行被代理类对象target .noTxM() ,在noTxM()内执行txM()函数 ,InvocationHandler.invoke()并不会再次执行，所以也就不会为txM()开启事务了。
5. 如果noTxM()调用txM()时，能使用代理类对象调用,事务就不会失效。
6. 这种情况不仅仅存在于事务管理中，同样Spring AOP 也会有这种情况，因为事务是基于AOP 实现的。

5 解决方案

1. 通过@Resouse 或 @Autowired 注入自己:这样获取到的就是代理类对象。

   @Service
   public class TxServiceImpl implements TxService {
   
       @Autowired
       private TxService txService;
   
       @Transactional
       @Override
       public void txM() {
           System.out.println("执行事务方法");
       }
       @Override
       public void noTxM() {
           System.out.println("执行无事务方法调用有事务方法->(");
           txService.txM();
           System.out.println(")");
       }
   }
   

2. AopContext.currentProxy()方式
   spring boot 项目 需要在启动类添加@EnableAspectJAutoProxy(exposeProxy = true)，spring 项目需要配置<aop:aspectj-autoproxy proxy-target-class="true"expose-proxy="true"/> ，否则会抛异常。

    @Override
    public void noTxM() {
        System.out.println("执行无事务方法调用有事务方法->(");
        TxService txService = (TxService) AopContext.currentProxy();
        txService.txM();
        System.out.println(")");
    }
   

3. 从Spring IOC 容器中获取到代理类对象

@Override
  public void noTxM() {
      System.out.println("执行无事务方法调用有事务方法->(");
      TxService txService = SpringContextUtil.getBean(TxService.class);
      txService.txM();
      System.out.println(")");
  }