spring-transaction源码分析(1)概述和事务传播级别

spring-tx概述

spring-tx包使用注解驱动和AOP通知将事务开启、提交/回滚、以及复杂的传播机制封装了起来，开发者不再需要编写事务管理的代码，而是可以只关注自己的业务逻辑。
本文将简单介绍spring-tx使用步骤以及七种事务传播级别。
后续文章会阅读源码，深入分析spring-tx aop通知、七种事务传播级别以及事务开启/提交/回滚的实现方式。
使用步骤

• 导入spring-tx依赖
  
• 使用@EnableTransactionManagement注解为应用开启事务支持
  
• 向spring容器注入一个TransactionManager实现，一般使用DataSourceTransactionManager类
  
• 在需要事务的业务方法上标注@Transactional注解即可为方法开启事务通知
  

Transactional注解参数

• transactionManager - 手动指定要使用的事务管理器
  
• propagation - 事务传播级别
  
• isolation - 事务隔离级别
  
• timeout - 事务超时时长
  
• rollbackFor - 发生指定的异常时回滚事务
  

事务传播级别

七种级别

• REQUIRED - Support a current transaction, create a new one if none exists. 支持当前存在的事务，如果当前没有事务，则新创建一个。默认的传播级别。
  
• SUPPORTS - Support a current transaction, execute non-transactionally if none exists. 支持当前存在的事务，如果当前没有事务，则在无事务状态下运行。
  1. For transaction managers with transaction synchronization, SUPPORTS is slightly different from
  2. no transaction at all, as it defines a transaction scope that synchronization will apply for.
  3. As a consequence, the same resources (JDBC Connection, Hibernate Session, etc) will be shared
  4. for the entire specified scope. Note that this depends on the actual synchronization configuration
  5. of the transaction manager.

  复制代码
• MANDATORY - Support a current transaction, throw an exception if none exists. 支持当前存在的事务，如果当前没有事务，则抛出异常。
  
• REQUIRES_NEW - Create a new transaction, and suspend the current transaction if one exists. 创建新事务，如果当前已存在事务则挂起这个事务，再创建新事务。
  
• NOT_SUPPORTED - Execute non-transactionally, suspend the current transaction if one exists. 在无事务状态下运行，如果当前已存在事务则挂起这个事务。
  
• NEVER - Execute non-transactionally, throw an exception if a transaction exists. 在无事务状态下运行，如果当前已存在事务，则抛出异常。
  
• NESTED - Execute within a nested transaction if a current transaction exists, behave like REQUIRED otherwise. 如果当前已存在事务，则嵌入到当前事务中运行，否则和REQUIRED效果一样。
  

示例方法

在测试事务传播级别的示例中，会反复使用以下6个方法，只是给Transactional添加的参数不同而已，此处记录一下这几个方法：

1. public void insertBlogList(List<Blog> blogList) {
2.   for (int i = 0; i < blogList.size(); i++) {
3.     this.blogMapper.insertBlog(blogList.get(i));
4.   }
5. }
7. public void deleteBlogByCondition(BlogSearchParameter parameter) {
8.   List<Blog> blogs = this.blogMapper.selectBlogByParameter(parameter);
9.   for (Blog blog : blogs) {
10.     this.blogMapper.deleteBlog(blog.getId());
11.   }
12.   // 抛出一个RuntimeException
13.   throw new RuntimeException("deleteBlogByCondition抛出一个异常");
14. }
16. public void insertAndDeleteBlogList1(List<Blog> blogList, BlogSearchParameter parameter) {
18.   // 这里从spring容器获取service对象，避免事务失效
19.   BlogRequiredTxService blogService =
20.       this.applicationContext.getBean(BlogRequiredTxService.class);
22.   // 插入数据
23.   blogService.insertBlogList(blogList);
25.   // 删除数据
26.   blogService.deleteBlogByCondition(parameter);
27. }
29. public void insertAndDeleteBlogList2(List<Blog> blogList, BlogSearchParameter parameter) {
31.   BlogRequiredTxService blogService =
32.       this.applicationContext.getBean(BlogRequiredTxService.class);
34.   // 插入数据
35.   blogService.insertBlogList(blogList);
37.   // 删除数据
38.   try {
39.     blogService.deleteBlogByCondition(parameter);
40.   } catch (Exception e) {
41.     System.err.printf("Err:%s%n", e.getMessage());
42.   }
44.   System.out.println("继续插入数据");
46.   // 继续插入数据
47.   blogService.insertBlogList(blogList);
48. }
50. public void insertAndDeleteBlogList3(List<Blog> blogList, BlogSearchParameter parameter) {
52.   BlogRequiredTxService blogService =
53.       this.applicationContext.getBean(BlogRequiredTxService.class);
55.   // 插入数据
56.   blogService.insertBlogList(blogList);
58.   // 删除数据
59.   blogService.deleteBlogByCondition(parameter);
60. }
62. public void insertAndDeleteBlogList4(List<Blog> blogList, BlogSearchParameter parameter) {
64.   BlogRequiredTxService blogService =
65.       this.applicationContext.getBean(BlogRequiredTxService.class);
67.   // 插入数据
68.   blogService.insertBlogList(blogList);
70.   // 删除数据
71.   try {
72.     blogService.deleteBlogByCondition(parameter);
73.   } catch (Exception e) {
74.     System.err.printf("Err:%s%n", e.getMessage());
75.   }
77.   System.out.println("继续插入数据");
79.   // 继续插入数据
80.   blogService.insertBlogList(blogList);
81. }

