Spring事务-阿里云开发者社区

一、事务简述

1、什么是事务（ Transaction（tx））

在⼀个业务流程当中，通常需要多条DML（insert delete update）语句共同联合才能完成，这多条DML语句必须同时成功，或者同时失败，这样才能保证数据的安全。

多条DML要么同时成功，要么同时失败，这叫做事务。

2、事务的四个处理过程

第⼀步：开启事务 (start transaction)

第⼆步：执⾏核⼼业务代码

第三步：提交事务（如果核⼼业务处理过程中没有出现异常）(commit transaction)

第四步：回滚事务（如果核⼼业务处理过程中出现异常）(rollback transaction)

3、事务的四个特性：

A 原⼦性：事务是最⼩的⼯作单元，不可再分。

C ⼀致性：事务要求要么同时成功，要么同时失败。事务前和事务后的总量不变。

I 隔离性：事务和事务之间因为有隔离性，才可以保证互不⼲扰。

D 持久性：持久性是事务结束的标志

二、Spring事务

1、简述

Spring实现事务的两种⽅式

第一种：编程式事务

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

第二种：声明式事务

既然事务控制的代码有规律可循，代码的结构基本是确定的，所以框架就可以将固定模式的代码抽取出来，进行相关的封装。封装起来后，我们只需要在配置文件中进行简单的配置即可完成操作。有基于注解⽅式和基于XML配置⽅式

Spring对事务的管理底层实现⽅式是基于AOP实现的。采⽤AOP的⽅式进⾏了封装。所以Spring专⻔针对事务开发了⼀套API，API的核⼼接⼝如下：

PlatformTransactionManager接⼝：spring事务管理器的核⼼接⼝。在Spring6中它有两个实现：
DataSourceTransactionManager：⽀持JdbcTemplate、MyBatis、Hibernate等事务管理。 JtaTransactionManager：⽀持分布式事务管理。

如果要在Spring6中使⽤JdbcTemplate，就要使⽤DataSourceTransactionManager来管理事务。（Spring内置写好了，可以直接⽤。）

2、编程式事务

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

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

编程式的实现方式存在缺陷：

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

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

3、声明式事务之注解方式

3.1、配置

依赖

<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.3.1</version>
</dependency>
<!-- Spring 在执行持久化层操作、与持久化层技术进行整合过程中，需要使用orm、jdbc、tx三个
jar包，导入 orm 包就可以通过 Maven 的依赖传递性把其他两个也导入 -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-orm</artifactId>
    <version>5.3.1</version>
</dependency>

⼀定要集成Log4j2⽇志框架，在⽇志信息中可以看到更加详细的信息。

jdbc配置文件

jdbc.user=root
jdbc.password=root
jdbc.url=jdbc:mysql://localhost:3306/ssm
jdbc.driver=com.mysql.cj.jdbc.Driver

spring配置文件

<!--扫描组件-->
<context:component-scan base-package="com.demo.spring.tx.annotation">
</context:component-scan>
 
<!-- 导入外部属性文件 -->
<context:property-placeholder location="classpath:jdbc.properties" />
 
<!-- 配置数据源 -->
<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.username}"/>
<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="dataSource"></property>
</bean>
 
<!--
开启事务的注解驱动
通过注解@Transactional所标识的方法或标识的类中所有的方法，都会被事务管理器管理事务
-->
<!-- transaction-manager属性的默认值是transactionManager，如果事务管理器bean的id正好就
是这个默认值，则可以省略这个属性 -->
<tx:annotation-driven transaction-manager="transactionManager" />

添加注解

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

@Transactional标识在方法上，只会影响该方法

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

接口BookDao：

public interface BookDao {
Integer getPriceByBookId(Integer bookId);
void updateStock(Integer bookId);
void updateBalance(Integer userId, Integer price);
}

实现类BookDaoImpl：

@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);
}
}

接口BookService：

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

实现类BookServiceImpl：

@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);
}
}

3.2、事务属性

事务属性包括哪些

事务中的重点属性：

事务传播⾏为
事务隔离级别
事务超时
只读事务
设置出现哪些异常回滚事务
设置出现哪些异常不回滚事务

事务传播⾏为

什么是事务的传播⾏为？在service类中有a()⽅法和b()⽅法，a()⽅法上有事务，b()⽅法上也有事务，当a()⽅法执⾏过程中调⽤了 b()⽅法，事务是如何传递的？合并到⼀个事务⾥？还是开启⼀个新的事务？这就是事务传播⾏为。

