功能第四篇——事务之Spring事务（）

Posted 2020-09-21 若浮若沉

综述                                                                                 

事务的实现方式有三种，JTA，Spring事务，Web Container方式。本篇讲述Spring事务。

Spring事务分为两个部分核心对象，Spring事务的实现方式。

      Spring事务实现的方式有三种。声明式，注解式，代码的方式。声明方式在实际项目中运用比较广泛，注解方式需要在每个方法上添加@Transactional注解，代码冗余度比较高。代码方式只是为了更好的理解Spring事务的机制，在实际项目中并不适用。

核心对象                                                                           

PlatformTransactionManager

事务管理接口。

1. Transaction getTransaction(transactionDefinition) :通过事务定义对象获取事务
2. commit(transactionStatus)：提交事务
3. rollback(transactionStatus)：回滚事务。

TransactionDefinition

事务的属性或定义对象。包含的属性如下：

Isolation：事务的隔离级别。

1. 1. TRANSACTION_NONE：表示不支持事务。值为0，
   2. TRANSACTION_READ_UNCOMMITED：表示一个事务可以读取另外事务未提交的数据。存在脏读。值为1
   3. TRANSACTION_READ_COMMITED：表示只读取已提交的数据。防止脏读。存在重复读，幻读。值为2
   4. TRANSACTION_REPEATABLE_READ：表示在读取过程中不允许修改操作。防止一个事务多次查询得到不同的值。防止脏读，重复读，存在虚读。值为4
   5. 当为TRANSACTION_SERIALIZABLE：TODO，值为8.

Propagation：事务的传播机制。

1. 1. Never：表示没有事务。
   2. NOT SUPPORT：表示不支持事务。
   3. REQUIRED：为每个方法的事务创建一个域（Scope），内部方法共享外部方法的域，内部方法可以在自己的域内回滚事务，此时外部方法的事务不受内部方法事务的影响，外部事物依然可以提交。但是外部事物会捕获到UnexeceptedRollBackException。类似于语言中的函数，或方法，内部方法有自己独立的域，外部方法也有自己独立的域，内部方法可以访问外部方法的变量等等。
   4. REQUIRED NEW：为每个方法创建一个事务，彼此无关联。
   5. NESTED：为外部方法创建一个事务，多个存档点。内部方法与外部方法在同一事务内。

Timeout：超时时间。

read-only：是否是只读的事务。

TransactionStatus

表示一个新创建的事务或者已存在的事务。

1. isNewTransaction：是否是新事务。
2. hasSavepoint：事务是否有存放点
3. setRollbackOnly：回滚事务
4. isRollbackOnly：TODO
5. flush：TODO
6. isCompleted：事务是否执行完成。

代码示例如下：

 1 //第一步：创建事务属性对象TransactionDefinition，创建事务管理对象TransactionManager。
 2 // 创建事务属性对象
 3 DefaultTransactionDefinition def = new DefaultTransactionDefinition();
 4 def.setName("trans1");
 5 def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
 6 // 创建事务管理对象
 7 DataSourceTransactionManager transcationManager = new DataSourceTransactionManager();
 8 
 9 //第二步：获取事务对象，
10 TransactionStatus status = transcationManager.getTransaction(def);
11 //第三步：实现业务逻辑代码
12 try
13 {
14     // 代码逻辑
15 }
16 catch(Exception e)
17 {
18     transcationManager.rollback(status);
19     throw e;
20 }
21 transcationManager.commit(status);

View Code

 

实现方式                                                                    

      spring事务实现的方式有三种。配置切面方式，注解方式，代码方式。配置切面方式在实际项目中运用比较广泛，注解方式需要在每个方法上添加@Transactional注解，代码冗余度比较高。代码方式只是为了更好的理解Spring事务的机制，在实际项目中并不适用。

配置切面方式                                         

第一步：配置事务管理。

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

     第二步：通过”tx:advice”标签配置事务的场景。指定在哪些方法上配置事务，以及这些事务的定义。tx:advice包含一个或多个tx:attribtue，tx:attribute包含一个或多个tx:method。tx:method标签配置具体的事务。

tx:method的属性有

1. name：表示方法的名称，可以使用通配符。例如get*表示以get开头的方法，如果配置多个，使用逗号隔开。
2. isolation：配置事务的隔离级别。参考TransactionDefinition
   
3. propagation：配置事务的传播机制。传播机制的种类如下：
4. rollbackFor：指定运行时让事务回滚的异常。这些异常必须是运行时异常，而且需要指定异常类的全路径名。默认情况下，只要运行时出现异常，就回滚事务。
5. noRollbackFor：指定运行时不会让事务回滚的异常。
6. timeout：表示超时时间，事务执行超过当前时间，事务自动回滚。默认值为-1，表示永不超时。

示例如下：

<tx:advice id="txAdvice">
    <tx:attributes>
        <!--方法名称以get开头的事务为只读事务，隔离级别为SERIALIZABLE-->
        <tx:method name="get*" read-only="true" isolation="SERIALIZABLE"  />
        <!--方法名称以insert开头的事务，隔离级别为SERIALIZABLE，传播机制为REQUIRED，当发生TestException时回滚事务，ArithmeticException不会回滚事务。-->
        <tx:method name="insert*" isolation="SERIALIZABLE" timeout="20" propagation="REQUIRED"
             rollback-for="com.rain.exception.TestException" 
