@

事务传播

• 对于Spring事务传播的七大行为，我们往往还停留在一些概念上，比如下面这张表：

定义	说明
PROPAGATION_REQUIRED	如果当前没有事务，就新建一个事务，如果已经存在一个事务，则加入到这个事务中。这是最常见的选择。
PROPAGATION_SUPPORTS	支持当前事务，如果当前没有事务，就以非事务方式执行。
PROPAGATION_MANDATORY	表示该方法必须在事务中运行，如果当前事务不存在，则会抛出一个异常。
PROPAGATION_REQUIRED_NEW	表示当前方法必须运行在它自己的事务中。一个新的事务将被启动。如果存在当前事务，在该方法执行期间，当前事务会被挂起。
PROPAGATION_NOT_SUPPORTED	表示该方法不应该运行在事务中。如果当前存在事务，就把当前事务挂起。
PROPAGATION_NEVER	表示当前方法不应该运行在事务上下文中。如果当前正有一个事务在运行，则会抛出异常。
PROPAGATION_NESTED	如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与PROPAGATION_REQUIRED类似的操作。

• 本文旨在通过实际案例代码进行分析Spring事务传播行为的各种特性。

案例准备

• 构建一个SpringBoot项目，增加以下代码：

1. 实体类

/**

*  User.java ： 用户类

*/

@Entity

public class User implements Serializable {

    // 用户id

    @Id

    @GeneratedValue(strategy = GenerationType.IDENTITY)

    private Long id;

    // 用户名

    @NotBlank(message = "用户名称不能为空")

    @Column(name="name")

    private String name;

    // 邮箱

    @Column(name="email")

    @Pattern(message ="邮箱格式不符", regexp = "^[A-Za-z0-9\\u4e00-\\u9fa5]+@[a-zA-Z0-9_-]+(\\.[a-zA-Z0-9_-]+)+$")

    private String email;

    public User(){}

    public User(Long id, String name, String email) {

        this.id = id;

        this.name = name;

        this.email = email;

    }

    public Long getId() {

        return id;

    }

    public void setId(Long id) {

        this.id = id;

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public String getEmail() {

        return email;

    }

    public void setEmail(String email) {

        this.email = email;

    }

    @Override

    public String toString() {

        return "User{" +

                "id=" + id +

                ", name='" + name + '\'' +

                ", email='" + email + '\'' +

                ", createTime=" + createTime +

                ", updateTime=" + updateTime +

                '}';

    }

}

1. DAO接口与实现类

/**

 * 用户数据访问层(DAO)接口

 */

public interface UserDAO {

    // 查找所有用户

    List<User> findAll();

    // 根据id查找用户

    User findById(Long id) throws SQLException;

    // 新增用户

    Long addUser(User user) throws SQLException;

    // 更新用户

    void updateUser(User user);

    // 删除用户

    void deleteById(Long id);

    // 自定义添加通过用户名称查找用户信息

    List<User> findByName(String name);

}

/**

 * 使用JdbcTemplate模板类实现用户数据访问层

 *

 */

@Repository

public class UserDAOImpl implements UserDAO {

    @Autowired

    private JdbcTemplate jdbcTemplate;

    @Override

    public List<User> findAll() {

        return jdbcTemplate.query("select id,name,email from user;",

                new Object[]{}, new BeanPropertyRowMapper<>(User.class));

    }

    @Override

    public User findById(Long id) {

        return jdbcTemplate.queryForObject("select id,name,email from user where id=?;",

                new Object[]{id}, new BeanPropertyRowMapper<>(User.class));

    }

    @Override

    public Long addUser(User user) {

        return Integer.toUnsignedLong(

                jdbcTemplate.update("insert into  user(id,name,email) values(?,?,?);"

                        , user.getId(), user.getName(), user.getEmail()));

    }

    @Override

    public void updateUser(User user) {

        jdbcTemplate.update("update user set name=?,email=? where id =?;"

                , user.getName(), user.getEmail(), user.getId());

    }

    @Override

    public void deleteById(Long id) {

        jdbcTemplate.update("delete from user where id=?", new Object[]{id});

    }

    @Override

    public List<User> findByName(String name) {

        return jdbcTemplate.query("select id,name,email from user where name=?;",

                new Object[]{name}, new BeanPropertyRowMapper<>(User.class));

    }

}

1. 测试类

/**

 * 事务传播测试案例

 */

public class TransactionalTest {

