细谈spring 事务不生效的情况-优快云博客

本文链接：https://blog.youkuaiyun.com/hu10131013/article/details/125797381

本文详细列举了Spring事务管理中可能出现的失效情况，包括数据库引擎不支持事务、未开启事务、对象未被Spring管理、方法修饰符不当、多线程调用、错误的事务传播机制、异常处理不当、手动抛出的异常处理以及嵌套事务回滚问题。并提供了相应的解决方案，帮助开发者排查和修复事务管理问题。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

背景

在业务代码中，经常需要保证事务的原子性，但是有的时候，确实是出现事务没有生效，那今天梳理下事务不生效的原因

1、数据库引擎不支持事务

PS: 事务生效的基础是所使用的数据库支持事务操作

## 事务生效的基础是数据库支持事务
以MySQL为例，InnoDB引擎是支持事务的，而像MyISAM、MEMORY等是不支持事务的。

从MySQL5.5.5开始默认的存储引擎是InnoDB，之前默认都是MyISAM。
所以在开发过程中发现事务失效，不一定是Spring的锅，最好确认一下数据库表是否支持事务。

2、未开启事务

对于SpringBoot项目，SpringBoot通过DataSourceTransactionManagerAutoConfiguration
自动配置事务管理，需要@EnableTransactionManagement注解开启使用就可以了。

## 如果其他spring或者是springmvc的项目，
可以采用xml或者是bean配置的方式，去配置事务管理

<!-- 配置事务管理器-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"/>
</bean>

<!-- 配置事务通知-->
<tx:advice id="Advice" transaction-manager="transactionManager">
<!-- 配置事务属性,即哪些方法要执行事务-->
<tx:attributes>
<tx:method name="insert*" propagation="REQUIRED"/> <!-- 所有insert开头的方法,以下同理 -->
<tx:method name="update*" propagation="REQUIRED"/>
<tx:method name="delete*" propagation="REQUIRED"/>
</tx:attributes>
</tx:advice>

<!-- 配置事务切面-->
<aop:config>
<aop:pointcut id="AdviceAop" expression="execution(* com.yy.service..*(..))"/> <!--要执行的方法在哪个包,意思为：com.yy.service下的所有包里面的包含任意参数的所有方法-->
<aop:advisor advice-ref="Advice" pointcut-ref="AdviceAop"/> <!-- 配置为AdviceAop执行哪个事务通知 -->
</aop:config>

<!--这样在执行service包下的增删改操作的方法时，就开启事务了，或者使用注解的方式-->

<!-- 配置事务管理器-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"/>
</bean>

<!-- 注解式事务声明配置-->
<tx:annotation-driven transaction-manager="transactionManager" />

3、未被Spring管理

使用Spring事务的前提是：对象要被Spring管理，事务方法所在的类要被加载为bean对象

，以下的案例不仅是事务失效，连这个service注入都是空

//@Service --- 没有使用spring能扫描到的service注解，会导致spring认为这个类是个不需要被管理的类
public class UserServiceImpl {

    @Transactional
    public void update() {
        // 业务代码
    }

}

4、事务方法没有被public修饰

PS:@Transactional注解只能作用在public修饰的方法上

## 在AbstractFallbackTransactionAttributeSource类
(Spring通过这个类获取@Transactional注解的配置属性信息)的computeTransactionAttribute
方法中有个判断，如果目标方法不是public，则TransactionAttribute返回null，即不支持事务。

@Nullable
protected TransactionAttribute computeTransactionAttribute(Method method, @Nullable Class<?> targetClass) {
// Don't allow no-public methods as required. 不是public方法事务不会被执行
    if (allowPublicMethodsOnly() && !Modifier.isPublic(method.getModifiers())) {
        return null;
    }
//………………

}

5、方法使用final修饰

## 如果一个方法不想被子类重写，那么我们就可以把他写成final修饰的方法

## 如果事务方法使用final修饰，那么aop就无法在代理类中重写该方法，事务就不会生效

6、使用static修饰的方法

## 动态代理的原理是通过实现接口或者继承来实现的，所以目标方法需要满足以下几个条件
##  1.必须是public修饰
##  2.不能是final修饰
##  3.不能是被static修饰

7、同一类中方法调用

PS:delete方法使用@Transactional注解标注，在testDelete()方法中调用了delete()方法，在外部调用testDelete()方法时，事务也不会生效，因为这里testDelete()方法中调用的是类本身的方法，而不是代理对象的方法。

@Service
public class UserServiceImpl {

    @Autowired
    UserMapper userMapper;

    public void testDelete() {
        // 这种 在同一个类中直接调用内部的方法是没有经过动态代理的
        //，因此事务并不生效 
       delelet();
    }

    @Transactional
    public void delelet() {
        userMapper.deleteById(200108);
        int i = 10 / 0; //模拟发生异常
    }

}

可以创建其他类实现该方法，或者是在本类中引入自身的bean
 引入自身的service对象
