万隆的笔记
2023-02-12
目录

Spring AOP声明式事务

# Spring AOP-声明式事务

编程式事务：在业务代码中添加事务控制代码，这样的事务控制机制就叫做编程式事务。

声明式事务：通过xml或者注解配置的⽅式达到事务控制的⽬的，叫做声明式事务。

# 事务回顾

# 事务的概念

事务指逻辑上的⼀组操作，组成这组操作的各个单元，要么全部成功，要么全部不成功。从⽽确保了数据的准确与安全。

例如：A—>B转帐，对应于如下两条sql语句:

 -- 转出账户减钱
 update account set money = money - 100 where name='a';
 -- 转⼊账户加钱
 update account set money = money + 100 where name='b';

这两条语句的执⾏，要么全部成功，要么全部不成功。

# 事务的ACID特性

特性 描述
原⼦性（Atomicity） 原⼦性是指事务是⼀个不可分割的⼯作单位，事务中的操作要么都发⽣，要么都不发⽣。从操作的⻆度来描述，事务中的各个操作要么都成功要么都失败
⼀致性（Consistency） 事务必须使数据库从⼀个⼀致性状态变换到另外⼀个⼀致性状态。例如转账前A有1000，B有1000。转账后A+B也得是2000。即⼀致性是从数据的⻆度来说的
隔离性（Isolation） 事务的隔离性是多个⽤户并发访问数据库时，数据库为每⼀个⽤户开启的事务。每个事务不能被其他事务的操作数据所⼲扰，多个并发事务之间要相互隔离。⽐如：事务1给员⼯涨⼯资2000，但是事务1尚未被提交，员⼯发起事务2查询⼯资，发现⼯资涨了2000块钱，读到了事务1尚未提交的数据（脏读）``
持久性（Durability） 持久性是指⼀个事务⼀旦被提交，它对数据库中数据的改变就是永久性的，接下来即使数据库发⽣故障也不应该对其有任何影响。

# 事务的隔离级别

如果不考虑隔离级别，会出现以下情况（有问题的场景，可以理解为隔离级别在解决事务并发问题）：

  • 脏读：⼀个线程中的事务读到了另外⼀个线程中未提交的数据。

  • 不可重复读：⼀个线程中的事务读到了另外⼀个线程中已经提交的update的数据（前后内容不⼀样）

    场景：员⼯A发起事务1，查询⼯资，⼯资为1w，此时事务1尚未关闭， 财务⼈员发起了事务2，给员⼯A涨了2000块钱，并且提交了事务，

    员⼯A通过事务1再次发起查询请求，发现⼯资为1.2w，原来读出来1w读不到了，叫做不可重复读

  • 虚读（幻读）：⼀个线程中的事务读到了另外⼀个线程中已经提交的insert或者delete的数据（前后条数不⼀样） 场景：事务1查询所有⼯资为1w的员⼯的总数，查询出来了10个⼈，此时事务尚未关闭 事务2财务⼈员发起，新来员⼯，⼯资1w，向表中插⼊了2条数据，并且提交了事务 事务1再次查询⼯资为1w的员⼯个数，发现有12个⼈，⻅了⻤了

数据库共定义了四种隔离级别：

  • Serializable（串⾏化）：可避免脏读、不可重复读、虚读情况的发⽣。
  • Repeatable read（可重复读）：可避免脏读、不可重复读情况的发⽣，幻读有可能发⽣。该机制下会对要update的⾏进⾏加锁。
  • Read committed（读已提交）：可避免脏读情况发⽣。不可重复读和幻读⼀定会发⽣。
  • Read uncommitted（读未提交）：最低级别，以上情况均⽆法保证。

注意：级别依次升⾼，效率依次降低，MySQL的默认隔离级别是：REPEATABLE READ（可重复读）。

查询当前使⽤的隔离级别： select @@tx_isolation;

设置MySQL事务的隔离级别： set session transaction isolation level xxx，设置的是当前mysql连接会话的，并不是永久改变的。

# 事务的传播⾏为

事务往往在Service层进⾏控制，如果出现Service层⽅法A调⽤了另外⼀个Service层⽅法B，A和B⽅法本身都已经被添加了事务控制，那么A调⽤B的时候，就需要进⾏事务的⼀些协商，这就叫做事务的传播⾏为。

A调⽤B，我们站在B的⻆度来观察来定义事务的传播⾏为：

名称 描述
PROPAGATION_REQUIRED 如果当前没有事务，就新建⼀个事务，如果已经存在⼀个事务中，加⼊到这个事务中。这是最常⻅的选择。
PROPAGATION_SUPPORTS ⽀持当前事务，如果当前没有事务，就以⾮事务⽅式执⾏。
PROPAGATION_MANDATORY 使⽤当前的事务，如果当前没有事务，就抛出异常。
PROPAGATION_REQUIRES_NEW 新建事务，如果当前存在事务，把当前事务挂起。
PROPAGATION_NOT_SUPPORTED 以⾮事务⽅式执⾏操作，如果当前存在事务，就把当前事务挂起。
PROPAGATION_NEVER 以⾮事务⽅式执⾏，如果当前存在事务，则抛出异常。
PROPAGATION_NESTED 如果当前存在事务，则在嵌套事务内执⾏。如果当前没有事务，则执⾏与PROPAGATION_REQUIRED类似的操作。

