@Transational事务注解未生效的原因探究

现象描述

代码简化如下：

@Controller
class XService {
    @Autowired
    private YService yService;public void doOutside(){        this.doInside(); //或者直接doInside();效果是一样的
    }
    @Transactional
    private void doInside(){
        //do sql statement
    }
}
@Controller
class Test {
    @Autowired
    private XService xService;
    public void test(){
        xService.doOutside();
    }
}

实际执行test()后发现doInside()的Sql执行过程没有被Spring Transaction Manager管理起来。

下面再看另一种情况：

/**
    * 调用child , 由于child 抛出异常，查看事物回滚
    * @return
    */
   @Transactional(propagation = Propagation.SUPPORTS ,rollbackFor = Exception.class)
   public Integer parent() {
       try {
           child();
       }catch (Exception e){
 
       }
       Course course = new Course();
       course.setName("childCourse");
       course.setCreateTime(new Date());
       testDao .insert(course);
       return Integer.MAX_VALUE;
   }
   /**
    * 被parent 调用，该事物传播机制为新启一个事物，关于事物传播，请另查询资料
    *
    *
    * 插入一条course 记录
    * @return
    */
   @Transactional(propagation = Propagation.REQUIRES_NEW ,rollbackFor = Exception.class)
   public Integer child() {
       Course course = new Course();
       course.setName("childCourse");
       course.setCreateTime(new Date());
       testDao .insert(course);
       // 抛出异常
       int i = 10 / 0 ;
       return Integer.MAX_VALUE;
   }

在child 方法中我声明事物传播为REQUIRES_NEW
，因此，child 在执行的时候应该挂起parent 方法的事物，等执行完毕child 方法的事物之后，唤醒parent 的事物，这种情况的预期结果是parent 插入成功，child 插入失败。但是结果，确实呵呵，全部成功。

发现的两个问题

在一个实例方法中调用被@Transactional注解标记的另一个方法，且两个方法都属于同一个类时，事务不会生效。
调用被@Transactional注解标记的非public方法，事务不会生效。

首先复习下相关知识：Spring AOP、JDK动态代理、CGLIB、AspectJ、@Aspect

@Transactional的实现原理是在业务方法外边通过Spring AOP包上一层事务管理器的代码（即插入切面），这是Java设计模式中常见的通过代理增强被代理类的做法。

Spring AOP的底层有2种实现：JDK动态代理、CGLIB。前者的原理是JDK反射，并且只支持Java接口的代理；后者的原理是继承（extend）与覆写（override），因此能支持普通的Java类的代理。两种方式都是动态代理，即运行时实时生成代理。

由于JVM的限制，CGLIB无法替换被代理类已经被载入的字节码，只能生成并载入一个新的子类作为代理类，被代理类的字节码依然存在于JVM中。

区别于前两者，AspectJ是一种静态代理的实现，即在编译时或者载入类时直接修改被代理类文件的字节码，而非运行时实时生成代理。因此这种方式需要额外的编译器或者JVM Agent支持，通过一些配置Spring和AspectJ也可以配合使用。

@Aspect一开始是AspectJ推出的Java注解形式，后来Spring AOP也支持使用这种形式表示切面，但实际上底层实现和AspectJ毫无关系，毕竟Spring AOP是动态代理，和静态代理是不兼容的。

进一步分析

既然事务管理器没有生效，那么首先需要确定一个问题：this到底是指向哪个对象，是未增强的XService还是增强后的XService？并且而且有没有可能已经调用增强后的实例和方法，但由于其他原因而导致事务管理器没有生效？

回忆下Java基础，this表示的是类的当前实例，那么关键就是确定类的实例是未被增强的XService（下面称其为XService），还是被CGLIB增强过的XService（下面称其为XService$$Cglib）。

在Test中，XService类的实例变量是一个由Spring框架管理的Bean，当执行test()时，根据@Autowired注解进行相应的注入，因此XService的实例实际为XService$$Cglib而不XService。被增强过的类的代码可以简化如下：

扫描二维码关注公众号，回复： 4896712 查看本文章

class XService$$Cglib extend XService {
    @Override
    public doInside(){
        //开始事务的增强代码
        super.doInside();
        //结束事务的增强代码
    }
}

当执行XService$$Cglib.doOutside()时，由于子类没有覆写父类同名方法，因此实际上执行了父类XService的doOutside()方法，所以在执行其this.doInside()时实际上调用的是父类未增强过的doInside()，因此事务管理器失效了。

这个问题在Spring AOP中广泛存在，即自调用，本质上是动态代理无法解决的盲区，只有AspectJ这类静态代理才能解决。

第二个问题则是Spring AOP不支持非public方法增强，与自调用类似，也是动态代理无法解决的盲区。

虽然CGLIB通过继承的方式是可以支持public、protected、package级别的方法增强的，但是由于JDK动态代理必须通过Java接口，只能支持public级别的方法，因此Spring AOP不得不取消非public方法的支持。

下面对接口进行动态代理进行分析

接口：

package proxy2;

