Spring 事务

快乐的小三菊

已于 2024-06-28 11:04:47 修改

阅读量330

点赞数

分类专栏： Spring 专栏文章标签： spring

于 2017-09-21 22:14:55 首次发布

本文链接：https://blog.csdn.net/xhf852963/article/details/78057595

版权

Spring 专栏专栏收录该内容

6 篇文章 0 订阅

订阅专栏

一、声明式事务概念

1.1 事务基本概念

1.1.1 什么是事务

数据库事务（transaction）是访问并可能操作各种数据项的一个数据库操作序列，这些操作要么全部执行，要么全部不执行，是一个不可分割的工作单位。事务由事务开始与事务结束之间执行的全部数据库操作组成。

1.1.2 事务特性

原子性：一个事务（transaction）中的所有操作，要么全部完成，要么全部不完成，不会结束在中间某个环节。事务在执行过程中发生错误，会被回滚（Rollback）到事务开始前的状态，就像这个事务从来没有执行过一样。

一致性：事务的一致性指的是在一个事务执行之前和执行之后数据库都必须处于一致性状态。如果事务成功地完成，那么系统中所有变化将正确地应用，系统处于有效状态。如果在事务中出现错误，那么系统中的所有变化将自动地回滚，系统返回到原始状态。

隔离性：指的是在并发环境中，当不同的事务同时操纵相同的数据时，每个事务都有各自的完整数据空间。由并发事务所做的修改必须与任何其他并发事务所做的修改隔离。事务查看数据更新时，数据所处的状态要么是另一事务修改它之前的状态，要么是另一事务修改它之后的状态，事务不会查看到中间状态的数据。

持久性：指的是只要事务成功结束，它对数据库所做的更新就必须保存下来。即使发生系统崩溃，重新启动数据库系统后，数据库还能恢复到事务成功结束时的状态。

1.2 编程式事务

事务功能的相关操作全部通过自己编写代码来实现，如下：

Connection conn = ...;
    
try {
    
    // 开启事务：关闭事务的自动提交
    conn.setAutoCommit(false);
    
    // 核心操作
    
    // 提交事务
    conn.commit();
    
}catch(Exception e){
    
    // 回滚事务
    conn.rollBack();
    
}finally{
    
    // 释放数据库连接
    conn.close();
    
}

1.2.1 缺陷

1、细节没有被屏蔽：具体操作过程中，所有细节都需要程序员自己来完成，比较繁琐。

2、代码复用性不高：如果没有有效抽取出来，每次实现功能都需要自己编写代码，代码就没有得到复用。

1.3 声明式事务

既然事务控制的代码有规律可循，代码的结构基本是确定的，所以框架就可以将固定模式的代码抽取出来，进行相关的封装。

封装起来后，我们只需要在配置文件中进行简单的配置即可完成操作。

二、基于注解的声明式事务

2.1 准备工作

2.1.1 添加配置

在 beans.xml 添加配置项，开启组件扫描

<!--扫描组件-->
<context:component-scan base-package="com.spring6"></context:component-scan>

2.1.2 创建表