复制代码

传播级别详细说明

REQUIRED

Support a current transaction, create a new one if none exists.
支持当前存在的事务，如果当前没有事务，则新创建一个。默认的传播级别。

1. @Transactional(propagation = Propagation.REQUIRED)
2. public void insertBlogList(List<Blog> blogList) {
3.   for (int i = 0; i < blogList.size(); i++) {
4.     this.blogMapper.insertBlog(blogList.get(i));
5.   }
6. }
8. @Transactional(propagation = Propagation.REQUIRED)
9. public void deleteBlogByCondition(BlogSearchParameter parameter) {
10.   List<Blog> blogs = this.blogMapper.selectBlogByParameter(parameter);
11.   for (Blog blog : blogs) {
12.     this.blogMapper.deleteBlog(blog.getId());
13.   }
14.   // 抛出一个RuntimeException
15.   throw new RuntimeException("deleteBlogByCondition抛出一个异常");
17.   // 如果调用方法前，没有事务，则delete操作都会回滚
18.   // 如果调用方法前，已经存在事务，则之前的事务操作都会回滚
19. }
21. @Transactional(propagation = Propagation.REQUIRED)
22. public void insertAndDeleteBlogList1(List<Blog> blogList, BlogSearchParameter parameter) {
24.   BlogRequiredTxService blogService =
25.       this.applicationContext.getBean(BlogRequiredTxService.class);
27.   // 插入数据
28.   blogService.insertBlogList(blogList);
30.   // 删除数据
31.   blogService.deleteBlogByCondition(parameter);
33.   // deleteBlogByCondition方法抛出异常之后，则insertAndDeleteBlogList1方法的操作会回滚
34.   // 如果insertAndDeleteBlogList1方法在另一个事务中，则之前的事务操作都会回滚
35. }
37. @Transactional(propagation = Propagation.REQUIRED)
38. public void insertAndDeleteBlogList2(List<Blog> blogList, BlogSearchParameter parameter) {
40.   BlogRequiredTxService blogService =
41.       this.applicationContext.getBean(BlogRequiredTxService.class);
43.   // 插入数据
44.   blogService.insertBlogList(blogList);
46.   // 删除数据
47.   try {
48.     blogService.deleteBlogByCondition(parameter);
49.   } catch (Exception e) {
50.     System.err.printf("Err:%s%n", e.getMessage());
51.   }
53.   System.out.println("继续插入数据");
55.   // 继续插入数据
56.   blogService.insertBlogList(blogList);
58.   // deleteBlogByCondition方法抛出异常之后，会执行catch代码块，之后继续向下执行，
59.   // 执行blogService.insertBlogList(blogList)方法之后，
60.   // 在commit的时候检测到insertAndDeleteBlogList2方法rollback-only状态，会抛出异常:
61.   // org.springframework.transaction.UnexpectedRollbackException:
62.   // Transaction rolled back because it has been marked as rollback-only
63. }
65. public void insertAndDeleteBlogList3(List<Blog> blogList, BlogSearchParameter parameter) {
67.   BlogRequiredTxService blogService =
68.       this.applicationContext.getBean(BlogRequiredTxService.class);
70.   // 插入数据
71.   blogService.insertBlogList(blogList);
73.   // 删除数据
74.   blogService.deleteBlogByCondition(parameter);
76.   // 由于insertAndDeleteBlogList3方法没有标注Transactional注解:
77.   // blogService.insertBlogList(blogList)方法插入的数据会提交保存下来
78.   // blogService.deleteBlogByCondition(parameter)方法的删除操作会回滚
79. }
81. public void insertAndDeleteBlogList4(List<Blog> blogList, BlogSearchParameter parameter) {
83.   BlogRequiredTxService blogService =
84.       this.applicationContext.getBean(BlogRequiredTxService.class);
86.   // 插入数据
87.   blogService.insertBlogList(blogList);
89.   // 删除数据
90.   try {
91.     blogService.deleteBlogByCondition(parameter);
92.   } catch (Exception e) {
93.     System.err.printf("Err:%s%n", e.getMessage());
94.   }
96.   System.out.println("继续插入数据");
98.   // 继续插入数据
99.   blogService.insertBlogList(blogList);
101.   // 由于insertAndDeleteBlogList3方法没有标注Transactional注解:
102.   // blogService.insertBlogList(blogList)方法插入的数据会提交保存下来
103.   // blogService.deleteBlogByCondition(parameter)方法的删除操作会回滚
104.   // 之后会继续执行blogService.insertBlogList(blogList)再插入数据
105. }

