【Spring】持久层事务处理、事务属性

墨蓝 2022-09-15 11:55 141阅读 0赞

### 文章目录 ###

*  一、事务介绍
 *  二、Spring控制事务分析
 *  三、Spring控制事务的编码
 *  四、Spring中的事务属性（Transaction Attribute）
 *   *  4.1 隔离属性（isolation）
     *  4.2 传播属性（PROPAGATION）
     *  4.3 只读属性（readOnly）
     *  4.4 超时属性（timeout）
     *  4.5 异常属性
     *  4.6 事务属性常见配置总结
 *  五、基于标签的事务配置方式

# 一、事务介绍 #

**1 什么是事务？**

*  事务时保证业务操作完整性的一种数据库机制。

**2 事务的 4 大特点**： A、C、I、D

*  `A(atomicity)` 原子性
 *  `C(consistency)` 一致性
 *  `I(isolation)` 隔离性
 *  `D(durability)` 持久性

**3 如何控制事务?（JDBC、Mybatis）**

JDBC

*  `Connection.setAutoCommit(false);`
 *  `Connection.commit();`
 *  `Connection.rollback();`

Mybatis

*  Mybatis 自动开启事务
 *  `sqlSession.commit()`;，底层还是调用的 Connection
 *  `sqlSession.rollback()`;，底层还是调用的 Connection

结论：控制事务的底层，都是通过 Connection 对象完成的。

# 二、Spring控制事务分析 #

Spring通过AOP的方式进行事务开发。

1 原始对象  
2 额外功能——事务  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5pyb5aSp6L655pif5a6_size_20_color_FFFFFF_t_70_g_se_x_16]  
3 切入点

@Transactional
    事务的额外功能计入给那些额外业务方法。
    在类上：类中所有的方法都会加入事务
    方法上：这个方法会加入事务

4 组装切面

# 三、Spring控制事务的编码 #

**搭建开发环境`pom.xml`**

<dependency>
    	<groupId>org.springframework</groupId>
    	<artifactId>spring-tx</artifactId>
    	<version>5.2.6.RELEASE</version>
    </dependency>

**编码**

@Transactional
    public class UserServiceImpl implements UserService { 
        private UserDAO userDAO;
    	...
    }

**细节**

进行动态代理底层实现的切换，默认 false 是 JDK，true 是 Cglib。

<tx:annotation-driven transaction-manager="dataSourceTransactionManager" proxy-target-class="true"/>

# 四、Spring中的事务属性（Transaction Attribute） #

**什么是事务属性？**

属性：描述物体特征的一系列值（性别、身高、体重）

事务属性：描述事务特征的一系列值

*  隔离属性
 *  传播属性
 *  只读属性
 *  超时属性
 *  异常属性

**如何添加事务属性？**

@Transactional(isolation=, propagation=, readOnly=,timeout=,rollbackFor,noRollbackFor=,)

--------------------

## 4.1 隔离属性（isolation） ##

概念：**描述了事务解决并发问题的特征**

1.  **什么是并发？**  
    多个事务（用户）在同一时间，访问操作了相同的数据。  
    同一时间：0.000 几秒左右
2.  **并发会产生那些问题？**
    
     *  脏读
     *  不可重复读
     *  幻影读
3.  **并发问题如何解决？**  
    通过隔离属性解决，隔离属性中设置不同过的值，解决并发处理的过程中的问题。

--------------------

**事务并发产生的问题**

*  **脏读**  
    一个事务，读取了另一个事务中没有提交的数据，会在本事务中产生数据不一样的现象  
    解决方案：`@Transaction(isolation=Isolation.READ_COMMITTED)`
 *  **不可重复读**  
    一个事务中，多次读取相同的数据，但是读取结果不一样，会在本事务中产生数据不一样的现象  
    注意：1.不是脏读 2.在一个事务中  
    解决方案：`@Transaction(isolation=Isolation.REPEATABLE_READ)`  
    本质：一把行锁（对数据库表的某一行加锁）
 *  **幻影读**  
    一个事务中，多次对整表进行查询统计，但是结果不一样，会在本事务中产生数据不一致的问题  
    解决方案：`@Transaction(isolation=Isolation.SERIALIZABLE)`  
    本质：表锁（对数据库某个表加锁）