事务传播⾏为在spring框架中被定义为枚举类型：

⼀共有七种传播⾏为：

REQUIRED：⽀持当前事务，如果不存在就新建⼀个(默认)【没有就新建，有就加⼊】
SUPPORTS：⽀持当前事务，如果当前没有事务，就以⾮事务⽅式执⾏【有就加⼊，没有就不管了】
MANDATORY：必须运⾏在⼀个事务中，如果当前没有事务正在发⽣，将抛出⼀个异常【有就加⼊，没有就抛异常】
REQUIRES_NEW：开启⼀个新的事务，如果⼀个事务已经存在，则将这个存在的事务挂起【不管有没有，直接开启⼀个新事务，开启的新事务和之前的事务不存在嵌套关系，之前事务被挂起】
NOT_SUPPORTED：以⾮事务⽅式运⾏，如果有事务存在，挂起当前事务【不⽀持事务，存在就挂起】
NEVER：以⾮事务⽅式运⾏，如果有事务存在，抛出异常【不⽀持事务，存在就抛异常】
NESTED：如果当前正有⼀个事务在进⾏中，则该⽅法应当运⾏在⼀个嵌套式事务中。被嵌套的事务可以独⽴于外层事务进⾏提交或回滚。如果外层事务不存在，⾏为就像REQUIRED⼀样。【有事务的话，就在这个事务⾥再嵌套⼀个完全独⽴的事务，嵌套的事务可以独⽴的提交和回滚。没有事务就和REQUIRED⼀样。】

在代码中设置事务的传播⾏为：

@Transactional(propagation = Propagation.REQUIRED)

事务隔离级别

数据库系统必须具有隔离并发运行各个事务的能力，使它们不会相互影响，避免各种并发问题。一个事务与其他事务隔离的程度称为隔离级别。

SQL标准中规定了多种事务隔离级别，不同隔离级别对应不同的干扰程度，隔离级别越高，数据一致性就越好，但并发性越弱。

数据库中读取数据存在的三⼤问题：（三⼤读问题）

脏读：读取到没有提交到数据库的数据，叫做脏读。
不可重复读：在同⼀个事务当中，第⼀次和第⼆次读取的数据不⼀样。
幻读：读到的数据是假的。

隔离级别一共有四种：

读未提交：READ UNCOMMITTED、允许Transaction01读取Transaction02未提交的修改。这种隔离级别，存在脏读问题，所谓的脏读(dirty read)表示能够读取到其它事务未提交的数据
读已提交：READ COMMITTED、要求Transaction01只能读取Transaction02已提交的修改。解决了脏读问题，其它事务提交之后才能读到，但存在不可重复读问题。
可重复读：REPEATABLE READ、确保Transaction01可以多次从一个字段中读取到相同的值，即Transaction01执行期间禁止其它事务对这个字段进行更新。解决了不可重复读，可以达到可重复读效果，只要当前事务不结束，读取到的数据⼀直都是⼀样的。但存在幻读问题。
串行化：SERIALIZABLE 、确保Transaction01可以多次从一个表中读取到相同的行，在Transaction01执行期间，禁止其它事务对这个表进行添加、更新、删除操作。可以避免任何并发问题，但性能十分低下。解决了幻读问题，事务排队执⾏。不⽀持并发。

各个隔离级别解决并发问题的能力

各种数据库产品对事务隔离级别的支持程度

使用,隔离级别在spring中以枚举类型存在：

代码使用

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

只读

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

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

对增删改操作设置只读会抛出下面异常： Caused by: java.sql.SQLException: Connection is read-only. Queries leading to data modification are not allowed

该特性的作⽤是：启动spring的优化策略。提⾼select语句执⾏效率。

如果该事务中确实没有增删改操作，建议设置为只读事务

超时

事务在执行过程中，有可能因为遇到某些问题，导致程序卡住，从而长时间占用数据库资源。而长时间占用资源，大概率是因为程序运行出现了问题（可能是Java程序或MySQL数据库或网络连接等等）。

此时这个很可能出问题的程序应该被回滚，撤销它已做的操作，事务结束，把资源让出来，让其他正常程序可以执行。

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

@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);
//System.out.println(1/0);
}

执行过程中抛出异常： org.springframework.transaction.TransactionTimedOutException