复制代码

REQUIRES_NEW

Create a new transaction, and suspend the current transaction if one exists.
创建新事务，如果当前已存在事务则挂起这个事务，再打开一个新的数据库连接创建新事务。

1. @Transactional(propagation = Propagation.REQUIRES_NEW)
2. public void insertBlogList(List<Blog> blogList) {
3.   for (Blog blog : blogList) {
4.     this.blogMapper.insertBlog(blog);
5.   }
6.   try {
7.     TimeUnit.SECONDS.sleep(15);
8.   } catch (InterruptedException e) {
9.     e.printStackTrace();
10.   }
11. }
13. @Transactional(propagation = Propagation.REQUIRES_NEW)
14. public void deleteBlogByCondition(BlogSearchParameter parameter) {
15.   List<Blog> blogs = this.blogMapper.selectBlogByParameter(parameter);
16.   for (Blog blog : blogs) {
17.     this.blogMapper.deleteBlog(blog.getId());
18.   }
19.   // 抛出一个RuntimeException
20.   throw new RuntimeException("deleteBlogByCondition抛出一个异常");
22.   // 只会回滚delete操作，因为该方法是新创建的事务
23. }
25. @Transactional
26. public void insertAndDeleteBlogList1(List<Blog> blogList, BlogSearchParameter parameter) {
28.   BlogRequiresNewTxService blogService =
29.       this.applicationContext.getBean(BlogRequiresNewTxService.class);
31.   // 插入数据
32.   blogService.insertBlogList(blogList);
34.   // 删除数据
35.   blogService.deleteBlogByCondition(parameter);
37.   // blogService.insertBlogList(blogList)成功
38.   // blogService.deleteBlogByCondition(parameter)会回滚
39.   // 同时insertAndDeleteBlogList1中的事务也会回滚
41.   // 如果使用show processlist查看客户端进程，
42.   // 可以看到insertBlogList和deleteBlogByCondition方法创建了新的数据库连接
43. }
45. @Transactional
46. public void insertAndDeleteBlogList2(List<Blog> blogList, BlogSearchParameter parameter) {
48.   BlogRequiresNewTxService blogService =
49.       this.applicationContext.getBean(BlogRequiresNewTxService.class);
51.   // 插入数据
52.   blogService.insertBlogList(blogList);
54.   // 删除数据
55.   try {
56.     blogService.deleteBlogByCondition(parameter);
57.   } catch (Exception e) {
58.     System.err.printf("Err:%s%n", e.getMessage());
59.   }
61.   System.out.println("继续插入数据");
63.   // 继续插入数据
64.   blogService.insertBlogList(blogList);
66.   // blogService.insertBlogList(blogList)成功
67.   // blogService.deleteBlogByCondition(parameter)会回滚
68.   // 此时insertAndDeleteBlogList1中的事务不会回滚，因为deleteBlogByCondition(parameter)的异常被"吞掉了"
69.   // 后续的blogService.insertBlogList(blogList)也会成功
70. }
72. public void insertAndDeleteBlogList3(List<Blog> blogList, BlogSearchParameter parameter) {
74.   BlogRequiresNewTxService blogService =
75.       this.applicationContext.getBean(BlogRequiresNewTxService.class);
77.   // 插入数据
78.   blogService.insertBlogList(blogList);
80.   // 删除数据
81.   blogService.deleteBlogByCondition(parameter);
83.   // blogService.insertBlogList(blogList)成功
84.   // blogService.deleteBlogByCondition(parameter)会回滚
85. }
87. public void insertAndDeleteBlogList4(List<Blog> blogList, BlogSearchParameter parameter) {
89.   BlogRequiresNewTxService blogService =
90.       this.applicationContext.getBean(BlogRequiresNewTxService.class);
92.   // 插入数据
93.   blogService.insertBlogList(blogList);
95.   // 删除数据
96.   try {
97.     blogService.deleteBlogByCondition(parameter);
98.   } catch (Exception e) {
99.     System.err.printf("Err:%s%n", e.getMessage());
100.   }
102.   System.out.println("继续插入数据");
104.   // 继续插入数据
105.   blogService.insertBlogList(blogList);
107.   // blogService.insertBlogList(blogList)成功
108.   // blogService.deleteBlogByCondition(parameter)会回滚
109.   // 后续的blogService.insertBlogList(blogList)也会成功
110. }