--------------------

**安全与效率对比**：

*  并发安全：SERIALIZABLE > READ\_ONLY > READ\_COMMITTED
 *  运行效率：READ\_COMMITTED > READ\_ONLY > SERIALIZABLE

--------------------

**默认的隔离属性**

<table> 
 <thead> 
  <tr> 
   <th>隔离属性的值</th> 
   <th>MySQL</th> 
   <th>Oracle</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>ISOLATION_READ_COMMITTED</td> 
   <td>支持</td> 
   <td>支持</td> 
  </tr> 
  <tr> 
   <td>ISOLATION_REPEATABLE_READ</td> 
   <td>支持</td> 
   <td>不支持</td> 
  </tr> 
  <tr> 
   <td>ISOLATION_SERIALIZABLE</td> 
   <td>支持</td> 
   <td>支持</td> 
  </tr> 
 </tbody> 
</table>

Oracle 不支持 REPEATABLE\_READ，那该如何解决不可重复读？  
采用 **多版本比对** 的方式解决不可重复读问题。

--------------------

**默认的隔离属性：**

*  Spring 会指定为 ISOLATION\_DEFAULT，调用不同数据库所设置的默认隔离属性  
    MySQL：REPEATABLE\_READ  
    Oracle：READ\_COMMITTED
 *  查看数据库的默认隔离属性：  
    MySQL：SELECT @@tx\_isolation;  
    Oracle：较麻烦，建议百度。

--------------------

**隔离属性在实验中的建议：**

*  推荐使用 Spring 默认指定的 ISOLATION\_DEFAULT
 *  未来的实战中，遇到并发访问的情况，很少见
 *  如果真的遇到并发问题，解决方案：乐观锁  
    Hibernate(JPA)：version  
    MyBatis：通过拦截器自定义开发

## 4.2 传播属性（PROPAGATION） ##

**概念**：描述了事务解决嵌套问题的特征。

**事务的嵌套**：指的是一个大的事务中，包含了若干个小的事务。

**事务嵌套产生的问题**： 大事务中融入了很多小的事务，他们彼此影响，最终就导致外部大的事务丧失了事务的原子性。

**传播属性的值及其用法**：

<table> 
 <thead> 
  <tr> 
   <th>传播属性的值</th> 
   <th>外部不存在事务</th> 
   <th>外部存在事务</th> 
   <th>用法</th> 
   <th>备足</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>REQUIRED</td> 
   <td>开启新的事务</td> 
   <td>融合到外部事务中</td> 
   <td><code>@Transactional(propagation = Propagation.REQUIRED)</code></td> 
   <td>增、删、改方法</td> 
  </tr> 
  <tr> 
   <td>SUPPORTS</td> 
   <td>不开启事务</td> 
   <td>融合到外部事务中</td> 
   <td><code>@Transactional(propagation = Propagation.SUPPORTS)</code></td> 
   <td>查询方法</td> 
  </tr> 
  <tr> 
   <td>REQUIRES_NEW</td> 
   <td>开启新的事务</td> 
   <td>挂起外部事务，创建新的事务</td> 
   <td><code>@Transactional(propagation = Propagation.REQUIRES_NEW)</code></td> 
   <td>日志记录方法中</td> 
  </tr> 
  <tr> 
   <td>NOT_SUPPORTED</td> 
   <td>不开启事务</td> 
   <td>挂起外部事务</td> 
   <td><code>@Transactional(propagation = Propagation.NOT_SUPPORTED)</code></td> 
   <td>极其不常用</td> 
  </tr> 
  <tr> 
   <td>NEVER</td> 
   <td>不开启事务</td> 
   <td>抛出异常</td> 
   <td><code>@Transactional(propagation = Propagation.NEVER)</code></td> 
   <td>极其不常用</td> 
  </tr> 
  <tr> 
   <td>MANDATORY</td> 
   <td>抛出异常</td> 
   <td>融合到外部事物中</td> 
   <td><code>@Transactional(propagation = Propagation.MANDATORY)</code></td> 
   <td>极其不常用</td> 
  </tr> 
 </tbody> 
