SpringBoot 实战 (十) | 声明式事务

青旅半醒 2022-03-17 01:38 686阅读 0赞

> 微信公众号：一个优秀的废人  
> 如有问题或建议，请后台留言，我会尽力解决你的问题。

#### 前言 ####

如题，今天介绍 SpringBoot 的 声明式事务。

#### Spring 的事务机制 ####

所有的数据访问技术都有事务处理机制，这些技术提供了 API 用于开启事务、提交事务来完成数据操作，或者在发生错误时回滚数据。

而 Spring 的事务机制是用统一的机制来处理不同数据访问技术的事务处理，Spring 的事务机制提供了一个 PlatformTransactionManager 接口，不同的数据访问技术的事务使用不同的接口实现，如下表：

<table> 
 <thead> 
  <tr> 
   <th>数据访问技术</th> 
   <th align="center">实现</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>JDBC</td> 
   <td align="center">DataSourceTransactionManager</td> 
  </tr> 
  <tr> 
   <td>JPA</td> 
   <td align="center">JPATransactionManager</td> 
  </tr> 
  <tr> 
   <td>Hibernate</td> 
   <td align="center">HibernateTransactionManager</td> 
  </tr> 
  <tr> 
   <td>JDO</td> 
   <td align="center">JdoTransactionManager</td> 
  </tr> 
  <tr> 
   <td>分布式事务</td> 
   <td align="center">JtaTransactionManager</td> 
  </tr> 
 </tbody> 
</table>

#### 声明式事务 ####

Spring 支持声明式事务，即使用注解来选择需要使用事务的方法，他使用 @Transactional 注解在方法上表明该方法需要事务支持。被注解的方法在被调用时，Spring 开启一个新的事务，当方法无异常运行结束后，Spring 会提交这个事务。如：

@Transactional
    public void saveStudent(Student student){ 
            // 数据库操作
    }

注意，@Transactional 注解来自于 org.springframework.transcation.annotation 包，而不是 javax.transaction。

Spring 提供一个 @EnableTranscationManagement 注解在配置类上来开启声明式事务的支持。使用了 @EnableTranscationManagement 后，Spring 容器会自动扫描注解 @Transactional 的方法与类。@EnableTranscationManagement 的使用方式如下：

@Configuration
    @EnableTranscationManagement 
    public class AppConfig{ 
    
    }

#### 注解事务行为 ####

@Transactional 有如下表所示的属性来定制事务行为。

<table> 
 <thead> 
  <tr> 
   <th>属性</th> 
   <th align="center">含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>propagation</td> 
   <td align="center">事务传播行为</td> 
  </tr> 
  <tr> 
   <td>isolation</td> 
   <td align="center">事务隔离级别</td> 
  </tr> 
  <tr> 
   <td>readOnly</td> 
   <td align="center">事务的读写性，boolean型</td> 
  </tr> 
  <tr> 
   <td>timeout</td> 
   <td align="center">超时时间，int型，以秒为单位。</td> 
  </tr> 
  <tr> 
   <td>rollbackFor</td> 
   <td align="center">一组异常类，遇到时回滚。（rollbackFor={SQLException.class}）</td> 
  </tr> 
  <tr> 
   <td>rollbackForCalssName</td> 
   <td align="center">一组异常类名，遇到回滚，类型为 string[]</td> 
  </tr> 
  <tr> 
   <td>noRollbackFor</td> 
   <td align="center">一组异常类，遇到不回滚</td> 
  </tr> 
  <tr> 
   <td>norollbackForCalssName</td> 
   <td align="center">一组异常类名，遇到时不回滚。</td> 
  </tr> 
 </tbody> 
</table>

#### 类级别使用 @Transactional ####

@Transactional 不仅可以注解在方法上，还可以注解在类上。注解在类上时意味着此类的所有 public 方法都是开启事务的。如果类级别和方法级别同时使用了 @Transactional 注解，则使用在类级别的注解会重载方法级别的注解。

#### SpringBoot 的事务支持 ####

1.  自动配置的事务管理器  
    在使用 JDBC 作为数据访问技术时，配置定义如下：

