Spring 详解（五）：Spring声明式事务

﹏ヽ暗。殇╰゛Y 2022-03-27 06:38 266阅读 0赞

事务管理是企业级应用程序开发中必备技术，用来确保数据的完整性和一致性。本文主要讲解事务涉及到一些概念以及spring中事务的使用。

# 1. 事务 #

数据库事务(Database Transaction) ，是指作为单个逻辑工作单元执行的一系列操作，要么完全地执行，要么完全地不执行。

事务四个属性ACID

> 1.  原子性（atomicity）  
>     事务是原子性操作，由一系列动作组成，事务的原子性确保动作要么全部完成，要么完全不起作用.
> 2.  一致性（consistency）  
>     一旦所有事务动作完成，事务就要被提交。数据和资源处于一种满足业务规则的一致性状态中.
> 3.  隔离性（isolation）  
>     可能多个事务会同时处理相同的数据，因此每个事务都应该与其他事务隔离开来，防止数据损坏.
> 4.  持久性（durability）  
>     事务一旦完成，无论系统发生什么错误，结果都不会受到影响。通常情况下，事务的结果被写到持久化存储器中.

# 2. Spring中的事务管理 #

Spring在不同的事务管理API之上定义了一个抽象层，使得开发人员不必了解底层的事务管理API就可以使用Spring的事务管理机制。Spring支持编程式事务管理和声明式的事务管理。

## 2.1 编程式事务 ##

将事务管理代码嵌到业务方法中来控制事务的提交和回滚，由程序员来编写事务，控制代码。

缺点：必须在每个事务操作业务逻辑中包含额外的事务管理代码。

## 2.2 声明式事务 ##

一般情况下比编程式事务好用。将事务管理代码从业务方法中分离出来，以声明的方式来实现事务管理。将事务管理作为横切关注点，通过aop方法模块化。Spring中通过Spring AOP框架支持声明式事务管理。

Spring中声明已经由Spring写好，程序员只需声明出有哪些方法需要进行事务控制和如何进行事务控制。

# 3. Spring 中的事务管理器 #

Spring的核心事务管理抽象，管理封装了一组独立于技术的方法，无论使用Spring的哪种事务管理策略（编程式或者声明式）事务管理器都是必须的。

Spring中定义了事务管理器基类，所有的事务管理器类都要继承该基类。

org.springframework.transaction.PlatformTransactionManager

Spring给出了几种常见的数据源事务管理器

### JDBC事务 ###

### Hibernate事务 ###

### JPA事务 ###

### Java原生API事务 ###

通常用于跨越多个事务管理源（多数据源），则需要使用下面的内容

# 4. 事务属性 #

数据库事务中包括一下这几种事务属性：传播行为、隔离规则、回滚规则、事务超时机制、是否是只读事务等

![在这里插入图片描述][20190112143117393.png]

## 4.1 事务传播行为 ##

事务方法被另一个事务方法调用时，必须指定事务应该如何传播。当一个具有事务控制的方法，被另一个有事务控制的方法调用。需要如何管理事务。新建还是事务，就在当前事务中执行，把事务挂起，报异常。例如方法可能继续在现有事务中运行，也可能开启一个新的事务，并在自己的事务运行。spring中的事务传播行为可以由传播属性指定。spring指定了7种类传播行为。

<table> 
 <thead> 
  <tr> 
   <th>事务</th> 
   <th>事务详解</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>REQUIRED</td> 
   <td>如果有事务在运行，当前的方法就在这个事务内运行，否则就开启一个新的事务，并在自己的事务内运行,默认传播行为</td> 
  </tr> 
  <tr> 
   <td>REQUIRED_NEW</td> 
   <td>当前方法必须启动新事务，并在自己的事务内运行，如果有事务正在运行，则将它挂起</td> 
  </tr> 
  <tr> 
   <td>SUPPORTS</td> 
   <td>如果有事务在运行，当前的方法就在这个事务内运行，否则可以不运行在事务中</td> 
  </tr> 
  <tr> 
   <td>NOT_SUPPORTED</td> 
   <td>表示该方法不应该运行在事务中。如果存在当前事务，在该方法运行期间，当前事务将被挂起。如果使用JTATransactionManager的话，则需要访问TransactionManager</td> 
  </tr> 
  <tr> 
   <td>MANDATORY</td> 
   <td>当前的方法必须运行在事务内部，如果没有正在运行的事务，就会抛出异常</td> 
  </tr> 
  <tr> 
   <td>NEVER</td> 
   <td>当前方法不应该运行在事务中，如果有运行的事务，就抛出异常</td> 
  </tr> 
  <tr> 
   <td>NESTED</td> 
   <td>如果有事务在运行，当前的方法就应该在这个事务的嵌套事务内运行。嵌套的事务可以独立于当前事务进行单独地提交或回滚。如果当前事务不存在，那么其行为与PROPAGATION_REQUIRED一样。</td> 
  </tr> 
 </tbody> 
