事务失效的几个场景

首先了解一下@Transaction注解

@Transaction是声明式事务的注解，可以被标记在类、接口、方法上。有下面几种属性：

transactionManager

指定事务管理器，值为bean的名称，这个主要用于多事务管理器情况下指定。比如多数据源配置的情况下。

isolation

事务的隔离级别，默认是Isolation.DEFAULT。几种值的含义如下：

Isolation.DEFAULT：事务默认的隔离级别，使用数据库默认的隔离级别。

Isolation.READ_UNCOMMITTED：事务最低隔离级别，它允许读取事务未提交的数据。这种隔离级别会产生脏读，不可重复读和幻读。

Isolation.READ.COMMITTED：保证一个事务修改的数据提交后才会被另外一个事务读取。另一个事务不能读取该事务未提交的数据。这种事务隔离级别可以避免脏读出现，但是可能会出现不可重复读和幻读。

Isolation.REPEATABLE_READ：这种事务隔离级别可以防止脏读，不可重复读。但是可能出现幻读。

Isolation.SERIALIZABLE：这是花费最高代价但是最可靠的事务隔离级别。事务被处理为顺序执行。能防止脏读、幻读、不可重复读。

propagation

代表事务的传播行为，默认值为Propagation.REQUIRED。

Propagation.REQUIRED：如果存在一个事务，则支持当前事务。如果没有事务则开启一个新事务。比如A方法内部调用了B方法，此时B方法将会使用A方法的事务。

Propagation.MANDATORY：支持当前事务，如果当前没有事务，就抛出异常。

Propagation.NEVER：以非事务方式执行，如果当前存在事务，则抛出异常。

Propagation.NOT_SUPPORTED：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。

Propagation.REQUIRES_NEW：新建事务，如果当前存在事务，把当前事务挂起。比如A方法使用默认的事务传播属性，B方法使用REQUIRES_NEW，此时A方法在内部B方法，一旦A方法出现异常，A方法中的事务回滚了，但是B方法并没有回滚，因为A方法和B方法使用的不是同一个事务，B方法新建了一个事务。

Propagation.NESTED：支持当前事务，新增Savepoint点，也就是在进入子事务之前，父事务建立一个回滚点，与当前事务同步提交或者回滚。子事务是父事务的一部分，在父事务还未提交时，子事务一定没有提交。嵌套事务一个非常重要的概念就是内层事务依赖于外层事务。外层事务失败时，会回滚内层事务所做的动作。而内层事务操作失败并不会引起外层事务的回滚。

timeout

事务的超时时间，单位为秒。

readOnly

该属性用于设置当前事务是否为只读事务。

rollbackFor

用于指定能够触发事务回滚的异常类型，可以指定多个异常类型。默认是在RuntimeException和Error上回滚。

noRollbackFor

抛出指定的异常类型，不回滚事务，也可以指定多个异常类型。

---

一、事务不生效

1. 访问权限问题

Spring要求被代理的方法必须是public修饰的。在AbstractFallbackTransactionAttributeSource类的computeTransactionAttribute方法中有个判断，如果目标方法不是public，则TransactionAttribute返回null，即不支持事务（但是加上@AspectJ可以替代）。

2. 方法用final修饰

如果某个方法不想被子类重写，这时我们可以将该方法定义成final。但是这样会导致事务失效。

Spring事务底层使用了AOP，也就是通过jdk动态代理或者cglib帮我们生成了代理类，在代理类中实现事务功能。但如果某个方法用final修饰了，那么在它的代理类中，就无法重写该方法而无法添加事务功能。

static修饰的方法同样无法通过动态代理，编程事务方法。

3. 方法内部调用

@Service
public class OrderServiceImpl implements OrderService {
 
    public void update(Order order) {
        updateOrder(order);
    }
    
    @Transactional
    public void updateOrder(Order order) {
        // update order
    }
}

update方法上面没有加@Transactional注解，调用有@Transactional注解的updateOrder，此时事务是不生效的，默认在外部调用事务才会生效。原因是在同一个类中，方法互相调用，AOP切面失效。

如果想在同一个类的某个方法中，调用它自己的另一个方法：

新增一个Service方法，把@Transaction注解加到新Service方法上：

@Service
public class ServiceA {
 
    @Autowired
    private ServiceB serviceB;

    public void save(User user){
        queryData1();
        queryData2();
        serviceB.doSave(user);
    }
}

@Service
public class ServiceB{
    @Transactional(rollbackFor=Exception.class)
    public void doSave(User user){
        addData1();
        updateData2();
    }
}

在该Service类中注入自己：

@Service
public class ServiceA {
    
    @Autowired
    private ServiceA serviceA;
 

    public void save(User user){
        queryData1();
        queryData2();
        serviceA.doSave(user);
    }

    @Transactional(rollbackFor=Exception.class)
    public void doSave(User user){
        addData1();
        updateData2();
    }
}

或是用过AOPProxy获取代理对象，实现相同的功能：

@Service
public class ServiceA {
    
    public void save(User user){
        queryData1();
        queryData2();
        ((SerivceA)AopContext.currentProxy()).doSave(user);
    }

    @Transactional(rollbackFor=Exception.class)
    public void doSave(User user){
        addData1();
        updateData2();
    }
}

4. 底层数据库引擎不支持事务

5. 使用try-catch

使用try-catch会把异常封锁在方法中，导致异常无法抛出，不能触发事务。

6. 未被Spring容器管理

使用Spring事务的前提是：对象要被Spring管理，需要创建bean实例。

通常情况下，我们通过@Controller、@Service、@Component、@Repository等注解，可以实现bean实例化和依赖注入的功能。

7. 多线程调用

Spring事务是通过数据库连接来实现的。当前线程中保存了一个map，key是数据源，value是数据库连接。

private static final ThreadLocal<Map<Object, Object>> resources =   new NamedThreadLocal<>("Transactional resources");

我们说的同一个事务，其实是指同一个数据库连接，只有拥有同一个数据库连接才能同时提交和回滚。

多线程调用会导致两个方法不在同一线程中，获取到的数据库连接不一样，从而是两个不同的事务。如果被调用事务抛出异常，调用者事务也不会回滚。

二、事务不回滚

1. 传播特性错误

Propagation.NOT_SUPPORTED类型的传播特性不支持事务，如果有事务会抛出异常。

2. 回滚异常类型配置错误

默认异常类型是RuntimeException，如果需要触发其它异常的回滚，需要在注解上配置，如@Transactional(rollbackFor=Exception.class)，这个配置仅限于Throwable异常类及其子类。