以上代码表示设置事务的超时时间为3秒。表示超过3秒如果该事务中所有的DML语句还没有执⾏完毕的话，最终结果会选择回滚。

默认值-1，表示没有时间限制。

这⾥有个坑，事务的超时时间指的是哪段时间？在当前事务当中，最后⼀条DML语句执⾏之前的时间。如果最后⼀条DML语句后⾯很有很多业务逻辑，这些业务代码执⾏的时间不被计⼊超时时间。

以下代码的超时不会被计⼊超时时间

@Transactional(timeout = 10) // 设置事务超时时间为10秒。
public void save(Account act) {
 accountDao.insert(act);
 // 睡眠⼀会
 try {
 Thread.sleep(1000 * 15);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
}

当然，如果想让整个⽅法的所有代码都计⼊超时时间的话，可以在⽅法最后⼀⾏添加⼀⾏⽆关紧要的 DML语句。

设置哪些异常回滚事务、哪些异常不回滚事务

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

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

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

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

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

@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);
}

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

表示只有发⽣RuntimeException异常或该异常的⼦类异常才回滚。

@Transactional(rollbackFor = RuntimeException.class)

3.3、事务的全注解式开发

编写⼀个类来代替配置⽂件，代码如下：

@Configuration
@ComponentScan("com.demo.bank")
@EnableTransactionManagement
public class Spring6Config {
    @Bean
    public DataSource getDataSource(){
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/spring6");
        dataSource.setUsername("root");
        dataSource.setPassword("root");
        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;
    }
}

4、声明式事务之xml方式

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

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

applicationContext.xml配置

<?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:component-scan base-package="com.demo"/>
 
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/spring6"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
    </bean>
 
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>
    </bean>
 
    <!--配置事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>
 
    <!--配置通知-->
    <!-- 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="find*" read-only="true"/>
            <!-- read-only属性：设置只读属性 -->
            <!-- rollback-for属性：设置回滚的异常 -->
            <!-- no-rollback-for属性：设置不回滚的异常 -->
            <!-- isolation属性：设置事务的隔离级别 -->
            <!-- timeout属性：设置事务的超时属性 -->
            <!-- propagation属性：设置事务的传播行为 -->
            <tx:method name="save*" propagation="REQUIRED"   read-only="false" rollback-for="java.lang.Throwable"/>
            <tx:method name="del*" propagation="REQUIRED"  read-only="false" rollback-for="java.lang.Throwable"/>
            <tx:method name="update*" propagation="REQUIRED"  read-only="false" rollback-for="java.lang.Throwable"/>
            <tx:method name="transfer*" propagation="REQUIRED"  read-only="false" rollback-for="java.lang.Throwable"/>
        </tx:attributes>
    </tx:advice>
 
    <!--配置切⾯-->
    <aop:config>
        <aop:pointcut id="txPointcut" expression="execution(* com.demo.service..*(..))"/>
        <!--切⾯ = 通知 + 切点-->
        <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointcut"/>
    </aop:config>
</beans>

事务注解 @Transactional 失效的3种场景及解决办法

Spring事务

一、事务简述

1、什么是事务（ Transaction（tx））

2、事务的四个处理过程

3、事务的四个特性：

二、Spring事务

1、简述

2、编程式事务

3、声明式事务之注解方式

3.1、配置

3.2、事务属性

事务传播⾏为

事务隔离级别

只读

超时

设置哪些异常回滚事务、哪些异常不回滚事务

3.3、事务的全注解式开发

4、声明式事务之xml方式

热门文章

最新文章

相关课程

相关电子书

探索云世界

热门

云计算

大数据

云原生

人工智能

数据库

开发与运维

活动广场

任务中心

训练营

直播

乘风者计划

下载

镜像站

技术资料

Spring事务

一、事务简述

1、什么是事务（ Transaction（tx））

2、事务的四个处理过程

3、事务的四个特性：

二、Spring事务

1、简述

2、编程式事务

3、声明式事务之注解方式

3.1、配置

3.2、事务属性

事务 传 播 ⾏ 为

事务隔离级别

只读

超时

设置哪些异常回滚事务、哪些异常不回滚事务

3.3、 事务的全注解式开发

4、声明式事务之xml方式

热门文章

最新文章

相关课程

相关电子书

事务传播⾏为

3.3、事务的全注解式开发