复制代码

MANDATORY

Support a current transaction, throw an exception if none exists.
支持当前存在的事务，如果当前没有事务，则抛出异常。

1. @Transactional(propagation = Propagation.MANDATORY)
2. public void insertBlogList(List<Blog> blogList) {
3.   for (Blog blog : blogList) {
4.     this.blogMapper.insertBlog(blog);
5.   }
7.   // 单独调用此方法时抛错:
8.   // org.springframework.transaction.IllegalTransactionStateException:
9.   // No existing transaction found for transaction marked with propagation 'mandatory'
10. }
12. @Transactional(propagation = Propagation.MANDATORY)
13. public void deleteBlogByCondition(BlogSearchParameter parameter) {
14.   List<Blog> blogs = this.blogMapper.selectBlogByParameter(parameter);
15.   for (Blog blog : blogs) {
16.     this.blogMapper.deleteBlog(blog.getId());
17.   }
18.   // 抛出一个RuntimeException
19.   throw new RuntimeException("deleteBlogByCondition抛出一个异常");
21.   // 单独调用此方法时抛错:
22.   // org.springframework.transaction.IllegalTransactionStateException:
23.   // No existing transaction found for transaction marked with propagation 'mandatory'
24. }
26. @Transactional
27. public void insertAndDeleteBlogList1(List<Blog> blogList, BlogSearchParameter parameter) {
29.   BlogMandatoryTxService blogService =
30.       this.applicationContext.getBean(BlogMandatoryTxService.class);
32.   // 插入数据
33.   blogService.insertBlogList(blogList);
35.   // 删除数据
36.   blogService.deleteBlogByCondition(parameter);
38.   // deleteBlogByCondition方法抛出异常之后，则insertAndDeleteBlogList1方法的操作会回滚
39.   // 如果insertAndDeleteBlogList1方法在另一个事务中，则之前的事务操作都会回滚
40. }
42. @Transactional
43. public void insertAndDeleteBlogList2(List<Blog> blogList, BlogSearchParameter parameter) {
45.   BlogMandatoryTxService blogService =
46.       this.applicationContext.getBean(BlogMandatoryTxService.class);
48.   // 插入数据
49.   blogService.insertBlogList(blogList);
51.   // 删除数据
52.   try {
53.     blogService.deleteBlogByCondition(parameter);
54.   } catch (Exception e) {
55.     System.err.printf("Err:%s%n", e.getMessage());
56.   }
58.   System.out.println("继续插入数据");
60.   // 继续插入数据
61.   blogService.insertBlogList(blogList);
63.   // deleteBlogByCondition方法抛出异常之后，会执行catch代码块，之后继续向下执行，
64.   // 执行blogService.insertBlogList(blogList)方法之后，
65.   // 在commit的时候检测到insertAndDeleteBlogList2方法rollback-only状态，会抛出异常:
66.   // org.springframework.transaction.UnexpectedRollbackException:
67.   // Transaction rolled back because it has been marked as rollback-only
68. }
70. public void insertAndDeleteBlogList3(List<Blog> blogList, BlogSearchParameter parameter) {
72.   BlogMandatoryTxService blogService =
73.       this.applicationContext.getBean(BlogMandatoryTxService.class);
75.   // 插入数据
76.   blogService.insertBlogList(blogList);
78.   // 删除数据
79.   blogService.deleteBlogByCondition(parameter);
81.   // 抛错:
82.   // org.springframework.transaction.IllegalTransactionStateException:
83.   // No existing transaction found for transaction marked with propagation 'mandatory'
84. }
86. public void insertAndDeleteBlogList4(List<Blog> blogList, BlogSearchParameter parameter) {
88.   BlogMandatoryTxService blogService =
89.       this.applicationContext.getBean(BlogMandatoryTxService.class);
91.   // 插入数据
92.   blogService.insertBlogList(blogList);
94.   // 删除数据
95.   try {
96.     blogService.deleteBlogByCondition(parameter);
97.   } catch (Exception e) {
98.     System.err.printf("Err:%s%n", e.getMessage());
99.   }
101.   System.out.println("继续插入数据");
103.   // 继续插入数据
104.   blogService.insertBlogList(blogList);
106.   // 抛错:
107.   // org.springframework.transaction.IllegalTransactionStateException:
108.   // No existing transaction found for transaction marked with propagation 'mandatory'
109. }