</table>

**通常情况下，第一种和第二种用的比较多，需要多理解一下**

## 4.2 事务隔离级别 ##

并发事务会导致发生以下三种类型的问题

### 脏读 ###

一个事务A读取到另一个事务B中未提交的数据（比如读取到了数据库缓存中的数据），另一个事务中数据进行了改变，此时这个事务A读取的数据就可能和数据库中数据不一致。此时认为数据是脏数据，读取脏数据过程叫做脏读。

### 不可重复读 ###

主要针对的是某一行数据或者行中某列数据。主要针对的操作是修改操作。当事务A在第一次读取事务后，事务B对事务A读取的数据进行**修改**，事务A中再次读取和之前读取的数据不一致，过程不可重复读。事务A中的两次读取在同一个事务当中。

### 幻读 ###

主要针对的操作是新增或者删除数据。事务A按照特定条件查询出结果，事务B新增一条符合条件的数据。事务A再次查询相同的数据和数据库中的数据不一致，事务A好像出现了幻觉。这种情况称为幻读。

**不可重复读和幻读的区别：不可重复读侧重点在相同数据被修改，而幻读是删除或新增**

spring中事务的隔离级别可以通过隔离属性指定

<table> 
 <thead> 
  <tr> 
   <th>事务</th> 
   <th>事务隔离级别</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>DEFAULT</td> 
   <td>使用底层数据库的默认隔离级别，大部分数据库，默认隔离级别都是READ_COMMITED</td> 
  </tr> 
  <tr> 
   <td>READ_COMMITED</td> 
   <td>只允许事务读取已经被其他事务提交的更改，可以避免脏读，但不可重复读和幻读问题仍然可能出现</td> 
  </tr> 
  <tr> 
   <td>READ_UNCOMMITED</td> 
   <td>允许事务读取未被其他事务提交的更改。脏读，不可重复读，幻读都可能会出现</td> 
  </tr> 
  <tr> 
   <td>REPEATABLE_READ</td> 
   <td>确保事务可以多次从一个字段中读取相同的值。在这个事务持续期间，禁止其他事务对这个字段进行更新，可以避免脏读和不可重复读，但是幻读的问题依然存在</td> 
  </tr> 
  <tr> 
   <td>SERIALIZABLE</td> 
   <td>确保事务可以从一个表中读取相同的行，在这个事务持续期间，禁止其他事务对该表执行插入，更新，删除。所有的并发问题都能避免，但是性能比较低。</td> 
  </tr> 
 </tbody> 
</table>

## 4.3 回滚规则 ##

默认情况下只有未检查异常（RuntimeException和Error类型的异常）会导致事务回滚。事务的回滚规则可以通过属性管理

>  *  rollback-for：遇到时必须进行回滚
>  *  no-rollback-for：一组异常类，遇到时必须不能回滚

## 4.4 只读属性 ##

事务可以在行和表上获得锁，因此长事务会占用资源，并对整体性能产生影响。可以配置超时事务属性，事务在强制回滚之前可以保持多久，这样可以避免长期运行的事务占用资源

readonly=“boolean” 是否是只读事务。如果是true，告诉此数据库为只读事务。数据库优化会对性能有一定提升。所以只要是查询方法，就使用此属性。如果为false，那么这个事务是需要提交的事务。建议新增、删除、修改。

# 5. 声明式管理事务 #

## 5.1 通过配置Spring AOP 声明式地管理事务 ##