通过applicationContext获取service对象
通过aop获取aop代理对象
(需要在启动类上添加注解@EnableAspectJAutoProxy(exposeProxy = true)，表示是否对外暴露代理对象
其实这几种方式，最终的方式都是以动态代理获取对应的实体对象

@Service
public class UserServiceImpl {

    @Autowired
    UserMapper userMapper;

    @Autowired
    UserServiceImpl userServiceImpl;

    @Autowired
    ApplicationContext applicationContext;

    public void testDelete() {
        // 1. 引入自身的service对象
        userServiceImpl.delelet();
        // 2.通过applicationContext获取service对象
        UserServiceImpl userService = (UserServiceImpl) applicationContext.getBean("userServiceImpl");
        userService.delelet();
        //3.通过aop获取aop代理对象(需要在启动类上添加注解@EnableAspectJAutoProxy(exposeProxy = true)，表示是否对外暴露代理对象)
        UserServiceImpl userServiceAop = (UserServiceImpl) AopContext.currentProxy();
        userServiceAop.delelet();
    }
    @Transactional
    public void delelet() {
        userMapper.deleteById(200108);
        int i = 10 / 0; //模拟发生异常
    }

}

8、方法中存在多线程调用

在事务方法testDelete()中，启动了一个新的线程，并在新的线程中发生了异常，这样testDelete是不会回滚的。

因为两个操作不在一个线程中，获取到的数据库连接不一样，从而是两个不同的事务，所以也不会回滚

@Service 
public class UserServiceImpl {
    @Autowired
    UserMapper userMapper;

    @Transactional
    public void testDelete() throws InterruptedException {
        userMapper.deleteById(200110);
        new Thread(() -> {
            userMapper.deleteById(200112);
            int i = 10 / 0; //模拟发生异常        }).start();
        }
    }
}

9、错误的传播机制

REQUIRED(0)：当前存在事务，就加入该事务，如果不存在就创建一个新的事务
SUPPORTS(1)：当前存在事务就加入该事务，否则以非事务的方式运行
MANDATORY(2)：如果当前有事务就加入该事务，否则抛出异常
REQUIRES_NEW(3)：创建一个新的事务运行，如果之前有事务就把之前的事务挂起
NOT_SUPPORTED(4)：以非事务方式运行，如果之前有事务的话就挂起之前的事务
NEVER(5)：以非事务方式运行，如果之前有事务的话就抛出异常
NESTED(6)：创建一个新的事务，之前有事务的话就嵌套运行，否则的话只执行新创建的事务

public enum Propagation {
    //当前存在事务，就加入该事务，如果不存在就创建一个新的事务
    REQUIRED(0),
    //当前存在事务就加入该事务，否则以非事务的方式运行
    SUPPORTS(1),
    //如果当前有事务就加入该事务，否则抛出异常
    MANDATORY(2),
    //创建一个新的事务运行，如果之前有事务就把之前的事务挂起
    REQUIRES_NEW(3),
    // 以非事务方式运行，如果之前有事务的话就挂起之前的事务
    NOT_SUPPORTED(4),
    //以非事务方式运行，如果之前有事务的话就抛出异常
    NEVER(5),
    //创建一个新的事务，之前有事务的话就嵌套运行，否则的话只执行新创建的事务
    NESTED(6);

    private final int value;

    private Propagation(int value) {
        this.value = value;
    }

    public int value() {
        return this.value;
    }
}

@Service
public class UserServiceImpl {
    @Autowired
    UserMapper userMapper;
    // 以不支持事务的方式运行-因此事务不生效
    @Transactional(propagation = Propagation.NOT_SUPPORTED)
    public void testDelete() throws InterruptedException {
        userMapper.deleteById(200114);
        int i = 10 / 0;
    }
}

10、做了异常处理

对异常处理之后，相当于业务是正常进行的，除非是手动回滚事务，否则事务不会回滚

@Service
public class UserServiceImpl {
    @Autowired
    UserMapper userMapper;

    @Transactional
    public void testDelete() {
        try {
            userMapper.deleteById(200115);
            int i = 10 / 0;
            // 异常操作
        } catch (Exception e) {
        }
    }
}

11、手动抛出了的异常不被spring默认接受

Spring默认只会回滚RuntimeException和Error对于普通的Exception，不会回滚

如果需要其他异常回滚需要指定回滚错误异常类型@Transactional(rollbackFor = Exception.class)

@Service
public class UserServiceImpl {
    @Autowired
    UserMapper userMapper;

    @Transactional
    //如果需要捕捉其他异常需要指定rollbackFor的类型
//    @Transactional(rollbackFor=Exception.class)
    public void doTest() throws Exception {
        try {
            userMapper.deleteById(200116);
            int i = 10 / 0;
//            异常操作
        } catch (Exception e) {
            throw new Exception();
        }
    }
}

## 即使rollbackFor有默认值，但阿里巴巴开发者规范中，还是要求开发者重新指定该参数。

因为如果使用默认值，一旦程序抛出了Exception，事务不会回滚，这会出现很大的bug
一般情况下，需要将该参数设置成：Exception或Throwable。

12、嵌套事务回滚错乱

@Service
public class UserServiceImpl {

    @Autowired
    UserMapper userMapper;

    @Transactional
    public void testDelete() {
        userMapper.deleteById(200118);
        ((UserServiceImpl) AopContext.currentProxy()).delete();
    }

    @Transactional(propagation = Propagation.NESTED)
    public void delete() {
        userMapper.deleteById(200119);
        int i = 10 / 0;
    }
}

## 上述代码，在delete方法中，出现异常，没有进行处理，当前方法会回滚掉，
## 因为异常会继续向上抛，导致在testDelete方法中也会接收到异常，
## 导致testDelete方法中的业务也会被回滚掉

修正后

需要根据业务将嵌套事务单独处理，使得内部事务不影响外部事务

@Service
public class UserServiceImpl {

    @Autowired
    UserMapper userMapper;

    @Transactional
    public void testDelete() {
        userMapper.deleteById(200118);
        try {
            //增加异常处理，只回滚delete方法中的业务，不影响其他的业务
            ((UserServiceImpl) AopContext.currentProxy()).delete();
        } catch (IllegalStateException e) {
        }
    }

    @Transactional(propagation = Propagation.NESTED)
    public void delete() {
        userMapper.deleteById(200119);
        int i = 10 / 0;
    }
}