    @Autowired

    private UserDAO userDAO;

    // 无事务

    public void noneTransaction() throws SQLException {

        User user1 = new User(100L, "Jack", "Jack@163.com");

        userDAO.addUser(user1);

        // 增加一个与user1主键相同的用户

        User user2 = new User(100L, "Jack", "Jack@163.com");

        userDAO.addUser(user2);

    }

	//....

}

案例解析

1、无事务

• 插入两个id(主键)相同的用户数据。

// 无事务

    public void noneTransaction() throws SQLException {

        User user1 = new User(100L, "Jack", "Jack@163.com");

        userDAO.addUser(user1);

        // 增加一个与user1主键相同的用户

        User user2 = new User(100L, "Jack", "Jack@163.com");

        userDAO.addUser(user2);

    }

• 插入第一条数据成功，第二条数据失败
• 由于没有事务控制，数据库表中会存在一条数据：
  
  

2、 Propagation.REQUIRED

• 这个是默认的事务传播行为：如果当前没有事务，就新建一个事务，如果已经存在一个事务，则加入到这个事务中。
• 仍然插入两个id(主键)相同的用户数据。

    // 事务传播为PROPAGATION_REQUIRED

    @Transactional(propagation = Propagation.REQUIRED)

    public void requiredTransaction() throws SQLException {

        User user1 = new User(100L, "Jack", "Jack@163.com");

        userDAO.addUser(user1);

        // 增加一个与user1主键相同的用户

        User user2 = new User(100L, "Jack", "Jack@163.com");

        userDAO.addUser(user2);

    }

• 第二条数据插入时报重复主键错误
  
  
• 由于启用了事务，提示事务回滚，表中没有插入任何数据
  
  

3. Propagation.SUPPORTS

• 支持当前事务，如果当前没有事务，就以非事务方式执行。这里我们做两个测试，首先以原来的代码，即调用外层没有启用事务来运行：

    // 事务传播为PROPAGATION_SUPPORTS

    // 调用的外层没有事务

    @Transactional(propagation = Propagation.SUPPORTS)

    public void supportsTransaction() throws SQLException {

        User user1 = new User(100L, "Jack", "Jack@163.com");

        userDAO.addUser(user1);

        // 增加一个与user1主键相同的用户

        User user2 = new User(100L, "Jack", "Jack@163.com");

        userDAO.addUser(user2);

    }

• 第一条插入成功，插入第二条事务时报主键重复错误，由于调用方外层启用事务，表中存留第一条数据。
  
  
  
  
• 接下来修改代码，用一个已启事务的调用方来调用该测试过程：

    // 事务传播为PROPAGATION_SUPPORTS

    // 调用方已启用事务

    @Transactional

    public void callSupportsTransaction() throws SQLException {

        supportsTransaction();

    }

	@Transactional(propagation = Propagation.SUPPORTS)

    public void supportsTransaction() throws SQLException {

        User user1 = new User(100L, "Jack", "Jack@163.com");

        userDAO.addUser(user1);

        // 增加一个与user1主键相同的用户

        User user2 = new User(100L, "Jack", "Jack@163.com");

        userDAO.addUser(user2);

    }

• 第一条插入成功，插入第二条事务时报主键重复错误，但由于这次调用方已启用了事务，表中没有插入任何数据。
  
  
  
  

4. Propagation.MANDATORY

• 表示该方法必须在事务中运行，如果当前事务不存在，则会抛出一个异常。
• 我们首先直接运行以下代码

    // 事务传播为PROPAGATION_MANDATORY

    @Transactional(propagation = Propagation.MANDATORY)

    public void mandatoryTransaction() throws SQLException {

        User user1 = new User(100L, "Jack", "Jack@163.com");

        userDAO.addUser(user1);

    }

• 由于调用外层没有启用事务，该段测试代码判断当前事务不存在，则会抛出不存在事务的错误
  
  
• 接下来使用调用方的外层启用事务，再调用这段测试代码:

// 事务传播为PROPAGATION_MANDATORY

    // 调用方启用事务

    @Transactional

    public void callMandatoryTransaction() throws SQLException {

        User user = new User(100L, "Jack", "Jack@163.com");

        userDAO.addUser(user);

        mandatoryTransaction();

    }