复制代码

SUPPORTS

Support a current transaction, execute non-transactionally if none exists.
支持当前存在的事务，如果当前没有事务，则在无事务状态下运行。

1. @Transactional(propagation = Propagation.SUPPORTS)
2. public void insertBlogList(List<Blog> blogList) {
3.   for (Blog blog : blogList) {
4.     this.blogMapper.insertBlog(blog);
5.   }
6. }
8. @Transactional(propagation = Propagation.SUPPORTS)
9. public void deleteBlogByCondition(BlogSearchParameter parameter) {
10.   List<Blog> blogs = this.blogMapper.selectBlogByParameter(parameter);
11.   for (Blog blog : blogs) {
12.     this.blogMapper.deleteBlog(blog.getId());
13.   }
14.   // 抛出一个RuntimeException
15.   throw new RuntimeException("deleteBlogByCondition抛出一个异常");
17.   // 单独调用时删除操作成功，因为没有事务
18.   // 如果在一个事务中执行该方法，则会回滚
19. }
21. @Transactional
22. public void insertAndDeleteBlogList1(List<Blog> blogList, BlogSearchParameter parameter) {
24.   BlogSupportsTxService blogService =
25.       this.applicationContext.getBean(BlogSupportsTxService.class);
27.   // 插入数据
28.   blogService.insertBlogList(blogList);
30.   // 删除数据
31.   blogService.deleteBlogByCondition(parameter);
33.   // deleteBlogByCondition方法抛出异常之后，则insertAndDeleteBlogList1方法的操作会回滚
34.   // 如果insertAndDeleteBlogList1方法在另一个事务中，则之前的事务操作都会回滚
35. }
37. @Transactional
38. public void insertAndDeleteBlogList2(List<Blog> blogList, BlogSearchParameter parameter) {
40.   BlogSupportsTxService blogService =
41.       this.applicationContext.getBean(BlogSupportsTxService.class);
43.   // 插入数据
44.   blogService.insertBlogList(blogList);
46.   // 删除数据
47.   try {
48.     blogService.deleteBlogByCondition(parameter);
49.   } catch (Exception e) {
50.     System.err.printf("Err:%s%n", e.getMessage());
51.   }
53.   System.out.println("继续插入数据");
55.   // 继续插入数据
56.   blogService.insertBlogList(blogList);
58.   // deleteBlogByCondition方法抛出异常之后，会执行catch代码块，之后继续向下执行，
59.   // 执行blogService.insertBlogList(blogList)方法之后，
60.   // 在commit的时候检测到insertAndDeleteBlogList2方法rollback-only状态，会抛出异常:
61.   // org.springframework.transaction.UnexpectedRollbackException:
62.   // Transaction rolled back because it has been marked as rollback-only
63. }
65. public void insertAndDeleteBlogList3(List<Blog> blogList, BlogSearchParameter parameter) {
67.   BlogSupportsTxService blogService =
68.       this.applicationContext.getBean(BlogSupportsTxService.class);
70.   // 插入数据
71.   blogService.insertBlogList(blogList);
73.   // 删除数据
74.   blogService.deleteBlogByCondition(parameter);
76.   // 由于insertAndDeleteBlogList3方法没有开启事务
77.   // 插入和删除都会成功，但是deleteBlogByCondition(parameter)还是会抛出异常
78. }
80. public void insertAndDeleteBlogList4(List<Blog> blogList, BlogSearchParameter parameter) {
82.   BlogSupportsTxService blogService =
83.       this.applicationContext.getBean(BlogSupportsTxService.class);
85.   // 插入数据
86.   blogService.insertBlogList(blogList);
88.   // 删除数据
89.   try {
90.     blogService.deleteBlogByCondition(parameter);
91.   } catch (Exception e) {
92.     System.err.printf("Err:%s%n", e.getMessage());
93.   }
95.   System.out.println("继续插入数据");
97.   // 继续插入数据
98.   blogService.insertBlogList(blogList);
100.   // 由于insertAndDeleteBlogList4方法没有开启事务
101.   // 插入和删除都会成功
102. }

