浅析@Transactional

0.@Transactional的工作原理***

1.Spring事务管理是基于spring动态代理技术，通过AOP实施事务增强的。

2.spring动态代理分为jdk动态代理和CGLib，这两种动态代理的实现，都是基于接口或者类来实现，因此事物生效也是基于类的，也就是事物必须过切面！

 3.对于基于接口动态代理的AOP事务增强来说，由于接口的方法是public的，这就要求实现类的实现方法必须是public的（不能是protected，private等），同时不能使用static的修饰符。所以，可以实施接口动态代理的方法只能是使用“public”或“public final”修饰符的方法，其它方法不可能被动态代理，相应的也就不能实施AOP增强，也即不能进行Spring事务增强。

4.基于CGLib字节码动态代理的方案是通过扩展被增强类，动态创建子类的方式进行AOP增强植入的。由于使用final,static,private修饰符的方法都不能被子类覆盖，相应的，这些方法将不能被实施的AOP增强。

小结：基于@Transactional注解，必须过切面也就是垮类，必须是public修饰，不能有static修饰，最好也不要有final修饰。

0-1.TransactionInterceptor初识***

image

继承自TransactionAspectSupport类（该类包含与Spring的底层事务API的集成），实现了MethodInterceptor接事务拦截器的拦截功能就是依靠实现了MethodInterceptor接口，熟悉spring的同学肯定很熟悉MethodInterceptor了，这个是spring的方法拦截器，主要看invoke方法。

演示：

image.png

image.png

image.png

image.png

1. TransactionInterceptor 整体流程***

当程序执行事务方法的时候，就会先走增强器TransactionInterceptor#invoke方法：

/**
*invocation目标方法
*/
public Object invoke(final MethodInvocation invocation) throws Throwable 
        // 获取目标类
        Class targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null);
        // 调用抽象类TransactionAspectSupport.java类中invokeWithinTransaction方法
        return invokeWithinTransaction(invocation.getMethod(), targetClass, new InvocationCallback() {
           //回调方法，就是目标类的方法调用
            @Override
            public Object proceedWithInvocation() throws Throwable {
                return invocation.proceed();
            }
        });
    }
protected Object invokeWithinTransaction(Method method, Class targetClass, final InvocationCallback invocation)
            throws Throwable {
        // 获取对应事务属性
        final TransactionAttribute txAttr = getTransactionAttributeSource().getTransactionAttribute(method, targetClass);
        // 获取 beanFactory 中的 transactionManager，需要配置
        final PlatformTransactionManager tm = determineTransactionManager(txAttr);
        // 获取方法唯一标识（类.方法 如 xxx.UserServiceImpl.save）
        final String joinpointIdentification = methodIdentification(method, targetClass, txAttr);
        // 声明式事务处理 @Transactional
        if (txAttr == null || !(tm instanceof CallbackPreferringPlatformTransactionManager)) {
            // 创建事物
            TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, joinpointIdentification);
            Object retVal = null;
            try {
                // 执行被增强方法
                retVal = invocation.proceedWithInvocation();
            }
            catch (Throwable ex) {
                // 异常回滚
                completeTransactionAfterThrowing(txInfo, ex);
                throw ex;
            }
            finally {//Reset the TransactionInfo ThreadLocal.
                cleanupTransactionInfo(txInfo);
            }
            // 提交事务
            commitTransactionAfterReturning(txInfo);
            return retVal;
        }
        // 编程式事务
         else {
             final ThrowableHolder throwableHolder = new ThrowableHolder();

             // It's a CallbackPreferringPlatformTransactionManager: pass a TransactionCallback in.
             try {
                 Object result = ((CallbackPreferringPlatformTransactionManager) tm).execute(txAttr,
                        new TransactionCallback