</table>

Spring中传播属性的**默认值**是：`REQUIRED`

推荐传播属性的使用方式：

*  增删改方法：使用默认值 `REQUIRED`
 *  查询方法：显示指定传播属性的值为 `SUPPORTS`

## 4.3 只读属性（readOnly） ##

针对于**只进行查询操作的业务方法**，可以加入只读属性，提高运行效率。  
默认值：false

@Transactional(readOnly = true)

## 4.4 超时属性（timeout） ##

指定了事务等待的最长时间。

*  为什么事务会进行等待？  
    当前事务访问数据时，有可能访问的数据被别的事务进行加锁的处理，那么此时本事务就必须进行等待。
 *  等待时间单位：秒
 *  如何使用：@Transactional(timeout = 2)
 *  超时属性的默认值：-1  
    \-1 表示超时属性由对应的数据库来指定（一般不会主动指定，-1 即可）

## 4.5 异常属性 ##

Spring 事务处理过程中：

*  默认对于 `RuntimeException` 及其子类，采用**回滚**的策略。
 *  默认对于 `Exception` 及其子类，采用**提交**的策略。

使用方法：

@Transactional(rollbackFor = java.lang.Exception.class, xxx, xxx)
    
    @Transactional(noRollbackFor = java.lang.RuntimeException, xxx, xxx)

建议：实战中使用 `RuntimeException` 及其子类，使用事务异常属性的默认值。

## 4.6 事务属性常见配置总结 ##

1.  隔离属性 默认值
2.  传播属性 Required（默认值）增删改、Supports 查询操作
3.  只读属性 readOnly=false 增删改，true 查询操作
4.  超时属性 默认值 -1
5.  异常属性 默认值

增删改操作：`@Transactional`  
查询操作：`@Transactional(propagation = Propagation.SUPPORTS, readOnly = true)`

# 五、基于标签的事务配置方式 #

基于注解 `@Transaction` 的事务配置回顾：

<bean id="userService" class="com.yusael.service.UserServiceImpl">
    	<property name="userDAO" ref="userDAO"/>
    </bean>
    
    
    <bean id="dataSourceTransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    	<property name="dataSource" ref="dataSource"/>
    </bean>
    
    @Transactional
    public class UserServiceImpl implements UserService {
        private UserDAO userDAO;
        ...
    }
    
    <tx:annotation-driven transaction-manager="dataSourceTransactionManager"/>

基于标签的事务配置：

<bean id="dataSourceTransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>
    
    <tx:advice id="txAdvice" transaction-manager="dataSourceTransactionManager">
        <tx:attributes>
            <tx:method name="register" isolation="DEFAULT" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>
    
    <aop:config>
        <aop:pointcut id="pc" expression="execution(* com.yusael.service.UserServiceImpl.register(..))"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="pc"/>
    </aop:config>

基于标签的事务配置在**实战**中的应用方式：

<tx:advice id="txAdvice" transaction-manager="dataSourceTransactionManager">
        <tx:attributes>
            <tx:method name="register"/>
            <tx:method name="modify*"/>
            编程时候, service中负责进行增删改操作的方法 都以 modify 开头
            						  查询操作 命名无所谓
            <tx:method name="*" propagation="SUPPORTS" read-only="true"/>
        </tx:attributes>
    </tx:advice>
    
    <aop:config>
        <aop:pointcut id="pc" expression="execution(* com.yusael.service..*.*(..))"/>
       	应用的过程中, 将 service 都放到 service 包下
        <aop:advisor advice-ref="txAdvice" pointcut-ref="pc"/>
    </aop:config>

[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5pyb5aSp6L655pif5a6_size_20_color_FFFFFF_t_70_g_se_x_16]: /images/20220828/46b1c5872420491da10a0e07d0dd3773.png