	 @Transactional(propagation = Propagation.MANDATORY)

    public void mandatoryTransaction() throws SQLException {

        User user1 = new User(100L, "Jack", "Jack@163.com");

        userDAO.addUser(user1);

    }

• 测试程序在插入第二条数据时报主键错误
  
  
• 由于调用方启用事务，事务回滚，没有插入任何数据。
  
  

5. Propagation.REQUIRED_NEW

• 表示当前方法必须运行在它自己的事务中。一个新的事务将被启动。如果存在当前事务，在该方法执行期间，当前事务会被挂起。

• 针对这种特性，我们做一个有趣的实验：调用方启用默认事务，并调用事务传播为PROPAGATION_REQUIRES_NEW的程序，并故意造成事务回滚。

// 调用方启用默认事务，并调用事务传播为PROPAGATION_REQUIRES_NEW的程序，在外层故意造成事务回滚

    @Transactional

    public void callRequiresNewTransaction() throws SQLException {

        User user1 = new User(100L, "Jack", "Jack@163.com");

        userDAO.addUser(user1);

        requiresNewTransaction();

        // 增加一个主键重复的用户，故意造成事务回滚

        User user2 = new User(100L, "Jack", "Jack@163.com");

        userDAO.addUser(user2);

    }

    // 事务传播为PROPAGATION_REQUIRES_NEW

    @Transactional(propagation=Propagation.REQUIRES_NEW)

    public void requiresNewTransaction() throws SQLException {

        User user = new User(101L, "Jack", "Jack@163.com");

        userDAO.addUser(user);

    }

• 测试情况如下：在外层事务造成回滚后，表中没有插入任何数据。
  
  
  
  
• 接下来再改下程序，调用方启用默认事务，并调用事务传播为PROPAGATION_REQUIRES_NEW的程序，但在调用的程序内层故意造成事务回滚。

  // 调用方启用默认事务，并调用事务传播为PROPAGATION_REQUIRES_NEW的程序

    @Transactional

    public void callRequiresNewTransaction() throws SQLException {

        User user1 = new User(100L, "Jack", "Jack@163.com");

        userDAO.addUser(user1);

        // 调用事务传播为PROPAGATION_REQUIRES_NEW的过程

        requiresNewTransaction();

        User user2 = new User(101L, "Rose", "Rose@163.com");

        userDAO.addUser(user2);

    }

    // 事务传播为PROPAGATION_REQUIRES_NEW

    // 内层错误造成事务回滚

    @Transactional(propagation = Propagation.REQUIRES_NEW)

    public void requiresNewTransaction(){

        // 增加一个主键重复的用户，故意造成事务回滚

        User user2 = new User(100L, "Jack", "Jack@163.com");

        userDAO.addUser(user2);

    }

• 同样会造成事务回滚，表中无任何数据插入
  
  
  
  

6. Propagation.NOT_SUPPORTED

• 该方法不应该运行在事务中。如果当前存在事务，就把当前事务挂起。
• 为了测试该特性，我们首先定义另外一个测试服务类，该服务类中定义了事务传播为Propagation.NOT_SUPPORTED的方法

/**

 * 测试 Propagation.NOT_SUPPORTED

 */

@Service

public class UserServiceTest {

    @Autowired

    private UserDAOImpl userDAO;

    // 事务传播为Propagation.NOT_SUPPORTED

    @Transactional(propagation = Propagation.NOT_SUPPORTED)

    public void notSupportedTransaction(){

        User user2 = new User(101L, "Rose", "Rose@163.com");

        userDAO.addUser(user2);

    }

}

• 在主测试类启用默认事务，并调用新增服务类中的事务传播为Propagation.NOT_SUPPORTED的方法，并且故意增加重复用户数据，造成主服务的事务回滚：

 // 主测试类启用默认事务，并调用Propagation.NOT_SUPPORTED的方法

    @Transactional