public interface TestService  {
    Integer test1();
    Integer test2();
    Integer abcTest();
}

实现类：

package proxy2;

public class TestServiceImpl implements TestService {

//    public Integer test1() {
//        System.out.println("test1 被调用");
//        return Integer.MAX_VALUE;
//    }
//
//    public Integer test2() {
//        System.out.println("test2 被调用");
//        return Integer.MAX_VALUE;
//    }
//
//    public Integer abcTest() {
//        System.out.println("abcTest 被调用");
//        return null;
//    }

    public Integer test1() {
        System.out.println("test1 被调用");
        test2();
        System.out.println("-------------------------------------------------------");
        return Integer.MAX_VALUE;
    }

    public Integer test2() {
        System.out.println("test2 被调用");
        System.out.println("-------------------------------------------------------");
        return Integer.MAX_VALUE;
    }

    public Integer abcTest() {
        System.out.println("abcTest 被调用");
        System.out.println("-------------------------------------------------------");
        return null;
    }
}

代理：

package proxy2;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class MyInvocationHandler implements InvocationHandler {
    private Object target ;

    public MyInvocationHandler(Object target){
        this.target = target ;
    }
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if(method.getName().startsWith("test")){
            System.out.println("我被代理了");
        }
        Object invoke = method.invoke(target, args);
        return invoke;
    }
}

测试：

package proxy2;

import java.lang.reflect.Proxy;

public class TestProxy {

    public static void main(String[] args) {
        MyInvocationHandler invocationHandler = new MyInvocationHandler(new TestServiceImpl());
        TestService testService =(TestService) Proxy.newProxyInstance(
                TestService.class.getClassLoader(),
                new TestServiceImpl().getClass().getInterfaces(),
                invocationHandler);

        testService.test1();
        testService.test2();
        testService.abcTest();
    }
}

结果：

我被代理了
test1 被调用
test2 被调用
-------------------------------------------------------
-------------------------------------------------------
我被代理了
test2 被调用
-------------------------------------------------------
abcTest 被调用
-------------------------------------------------------

原因

Spring AOP使用JDK动态代理和CGLib，当方法被代理时，其实通过动态代理生成了代理对象，然后代理对象执行invoke方法，在调用被代理对象的方法时，执行其他操作。问题就在于被代理对象的方法中调用被代理对象的其他方法时，使用的是被代理对象本身，而非代理对象。这就导致了一个方法时代理对象调用的，一个是被代理对象调用的。他们的调用始终不出于同一个对象。

“自调用”的解决方法

1. 最好在被代理类的外部调用其方法

2. 自注入（Self Injection, from Spring 4.3）

@Controller
class XService {
    @Autowired
    private YService yService;
    @Autowired
    private XService xService;
    public void doOutside(){
        xService.doInside();//从this换成了xService
    }
    @Transactional
    private void doInside(){
        //do sql statement
    }
}
@Controller
class Test {
    @Autowired
    private XService xService;
    public void test(){
        xService.doOutside();
    }
}

由于xService变量是被Spring注入的，因此实际上指向XService$$Cglib对象，xService.doInside()因此也能正确的指向增强后的方法。

3.通过ThreadLocal暴露Aop代理对象

1、开启暴露Aop代理到ThreadLocal支持（如下配置方式从spring3开始支持）

<aop:aspectj-autoproxy expose-proxy="true"/><!—注解风格支持-->
<aop:config expose-proxy="true"><!—xml风格支持-->

2、修改我们的业务实现类

@Transactional(propagation = Propagation.SUPPORTS,rollbackFor = Exception.class)
    public Integer parent() {
        try {
            ((TestService) AopContext.currentProxy()). child();
        }catch (Exception e){

        }
        Course course = new Course();
        course.setName("parent");
        course.setCreateTime(new Date());
        testDao .insert(course);
        return Integer.MAX_VALUE;
    }

配置

<tx:annotation-driven transaction-manager="transactionManager"/>
<!-- (事务管理)transaction manager, use JtaTransactionManager for global tx -->
<bean id="transactionManager"class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
      <property name="dataSource" ref="dataSourceForSqlServer" />
</bean>

注意事项

1.在需要事务管理的地方加@Transactional 注解。@Transactional 注解可以被应用于接口定义和接口方法、类定义和类的 public 方法上。
2.@Transactional 注解只能应用到 public 可见度的方法上。如果你在 protected、private 或者 package-visible 的方法上使用 @Transactional 注解，它也不会报错，但是这个被注解的方法将不会展示已配置的事务设置。
3.注意仅仅 @Transactional 注解的出现不足于开启事务行为，它仅仅是一种元数据。必须在配置文件中使用配置元素，才真正开启了事务.
4.spring事物是基于类和接口的所以只能在类里面调用另一个类里面的事物，同一个类里面调用自己类的事物方法是无效的。spring事物也不要频繁使用，在事物处理的同时操作的第一张表会被限制查看的（即被临时锁住）。数据量大的时候会有一定影响。

参考：https://segmentfault.com/a/1190000011440783