CREATE TABLE `t_book` (
  `book_id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键',
  `book_name` varchar(20) DEFAULT NULL COMMENT '图书名称',
  `price` int(11) DEFAULT NULL COMMENT '价格',
  `stock` int(10) unsigned DEFAULT NULL COMMENT '库存（无符号）',
  PRIMARY KEY (`book_id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;
insert  into `t_book`(`book_id`,`book_name`,`price`,`stock`) values (1,'斗破苍穹',80,100),(2,'斗罗大陆',50,100);

CREATE TABLE `t_user` (
  `user_id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键',
  `username` varchar(20) DEFAULT NULL COMMENT '用户名',
  `balance` int(10) unsigned DEFAULT NULL COMMENT '余额（无符号）',
  PRIMARY KEY (`user_id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;
insert  into `t_user`(`user_id`,`username`,`balance`) values (1,'admin',1000);

2.1.3 创建相关类

1、创建 BookController

import com.spring6.tx.service.BookService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

@Controller
public class BookController {

    @Autowired
    private BookService bookService;

    public void buyBook(Integer bookId, Integer userId){
        bookService.buyBook(bookId, userId);
    }
}

2、创建接口 BookService 和实现类 BookServiceImpl

public interface BookService {
    void buyBook(Integer bookId, Integer userId);
}

import com.spring6.tx.dao.BookDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class BookServiceImpl implements BookService {

    @Autowired
    private BookDao bookDao;

    @Override
    public void buyBook(Integer bookId, Integer userId) {
        // 查询图书的价格
        Integer price = bookDao.getPriceByBookId(bookId);
        // 更新图书的库存
        bookDao.updateStock(bookId);
        // 更新用户的余额
        bookDao.updateBalance(userId, price);
    }
}

3、创建接口 BookDao 和实现类 BookDaoImpl

public interface BookDao {
    Integer getPriceByBookId(Integer bookId);

    void updateStock(Integer bookId);

    void updateBalance(Integer userId, Integer price);
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

@Repository
public class BookDaoImpl implements BookDao {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Override
    public Integer getPriceByBookId(Integer bookId) {
        String sql = "select price from t_book where book_id = ?";
        return jdbcTemplate.queryForObject(sql, Integer.class, bookId);
    }

    @Override
    public void updateStock(Integer bookId) {
        String sql = "update t_book set stock = stock - 1 where book_id = ?";
        jdbcTemplate.update(sql, bookId);
    }

    @Override
    public void updateBalance(Integer userId, Integer price) {
        String sql = "update t_user set balance = balance - ? where user_id = ?";
        jdbcTemplate.update(sql, price, userId);
    }
}

2.2 测试无事务场景

2.2.1 创建测试类

import com.spring6.tx.controller.BookController;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.junit.jupiter.SpringJUnitConfig;

@SpringJUnitConfig(locations = "classpath:bean.xml")
public class TxByAnnotationTest {

    @Autowired
    private BookController bookController;

    @Test
    public void testBuyBook(){
        bookController.buyBook(1, 1);
    }

}

执行上面的测试类，数据库表的数据状态如下：

2.2.2 模拟场景

修改 t_user 的用户余额，将其改成 50，再次执行上面的测试程序，如下，报错了，

用户购买图书，先查询图书的价格，再更新图书的库存和用户的余额，假设用户 id 为 1 的用户，购买 id 为 1 的图书，用户余额为 50，而图书价格为 80，购买图书之后，用户的余额为 -30，数据库中余额字段设置了无符号，因此无法将 -30 插入到余额字段，此时执行 sql 语句会抛出 SQLException。

2.2.3 观察结果

因为没有添加事务，图书的库存更新了，但是用户的余额没有更新，如下图，显然这样的结果是错误的，购买图书是一个完整的功能，更新库存和更新余额要么都成功要么都失败。

2.3 加入事务

2.3.1 添加事务配置

在 spring 配置文件中引入 tx 命名空间

<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"
       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">

</beans>

然后继续添加如下配置：

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="druidDataSource"></property>
</bean>

<!--
    开启事务的注解驱动
    通过注解@Transactional所标识的方法或标识的类中所有的方法，都会被事务管理器管理事务
-->
<!-- transaction-manager属性的默认值是transactionManager，如果事务管理器bean的id正好就是这个默认值，则可以省略这个属性 -->
<tx:annotation-driven transaction-manager="transactionManager" />

2.3.2 添加事务注解

因为 service 层表示业务逻辑层，一个方法表示一个完成的功能，因此处理事务一般在 service 层处理，即在 BookServiceImpl 的 buybook() 添加注解 @Transactional，如下：

@Service
public class BookServiceImpl implements BookService {

    @Autowired
    private BookDao bookDao;

    @Transactional
    @Override
    public void buyBook(Integer bookId, Integer userId) {
        // 查询图书的价格
        Integer price = bookDao.getPriceByBookId(bookId);
        // 更新图书的库存
        bookDao.updateStock(bookId);
        // 更新用户的余额
        bookDao.updateBalance(userId, price);
    }
}

2.3.3 观察结果

由于使用了 Spring 的声明式事务，更新库存和更新余额都没有执行，执行测试类之后，虽然程序报错了，但是数据库表的数据没有发生变化。

2.4 事务注解标识的位置

1、@Transactional 标识在方法上，则只会影响该方法。

2、@Transactional 标识的类上，则会影响类中所有的方法。

2.5 事务属性 - 只读

2.5.1 简介

对一个查询操作来说，如果我们把它设置成只读，就能够明确告诉数据库，这个操作不涉及写操作。这样数据库就能够针对查询操作来进行优化。

2.5.2 使用方式

@Transactional(readOnly = true)
public void buyBook(Integer bookId, Integer userId) {
    // 查询图书的价格
    Integer price = bookDao.getPriceByBookId(bookId);
    // 更新图书的库存
    bookDao.updateStock(bookId);
    // 更新用户的余额
    bookDao.updateBalance(userId, price);
}

2.5.3 观察结果

对增删改操作设置只读时会抛出异常，如执行上面的代码会抛出下面异常：

2.6 事务属性 - 超时

2.6.1 简介

事务在执行过程中，有可能因为遇到某些问题，导致程序卡住，从而长时间占用数据库资源。而长时间占用资源，大概率是因为程序运行出现了问题（可能是 Java 程序或 MySQL 数据库或网络连接等等）。此时这个很可能出问题的程序应该被回滚，撤销它已做的操作，事务结束，把资源让出来，让其他正常程序可以执行。

概括来说就是一句话：超时回滚，释放资源。

2.6.2 使用方式

// 超时时间单位秒
@Transactional(timeout = 3)
public void buyBook(Integer bookId, Integer userId) {
	try {
		TimeUnit.SECONDS.sleep(5);
	} catch (InterruptedException e) {
		e.printStackTrace();
	}
	// 查询图书的价格
	Integer price = bookDao.getPriceByBookId(bookId);
	// 更新图书的库存
	bookDao.updateStock(bookId);
	// 更新用户的余额
	bookDao.updateBalance(userId, price);
}

2.6.3 观察结果

执行过程中抛出异常如下：

2.7 事务属性 - 回滚策略

2.7.1 简介

声明式事务默认只针对运行时异常回滚，编译时异常不回滚。可以通过 @Transactional 中相关属性设置回滚策略。

1、rollbackFor 属性：需要设置一个 Class 类型的对象

2、rollbackForClassName 属性：需要设置一个字符串类型的全类名

3、noRollbackFor 属性：需要设置一个 Class 类型的对象

4、rollbackFor 属性：需要设置一个字符串类型的全类名

2.7.2 使用方式

// 当发生 ArithmeticException 异常的时候不回滚
// 下面的这两种写法均可
@Transactional(noRollbackFor = ArithmeticException.class)
//@Transactional(noRollbackForClassName = "java.lang.ArithmeticException")
public void buyBook(Integer bookId, Integer userId) {
	// 查询图书的价格
	Integer price = bookDao.getPriceByBookId(bookId);
	// 更新图书的库存
	bookDao.updateStock(bookId);
	// 更新用户的余额
	bookDao.updateBalance(userId, price);
	System.out.println(1/0);
}

2.7.3 观察结果

虽然购买图书功能中出现了数学运算异常（ArithmeticException），但是我们设置的回滚策略是，当出现 ArithmeticException 不发生回滚，因此购买图书的操作正常执行。

2.8 事务属性 - 隔离级别

2.8.1 简介

数据库系统必须具有隔离并发运行各个事务的能力，使它们不会相互影响，避免各种并发问题。一个事务与其他事务隔离的程度称为隔离级别。SQL 标准中规定了多种事务隔离级别，不同隔离级别对应不同的干扰程度，隔离级别越高，数据一致性就越好，但并发性越弱。

1、读未提交（READ UNCOMMITTED）：允许 Transaction01 读取 Transaction02 未提交的修改。

2、读已提交（READ COMMITTED）：要求 Transaction01 只能读取 Transaction02 已提交的修改。

3、可重复读（REPEATABLE READ）：确保 Transaction01 可以多次从一个字段中读取到相同的值，即 Transaction01 执行期间禁止其它事务对这个字段进行更新。

4、串行化（SERIALIZABLE）：确保 Transaction01 可以多次从一个表中读取到相同的行，在 Transaction01 执行期间，禁止其它事务对这个表进行添加、更新、删除操作。可以避免任何并发问题，但性能十分低下。

2.8.2 使用方式

@Transactional(isolation = Isolation.DEFAULT)           // 使用数据库默认的隔离级别
@Transactional(isolation = Isolation.READ_UNCOMMITTED)  // 读未提交
@Transactional(isolation = Isolation.READ_COMMITTED)    // 读已提交
@Transactional(isolation = Isolation.REPEATABLE_READ)   // 可重复读
@Transactional(isolation = Isolation.SERIALIZABLE)      // 串行化

2.9 事务属性 - 传播行为

2.9.1 简介

什么是事务的传播行为？假设在 service 类中有 a() 方法和 b() 方法，a() 方法上有事务，b() 方法上也有事务，当 a() 方法执行过程中调用了 b() 方法，事务是如何传递的？合并到一个事务里？还是开启一个新的事务？这就是事务传播行为。

2.9.2 传播行为分类

2.9.2.1 REQUIRED

spring 默认的传播属性，如果当前存在事务，则加入该事务，如果不存在事务，则创建一个事务。

当方法 a 声明了该事务，方法 b 也声明该事务时，如果方法 a 调用了方法 b，那么 b 不会再创建自己事务而是加入方法 a 的事务，他们共享同一个事务上下文，b 回滚 a 也回滚、a 回滚 b 也回滚。

当方法 a 未声明事务，方法 b 声明了该事务时，a 调用 b，会为方法 b 创建事务，而 a 不会创建事务。

2.9.2.2 SUPPORTS

如果当前存在事务，则加入该事务，如果不存在事务，则以非事务的方式执行。

当方法 a 声明了一个事务，方法 b 也声明了该事务时，如果方法 a 调用了方法 b，那么 b 不会再创建自己事务而是加入方法 a 的事务，他们共享同一个事务上下文，b 回滚 a 也回滚、a 回滚 b 也回滚。

当方法 a 未声明事务，方法 b 声明该事务，a 调用 b，a 和 b 都没有事务，出现异常时 a 和 b 都不回滚。

当然如果有一个方法 c 声明了该事务，我们直接调用该方法，出现异常也不会回滚，因为主方法是未声明事务的因此 c 也以非事务的方式执行。

2.9.2.3 MANDATORY

必须运行在一个事务中，如果当前没有事务正在发生，将抛出一个异常，即有就加入，没有就抛异常。

当方法 a 声明了一个事务，方法 b 声明了该事务时，如果方法 a 调用了方法 b，那么 b 不会再创建自己事务而是加入方法 a 的事务，他们共享同一个事务上下文，b 回滚 a 也回滚、a 回滚 b 也回滚。

当方法 a 未声明事务，方法 b 声明该事务，a 调用 b，抛出异常。

当方法 a 声明事务，方法 b 未声明事务，a 调用 b，抛出异常。

2.9.2.4 REQUIRES_NEW

开启一个新的事务，如果一个事务已经存在，则将这个存在的事务挂起，即不管有没有，直接开启一个新事务，开启的新事务和之前的事务不存在嵌套关系，之前事务被挂起。

不论方法 a 是否声明事务，方法 b 声明了该事务时，a 调用 b，都会为 b 创建一个自己的事务。

而当 a 没有事务时，b 独立事务运行；当 a 有事务时，挂起 a 的事务，等待 b 的事务执行完毕后再恢复执行 a。

2.9.2.5 NOT_SUPPORTED

以非事务方式执行操作，如果当前存在事务，则挂起当前事务。

如果方法 a 存在事务，会挂起 a 的事务，等待 b 执行完毕后再恢复执行 a。

2.9.2.6 NEVER

以非事务方式执行操作，如果当前存在事务，则抛出异常。

当方法 a 声明了一个事务，方法 b 声明了该事务时，a 调用 b，b 方法会抛出异常。

2.9.2.7 NESTED

如果当前存在事务，则在当前事务中创建一个新的嵌套事务；如果当前没有事务，则创建一个新的事务。

如果数据库支持嵌套事务，那么就会存在多个 begin 和 commit，a 调用 b，方法 b 运行完就提交了，与 a 互不影响。如果数据库不支持嵌套事务比如常用的 MySQL，那么使用 savepoint 设置保存点，如果代码出现问题需要回滚，就使用 rollback 返回到保持点，最后在代码执行完后 commit。

2.9.3 测试

1、创建接口 CheckoutService 和实现类 CheckoutServiceImpl

public interface CheckoutService {
    void checkout(Integer[] bookIds, Integer userId);
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class CheckoutServiceImpl implements CheckoutService {

    @Autowired
    private BookService bookService;

    @Override
    @Transactional
    // 一次购买多本图书
    public void checkout(Integer[] bookIds, Integer userId) {
        for (Integer bookId : bookIds) {
            bookService.buyBook(bookId, userId);
        }
    }
}

2、在 BookController 中添加方法

@Autowired
private CheckoutService checkoutService;

public void checkout(Integer[] bookIds, Integer userId){
	checkoutService.checkout(bookIds, userId);
}

3、在数据库中将用户的余额修改为 100 元

2.9.4 观察结果

可以通过 @Transactional 中的 propagation 属性设置事务传播行为，在 BookServiceImpl 中的 buyBook() 方法上加上 propagation 属性，如下：

@Transactional(propagation = Propagation.REQUIRED)
public void buyBook(Integer bookId, Integer userId) {
	// 查询图书的价格
	Integer price = bookDao.getPriceByBookId(bookId);
	// 更新图书的库存
	bookDao.updateStock(bookId);
	// 更新用户的余额
	bookDao.updateBalance(userId, price);
}

默认情况，表示如果当前线程上有已经开启的事务可用，那么就在这个事务中运行。经过观察，购买图书的方法 buyBook() 在 checkout() 中被调用，checkout() 上有事务注解，因此在此事务中执行。所购买的两本图书的价格为 80 和 50，而用户的余额为 100，因此在购买第二本图书时余额不足失败，导致整个 checkout() 回滚，即只要有一本书买不了，就都买不了。

@Transactional(propagation = Propagation.REQUIRES_NEW)
public void buyBook(Integer bookId, Integer userId) {
	// 查询图书的价格
	Integer price = bookDao.getPriceByBookId(bookId);
	// 更新图书的库存
	bookDao.updateStock(bookId);
	// 更新用户的余额
	bookDao.updateBalance(userId, price);
}

表示不管当前线程上是否有已经开启的事务，都要开启新事务。同样的场景，每次购买图书都是在 buyBook() 的事务中执行，因此第一本图书购买成功，事务结束，第二本图书购买失败，只在第二次的 buyBook() 中回滚，购买第一本图书不受影响，即能买几本就买几本。

2.9.5 49 种组合

这里都以方法 a 和方法 b 举例，a 调用 b。

1、当方法 a 事务传播方式为 REQUIRED 时

# 如果a方法在事务中运行，则b方法将继承a方法的事务。如果a方法没有事务，则b方法将在一个新的事务中运行。
REQUIRED - REQUIRED

# 如果a方法在事务中运行，则b方法将继承a方法的事务。如果a方法没有事务，则b方法将以非事务方式运行。
REQUIRED - SUPPORTS

# 如果a方法在事务中运行，则b方法将继承a方法的事务。如果a方法没有事务，则b方法将抛出异常。
REQUIRED - MANDATORY

# 无论a方法是否在事务中运行，b方法都会开启一个新的事务并在该事务中运行。
REQUIRED - REQUIRES_NEW

# 如果a方法在事务中运行，则b方法将以非事务方式运行。如果a方法没有事务，则b方法也将以非事务方式运行。
REQUIRED - NOT_SUPPORTED

# 如果a方法在事务中运行，则b方法将抛出异常。如果a方法没有事务，则b方法将以非事务方式运行。
REQUIRED - NEVER

# 如果a方法在事务中运行，则b方法将作为a方法的嵌套事务运行。如果a方法没有事务，则b方法将在一个新的事务中运行。
REQUIRED - NESTED

2、方法 a 事务传播方式为 SUPPORTS 时

# 如果a方法在事务中运行，则b方法将继承a方法的事务。如果a方法没有事务，则b方法将在一个新的事务中运行。
SUPPORTS - REQUIRED

# 无论a方法是否在事务中运行，b方法都不会开启新的事务，而是以非事务方式运行。
SUPPORTS - SUPPORTS

# 如果a方法在事务中运行，则b方法将继承a方法的事务。如果a方法没有事务，则b方法将抛出异常。
SUPPORTS - MANDATORY

# 无论a方法是否在事务中运行，b方法都会开启一个新的事务并在该事务中运行。
SUPPORTS - REQUIRES_NEW

# 无论a方法是否在事务中运行，b方法都将以非事务方式运行。
SUPPORTS - NOT_SUPPORTED

# 如果a方法在事务中运行，则b方法将抛出异常。如果a方法没有事务，则b方法将以非事务方式运行。
SUPPORTS - NEVER

# 如果a方法在事务中运行，则b方法将作为a方法的嵌套事务运行。如果a方法没有事务，则b方法将以非事务方式运行。
SUPPORTS - NESTED

3、方法 a 事务传播方式为 MANDATORY 时

# 如果a方法在事务中运行，则b方法将继承a方法的事务。如果a方法没有事务，则b方法将抛出异常。
MANDATORY - REQUIRED

# 如果a方法在事务中运行，则b方法将继承a方法的事务。如果a方法没有事务，则b方法将以非事务方式运行。
MANDATORY - SUPPORTS

# 如果a方法在事务中运行，则b方法将继承a方法的事务。如果a方法没有事务，则b方法将抛出异常。
MANDATORY - MANDATORY

# 无论a方法是否在事务中运行，b方法都会开启一个新的事务并在该事务中运行。
MANDATORY - REQUIRES_NEW

# 如果a方法在事务中运行，则b方法将以非事务方式运行。如果a方法没有事务，则b方法也将以非事务方式运行。
MANDATORY - NOT_SUPPORTED

# 如果a方法在事务中运行，则b方法将抛出异常。如果a方法没有事务，则b方法将以非事务方式运行。
MANDATORY - NEVER

# 如果a方法在事务中运行，则b方法将作为a方法的嵌套事务运行。如果a方法没有事务，则b方法将抛出异常。
MANDATORY - NESTED

4、方法 a 事务传播方式为 REQUIRES_NEW 时

# 无论a方法是否在事务中运行，b方法都会开启一个新的事务并在该事务中运行。
REQUIRES_NEW - REQUIRED

# 无论a方法是否在事务中运行，b方法都会开启一个新的事务并在该事务中运行。
REQUIRES_NEW - SUPPORTS

# 无论a方法是否在事务中运行，b方法都会开启一个新的事务并在该事务中运行。
REQUIRES_NEW - MANDATORY

# 无论a方法是否在事务中运行，b方法都会开启一个新的事务并在该事务中运行。
REQUIRES_NEW - REQUIRES_NEW

# 无论a方法是否在事务中运行，b方法都将以非事务方式运行。
REQUIRES_NEW - NOT_SUPPORTED

# 无论a方法是否在事务中运行，b方法都会以非事务方式运行。
REQUIRES_NEW - NEVER

# 无论a方法是否在事务中运行，b方法都会开启一个新的事务并在该事务中运行。
REQUIRES_NEW - NESTED

5、方法 a 事务传播方式为 NOT_SUPPORTED 时

# 如果a方法在事务中运行，则b方法将以非事务方式运行。如果a方法没有事务，则b方法将在一个新的事务中运行。
NOT_SUPPORTED - REQUIRED

# 无论a方法是否在事务中运行，b方法都将以非事务方式运行。
NOT_SUPPORTED - SUPPORTS

# 如果a方法在事务中运行，则b方法将以非事务方式运行。如果a方法没有事务，则b方法将抛出异常。
NOT_SUPPORTED - MANDATORY

# 无论a方法是否在事务中运行，b方法都会开启一个新的事务并在该事务中运行。
NOT_SUPPORTED - REQUIRES_NEW

# 无论a方法是否在事务中运行，b方法都将以非事务方式运行。
NOT_SUPPORTED - NOT_SUPPORTED

# 如果a方法在事务中运行，则b方法将抛出异常。如果a方法没有事务，则b方法将以非事务方式运行。
NOT_SUPPORTED - NEVER

# 如果a方法在事务中运行，则b方法将以非事务方式运行。如果a方法没有事务，则b方法将在一个新的事务中运行。
NOT_SUPPORTED - NESTED

6、方法 a 事务传播方式为 NEVER 时

# 如果a方法在事务中运行，则b方法将抛出异常。如果a方法没有事务，则b方法将在一个新的事务中运行。
NEVER - REQUIRED

# 如果a方法在事务中运行，则b方法将抛出异常。如果a方法没有事务，则b方法将以非事务方式运行。
NEVER - SUPPORTS

# 如果a方法在事务中运行，则b方法将抛出异常。如果a方法没有事务，则b方法将抛出异常。
NEVER - MANDATORY

# 无论a方法是否在事务中运行，b方法都会开启一个新的事务并在该事务中运行。
NEVER - REQUIRES_NEW

# 无论a方法是否在事务中运行，b方法都将以非事务方式运行。
NEVER - NOT_SUPPORTED

# 如果a方法在事务中运行，则b方法将抛出异常。如果a方法没有事务，则b方法将以非事务方式运行。
NEVER - NEVER

# 如果a方法在事务中运行，则b方法将抛出异常。如果a方法没有事务，则b方法将以非事务方式运行。
NEVER - NESTED

7、方法 a 事务传播方式为 NESTED 时

# 如果a方法在事务中运行，则b方法将作为a方法的嵌套事务运行。如果a方法没有事务，则b方法将在一个新的事务中运行。
NESTED - REQUIRED

# 如果a方法在事务中运行，则b方法将作为a方法的嵌套事务运行。如果a方法没有事务，则b方法将以非事务方式运行。
NESTED - SUPPORTS

# 如果a方法在事务中运行，则b方法将作为a方法的嵌套事务运行。如果a方法没有事务，则b方法将抛出异常。
NESTED - MANDATORY

# 无论a方法是否在事务中运行，b方法都会开启一个新的事务并在该事务中运行。
NESTED - REQUIRES_NEW

# 如果a方法在事务中运行，则b方法将以非事务方式运行。如果a方法没有事务，则b方法将以非事务方式运行。
NESTED - NOT_SUPPORTED

# 如果a方法在事务中运行，则b方法将抛出异常。如果a方法没有事务，则b方法将以非事务方式运行。
NESTED - NEVER

# 如果a方法在事务中运行，则b方法将作为a方法的嵌套事务运行。如果a方法没有事务，则b方法将在一个新的事务中运行。
NESTED - NESTED

2.10 全注解配置事务

2.10.1 创建配置类

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import javax.sql.DataSource;

@Configuration
@ComponentScan("com.spring6")
// 开启事务
@EnableTransactionManagement
public class SpringConfig {

    @Bean
    public DataSource getDataSource(){
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/spring?characterEncoding=utf8&useSSL=false");
        dataSource.setUsername("root");
        dataSource.setPassword("123456");
        return dataSource;
    }

    @Bean(name = "jdbcTemplate")
    public JdbcTemplate getJdbcTemplate(DataSource dataSource){
        JdbcTemplate jdbcTemplate = new JdbcTemplate();
        jdbcTemplate.setDataSource(dataSource);
        return jdbcTemplate;
    }

    @Bean
    public DataSourceTransactionManager getDataSourceTransactionManager(DataSource dataSource){
        DataSourceTransactionManager dataSourceTransactionManager = new DataSourceTransactionManager();
        dataSourceTransactionManager.setDataSource(dataSource);
        return dataSourceTransactionManager;
    }
}

2.10.2 测试

public class TxByAllAnnotationTest {

    @Test
    public void testTxAllAnnotation(){
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringConfig.class);
        BookController accountService = applicationContext.getBean("bookController", BookController.class);
        accountService.buyBook(1, 1);
    }
}

三、基于 XML 的声明式事务

3.1 修改 Spring 配置文件

将 Spring 配置文件中去掉 tx:annotation-driven 标签，并添加配置，完整的配置文件如下所示：

<?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:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       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/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd
       http://www.springframework.org/schema/tx
       http://www.springframework.org/schema/tx/spring-tx.xsd">

    <!-- 导入外部属性文件 -->
    <context:property-placeholder location="classpath:jdbc.properties" />
    <!--扫描组件-->
    <context:component-scan base-package="com.spring6"></context:component-scan>

    <!-- 配置数据源 -->
    <bean id="druidDataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="url" value="${jdbc.url}"/>
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="username" value="${jdbc.user}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>
    <!-- 配置 JdbcTemplate -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <!-- 装配数据源 -->
        <property name="dataSource" ref="druidDataSource"/>
    </bean>

    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="druidDataSource"></property>
    </bean>
    <aop:config>
        <!-- 配置事务通知和切入点表达式 -->
        <aop:advisor advice-ref="txAdvice" pointcut="execution(* com.spring6.tx.service.*.*(..))"></aop:advisor>
    </aop:config>
    <!-- tx:advice标签：配置事务通知 -->
    <!-- id 属性：给事务通知标签设置唯一标识，便于引用 -->
    <!-- transaction-manager属性：关联事务管理器 -->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
             <!-- tx:method标签：配置具体的事务方法 -->
             <!-- name属性：指定方法名，可以使用星号代表多个字符 -->
             <tx:method name="get*" read-only="true"/>
             <tx:method name="query*" read-only="true"/>
             <tx:method name="buy*" read-only="false"/>

             <!-- read-only属性：设置只读属性 -->
             <!-- rollback-for属性：设置回滚的异常 -->
             <!-- no-rollback-for属性：设置不回滚的异常 -->
             <!-- isolation属性：设置事务的隔离级别 -->
             <!-- timeout属性：设置事务的超时属性 -->
             <!-- propagation属性：设置事务的传播行为 -->
             <tx:method name="save*" read-only="false" rollback-for="java.lang.Exception" propagation="REQUIRES_NEW"/>
             <tx:method name="update*" read-only="false" rollback-for="java.lang.Exception" propagation="REQUIRES_NEW"/>
             <tx:method name="delete*" read-only="false" rollback-for="java.lang.Exception" propagation="REQUIRES_NEW"/>
        </tx:attributes>
    </tx:advice>
</beans>

3.2 注意

基于 xml 实现的声明式事务，必须引入 aspectJ 的依赖

<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-aspects</artifactId>
	<version>6.0.16</version>
</dependency>

快乐的小三菊

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
1
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录