no-rollbackfor="java.lang.ArithmeticException" />
        <tx:method name="*" isolation="READ_COMMITTED" />
    </tx:attributes>
</tx:advice>

      第三步：通过aop:config配置事务切面。aop:config包含一个或多个（aop:pointcut，aop:advisor）。aop:pointcut指定为哪些类配置切面，aop:advisor将tx:advice与aop:pointcut关联起来。其中aop:config标签中expression的格式为：execution(* packageName.className.*(..))。它是SPEL表达式。

示例如下：

<aop:config>
    <aop:pointcut expression="execution(* com.rain.service.*.*(..))"  id="studentServiceMethod" />
    <aop:advisor advice-ref="txAdvice" pointcut-ref="studentServiceMethod" />
</aop:config> 

如果配置多个事务，重复上述步骤。也可以在aop:config中配置多组(aop:pointcut，aop:advisor)。

第四步：验证。使用Log4J日志，将级别设置为DEBUG。启动时，会加载事务的配置。

2017-05-30 12:22:00 DEBUG NameMatchTransactionAttributeSource:96 - Adding transactional method [get*] with attribute [PROPAGATION_REQUIRED,ISOLATION_READ_COMMITTED,readOnly]

2017-05-30 12:22:00 DEBUG NameMatchTransactionAttributeSource:96 - Adding transactional method [insert*] with attribute [PROPAGATION_REQUIRED,ISOLATION_SERIALIZABLE,timeout_20,-com.rain.exception.TestException,+java.lang.ArithmeticException]

2017-05-30 12:22:00 DEBUG NameMatchTransactionAttributeSource:96 - Adding transactional method [*] with attribute [PROPAGATION_REQUIRED,ISOLATION_READ_COMMITTED]

运行insertXX方法时，显示事务处理的详细过程。

2017-05-30 11:49:57 DEBUG DataSourceTransactionManager:367 - Creating new transaction with name [com.rain.service.impl.StudentServiceImpl.insertStudent]: PROPAGATION_REQUIRED,ISOLATION_SERIALIZABLE,timeout_20,-com.rain.exception.TestException,+java.lang.ArithmeticException。

2017-05-30 11:49:58 TRACE TransactionInterceptor:517 - Completing transaction for [com.rain.service.impl.StudentServiceImpl.insertStudent] after exception: java.lang.ArithmeticException: / by zero

2017-05-30 11:49:58 TRACE RuleBasedTransactionAttribute:131 - Applying rules to determine whether transaction should rollback on java.lang.ArithmeticException: / by zero

2017-05-30 11:49:58 TRACE RuleBasedTransactionAttribute:148 - Winning rollback rule is: NoRollbackRuleAttribute with pattern [java.lang.ArithmeticException]

2017-05-30 11:49:58 DEBUG DataSourceTransactionManager:759 - Initiating transaction commit
2017-05-30 11:49:58 DEBUG DataSourceTransactionManager:310 - Committing JDBC transaction on Connection [com.mchange.v2.c3p0.impl.NewProxyConnection@25df00a0]
2017-05-30 11:49:58 TRACE TransactionSynchronizationManager:331 - Clearing transaction synchronization

当insertXX方法有java.lang.ArithmeticException异常时。不会回滚事务。

2017-05-30 12:09:17 TRACE RuleBasedTransactionAttribute:131 -
Applying rules to determine whether transaction should rollback on java.lang.ArithmeticException: / by zero
2017-05-30 12:09:17 TRACE RuleBasedTransactionAttribute:148 - Winning rollback rule is: NoRollbackRuleAttribute with pattern [java.lang.ArithmeticException]

当insertXX方法中有TestException异常时。回滚事务。

Applying rules to determine whether transaction should rollback on com.rain.exception.TestException: 这是测试用的异常
2017-05-30 12:22:01 TRACE RuleBasedTransactionAttribute:148 - Winning rollback rule is: RollbackRuleAttribute with pattern [com.rain.exception.TestException]
2017-05-30 12:22:01 DEBUG DataSourceTransactionManager:851 - Initiating transaction rollback
2017-05-30 12:22:01 DEBUG DataSourceTransactionManager:325 - Rolling back JDBC transaction on Connection [com.mchange.v2.c3p0.impl.NewProxyConnection@aba625]

注解方式

第一步：配置事务管理。与声明式事务完全相同。参考配置切面方式第一步

第二步：通过tx:annotation-driven配置事务支持注解方式。tx:annotation-driven的属性有

1. transaction-manager：指定事务管理的名称，默认值为transactionManager。所以当名称为transactionManager时，可以忽略。
2. mode：注解的模式，模式有两种，proxy与aspectj，默认方式为proxy。
3. proxy-target-class：识别注解的方式。@Transactional可以在接口的方法上，也可以在具体类的方法上。当设置为false时，既可以识别具体类上的@Transactional注解，也可以识别接口上的@Transactional。当为true时，接口上的@Transactional将被忽略。默认值为false。
4. order：TODO。