复制代码

NOT_SUPPORTED

Execute non-transactionally, suspend the current transaction if one exists.
在无事务状态下运行，如果当前已存在事务则挂起这个事务。

1. @Transactional
2. public void insertBlogList(List<Blog> blogList) {
3.   for (Blog blog : blogList) {
4.     this.blogMapper.insertBlog(blog);
5.   }
6. }
8. @Transactional(propagation = Propagation.NOT_SUPPORTED)
9. public void deleteBlogByCondition(BlogSearchParameter parameter) {
10.   List<Blog> blogs = this.blogMapper.selectBlogByParameter(parameter);
11.   for (Blog blog : blogs) {
12.     this.blogMapper.deleteBlog(blog.getId());
13.   }
14.   // 抛出一个RuntimeException
15.   throw new RuntimeException("deleteBlogByCondition抛出一个异常");
17.   // 删除操作始终都会成功，但还是会抛出异常
18. }
20. @Transactional
21. public void insertAndDeleteBlogList1(List<Blog> blogList, BlogSearchParameter parameter) {
23.   BlogNotSupportedTxService blogService =
24.       this.applicationContext.getBean(BlogNotSupportedTxService.class);
26.   // 插入数据
27.   blogService.insertBlogList(blogList);
29.   // 删除数据
30.   blogService.deleteBlogByCondition(parameter);
32.   // blogService.deleteBlogByCondition(parameter)的删除操作成功
33.   // deleteBlogByCondition方法抛出异常之后，则insertAndDeleteBlogList1方法的操作会回滚
34.   // 如果insertAndDeleteBlogList1方法在另一个事务中，则之前的事务操作都会回滚
35. }
37. @Transactional
38. public void insertAndDeleteBlogList2(List<Blog> blogList, BlogSearchParameter parameter) {
40.   BlogNotSupportedTxService blogService =
41.       this.applicationContext.getBean(BlogNotSupportedTxService.class);
43.   // 插入数据
44.   blogService.insertBlogList(blogList);
46.   // 删除数据
47.   try {
48.     blogService.deleteBlogByCondition(parameter);
49.   } catch (Exception e) {
50.     System.err.printf("Err:%s%n", e.getMessage());
51.   }
53.   System.out.println("继续插入数据");
55.   // 继续插入数据
56.   blogService.insertBlogList(blogList);
58.   // 插入数据和删除操作都会成功
59. }
61. public void insertAndDeleteBlogList3(List<Blog> blogList, BlogSearchParameter parameter) {
63.   BlogNotSupportedTxService blogService =
64.       this.applicationContext.getBean(BlogNotSupportedTxService.class);
66.   // 插入数据
67.   blogService.insertBlogList(blogList);
69.   // 删除数据
70.   blogService.deleteBlogByCondition(parameter);
72.   // 插入数据和删除操作都会成功
73.   // 但是会抛出异常
74. }
76. public void insertAndDeleteBlogList4(List<Blog> blogList, BlogSearchParameter parameter) {
78.   BlogNotSupportedTxService blogService =
79.       this.applicationContext.getBean(BlogNotSupportedTxService.class);
81.   // 插入数据
82.   blogService.insertBlogList(blogList);
84.   // 删除数据
85.   try {
86.     blogService.deleteBlogByCondition(parameter);
87.   } catch (Exception e) {
88.     System.err.printf("Err:%s%n", e.getMessage());
89.   }
91.   System.out.println("继续插入数据");
93.   // 继续插入数据
94.   blogService.insertBlogList(blogList);
96.   // 插入数据和删除操作都会成功
97. }

