事务传播行为

Spring 中有7 种类型的事务传播行为。事务传播行为是 Spring 框架提供的一种事务管理方式，它是 Spring 框架之中非常重要的一个技术点，毕竟事务关系到应用程序和数据库的交互，而数据更是互联网行业最为重要的资源。

事务的特性(ACID)

  1. 原子性： 事务是最小的执行单位，不允许分割。事务的原子性确保动作要么全部完成，要么完全不起作用；

  2. 一致性： 执行事务前后，数据保持一致，多个事务对同一个数据读取的结果是相同的；

  3. 隔离性： 一个事务的执行不被其他事务所干扰，各并发事务之间数据库是独立的；

  4. 持久性： 一个事务被提交之后。它对数据库中数据的改变是持久的，即使数据库发生故障也不应该对其有任何影响。

传播行为实战

1.PROPAGATION_REQUIRED

如果当前没有事务，就创建一个新事务，如果当前存在事务，就加入该事务，这是最常见的选择，也是Spring默认的事务传播行为。

场景一

此场景外围方法没有开启事务。

  • 1.验证方法

两个实现类UserServiceImpl和UserRoleServiceImpl制定事物传播行为propagation=Propagation.REQUIRED，然后在测试方法中同时调用两个方法并在调用结束后抛出异常。

  • 2.主要代码

外层调用方法代码：

/**
     * 测试 PROPAGATION_REQUIRED
     *
     * @Author: lj
     */
    @Test
    void test_PROPAGATION_REQUIRED() {
        // 增加用户表
        User user = new User();
        user.setName("Java碎碎念");
        user.setPassword("123456");
        userService.add(user);
        // 增加用户角色表
        UserRole userRole = new UserRole();
        userRole.setUserId(user.getId());
        userRole.setRoleId(200);
        userRoleService.add(userRole);
        //抛异常
        throw new RuntimeException();
    }

UserServiceImpl代码：

/**
     * 增加用户
     */
    @Transactional(propagation = Propagation.REQUIRED)
    @Override
    public int add(User user) {
        return userMapper.add(user);
    }

UserRoleServiceImpl代码：

    /**
     * 增加用户角色
     */
    @Transactional(propagation = Propagation.REQUIRED)
    @Override
    public int add(UserRole userRole) {
        return userRoleMapper.add(userRole);
    }

  • 3.代码执行后数据库

两张表数据都新增成功

  • 4.结果分析

外围方法未开启事务，插入用户表和用户角色表的方法在自己的事务中独立运行，外围方法异常不影响内部插入，所以两条记录都新增成功。

场景二

此场景外围方法开启事务。

  • 1.主要代码

测试方法代码如下：

/**
     * 测试 PROPAGATION_REQUIRED
     *
     * @Author: lj
     */
    @Transactional
    @Test
    void test_PROPAGATION_REQUIRED() {
        // 增加用户表
        User user = new User();
        user.setName("Java碎碎念");
        user.setPassword("123456");
        userService.add(user);
        // 增加用户角色表
        UserRole userRole = new UserRole();
        userRole.setUserId(user.getId());
        userRole.setRoleId(200);
        userRoleService.add(userRole);
        //抛异常
        throw new RuntimeException();
    }

  • 2.代码执行后数据库

两张表数据都为空

  • 3.结果分析

外围方法开启事务，内部方法加入外围方法事务，外围方法回滚，内部方法也要回滚，所以两个记录都插入失败。

结论：以上结果证明在外围方法开启事务的情况下Propagation.REQUIRED修饰的内部方法会加入到外围方法的事务中，所以Propagation.REQUIRED修饰的内部方法和外围方法均属于同一事务，只要一个方法回滚，整个事务均回滚。

2.PROPAGATION_SUPPORTS

支持当前事务，如果当前存在事务，就加入该事务，如果当前不存在事务，就以非事务执行。

场景一

此场景外围方法没有开启事务。

  • 1.验证方法

两个实现类UserServiceImpl和UserRoleServiceImpl制定事物传播行为propagation=Propagation.SUPPORTS，然后在测试方法中同时调用两个方法并在调用结束后抛出异常。

  • 2.主要代码