示例如下：

<!-- 配置注解驱动-->
<tx:annotation-driven transaction-manager="transactionManager" mode="proxy" proxy-target-class="true"/>

第三步：在方法上加@Transactional注解，该注解属性的含义如下：

1. value：表示事务管理器的名称，如果配置中存在多个事务管理器，trans1，trans2。value值用来指定当前事务所属的事务管理器。
2. isolation：事务的隔离级别。参考事务隔离级别，默认值为READ_COMMITED。
3. propagation：事务的传播机制，参考事务传播机制
4. readOnly：是否是只读事务。true表示是，false表示否，默认值为false。
5. rollbackFor：指定发生哪些异常时，事务回滚，默认值为Exception.class。异常类型为运行时异常
6. rollbackForClassName：含义与rollbackFor相同，值为异常类的名称字符串。
7. noRollbackFor：指定发生哪些异常时，事务不会回滚，无默认值
8. noRollbackForClassName：含义为noRollbackFor相同，值为异常类的名称字符串。

    @Transactional(propagation=Propagation.REQUIRED,isolation = Isolation.SERIALIZABLE,timeout=20,rollbackFor = {com.rain.exception.TestException.class},
            noRollbackFor = {java.lang.ArithmeticException.class})

第四步：验证。在运行该方法时。会加载事务属性，并创建事务。

2017-05-30 14:06:57 DEBUG AnnotationTransactionAttributeSource:116 - 
Adding transactional method \'com.rain.service.impl.StudentServiceImpl.insertStudent\' with attribute: PROPAGATION_REQUIRED,ISOLATION_SERIALIZABLE; \'\',-com.rain.exception.TestException,-java.lang.NullPointerException,+java.lang.ArithmeticException

2017-05-30 14:06:57 DEBUG DataSourceTransactionManager:367 - 
Creating new transaction with name [com.rain.service.impl.StudentServiceImpl.insertStudent]: PROPAGATION_REQUIRED,ISOLATION_SERIALIZABLE; \'\',-com.rain.exception.TestException,-java.lang.NullPointerException,+java.lang.ArithmeticException

当发生TestException时，事务回滚。

2017-05-30 14:06:57 TRACE RuleBasedTransactionAttribute:131 - Applying rules to determine whether transaction should rollback on com.rain.exception.TestException: 这是测试用的异常
2017-05-30 14:06:57 TRACE RuleBasedTransactionAttribute:148 - Winning rollback rule is: RollbackRuleAttribute with pattern [com.rain.exception.TestException]

当发生ArithmeticException时，事务不会回滚。

2017-05-30 12:09:17 TRACE RuleBasedTransactionAttribute:131 - Applying rules to determine whether transaction should rollback on java.lang.ArithmeticException: / by zero
2017-05-30 12:09:17 TRACE RuleBasedTransactionAttribute:148 - Winning rollback rule is: NoRollbackRuleAttribute with pattern [java.lang.ArithmeticException]

代码方式

      代码实现事务的方式有两种，一种是TransactionTemplate，该对象可以设置事务的属性。另外一种是TransactionManager方式。TransactionManager方参考核心对象下面的代码示例。

TransactionTemplate方式

第一步：初始化TransactionTemplate，

 1 // 创建事务template类
 2 private final TransactionTemplate tranTemp;
 3 
 4 // 创建学生的service类
 5 @Autowired
 6 private IStudentService studentService;
 7 
 8 // 在构造器中初始化TransactionTemplate
 9 public TransactionServiceImpl(PlatformTransactionManager tranManager) {
10     Assert.notNull(tranManager, "The \'tranManager\' argument must not be null ");
11     this.tranTemp = new TransactionTemplate(tranManager);
12 }

      第二步：调用transactionTemplate的execute方法，参数为TransactionCallback，或者是TransactionCallbackWithoutResult，前者返回类型为void，后者有返回类型。

无返回类型TransactionCallbackWithoutResult

 1 // 通过代码的方式实现事务
 2 @Override
 3 public void insertStudent(Student stu) {
 4     tranTemp.execute(new TransactionCallbackWithoutResult() {
 5         @Override
 6         protected void doInTransactionWithoutResult(TransactionStatus status) {
 7             try {
 8                  // 代码逻辑
 9             } catch (Exception e) {
10                 e.printStackTrace();
11                 status.setRollbackOnly();
12             }
13         }
14     });
15 }      

有返回类型TransactionCallback<T>

 1 public void insertStudentWithReturn(Student stu)
 2 {
 3     tranTemp.execute(new TransactionCallback<Student>() {
 4         @Override
 5         public Student doInTransaction(TransactionStatus status) {
 6             try
 7             {
 8                 // 代码逻辑
 9             }catch(Exception e)
10             {
11                 e.printStackTrace();
12                 // 回滚事务
13                 status.setRollbackOnly();
14             }
15             return stu;
16         }});
17 }

至此本篇内容结束