复制代码

NEVER

Execute non-transactionally, throw an exception if a transaction exists.在无事务状态下运行，如果当前已存在事务，则抛出异常。

1. @Transactional
2. public void insertBlogList(List<Blog> blogList) {
3.   for (Blog blog : blogList) {
4.     this.blogMapper.insertBlog(blog);
5.   }
6. }
8. @Transactional(propagation = Propagation.NEVER)
9. public void deleteBlogByCondition(BlogSearchParameter parameter) {
10.   List<Blog> blogs = this.blogMapper.selectBlogByParameter(parameter);
11.   for (Blog blog : blogs) {
12.     this.blogMapper.deleteBlog(blog.getId());
13.   }
14.   // 抛出一个RuntimeException
15.   throw new RuntimeException("deleteBlogByCondition抛出一个异常");
16. }
18. @Transactional
19. public void insertAndDeleteBlogList1(List<Blog> blogList, BlogSearchParameter parameter) {
21.   BlogNeverTxService blogService =
22.       this.applicationContext.getBean(BlogNeverTxService.class);
24.   // 插入数据
25.   blogService.insertBlogList(blogList);
27.   // 删除数据
28.   blogService.deleteBlogByCondition(parameter);
30.   // 插入数据操作回滚
31.   // 因为blogService.deleteBlogByCondition(parameter)检查到存在事务会抛出异常:
32.   // org.springframework.transaction.IllegalTransactionStateException:
33.   // Existing transaction found for transaction marked with propagation 'never'
34. }
36. @Transactional
37. public void insertAndDeleteBlogList2(List<Blog> blogList, BlogSearchParameter parameter) {
39.   BlogNeverTxService blogService =
40.       this.applicationContext.getBean(BlogNeverTxService.class);
42.   // 插入数据
43.   blogService.insertBlogList(blogList);
45.   // 删除数据
46.   try {
47.     blogService.deleteBlogByCondition(parameter);
48.   } catch (Exception e) {
49.     System.err.printf("Err:%s%n", e.getMessage());
50.   }
52.   System.out.println("继续插入数据");
54.   // 继续插入数据
55.   blogService.insertBlogList(blogList);
57.   // 两次插入操作会成功
58.   // 但是删除操作失败，因为blogService.deleteBlogByCondition(parameter)检查到存在事务会抛出异常:
59.   // org.springframework.transaction.IllegalTransactionStateException:
60.   // Existing transaction found for transaction marked with propagation 'never'
61. }
63. public void insertAndDeleteBlogList3(List<Blog> blogList, BlogSearchParameter parameter) {
65.   BlogNeverTxService blogService =
66.       this.applicationContext.getBean(BlogNeverTxService.class);
68.   // 插入数据
69.   blogService.insertBlogList(blogList);
71.   // 删除数据
72.   blogService.deleteBlogByCondition(parameter);
74.   // 插入和删除都成功
75.   // 但是会抛出异常
76. }
78. public void insertAndDeleteBlogList4(List<Blog> blogList, BlogSearchParameter parameter) {
80.   BlogNeverTxService blogService =
81.       this.applicationContext.getBean(BlogNeverTxService.class);
83.   // 插入数据
84.   blogService.insertBlogList(blogList);
86.   // 删除数据
87.   try {
88.     blogService.deleteBlogByCondition(parameter);
89.   } catch (Exception e) {
90.     System.err.printf("Err:%s%n", e.getMessage());
91.   }
93.   System.out.println("继续插入数据");
95.   // 继续插入数据
96.   blogService.insertBlogList(blogList);
98.   // 插入和删除都成功
99. }