# Spring的事务管理

我们知道事务（Transaction ）原本是数据库中的概念，用于数据访问层。但一般情况下，需要将事务提升到业务层，即Service层。这样做是为了能够使用事务的特性来管理具体的业务。

在 Spring 中通常可以通过以下三种方式来实现对事务的管理：

  1. 使用 Spring 的事务代理工厂管理事务（已过时）
  2. 使用 Spring 的事务注解管理事务
  3. 使用 AspectJ 的 AOP 配置管理事务

# Spring的事务管理 API

Spring 的事务管理，主要用到两个事务相关的接口：事务管理器接口和事务定义接口。

# 事务管理器接口

事务管理器接口是指 PlatformTransactionManager ，其主要用于完成事务的提交、回滚，及获取事务的状态信息。该接口定义了 3 个事务方法：

public interface PlatformTransactionManager {
  /**
  * 获取事务的状态
  */
  TransactionStatus getTransaction(@Nullable TransactionDefinition definition) throws TransactionException;

  /**
  * 提交事务
  */
  void commit(TransactionStatus status) throws TransactionException;

  /**
  * 回滚事务
  */
  void rollback(TransactionStatus status) throws TransactionException;
}

此接⼝是Spring的事务管理器核⼼接⼝。Spring本身并不⽀持事务实现，只是负责提供标准，应⽤底层⽀持什么样的事务，需要提供具体实现类。此处也是策略模式的具体应⽤。在Spring框架中，也为我们内置了⼀些具体策略，例如：DataSourceTransactionManager , HibernateTransactionManager 等等。

  • DataSourceTransactionManager：使用 JDBC 或 MyBatis 进行持久化数据时使用。归根结底是横切逻辑代码，声明式事务要做的就是使⽤Aop（动态代理）来将事务控制逻辑织⼊到业务代码理）来将事务控制逻辑织⼊到业务代码.
  • HibernateTransactionManager：使用 Hibernate 进行持久化数据时使用。

PS：Spring事务的默认回滚方式是：发生运行时异常回滚。

# 事务定义接口

事务定义接口 TransactionDefinition 中定义了事务描述相关的三类常量：事务隔离级别、事务传播行为、事务默认超时时限，以及对它们的操作。分别有四种隔离级别和七种传播行为：

事务的四种隔离级别

1. DEFAULT（不是隔离级别）：采用 DB 默认的事务隔离级别。MySql 默认为 REPEATABLE_READ；Oracle 默认为：READ_COMMITTED；
2. READ_UNCOMMITTED：读未提交。未解决任何并发问题。
3. READ_COMMITTED：读已提交。解决脏读，存在不可重复读与幻读。
4. REPEATABLE_READ：可重复读。解决脏读、不可重复读。存在幻读。
5. SERIALIZABLE：串行化。不存在并发问题。

事务的七种传播行为

所谓事务传播行为是指：处于不同事务中的方法在相互调用时，执行期间事务的维护情况。如，A 事务中的方法 a() 调用 B 事务中的方法 b()，在调用执行期间事务的维护情况，就称为事务传播行为。事务传播行为是加在方法上的。

1. REQUIRED：指定的方法必须在事务内执行。若当前存在事务，就加入到当前事务中；若当前没有事务，则创建一个新事务。这种传播行为是最常见的选择，也是 Spring 默认的事务传播行为。
2. SUPPORTS：指定的方法支持当前事务，但若当前没有事务，也可以以非事务方式执行。
3. MANDATORY：指定的方法必须在当前事务内执行，若当前没有事务，则直接抛出异常。
4. REQUIRES_NEW：总是新建一个事务，若当前存在事务，就将当前事务挂起，直到新事务执行完毕。
5. NOT_SUPPORTED：指定的方法不能在事务环境中执行，若当前存在事务，就将当前事务挂起。
6. NEVER：指定的方法不能在事务环境下执行，若当前存在事务，就直接抛出异常。
7. NESTED：指定的方法必须在事务内执行。若当前存在事务，则在嵌套事务内执行；若当前没有事务，则创建一个新事务。

# 使用 AspectJ 的 AOP 配置管理事务

AspectJ 主要是使用 XML 配置顾问方式自动为每个符合切入点表达式的类生成事务代理。

# POM.XML

POM中增加 org.springframework:spring-aspects 依赖：

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
    <version>${spring.version}</version>
</dependency>

# 配置Spring.xml

