【有料】Spring声明式事务原理

已于 2022-04-16 16:34:38 修改
阅读量101 收藏 1
点赞数
分类专栏： spring 文章标签： spring
于 2022-04-16 16:34:03 首次发布
原文链接：https://mrbird.cc/Spring%E5%A3%B0%E6%98%8E%E5%BC%8F%E4%BA%8B%E5%8A%A1%E5%8E%9F%E7%90%86.html
版权

在Spring-事务管理一节中，我们了解了在Spring中如何方便的管理数据库事务，并了解了一些和事务相关的专业术语。本节将通过一个简单的例子回顾Spring声明式事务的使用，并通过源码解读内部实现原理，最后通过列举一些常见事务不生效的场景来加深对Spring事务原理的理解。

事务例子回顾

新建SpringBoot项目，Boot版本2.4.0，然后引入如下依赖：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-jdbc</artifactId>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>2.1.2</version>
    </dependency>
</dependencies>

引入了JDBC、MySQL驱动和mybatis等依赖。

然后在Spring入口类上加上@EnableTransactionManagement注解，以开启事务：

1
2
3
4
5
6
7
8

@EnableTransactionManagement
@SpringBootApplication
public class TransactionApplication {

    public static void main(String[] args) throws Exception {
        SpringApplication.run(TransactionApplication.class, args);
    }
}

接着新建名称为test的MySQL数据库，并创建USER表：

1
2
3
4
5
6