外层调用方法代码：

    /**
     * 测试 PROPAGATION_SUPPORTS
     *
     * @Author: lj
     */
    @Test
    void test_PROPAGATION_SUPPORTS() {
        // 增加用户表
        User user = new User();
        user.setName("Java碎碎念");
        user.setPassword("123456");
        userService.add(user);
        // 增加用户角色表
        UserRole userRole = new UserRole();
        userRole.setUserId(user.getId());
        userRole.setRoleId(200);
        userRoleService.add(userRole);
        //抛异常
        throw new RuntimeException();
    }

UserServiceImpl代码：

/**
     * 增加用户
     */
    @Transactional(propagation = Propagation.SUPPORTS)
    @Override
    public int add(User user) {
        return userMapper.add(user);
    }

UserRoleServiceImpl代码：

    /**
     * 增加用户角色
     */
    @Transactional(propagation = Propagation.SUPPORTS)
    @Override
    public int add(UserRole userRole) {
        return userRoleMapper.add(userRole);
    }

  • 3.代码执行后数据库

两张表数据都新增成功

  • 4.结果分析

外围方法未开启事务，插入用户表和用户角色表的方法以非事务的方式独立运行，外围方法异常不影响内部插入，所以两条记录都新增成功。

场景二

此场景外围方法开启事务。

  • 1.主要代码

test_PROPAGATION_SUPPORTS方法添加注解@Transactional即可。

  • 2.代码执行后数据库

两张表数据都为空

  • 3.结果分析

外围方法开启事务，内部方法加入外围方法事务，外围方法回滚，内部方法也要回滚，所以两个记录都插入失败。

结论：以上结果证明在外围方法开启事务的情况下Propagation.SUPPORTS修饰的内部方法会加入到外围方法的事务中，所以Propagation.SUPPORTS修饰的内部方法和外围方法均属于同一事务，只要一个方法回滚，整个事务均回滚。

3.PROPAGATION_MANDATORY

支持当前事务，如果当前存在事务，就加入该事务，如果当前不存在事务，就抛出异常。

通过上面的测试，“支持当前事务，如果当前存在事务，就加入该事务”，这句话已经验证了，外层添加@Transactional注解后两条记录都新增失败，所以这个传播行为只测试下外层没有开始事务的场景。

场景一

此场景外围方法没有开启事务。

  • 1.验证方法

两个实现类UserServiceImpl和UserRoleServiceImpl制定事物传播行为propagation = Propagation.MANDATORY，主要代码如下。

  • 2.主要代码

外层调用方法代码：

    /**
     * 测试 PROPAGATION_MANDATORY
     *
     * @Author: lj
     */
    @Test
    void test_PROPAGATION_MANDATORY() {
        // 增加用户表
        User user = new User();
        user.setName("Java碎碎念");
        user.setPassword("123456");
        userService.add(user);
        // 增加用户角色表
        UserRole userRole = new UserRole();
        userRole.setUserId(user.getId());
        userRole.setRoleId(200);
        userRoleService.add(userRole);
        //抛异常
        throw new RuntimeException();
    }

UserServiceImpl代码：

/**
     * 增加用户
     */
    @Transactional(propagation = Propagation.MANDATORY)
    @Override
    public int add(User user) {
        return userMapper.add(user);
    }

UserRoleServiceImpl代码：

    /**
     * 增加用户角色
     */
    @Transactional(propagation = Propagation.MANDATORY)
    @Override
    public int add(UserRole userRole) {
        return userRoleMapper.add(userRole);
    }

  • 3.代码执行后数据库

两张表数据都为空

  • 4.结果分析

运行日志如下，可以发现在调用userService.add()时候已经报错了，所以两个表都没有新增数据，验证了“如果当前不存在事务，就抛出异常”。