AspectJ的AOP的配置示例：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

    <context:annotation-config/>
    <context:component-scan base-package="xxx.xxx.your.package">
        <context:exclude-filter type="annotation" expression="xxx.xxx.xxx"/>
    </context:component-scan>

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

    <!-- 配置事务通知 -->
    <tx:advice id="myAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="save*" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>

    <!-- 配置顾问和切入点 -->
    <aop:config>
        <aop:pointcut id="myPointcut" expression="execution(* reference.service.*.*(..))" />
        <aop:advisor advice-ref="myAdvice" pointcut-ref="myPointcut" />
    </aop:config>
</beans>

# 使用 Spring 注解管理事务

通过 @Transactional 注解方式，也可将事务织入到相应方法中。而使用注解方式，只需在配置文件中加入一个 tx 标签，以告诉 Spring 使用注解来完成事务的织入。该标签只需指定一个属性：开启事务注解驱动。

# 配置Spring.xml

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

<!-- 开启事务注解驱动 -->
<tx:annotation-driven transaction-manager="transactionManager" />

# @Transactional 注解所有可选属性

1. propagation：用于设置事务传播属性。该属性类型为 Propagation 枚举，默认值为Propagation.REQUIRED。
2. isolation：用于设置事务的隔离级别。该属性类型为 Isolation 枚举 ，默认值为 Isolation.DEFAULT。
3. readOnly：用于设置该方法对数据库的操作是否是只读的。该属性为 boolean，默认值为 false。
4. timeout：用于设置本操作与数据库连接的超时时限。单位为秒，类型为 int，默认值为 -1，即没有时限。
5. rollbackFor：指定需要回滚的异常类。类型为 Class[]，默认值为空数组。当然，若只有一个异常类时，可以不使用数组。
6. rollbackForClassName：指定需要回滚的异常类类名。类型为 String[]，默认值为空数组。当然，若只有一个异常类时，可以不使用数组。
7. noRollbackFor：指定不需要回滚的异常类。类型为 Class[]，默认值为空数组。当然，若只有一个异常类时，可以不使用数组。
8. noRollbackForClassName： 指定不需要回滚的异常类类名。类型为 String[]，默认值为空数组。当然，若只有一个异常类时，可以不使用数组。

需要注意的是：

  1. @Transactional 若用在方法上，只能用于 public 方法上。对于其他非 public 方法，如果加上了注解 @Transactional，虽然 Spring 不会报错，但不会将指定事务织入到该方法中，因为 Spring 会忽略掉所有非 public 方法上的 @Transaction 注解。
  2. 若 @Transaction 注解在类上，则表示该类上所有的（public）方法均将在执行时织入事务。

# Spring 声明式事务配置

# 纯xml模式

引入jar包：

<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>5.1.12.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.aspectj</groupId>
  <artifactId>aspectjweaver</artifactId>
  <version>1.9.4</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-jdbc</artifactId>
  <version>5.1.12.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-tx</artifactId>
  <version>5.1.12.RELEASE</version>
</dependency>

xml配置

<beans xmlns="......
              xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="......
        http://www.springframework.org/schema/tx
        https://www.springframework.org/schema/tx/spring-tx.xsd
">
		
 		<!--......-->
 
  	<!--Spring声明式事务配置，声明式事务无非就是配置一个aop，只不过有些标签不一样罢了-->
    <!--配置事务管理器, 横切逻辑-->
    <!--横切逻辑-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <constructor-arg name="dataSource" ref="dataSource"/>
    </bean>
    <!--定制事务细节，传播⾏为、隔离级别等-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
      <tx:attributes>
          <!--⼀般性配置-->
          <tx:method name="*" read-only="false" propagation="REQUIRED" isolation="DEFAULT" timeout="-1"/>
          <!--针对查询的覆盖性配置-->
          <tx:method name="query*" read-only="true" propagation="SUPPORTS"/>
      </tx:attributes>
    </tx:advice>

    <aop:config>
      <!--advice-ref指向增强=横切逻辑+⽅位-->
      <aop:advisor advice-ref="txAdvice" pointcut="execution(* com.example.transfer.service.impl.TransferServiceImpl.*(..))"/>
    </aop:config>
</beans>

# XML+注解

xml配置

<!--配置事务管理器-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
 <property name="dataSource" ref="dataSource"/>
</bean>
<!--开启spring对注解事务的⽀持-->
<tx:annotation-driven transaction-manager="transactionManager"/>

在接⼝、类或者⽅法上添加@Transactional注解

@Transactional(readOnly = true,propagation = Propagation.SUPPORTS)

# 纯注解

Spring基于注解驱动开发的事务控制配置，只需要把 xml 配置部分改为注解实现。只是需要⼀个注解替换掉xml配置⽂件中的 <tx:annotation-driven transaction-manager="transactionManager"/> 配置。

在 Spring 的配置类上添加 @EnableTransactionManagement 注解即可'

// 开启spring注解事务的⽀持
@EnableTransactionManagement
public class SpringConfiguration {
}
上次更新: 11/29/2023, 12:35:02 AM
Spring AOP源码剖析

Spring AOP源码剖析→

最近更新
01
2025
01-15
02
Elasticsearch面试题
07-17
03
Elasticsearch进阶
07-16
更多文章>
Theme by Vdoing