复制代码

NESTED

Execute within a nested transaction if a current transaction exists, behave like REQUIRED otherwise.
如果当前已存在事务，则嵌入到当前事务中运行，否则和REQUIRED效果一样。

1. @Transactional(propagation = Propagation.NESTED)
2. public void insertBlogList(List<Blog> blogList) {
3.   for (Blog blog : blogList) {
4.     this.blogMapper.insertBlog(blog);
5.   }
6. }
8. @Transactional(propagation = Propagation.NESTED)
9. public void deleteBlogByCondition(BlogSearchParameter parameter) {
10.   List<Blog> blogs = this.blogMapper.selectBlogByParameter(parameter);
11.   for (Blog blog : blogs) {
12.     this.blogMapper.deleteBlog(blog.getId());
13.   }
14.   // 抛出一个RuntimeException
15.   throw new RuntimeException("deleteBlogByCondition抛出一个异常");
16. }
18. @Transactional
19. public void insertAndDeleteBlogList1(List<Blog> blogList, BlogSearchParameter parameter) {
21.   BlogNestedTxService blogService =
22.       this.applicationContext.getBean(BlogNestedTxService.class);
24.   // 插入数据
25.   blogService.insertBlogList(blogList);
27.   // 删除数据
28.   blogService.deleteBlogByCondition(parameter);
30.   // 所有操作都会回滚
31. }
33. @Transactional
34. public void insertAndDeleteBlogList2(List<Blog> blogList, BlogSearchParameter parameter) {
36.   BlogNestedTxService blogService =
37.       this.applicationContext.getBean(BlogNestedTxService.class);
39.   // 插入数据
40.   blogService.insertBlogList(blogList);
42.   // 删除数据
43.   try {
44.     blogService.deleteBlogByCondition(parameter);
45.   } catch (Exception e) {
46.     System.err.printf("Err:%s%n", e.getMessage());
47.   }
49.   System.out.println("继续插入数据");
51.   // 继续插入数据
52.   blogService.insertBlogList(blogList);
54.   // 前后两次插入操作成功，
55.   // 中间的删除操作因为抛出异常，会回滚，
56.   // 又因为blogService.deleteBlogByCondition(parameter)的异常被try...catch了，
57.   // 没有抛到insertAndDeleteBlogList2中，所以insertAndDeleteBlogList2的操作可以成功提交
58. }
60. public void insertAndDeleteBlogList3(List<Blog> blogList, BlogSearchParameter parameter) {
62.   BlogNestedTxService blogService =
63.       this.applicationContext.getBean(BlogNestedTxService.class);
65.   // 插入数据
66.   blogService.insertBlogList(blogList);
68.   // 删除数据
69.   blogService.deleteBlogByCondition(parameter);
71.   // 插入成功，删除回滚
72. }
74. public void insertAndDeleteBlogList4(List<Blog> blogList, BlogSearchParameter parameter) {
76.   BlogNestedTxService blogService =
77.       this.applicationContext.getBean(BlogNestedTxService.class);
79.   // 插入数据
80.   blogService.insertBlogList(blogList);
82.   // 删除数据
83.   try {
84.     blogService.deleteBlogByCondition(parameter);
85.   } catch (Exception e) {
86.     System.err.printf("Err:%s%n", e.getMessage());
87.   }
89.   System.out.println("继续插入数据");
91.   // 继续插入数据
92.   blogService.insertBlogList(blogList);
94.   // 插入成功，删除回滚
95. }

复制代码

小结

本文通过示例介绍了spring-tx的七种事务传播级别，后续的文章将阅读源码，分析spring-tx的实现方式。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！