@Bean
    @ConditionalOnMissingBean
    @ConditionalOnBean(DataSource.class)
    public PlatformTransactionManager transactionManager(){ 
        return new DataSourceTransactionManager(this.dataSource)
    }

在使用 JPA 作为数据访问技术时，配置定义如下：

@Bean
    @ConditionalOnMissingBean(PlatformTransactionManager.class)
    public PlatformTransactionManager transactionManager(){ 
        return new JpaTransactionManager()
    }

1.  自动开启注解事务的支持  
    SpringBoot 专门用于配置事务的类为 org.springframework.boot.autoconfigure.transcation.TransactionAutoConfiguration，此配置类依赖于 JpaBaseConfiguration 和 DataSourceTransactionManagerAutoConfiguration。  
    而在 DataSourceTransactionManagerAutoConfiguration 配置里还开启了对声明式事务的支持，代码如下：

@ConditionalOnMissingBean(AbstractTransactionManagementConfiguration.class)
    @Configuration
    @EnableTransactionManagement
    protected static class TransactionManagementConfiguration{ 
    
    }

所以在 SpringBoot 中，无须显式开启使用 @EnableTransactionManagement 注解。

#### 实战 ####

演示如何使用 Transactional 使用异常导致数据回滚与使用异常导致数据不回滚。

1.  准备工作：  
    SpringBoot 2.1.3  
    JDK 1.8  
    IDEA
2.  pom.xml 依赖：

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.1.3.RELEASE</version>
            <relativePath/> 
        </parent>
        <groupId>com.nasus</groupId>
        <artifactId>transaction</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <name>transaction</name>
        <description>transaction Demo project for Spring Boot</description>
    
        <properties>
            <java.version>1.8</java.version>
        </properties>
    
        <dependencies>
            
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-jpa</artifactId>
            </dependency>
            
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <scope>runtime</scope>
            </dependency>
            
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>1.16.20</version>
            </dependency>
            
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
            </dependency>
        </dependencies>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
    </project>

代码注释很清楚，没啥好说的。

1.  application.yaml 配置：

spring:
      # \u6570\u636E\u5E93\u76F8\u5173
      datasource:
        driver-class-name: com.mysql.cj.jdbc.Driver
        url: jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=utf8&serverTimezone=UTC&useSSL=true
        username: root
        password: 123456
      # jpa \u76F8\u5173
      jpa:
        hibernate:
          ddl-auto: update   # ddl-auto:\u8BBE\u4E3A create \u8868\u793A\u6BCF\u6B21\u90FD\u91CD\u65B0\u5EFA\u8868
        show-sql: true

1.  实体类：

import javax.persistence.Entity;
    import javax.persistence.GeneratedValue;
    import javax.persistence.Id;
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    @Data
    @Entity
    @AllArgsConstructor
    @NoArgsConstructor
    public class Student { 
    
        @Id
        @GeneratedValue
        private Integer id;
    
        private String name;
    
        private Integer age;
    }

1.  dao 层

import com.nasus.transaction.domain.Student;
    import org.springframework.data.jpa.repository.JpaRepository;
    import org.springframework.stereotype.Repository;
    
    @Repository
    public interface StudentRepository extends JpaRepository<Student, Integer> { 
    }

1.  service 层

import com.nasus.transaction.domain.Student;
    
    public interface StudentService { 
    
        Student saveStudentWithRollBack(Student student);
    
        Student saveStudentWithoutRollBack(Student student);
    
    }

实现类：

import com.nasus.transaction.domain.Student;
    import com.nasus.transaction.repository.StudentRepository;
    import com.nasus.transaction.service.StudentService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    import org.springframework.transaction.annotation.Transactional;
    
    @Service
    public class StudentServiceImpl implements StudentService { 
    
        @Autowired
        // 直接注入 StudentRepository 的 bean
        private StudentRepository studentRepository;
    
        // 使用 @Transactional 注解的 rollbackFor 属性，指定特定异常时，触发回滚
        @Transactional(rollbackFor = { IllegalArgumentException.class})
        @Override
        public Student saveStudentWithRollBack(Student student) { 
            Student s = studentRepository.save(student);
            if ("高斯林".equals(s.getName())){ 
                //硬编码，手动触发异常
                throw new IllegalArgumentException("高斯林已存在，数据将回滚");
            }
            return s;
        }
    
        // 使用 @Transactional 注解的 noRollbackFor 属性，指定特定异常时，不触发回滚
        @Transactional(noRollbackFor = { IllegalArgumentException.class})
        @Override
        public Student saveStudentWithoutRollBack(Student student) { 
            Student s = studentRepository.save(student);
            if ("高斯林".equals(s.getName())){ 
                throw new IllegalArgumentException("高斯林已存在，数据将不会回滚");
            }
            return s;
        }
    
    }