    public void callNotSupportedTransaction() {

        User user1 = new User(100L, "Jack", "Jack@163.com");

        userDAO.addUser(user1);

        // 调用事务传播为Propagation.NOT_SUPPORTED的过程

        userServiceTest.notSupportedTransaction();

        // 增加重复用户数据

        User user2 = new User(100L, "Jack", "Jack@163.com");

        userDAO.addUser(user2);

    }

• 由于主服务类中启用了事务，在插入第二条重复用户数据时，会报主键冲突，造成事务回滚，两条数据都没有插入；但新增的服务类的方法没有运行在事务中，新增的用户数据会插入表中。
  
  
  
  

7. Propagation.NEVER

• 表示当前方法不应该运行在事务上下文中。如果当前正有一个事务在运行，则会抛出异常。
• 按测试Propagation.NOT_SUPPORTED进行改造，主服务类启用默认事务特性，并调用测试服务类Propagation.NEVER的过程

// 调用方启用默认事务，并调用Propagation.NEVER的过程

    // 调用方启用默认事务，并调用Propagation.NEVER的过程

    @Transactional

    public void callNeverTransaction  {

        User user1 = new User(100L, "Jack", "Jack@163.com");

        userDAO.addUser(user1);

        // 调用事务传播为Propagation.NEVER的过程

        userServiceTest.neverTransaction();

    }

// 事务传播为Propagation.NEVER的过程

    @Transactional(propagation = Propagation.NEVER)

    public void neverTransaction() {

        User user2 = new User(101L, "Rose", "Rose@163.com");

        userDAO.addUser(user2);

    }

• 由于主服务类启用了事务，而测试服务类的Propagation.NEVER不允许运行在事务中，会抛出异常。
  
  

8. Propagation.NESTED

• 如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与PROPAGATION_REQUIRED类似的操作。
• 测试案例如下：主服务类不起任何事务，调用测试服务类Propagation.NESTED 的方法，且该方法中故意制造主键冲突的重复数据

// 调用方不起事务，并调用Propagation.NESTED的过程

    public void callNestedTransaction(User user)  {

        User user1 = new User(100L, "Jack", "Jack@163.com");

        userDAO.addUser(user1);

        // 调用事务传播为Propagation.NEVER的过程

        userServiceTest.nestedTransaction();

    }

// 事务传播为Propagation.NESTED

    @Transactional(propagation = Propagation.NESTED)

    public void nestedTransaction() {

        User user2 = new User(101L, "Rose", "Rose@163.com");

        userDAO.addUser(user2);

        // 插入重复数据，造成主键冲突

        User user3 = new User(101L, "Rose", "Rose@163.com");

        userDAO.addUser(user3);

    }

• 由于主服务类没有启用事务，则第一条数据会插入表中，但测试服务类启用了Propagation.NESTED特性的事务，也即相当于默认事务行为，主键冲突抛出异常后，造成事务回滚，后面增加的两条数据都没有插入表。
  
  
  
  

注意点

• 需要嵌套测试事务传播特性时应建立两个服务类，尽量不要在同一服务类中调用。

最新文章

1. gem安装cocoapods
2. yii 常用的多表查询
3. 制作QQ空间的一些想法
4. 7.django之自定义分页记录
5. NYOJ之字符串逆序输出
6. quick Cocos2dx lua 接anysdk
7. Java设计模式——适配器模式
8. 【Android测试】【随笔】搜狗、腾讯技术交流会心得
9. asp.net 安全性相关参考
10. php中检查文件或目录是否存在的代码小结
11. JAVA 对象数组，加载图片实例 分类： Java Game 2014-08-14 16:57 80人阅读 评论(0) 收藏
12. codeforces 652E Pursuit For Artifacts 边双连通分量
13. POJ_3321_APPLE_TREE
14. delphi 保存 和 打开 TREE VIEW的节点已经展开的状态
15. [LeetCode OJ] Reorder List—Given a singly linked list L: L0→L1→…→Ln-1→Ln, reorder it to: L0→Ln→L1→Ln-1→L2→Ln-2→…
16. 无法安装或运行此应用程序。该应用程序要求首先在"全局程序集缓存(GAC)"中安装程序集
17. NPOI导出多张图片到Excel
18. Hotel(线段树合并)
19. Bestcoder Round#45
20. [ZZ]新手学 appium-合集第一季度

热门文章

1. 手把手带你玩转 DialogFragment
2. MySQL数据库---表的操作
3. SQL order by语句
4. ISE和modelsim的配合
5. Redis知识总结
6. Java基础之Bridge method（桥接方法）
7. Monster Audio 使用教程（一）入门教程 + 常见问题
8. 16 . Go之网络编程
9. etcd3.0集群安装
10. PHP array_udiff_assoc() 函数