<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
            <property name="url" value="${url}"/>
            <property name="username" value="${username}"/>
            <property name="password" value="${password}"/>
            <property name="driverClassName" value="${driverClassName}"/>
        </bean>
    
        
        <bean id="sqlSessionFactoryBean" class="org.mybatis.spring.SqlSessionFactoryBean">
            <property name="typeAliasesPackage" value="com.hust.edu.pojo"></property>
            <property name="dataSource" ref="dataSource"></property>
            
            
        </bean>
    
        
        <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
            <property name="basePackage" value="com.hust.edu.mapper"></property>
            <property name="sqlSessionFactoryBeanName" value="sqlSessionFactoryBean"></property>
        </bean>
    
        
        <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
            <property name="dataSource" ref="dataSource"></property>
        </bean>
    
        <tx:advice id="txAdvice" transaction-manager="txManager">
            
            <tx:attributes>
                <tx:method name="ins*" />
                <tx:method name="del*"/>
                <tx:method name="upd*"/>
                <tx:method name="*" read-only="true"/>
            </tx:attributes>
        </tx:advice>
    
        
        <aop:config>
            <aop:pointcut id="pointcunt" expression="execution(* com.hust.edu.service.impl.*.*(..))"/>
            <aop:advisor advice-ref="txAdvice" pointcut-ref="pointcunt"/>
        </aop:config>

## 5.2 用 @Transactional 注解声明式地管理事务 ##

Spring中注解的方式@Transactional标注事务方法。为了将方法定义为支持事务处理，可以在方法上添加@Transactional注解。根据Spring AOP基于代理机制，只能标注公有方法。如果在类上标注@Transactional注解，那么这个类中所有公有方法都会被定义为支持事务。

<bean id="transactionManager"
              class="org.springframework.orm.hibernate4.HibernateTransactionManager">
            <property name="sessionFactory" ref="sessionFactory" />
        </bean>
        <aop:aspectj-autoproxy proxy-target-class="true"></aop:aspectj-autoproxy>
    
        
        <tx:annotation-driven transaction-manager="transactionManager" />

在事务声明方法上添加

//添加事务注解
    //1.使用 propagation 指定事务的传播行为, 即当前的事务方法被另外一个事务方法调用时
    //如何使用事务, 默认取值为 REQUIRED, 即使用调用方法的事务
    //REQUIRES_NEW: 事务自己的事务, 调用的事务方法的事务被挂起. 
    //2.使用 isolation 指定事务的隔离级别, 最常用的取值为 READ_COMMITTED
    //3.默认情况下 Spring 的声明式事务对所有的运行时异常进行回滚. 也可以通过对应的
    //属性进行设置. 通常情况下去默认值即可. 
    //4.使用 readOnly 指定事务是否为只读. 表示这个事务只读取数据但不更新数据, 
    //这样可以帮助数据库引擎优化事务. 若真的事一个只读取数据库值的方法, 应设置 readOnly=true
    //5.使用 timeout 指定强制回滚之前事务可以占用的时间.
    @Transactional(propagation=Propagation.REQUIRES_NEW,
    		isolation=Isolation.READ_COMMITTED,
    		noRollbackFor={ UserAccountException.class},
    		rollbackFor = IOException.class,
    		readOnly=false,
    		timeout=3)
    @Override
    public void purchase(String username, String isbn) { }

# 6. 事务失效 #

因为spring事务是基于aop的代理机制，当方法中调用this本身的方法时候即使在this的方法标明事务注解，但是事务注解会失效。如下

@Transactional
    @Override
    public void purchase(String username, String isbn) { 
    	this.update(username, isbn);
    }
     
    @Transactional
    public void update(String username, String isbn) { 
    	//1. 获取书的单价
    	int price = bookShopDao.findBookPriceByIsbn(isbn);
    	//2. 更新数的库存
    	bookShopDao.updateBookStock(isbn);
    	//3. 更新用户余额
    	bookShopDao.updateUserAccount(username, price);
    }

**原因：因为调用this本身方法不走代理机制，这个时候可以通过配置解决这个问题。**

## 6.1 解决事务失效 ##

在配置中添加如下内容

<aop:aspectj-autoproxy expose-proxy="true"/>

将上述调用的地方改成如下

@Transactional
    @Override
    public void purchase(String username, String isbn) { 
    	((BookShopServiceImpl)AopContext.currentProxy()).update(username, isbn);
    }

[20190112143117393.png]: /images/20220327/654aa4f6e705416182f5060f8d34d5b0.png