CREATE TABLE `USER` (
  `USER_ID` varchar(10) NOT NULL COMMENT '用户ID',
  `USERNAME` varchar(10) DEFAULT NULL COMMENT '用户名',
  `AGE` varchar(3) DEFAULT NULL COMMENT '用户年龄',
  PRIMARY KEY (`USER_ID`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

其中USER_ID字段非空。

在application.properties配置中添加数据库相关配置：

1
2
3
4

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=UTF-8&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=GMT%2b8

创建USER表对应实体类User：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

public class User implements Serializable {

    private String userId;
    private String username;
    private String age;

    public User(String userId, String username, String age) {
        this.userId = userId;
        this.username = username;
        this.age = age;
    }

    public User() {
    }

    public String getUserId() {
        return userId;
    }

    public void setUserId(String userId) {
        this.userId = userId;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getAge() {
        return age;
    }

    public void setAge(String age) {
        this.age = age;
    }
}

创建UserMapper：

1
2
3
4
5
6

@Mapper
public interface UserMapper {

    @Insert("insert into user(user_id,username,age) values(#{userId},#{username},#{age})")
    void save(User user);
}

包含一个新增用户的方法save。

创建Service接口UserService：

1
2
3
4
5

public interface UserService {

    void saveUser(User user);

}

其实现类UserServiceImpl：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

@Service
public class UserServiceImpl implements UserService {

    private final UserMapper userMapper;

    public UserServiceImpl(UserMapper userMapper) {
        this.userMapper = userMapper;
    }

    @Transactional
    @Override
    public void saveUser(User user) {
        userMapper.save(user);
        // 测试事务回滚
        if (!StringUtils.hasText(user.getUsername())) {
            throw new RuntimeException("username不能为空");
        }
    }
}

在SpringBoot的入口类中测试一波：

1
2
3
4
5
6
7
8
9
10
11

@EnableTransactionManagement
@SpringBootApplication
public class TransactionApplication {

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(TransactionApplication.class, args);
        UserService userService = context.getBean(UserService.class);
        User user = new User("1", null, "18");
        userService.saveUser(user);
    }
}

如果事务生效的话，这条数据将不会被插入到数据库中，运行程序后，查看库表：

可以看到数据并没有被插入，说明事务控制成功。

我们注释掉UserServiceImpl的saveUser方法上的@Transactional注解，重新运行程序，查看库表：

可以看到数据被插入到数据库中了，事务控制失效。

事务原理

@EnableTransactionManagement

上面例子中，我们通过模块驱动注解@EnableTransactionManagement开启了事务管理功能，查看其源码：

接着查看TransactionManagementConfigurationSelector的源码：

对通过Selector往IOC容器中导入组件不熟悉的读者可以参考深入学习Spring组件注册。

所以接下来我们重点关注AutoProxyRegistrar和ProxyTransactionManagementConfiguration的逻辑即可。

AutoProxyRegistrar

查看AutoProxyRegistrar的源码：

查看AopConfigUtils.registerAutoProxyCreatorIfNecessary(registry)源码：

查看InfrastructureAdvisorAutoProxyCreator的层级关系图：

这和深入理解Spring-AOP原理一文中的AnnotationAwareAspectJAutoProxyCreator的层级关系图一致，所以我们可以推断出InfrastructureAdvisorAutoProxyCreator的作用为：为目标Service创建代理对象，增强目标Service方法，用于事务控制。

ProxyTransactionManagementConfiguration

查看ProxyTransactionManagementConfiguration源码：

  1. 注册BeanFactoryTransactionAttributeSourceAdvisor增强器，该增强器需要如下两个Bean：

    • TransactionAttributeSource
    • TransactionInterceptor

  2. 注册TransactionAttributeSource：

    方法体内部创建了一个类型为AnnotationTransactionAttributeSource的Bean，查看其源码：

    查看SpringTransactionAnnotationParser源码：

  3. 注册TransactionInterceptor事务拦截器：

    查看TransactionInterceptor源码，其实现了MethodInterceptor方法拦截器接口，在深入理解Spring-AOP原理一文中曾介绍过，MethodBeforeAdviceInterceptor、AspectJAfterAdvice、AfterReturningAdviceInterceptor和AspectJAfterThrowingAdvice等增强器都是MethodInterceptor的实现类，目标方法执行的时候，对应拦截器的invoke方法会被执行，所以重点关注TransactionInterceptor实现的invoke方法：

    查看invokeWithinTransaction方法源码：

completeTransactionAfterThrowing源码如下：

这里，假如没有在@Transactional注解上指定回滚的异常类型的话，默认只对RunTimeExcetion和Error类型异常进行回滚：

commitTransactionAfterReturning源码如下：

debug验证

重新打开UserServiceImpl的saveUser方法上的@Transactional注解，然后在如下所示位置打个断点：

以debug的方式启动程序：

可以看到目标对象已经被JDK代理（目标对象实现了接口，默认走JDK动态代理。可以通过spring.aop.proxy-target-class=true配置来强制使用cglib代理，需要额外引入AOP自动装配依赖）。

在断点处执行Step Into，程序跳转到JdkDynamicAopProxy的invoke方法：

程序跳转到TransactionInterceptor的invoke方法：

 可以看到整个过程和深入理解Spring-AOP原理一文介绍的一致。

事务不生效场景

对Spring事务机制不熟悉的coder经常会遇到事务不生效的场景，这里列举两个最为常见的场景，并给出对应的解决方案。

场景一

Service方法抛出的异常不是RuntimeException或者Error类型，并且@Transactional注解上没有指定回滚异常类型。

对应的代码例子为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

@Service
public class UserServiceImpl implements UserService {

    private final UserMapper userMapper;

    public UserServiceImpl(UserMapper userMapper) {
        this.userMapper = userMapper;
    }

    @Transactional
    @Override
    public void saveUser(User user) throws Exception {
        userMapper.save(user);
        // 测试事务回滚
        if (!StringUtils.hasText(user.getUsername())) {
            throw new Exception("username不能为空");
        }
    }
}

这冲情况下，Spring并不会进行事务回滚操作。

正如@Transactional注解源码注释所述的那样：

默认情况下，Spring事务只对RuntimeException或者Error类型异常（错误）进行回滚，检查异常（通常为业务类异常）不会导致事务回滚。。

所以要解决上面这个事务不生效的问题，我们主要有以下两种方式：

  1. 手动在@Transactional注解上声明回滚的异常类型（方法抛出该异常及其所有子类型异常都能触发事务回滚）：

    1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

    @Service
public class UserServiceImpl implements UserService {

    private final UserMapper userMapper;

    public UserServiceImpl(UserMapper userMapper) {
        this.userMapper = userMapper;
    }

    @Transactional(rollbackFor = Exception.class)
    @Override
    public void saveUser(User user) throws Exception {
        userMapper.save(user);
        // 测试事务回滚
        if (!StringUtils.hasText(user.getUsername())) {
            throw new Exception("username不能为空");
        }
    }
}

  2. 方法内手动抛出的检查异常类型改为RuntimeException子类型：

    定义一个自定义异常类型ParamInvalidException：

    1
2
3
4
5
6

    public class ParamInvalidException extends RuntimeException{

    public ParamInvalidException(String message) {
        super(message);
    }
}

    修改UserServiceImpl的saveUser方法：

    1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

    @Service
public class UserServiceImpl implements UserService {

    private final UserMapper userMapper;

    public UserServiceImpl(UserMapper userMapper) {
        this.userMapper = userMapper;
    }

    @Transactional
    @Override
    public void saveUser(User user) {
        userMapper.save(user);
        // 测试事务回滚
        if (!StringUtils.hasText(user.getUsername())) {
            throw new ParamInvalidException("username不能为空");
        }
    }
}

这两种方式都能让事务按照我们的预期生效。

场景二

非事务方法直接通过this调用本类事务方法。这种情况也是比较常见的，举个例子，修改UserServiceImpl：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

@Service
public class UserServiceImpl implements UserService {

    private final UserMapper userMapper;

    public UserServiceImpl(UserMapper userMapper) {
        this.userMapper = userMapper;
    }

    @Override
    public void saveUserTest(User user) {
        this.saveUser(user);
    }

    @Transactional
    @Override
    public void saveUser(User user) {
        userMapper.save(user);
        // 测试事务回滚
        if (!StringUtils.hasText(user.getUsername())) {
            throw new ParamInvalidException("username不能为空");
        }
    }
}

在UserServiceImpl中，我们新增了saveUserTest方法，该方法没有使用@Transactional注解标注，为非事务方法，内部直接调用了saveUser事务方法。

在入口类里测试该方法的调用：

1
2
3
4
5
6
7
8
9
10
11

@EnableTransactionManagement
@SpringBootApplication
public class TransactionApplication {

    public static void main(String[] args) throws Exception {
        ConfigurableApplicationContext context = SpringApplication.run(TransactionApplication.class, args);
        UserService userService = context.getBean(UserService.class);
        User user = new User("2", null, "28");
        userService.saveUserTest(user);
    }
}

启动程序，观察数据库数据：

可以看到，事务并没有回滚，数据已经被插入到了数据库中。

这种情况下事务失效的原因为：Spring事务控制使用AOP代理实现，通过对目标对象的代理来增强目标方法。而上面例子直接通过this调用本类的方法的时候，this的指向并非代理类，而是该类本身。

使用debug来验证this是否为代理对象：

这种情况下要让事务生效主要有如下两种解决方式（原理都是使用代理对象来替代this）：

  1. 从IOC容器中获取UserService Bean，然后调用它的saveUser方法：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

@Service
public class UserServiceImpl implements UserService, ApplicationContextAware {

    private final UserMapper userMapper;
    private ApplicationContext context;

    public UserServiceImpl(UserMapper userMapper) {
        this.userMapper = userMapper;
    }

    @Override
    public void saveUserTest(User user) {
        UserService userService = context.getBean(UserService.class);
        userService.saveUser(user);
    }

    @Transactional
    @Override
    public void saveUser(User user) {
        userMapper.save(user);
        // 测试事务回滚
        if (!StringUtils.hasText(user.getUsername())) {
            throw new ParamInvalidException("username不能为空");
        }
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.context = applicationContext;
    }
}

上面代码我们通过实现ApplicationContextAware接口注入了应用上下文ApplicationContext，然后从中取出UserService Bean来代替this。

  1. 从AOP上下文中取出当前代理对象：

    这种情况首先需要引入AOP Starter：

    1
2
3
4

    <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

    然后在SpringBoot入口类中通过注解@EnableAspectJAutoProxy(exposeProxy = true)将当前代理对象暴露到AOP上下文中（通过AopContext的ThreadLocal实现）。

    最后在UserServcieImpl的saveUserTest方法中通过AopContext获取UserServce的代理对象：

    1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

    @Service
public class UserServiceImpl implements UserService {

    private final UserMapper userMapper;

    public UserServiceImpl(UserMapper userMapper) {
        this.userMapper = userMapper;
    }

    @Override
    public void saveUserTest(User user) {
        UserService userService = (UserService) AopContext.currentProxy();
        userService.saveUser(user);
    }

    @Transactional
    @Override
    public void saveUser(User user) {
        userMapper.save(user);
        // 测试事务回滚
        if (!StringUtils.hasText(user.getUsername())) {
            throw new ParamInvalidException("username不能为空");
        }
    }

}

转自：Spring声明式事务原理 | MrBird

daobuxinzi
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring学习笔记(十六)-声明式事务的例子
05-24
NULL 博文链接：https://vzhchv0010.iteye.com/blog/356142
Spring声明式事务原理
Java是世界上最好的语言
05-03 1696
本文我们将通过一个简单的例子回顾Spring声明式事务的使用，并通过源码解读内部实现原理，最后通过列举一些常见事务不生效的场景来加深对Spring事务原理的理解。 1. 案例 新建SpringBoot项目，然后引入如下依赖： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter</artifactId> &lt
spring 声明式事务例子
赖进杰的专栏
03-29 548
spring支持编程式事务管理和声明式事务管理两种方式。 编程式事务管理使用TransactionTemplate或者直接使用底层的PlatformTransactionManager。对于编程式事务管理，spring推荐使用TransactionTemplate。 声明式事务管理建立在AOP之上的。其本质是对方法前后进行拦截，然后在目标方法开始之前创建或者加入一个事务，在执行完目标方法之后根...
Spring声明式事务示例
最佳 Java 编程
05-05 153
事务是具有ACID （原子的，一致的，隔离的和持久的）属性的工作单元。 原子意味着所有更改都发生或什么都没有发生。 如果从一个帐户借钱并贷记到另一个帐户，则交易将确保借记和贷项均已完成或均未完成。 一致表示更改使数据保持一致状态。 孤立表示更改不会干扰其他更改。 持久意味着更改一旦提交，就保持提交。 关系数据库等资源管理器提供了一个事务管理器和一个用于控制事务的API。 熟悉JDBC的人会...
spring声明式事务的测试示例
xilin6664的博客
12-13 173
测试代码如下: 运行结果如下: 数据库数据: 可以看到此时数据是没有回滚的,因为声明式事物是由AOP实现的,如上代码add方法是通过代理来执行的,而test方法是通过this来调用的,所以发生异常之后没有回滚. 改成如下: 运行结果: 此时已经回滚了. 或者改成如下直接调用test方法: 运行结果如下: 这时test方法是通过代理运行的事务回滚了. ...
spring-aop.rar_java aop_spring aop
09-23
Spring AOP是Spring框架的一个重要组成部分，它提供了一种声明式的方式来实现切面。开发者可以定义切点（pointcut）、通知（advice）、切面（aspect）等，Spring AOP会自动在适当的时候插入这些通知，从而简化代码...
精通Spring+4.x++企业应用开发实战与源码
08-15
6. **事务管理**：Spring提供了声明式和编程式事务管理，使得事务处理更加简洁，降低了出错的可能性。 7. **MVC框架**：Spring MVC是Spring的Web模块，用于构建Web应用程序，提供模型-视图-控制器模式的支持，增强...
spring开发视频高级教程.txt
10-23
- **声明式AOP**：通过XML配置或注解来实现。 - **编程式AOP**：通过动态代理等方式手动实现。 #### 4. Spring与J2EE集成 - **简介**：Spring框架与Java EE标准集成良好，可以在Java EE容器中无缝运行。 - **特点...
Spring相关外文文献和翻译.zip
12-03
Spring的AOP模块提供了声明式的企业级服务，如日志记录、性能监控、事务管理等。它通过定义切面、通知和连接点来实现，使得这些服务能独立于业务逻辑进行处理。 5. **数据访问集成**： Spring支持多种数据库访问...
Spring Framework v5.2.22.zip
最新发布
04-10
2. 面向切面编程（AOP）：提供声明式事务管理、日志记录等跨切面的功能，让代码更专注于业务逻辑。 3. Spring MVC：强大的Web MVC框架，支持RESTful API，提供模型-视图-控制器架构模式。 4. 数据访问/集成：支持...
Springboot事务的实现原理
li-zhang-yu的博客
06-12 3915
Springboot事务的实现原理 Spring实现事务的方式分为编程式和声明式，其中声明式是最为常见的，声明式事务的实现又分为XML配置文件、@Transactional注解两种实现方式，SpringBoot因为取消了XML配置文件的书写，所以SpringBoot中的事务主要是使用@Transactional注解来实现的，下面从源码角度分析其原理 已知@Transactional事务实现的原理是基于AOP来实现的，在之前的博客中详细讲解了AOP的实现原理：动态代理+拦截链，由此可以大概推测出@Tr
Spring 声明式事务实例
春风化雨
01-06 337
1、测试类 package com.tx.sm; import org.springframework.context.annotation.AnnotationConfigApplicationContext; import org.springframework.jdbc.core.JdbcTemplate; import java.util.List; import java.util.Map; public class TestTransaction3 { public stat
SpringApplication.run 流程和源码分析
激流丶的博客
07-02 1291
SpringBoot 启动的源码分析，详细介绍了启动流程和每个执行部分的源码介绍
详解 spring 声明式事务(@Transactional)
热门推荐
Purpletaro的专栏
09-24 1万+
spring事务有2种用法：编程式事务和声明式事务。 编程式事务上一篇文章中已经介绍了，不熟悉的建议先看一下编程式事务的用法。 这篇主要介绍声明式事务的用法，我们在工作中基本上用的都是声明式事务，所以这篇文章是比较重要的，建议各位打起精神，正式开始。 什么是声明式事务？ 所谓声明式事务，就是通过配置的方式，比如通过配置文件（xml）或者注解的方式，告诉spring，哪些方法需要spring帮忙管理事务，然后开发者只用关注业务代码，而事务的事情spring自动帮我们控制。 比如注解的方式，只需在方法
Spring编程式和声明式事务实例讲解
weixin_34186931的博客
05-22 441
Java面试通关手册（Java学习指南）：github.com/Snailclimb/… 历史回顾： 可能是最漂亮的Spring事务管理详解 Spring事务管理 Spring支持两种方式的事务管理： 编程式事务管理： 通过Transaction Template手动管理事务，实际应用中很少使用， 使用XML配置声明式事务： 推荐使用（代码侵入性最小），实际是通过AOP实现 实现声明式事...
Spring学习之Spring的声明式事务管理详解
一大三千的博客
05-01 1万+
声明式事务管理大多数Spring用户选择声明式事务管理的原因是，这个是对应用代码影响最小的选择，因此也最符合 非侵入式 轻量级容器的理念。 Spring声明式事务管理可以在任何环境下使用。只需更改配置文件， 它就可以和JDBC、JDO、Hibernate或其他的事务机制一起工作。 Spring的声明式事务管理可以被应用到任何类（以及那个类的实例）上。 Spring提供了声明式的回滚规则。 Sprin
springboot提供的声明式的事务管理机制
weixin_43708218的博客
06-13 1000
一、概念 声明式的事务管理是基于AOP的，在springboot中可以通过@Transactional注解的方式获得支持，这种方式的优点是： 1）非侵入式，业务逻辑不受事务管理代码的污染。 2）方法级别的事务回滚，合理划分方法的粒度可以做到符合各种业务场景的事务管理。 二、springboot mybatis事务配置 1、pom依赖 其中： 1）标签引入springboot父依赖 2）使用了spring和mybatis集成包，整合spring和mybatis 3）mysql数据库驱动包 4）序列化支持fas
Spring 声明式事务
Tom_sensen的博客
09-24 604
1、引言 Spring 的声明式事务极大地方便了日常的事务相关代码编写，它的设计如此巧妙，以至于在使用中几乎感觉不到它的存在，只需要优雅地加一个 @Transactional 注解，一切就都顺理成章地完成了！ 毫不夸张地讲，Spring 的声明式事务实在是太好用了，以至于大多数人都忘记了编程式事务应该怎么写。 不过，越是你认为理所应当的事情，如果出了问题，就越难排查。不知道你和身边的小伙伴有没有遇到过 @Transactional 失效的场景，这不但是日常开发中常踩的坑，也是面试中的高频问题。 其实
Spring 声明式事务配置方法详解
Spring 声明式事务配置方法 Spring 声明式事务配置是指在 Spring 框架中通过配置文件或注解的方式来管理事务的提交和回滚。这种配置方法可以使得事务管理变得更加灵活和可靠。 TransactionProxyFactoryBean 方式是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值