代码注释同样很清楚，没啥好说的。

1.  controller 层

import com.nasus.transaction.domain.Student;
    import com.nasus.transaction.service.StudentService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.PostMapping;
    import org.springframework.web.bind.annotation.RequestBody;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    @RestController
    @RequestMapping("/student")
    public class StudentController { 
    
        // 注入 studentservice 的 bean
        @Autowired
        private StudentService studentService;
    
        // 测试回滚情况
        @PostMapping("/withRollBack")
        public Student saveStudentWithRollBack(@RequestBody Student student){ 
            return studentService.saveStudentWithRollBack(student);
        }
    
        // 测试不回滚情况
        @PostMapping("/withOutRollBack")
        public Student saveStudentWithoutRollBack(@RequestBody Student student){ 
            return studentService.saveStudentWithoutRollBack(student);
        }
    }

#### Postman 测试结果 ####

为了更清楚地理解回滚，以 debug (调试模式) 启动程序。并在 StudentServiceImpl 的 saveStudentWithRollBack 方法上打上断点。

测试前数据库结果：  
![测试前数据库结果][1240]

1.  Postman 测试回滚  
    ![Postman 测试异常导致数据回滚][Postman]  
    debug 模式下可见数据已保存，且获得 id 为 1。：  
    ![回滚][1240 1]

继续执行抛出异常 IllegalArgumentException，将导致数据回滚：  
![导致数据回滚，控制台打印出信息][1240 2]

测试后数据库结果：并无新增数据，回滚成功。  
![测试后数据库结果][1240]

1.  Postman 测试不回滚

测试前数据库结果：  
![测试前数据库结果][1240]

遇到 IllegalArgumentException 异常数据不会回滚：  
![数据不回滚，控制台打印信息][1240 3]

测试后数据库结果：新增数据，数据不回滚。  
![新增数据，数据不回滚][1240 4]

#### 源码下载 ####

[https://github.com/turoDog/Demo/tree/master/springboot\_transaction\_demo][https_github.com_turoDog_Demo_tree_master_springboot_transaction_demo]

#### 后语 ####

以上为 SpringBoot 声明式事务的教程。最后，对 Python 、Java 感兴趣请长按二维码关注一波，我会努力带给你们价值，如果觉得本文对你哪怕有一丁点帮助，请帮忙点好看，让更多人知道。

另外，关注之后在发送 **1024** 可领取免费学习资料。资料内容详情请看这篇旧文：[Python、C++、Java、Linux、Go、前端、算法资料分享][Python_C_Java_Linux_Go]

![1240 5][]

[1240]: /images/20220317/452555ae63224c1aa9b2e4d6a37a6c9f.png
[Postman]: /images/20220317/0207da53f8e147cc9f1ef2bbffde267d.png
[1240 1]: /images/20220317/b187dab4f0cc4c14953e5d8b4f9bf524.png
[1240 2]: /images/20220317/fc6b44622879488c9a1a9bda95999c12.png
[1240 3]: /images/20220317/a79a11d6b51f4f91a45e5c0646c0edef.png
[1240 4]: /images/20220317/ccd878acda6745bca199a7b0fde49684.png
[https_github.com_turoDog_Demo_tree_master_springboot_transaction_demo]: https://github.com/turoDog/Demo/tree/master/springboot_transaction_demo
[Python_C_Java_Linux_Go]: https://www.jianshu.com/p/ed43dc8aa11e
[1240 5]: /images/20220317/8e6a6c1428864479b482992a12048f88.png