at com.example.springboot.mybatisannotation.service.impl.UserServiceImpl$$EnhancerBySpringCGLIB$$50090f18.add(<generated>)
    at com.example.springboot.mybatisannotation.SpringBootMybatisAnnotationApplicationTests.test_PROPAGATION_MANDATORY(SpringBootMybatisAnnotationApplicationTests.java:78)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:498)

4.PROPAGATION_REQUIRES_NEW

创建新事务，无论当前存不存在事务，都创建新事务。

这种情况每次都创建事务，所以我们验证一种情况即可。

场景一

此场景外围方法开启事务。

  • 1.验证方法

两个实现类UserServiceImpl和UserRoleServiceImpl制定事物传播行为propagation = Propagation.REQUIRES_NEW，主要代码如下。

  • 2.主要代码

外层调用方法代码：

    /**
     * 测试 REQUIRES_NEW
     *
     * @Author: lj
     */
    @Test
    @Transactional
    void test_REQUIRES_NEW() {
        // 增加用户表
        User user = new User();
        user.setName("Java碎碎念");
        user.setPassword("123456");
        userService.add(user);
        // 增加用户角色表
        UserRole userRole = new UserRole();
        userRole.setUserId(user.getId());
        userRole.setRoleId(200);
        userRoleService.add(userRole);
        //抛异常
        throw new RuntimeException();
    }

UserServiceImpl代码：

/**
     * 增加用户
     */
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    @Override
    public int add(User user) {
        return userMapper.add(user);
    }

UserRoleServiceImpl代码：

    /**
     * 增加用户角色
     */
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    @Override
    public int add(UserRole userRole) {
        return userRoleMapper.add(userRole);
    }

  • 3.代码执行后数据库截图

两张表数据都新增成功

  • 4.结果分析

无论当前存不存在事务，都创建新事务，所以两个数据新增成功。

5.PROPAGATION_NOT_SUPPORTED

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

场景一

此场景外围方法不开启事务。

  • 1.验证方法

两个实现类UserServiceImpl和UserRoleServiceImpl制定事物传播行为propagation = Propagation.NOT_SUPPORTED，主要代码如下。

  • 2.主要代码

外层调用方法代码：

    /**
     * 测试 PROPAGATION_NOT_SUPPORTED
     *
     * @Author: lj
     */
    @Test
    void test_PROPAGATION_NOT_SUPPORTED() {
        // 增加用户表
        User user = new User();
        user.setName("Java碎碎念");
        user.setPassword("123456");
        userService.add(user);
        // 增加用户角色表
        UserRole userRole = new UserRole();
        userRole.setUserId(user.getId());
        userRole.setRoleId(200);
        userRoleService.add(userRole);
        //抛异常
        throw new RuntimeException();
    }

UserServiceImpl代码：

/**
     * 增加用户
     */
    @Transactional(propagation = Propagation.NOT_SUPPORTED)
    @Override
    public int add(User user) {
        return userMapper.add(user);
    }

UserRoleServiceImpl代码：

    /**
     * 增加用户角色
     */
    @Transactional(propagation = Propagation.NOT_SUPPORTED)
    @Override
    public int add(UserRole userRole) {
        return userRoleMapper.add(userRole);
    }

  • 3.代码执行后数据库

两张表数据都新增成功，截图如下：

  • 4.结果分析

以非事务方式执行，所以两个数据新增成功。

场景二

此场景外围方法开启事务。

  • 1.主要代码

test_PROPAGATION_NOT_SUPPORTED方法添加注解@Transactional即可。

  • 2.代码执行后数据库

两张表数据都新增成功

  • 3.结果分析

如果当前存在事务，就把当前事务挂起，相当于以非事务方式执行，所以两个数据新增成功。

6.PROPAGATION_NEVER测试

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

上面已经有类似情况，外层没有事务会以非事务的方式运行，两个表新增成功；有事务则抛出异常，两个表都都没有新增数据。

7.PROPAGATION_NESTED测试

如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则按REQUIRED属性执行。

上面已经有类似情况，外层没有事务会以REQUIRED属性的方式运行，两个表新增成功；有事务但是用的是一个事务，方法最后抛出了异常导致回滚，两个表都都没有新增数据。