Spring事务失效

基础代码

事务配置类

@Configuration
@EnableTransactionManagement
@ComponentScan("life.cqq.transactional")
@EnableAspectJAutoProxy(proxyTargetClass = true, exposeProxy = true)
public class TxConfig {
    @Bean
    public DataSource dataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setUsername("root");
        dataSource.setPassword("root");
        dataSource.setUrl("jdbc:mysql://localhost:3306/test?useSSL=false&serverTimezone=Asia/Shanghai");
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        return dataSource;
    }

    @Bean
    public JdbcTemplate jdbcTemplate(DataSource dataSource) {
        return new JdbcTemplate(dataSource);
    }

    /**
     * 事务管理器
     */
    @Bean
    public PlatformTransactionManager platformTransactionManager() {
        return new DataSourceTransactionManager(dataSource());
    }
}

业务类

@Component
public class Service {

    @Autowired
    private JdbcTemplate jdbcTemplate;
    
    @Transactional(rollbackFor = Exception.class)
    public void insert() {
        jdbcTemplate.execute("INSERT INTO `test_table`(`username`, `password`) VALUES ('root1', 'root1')");
    }
}

测试类

public class TransactionalTest {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(TxConfig.class);
        Service service = context.getBean(Service.class);
        service.insert();
    }
}

前置问题

1. 测试类中获取的service实例，是否有被代理？
2. 当业务类中当insert方法的@Transactional注解删除时，测试类中获取的service实例，是否有被代理？

解：第一种情况在getBean时，获取的是代理对象。第二种情况会获取到原bean。

进而又引出了一个新问题，spring是如何根据方法的@Transactional注解生成的代理对象？

大胆推测，当bean在初始化后，会被一组BeanPostProcessor执行后置处理。那么，一定有一个针对于事务的Bean后置处理器，将bean转为代理后的bean。经过追踪源码，推测的结果是正确的。
简单来说：BeanPostProcessor: AnnotationAwareAspectJAutoProxyCreator 判断bean是否有能被computeTransactionAttribute方法计算出事务属性的方法，有则生成关于事务的代理类。

事务失效情景

一、无事务注解方法中调用有事务注解方法

@Component
public class Service {

    @Autowired
    private JdbcTemplate jdbcTemplate;
    
    public void insert() {
        jdbcTemplate.execute("INSERT INTO `test_table`(`username`, `password`) VALUES ('root1', 'root1')");
        insert2();
        throw new NullPointerException();
    }
    @Transactional(rollbackFor = Exception.class)
    public void insert2() {
        jdbcTemplate.execute("INSERT INTO `test_table`(`username`, `password`) VALUES ('root2', 'root2')");
    }
}

即使insert方法抛出了运行时异常，但两条数据都会被新增成功，不会被回滚。为什么？

首先，insert2添加了@Transactional注解，且无实现接口，那么getBean时获取到的是一个Cglib代理类，代理内容与事务相关。

private static class DynamicAdvisedInterceptor implements MethodInterceptor, Serializable {
    @Override
    @Nullable
    public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        // ....
        List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
        Object retVal;
        if (chain.isEmpty() && Modifier.isPublic(method.getModifiers())) {
            Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
            retVal = methodProxy.invoke(target, argsToUse);
        }
        else {
            // We need to create a method invocation...
            retVal = new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed();
        }
        // ....
    }
}

当通过代理类调用bean的方法时，会被拦截，判断方法前后是否需要执行事务代码，事务代码实际被封装在chain中的TransactionInterceptor中。如果判断方法不需要，chain的拦截器列表为空，则直接通过代理对象中的原Bean（proxy参数）调用bean方法。要理清一点：即使方法前后需要执行事务代码，但调用bean方法时，仍需要通过原Bean（proxy参数）进行调用。

那么由于我们调用的是没有事务注解的insert，getInterceptorsAndDynamicInterceptionAdvice时获取的chain为空，所以，当出现异常时，也没有进行事务回滚。

二、不同事务传播机制的方法间调用

@Component
public class Service {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Transactional(rollbackFor = Exception.class)
    public void insert() {
        jdbcTemplate.execute("INSERT INTO `test_table`(`username`, `password`) VALUES ('root1', 'root1')");
        insert2();
    }
    @Transactional(rollbackFor = Exception.class, propagation = Propagation.NEVER)
    public void insert2() {
        jdbcTemplate.execute("INSERT INTO `test_table`(`username`, `password`) VALUES ('root2', 'root2')");
    }
}

以上代码，是可以正常结束的。并没有因为insert2的propagation配置的NEVER而抛出异常（NEVER简单来说为不在事务下执行，如果执行时已存在事务则抛出异常）为什么没有生效呢？

代理对象执行insert方法前执行intercept方法虽然获取到了事务拦截器，但是调用insert2方法时，并没有走intercept，而是通过内部的原Bean对象调用的。

如何解决呢，可以通过显示调用代理对象的方式调用insert2

@Transactional(rollbackFor = Exception.class)
public void insert() {
    jdbcTemplate.execute("INSERT INTO `test_table`(`username`, `password`) VALUES ('root1', 'root1')");
    // insert2();
    ((Service) AopContext.currentProxy()).insert2();
}

这样，执行insert2方法时，通过代理对象进行调用，会执行intercept方法判断并获取执行insert2方法时的事务拦截器。

又产生一个疑问，AopContext.currentProxy()是如何获取到的代理对象？

private static class DynamicAdvisedInterceptor implements MethodInterceptor, Serializable {
    Object oldProxy = null;
    boolean setProxyContext = false;
    Object target = null;
    TargetSource targetSource = this.advised.getTargetSource();
    try {
        if (this.advised.exposeProxy) {
            // Make invocation available if necessary.
            oldProxy = AopContext.setCurrentProxy(proxy);
            setProxyContext = true;
        }
     // ....
}

又是在拦截方法中处理的，AopContext内部使用ThreadLocal存储的代理对象，所以可以通过AopContext获取到代理对象了。需要说明：此功能需要手动启用，配置如下：

@EnableAspectJAutoProxy(proxyTargetClass = true, exposeProxy = true)