• 07 Spring事务

    目录

    一、Spring事务_事务简介

    二、Spring事务_事务管理方案

    三、Spring事务_事务管理器

    四、Spring事务_事务控制的API

    五、Spring事务_事务的相关配置

    六、Spring事务_事务的传播行为

    七、Spring事务_事务的隔离级别

    八、Spring事务_注解配置声明式事务

    第一种：半注解半配置文件方式

    第二种：全注解方式（配置类方式）

    九、知识点整理：

    一、Spring事务_事务简介

     事务：不可分割的原子操作，即一系列的操作要么同时成功，要么同时失败。

    开发过程中，事务管理一般在 service 层， service 层中可能会操作多次数据库，这些操作是不可分割的。否则当程序报错时，可能会造 成数据异常 。

    如：张三给李四转账时，需要两次操作数据库：张三存款减少、李四存款增加。如果这两次数据库操作间出现异常，则会造成数据错误。
    项目结构：

     1.准备数据库

    1. CREATE DATABASE `spring` ;
    2. USE `spring`;
    3. DROP TABLE IF EXISTS `account`;
    4. CREATE TABLE `account` (
    5.   `id` int(11) NOT NULL AUTO_INCREMENT,
    6.   `username` varchar(255) DEFAULT NULL,
    7.   `balance` double DEFAULT NULL,
    8.   PRIMARY KEY (`id`) ) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT
    9. CHARSET=utf8;
    10. insert  into
    11. `account`(`id`,`username`,`balance`)
    12. values (1,'张三',1000),(2,'李四',1000);

    2.创建Maven项目，引入依赖

    1. <dependencies>
    2.         
    3.         <dependency>
    4.             <groupId>org.mybatisgroupId>
    5.             <artifactId>mybatisartifactId>
    6.             <version>3.5.7version>
    7.         dependency>
    8.  
    9.         
    10.         <dependency>
    11.             <groupId>mysqlgroupId>
    12.             <artifactId>mysql-connector-javaartifactId>
    13.             <version>8.0.26version>
    14.         dependency>
    15.  
    16.         
    17.         <dependency>
    18.             <groupId>org.aspectjgroupId>
    19.             <artifactId>aspectjweaverartifactId>
    20.             <version>1.8.7version>
    21.         dependency>
    22.  
    23.         
    24.         <dependency>
    25.             <groupId>org.springframeworkgroupId>
    26.             <artifactId>spring-contextartifactId>
    27.             <version>5.3.13version>
    28.         dependency>
    29.         
    30.         <dependency>
    31.             <groupId>org.springframeworkgroupId>
    32.             <artifactId>spring-txartifactId>
    33.             <version>5.2.12.RELEASEversion>
    34.         dependency>
    35.         <dependency>
    36.             <groupId>org.springframeworkgroupId>
    37.             <artifactId>spring-jdbcartifactId>
    38.             <version>5.2.12.RELEASEversion>
    39.         dependency>
    40.  
    41.         
    42.         <dependency>
    43.             <groupId>org.mybatisgroupId>
    44.             <artifactId>mybatis-springartifactId>
    45.             <version>2.0.6version>
    46.         dependency>
    47.  
    48.         
    49.         <dependency>
    50.             <groupId>com.alibabagroupId>
    51.             <artifactId>druidartifactId>
    52.             <version>1.2.8version>
    53.         dependency>
    54.  
    55.         
    56.         <dependency>
    57.             <groupId>junitgroupId>
    58.             <artifactId>junitartifactId>
    59.             <version>4.12version>
    60.             <scope>testscope>
    61.         dependency>
    62.  
    63.         
    64.         <dependency>
    65.             <groupId>org.springframeworkgroupId>
    66.             <artifactId>spring-testartifactId>
    67.             <version>5.2.12.RELEASEversion>
    68.         dependency>
    69.     dependencies>

    3.创建配置文件applicationContext.xml

    1. <beans xmlns="http://www.springframework.org/schema/beans"
    2.        xmlns:context="http://www.springframework.org/schema/context"
    3.        xmlns:aop="http://www.springframework.org/schema/aop"
    4.        xmlns:tx="http://www.springframework.org/schema/tx"
    5.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    6.        xmlns:comtext="http://www.springframework.org/schema/c"
    7.        xsi:schemaLocation="http://www.springframework.org/schema/beans
    8.        http://www.springframework.org/schema/beans/spring-beans.xsd
    9.        http://www.springframework.org/schema/context
    10.        http://www.springframework.org/schema/context/spring-context.xsd
    11.        http://www.springframework.org/schema/aop
    12.        http://www.springframework.org/schema/aop/spring-aop.xsd
    13.        http://www.springframework.org/schema/tx
    14.        http://www.springframework.org/schema/tx/spring-tx.xsd">
    15.     
    16.     <context:component-scan base-package="com.itbaizhan"/>
    17.  
    18.     
    19.     <context:property-placeholder location="db.properties">context:property-placeholder>
    20.  
    21.     
    22.     <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    23.         <property name="driverClassName" value="${jdbc.driverClassName}">property>
    24.         <property name="url" value="${jdbc.url}">property>
    25.         <property name="username" value="${jdbc.username}">property>
    26.         <property name="password" value="${jdbc.password}">property>
    27.     bean>
    28.  
    29.     
    30.     <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    31.         <property name="dataSource" ref="dataSource">property>
    32.     bean>
    33.  
    34.     
    35.     <bean id="mapperScanner" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    36.         
    37.         <property name="basePackage" value="com.itbaizhan.dao">property>
    38.     bean>
    39. beans>

    4.在domain层编写实体类Account代码

    1. // 账户
    2. public class Account {
    3.     private int id; // 账号
    4.     private String username; // 用户名
    5.     private double balance; // 余额
    6.     
    7.     // 省略getter/setter/tostring/构造方法
    8. }

    5.在dao层编写AccountDao接口

    1. @Repository
    2. public interface AccountDao {
    3. //      根据id查找用户
    4.     @Select("select * from account where id = #{id} ")
    5.     Account findById(int id);
    6.  
    7. //      修改用户
    8.     @Update("update account set balance = #{balance} where id = #{id} ")
    9.     void update(Account account);
    10. }

    6.在service层编写AccountService类

    1. @Service("accountService")
    2. public class AccountService {
    3.     @Autowired
    4.     private AccountDao accountDao;
    5.  
    6.     /**
    7.      * 转账
    8.      * @param id1     转出人id
    9.      * @param id2     转入人id
    10.      * @param price    金额
    11.      */
    12.     public void transfer(int id1,int id2,double price){
    13. //        转出人减少余额
    14.         Account account1 = accountDao.findById(id1);
    15.         account1.setBalance(account1.getBalance()-price);
    16.         accountDao.update(account1);
    17.  
    18.         int i = 1/0;//设置异常，模拟程序出错
    19.  
    20. //        转入人增加金额
    21.         Account account2 = accountDao.findById(id2);
    22.         account2.setBalance(account2.getBalance()+price);
    23.         accountDao.update(account2);
    24.     }
    25. }

    7.测试转账

    1. @RunWith(SpringJUnit4ClassRunner.class)
    2. @ContextConfiguration(locations = "classpath:applicationContext.xml")
    3. public class serviceTest {
    4.     @Autowired
    5.     private AccountService accountService;
    6.  
    7.     @Test
    8.     public void testTransfer(){
    9.         accountService.transfer(1,2,500);
    10.     }
    11. }
    8.测试结果：
    程序执行了异常前面的代码，异常后面的代码没有执行，此时没有事务管理，会造成张三的余额减少，而李四的余额并没有增加。所以事务处理位于业务层，即一个service 方法是不能分割的。

    二、Spring事务_事务管理方案

     在service层手动添加事务可以解决该问题：

    1. @Service("accountService")
    2. public class AccountService {
    3.     @Autowired
    4.     private AccountDao accountDao;
    5.  
    6.     /**
    7.      * 转账
    8.      * @param id1     转出人id
    9.      * @param id2     转入人id
    10.      * @param price    金额
    11.      */
    12.     public void transfer(int id1,int id2,double price){
    13.      try{
    14.             //        转出人减少余额
    15.         Account account1 = accountDao.findById(id1);
    16.         account1.setBalance(account1.getBalance()-price);
    17.         accountDao.update(account1);
    18.  
    19.         int i = 1/0;//设置异常，模拟程序出错
    20.  
    21. //        转入人增加金额
    22.         Account account2 = accountDao.findById(id2);
    23.         account2.setBalance(account2.getBalance()+price);
    24.         accountDao.update(account2);
    25.             sqlSession.commit();
    26.         }catch(Exception e){
    27.             sqlSession.rollback();
    28.          }
    29.  
    30.     }
    31. }
    但在 Spring 管理下不允许手动提交和回滚事务。此时我们需要使用Spring的事务管理方案，在 Spring 框架中提供了两种事务管理方案：
    1.   编程式事务：通过编写代码实现事务管理。
    2.声明式事务：基于AOP技术实现事务管理。
    在Spring框架中，编程式事务管理很少使用，我们对声明式事务管理进行详细学习。
    Spring的声明式事务管理在底层采用了AOP 技术，其最大的优点在于无需通过编程的方式管理事务，只需要在配置文件中进行相关的规则声明，就可以将事务规则应用到业务逻辑中。
    使用AOP技术为service方法添加如下通知：

    三、Spring事务_事务管理器

     Spring依赖事务管理器进行事务管理，事务管理器即一个通知类，我们为该通知类设置切点为service层方法即可完成事务自动管理。由于不同技术操作数据库，进行事务操作的方法不同。如：JDBC提交事务是 connection.commit() ，MyBatis提交事务是 sqlSession.commit() ，所以Spring提供了多个事务管理器。

    事务管理器名称作用
    org.springframework.jdbc.datasource.DataSourceTransactionManager针对JDBC技术提供的事务管理器，适用于JDBC和MyBatis
    org.springframework.orm.hibernate3.HibernateTransactionManger针对于Hibernate框架提供的事务管理器。适用于Hibernate
    org.springframework.orm.jpa.JpaTransactionManger针对于JPA技术提供的事务管理器。适用于JPA
    org.springframework.transaction.jta.JtaTransactionManger跨越了多个事务管理源。适用在两个或者多个不同的数据源中实现事务控制。

     我们使理。

     1.引入依赖

    2. <dependency>
    3.     <groupId>org.springframeworkgroupId>
    4.     <artifactId>spring-txartifactId>
    5.     <version>5.3.13version>
    6. dependency>
    8. <dependency>
    9.     <groupId>org.aspectjgroupId>
    10.     <artifactId>aspectjweaverartifactId>
    11.     <version>1.8.7version>
    12. dependency>

    2.在配置文件中引入约束

    1. xmlns:aop="http://www.springframework.org/schema/aop"
    2. xmlns:tx="http://www.springframework.org/schema/tx"
    3. http://www.springframework.org/schema/aop
    4. http://www.springframework.org/schema/aop/spring-aop.xsd
    5. http://www.springframework.org/schema/tx
    6. http://www.springframework.org/schema/tx/spring-tx.xsd

    3.进行事务配置

    1.     
    2.     <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    3.         <property name="dataSource" ref="dataSource">property>
    4.     bean>
    5.  
    6.     
    7.     <tx:advice id="txAdvice">
    8.         <tx:attributes>
    9.             
    10.             <tx:method name="*" propagation="REQUIRED" isolation="DEFAULT"/>
    11.             
    12.             <tx:method name="find*" read-only="true" isolation="READ_UNCOMMITTED">tx:method>
    13.         tx:attributes>
    14.     tx:advice>
    15.  
    16.     
    17.     <aop:config>
    18.         
    19.         <aop:pointcut id="pointcut" expression="execution(* com.itbaizhan.service.*.*(..))"/>
    20.         
    21.         <aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut">aop:advisor>
    22.     aop:config>

    配置好Spring事务之后，这是再执行上面的“张三李四转账”操作，要么全部执行，要么全部不执行。

    四、Spring事务_事务控制的API

     Spring进行事务控制的功能是由三个接口提供的，这三个接口是Spring实现的，在开发中我们很少使用到，只需要了解他们的作用即可：

    PlatformTransactionManager 接口
    PlatformTransactionManager 是 Spring 提供的事务管理器接口，所有事务管理器都实现了该接口。
    该接口中提供了三个事务操作方法：
    TransactionStatus getTransaction（TransactionDefinition definition ）：获取事务状态信息。
    void commit（TransactionStatus status ）：事务提交
    void rollback（TransactionStatus status ）：事务回滚
    TransactionDefinition 接口
    TransactionDefinition是事务的定义信息对象， 它有如下方法：
    String getName() ：获取事务对象名称。
    int getIsolationLevel() ：获取事务的隔离级别。
    int getPropagationBehavior() ：获取事务的传播行为。
    int getTimeout() ：获取事务的超时时间。
    boolean isReadOnly() ：获取事务是否只读。
    TransactionStatus 接口
    TransactionStatus 是事务的状态接口，它描述了某一时间点上事务的状态信息。它有如下方法：
    void flush() : 刷新事务
    boolean hasSavepoint() : 获取是否存在保存点
    boolean isCompleted():  获取事务是否完成
    boolean isNewTransaction():  获取是否是新事务
    boolean isRollbackOnly():  获取是否回滚
    void setRollbackOnly() : 设置事务回滚

    五、Spring事务_事务的相关配置

    在 中可以进行事务的相关配置： 
    2.     <tx:advice id="txAdvice">
    3.         <tx:attributes>
    4.             
    5.             <tx:method name="*" propagation="REQUIRED" isolation="DEFAULT"/>
    6.             
    7.             <tx:method name="find*" read-only="true" isolation="READ_UNCOMMITTED">tx:method>
    8.         tx:attributes>
    9.     tx:advice>
    中的属性：
    name ：指定配置的方法。 * 表示所有方法， find* 表示所有以 find 开头的方法。
    read-only ：是否是只读事务，只读事务不存在数据的修改，数据库将会为只读事务提供一些
    优化手段，会对性能有一定提升，建议在查询中开启只读事务。
    timeout ：指定超时时间，在限定的时间内不能完成所有操作就会抛异常。默认永不超时(一般不配置)
    rollback-for：指定某个异常事务回滚，其他异常不回滚。默认所有异常回滚。（一般不配置)
    no-rollback-for ：指定某个异常不回滚，其他异常回滚。默认所有异常回滚。（一般不配置）
    propagation ：事务的传播行为
    isolation ：事务的隔离级别

    六、Spring事务_事务的传播行为

     事务传播行为是指多个含有事务的方法相互调用时，事务如何在这些方法间传播。

    如果在 service 层的方法中调用了其他的 service 方法，假设每次执行service方法都要开启事务，此时就无法保证外层方法和内层方法处于同一个事务当中。 
    1. // method1的所有方法在同一个事务中
    2. public void method1(){
    3.     // 此时会开启一个新事务，这就无法保证method1()
    4. 中所有的代码是在同一个事务中
    5.     method2();
    6.     System.out.println("method1");
    7. }
    8. public void method2(){
    9.     System.out.println("method2");
    10. }
    事务的传播特性就是解决这个问题的，Spring帮助我们将外层方法和内层方法放入同一事务中。
    传播行为介绍
    REQUIRED
    默认。支持当前事务，如果当前没有事务，就新建一个事务这是最常见的选择。
    SUPPORTS
    支持当前事务，如果当前没有事务，就以非事务方式执行。
    MANDATORY
    支持当前事务，如果当前没有事务，就抛出异常。
    REQUIRES_NEW
    新建事务，如果当前存在事务，把当前事务挂起。
    NOT_SUPPORTED
    以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
    NEVER
    以非事务方式执行，如果当前存在事务，则抛出异常。
    NESTED
    必须在事务状态下执行，如果没有事务则新建事务，如果当前有事务则创建一个嵌套事务

    七、Spring事务_事务的隔离级别

     事务隔离级别反映事务提交并发访问时的处理态度，隔离级别越高，数据出问题的可能性越低，但效率也会越低。

    隔离级别脏读不可重复读幻读
    READ_UNCOMMITED （读取未提交内容）
    		√√√
    READ_COMMITED （读取提交内容）
    		×√√
    REPEATABLE_READ （重复读）
    		××√
    SERIALIZABLE （可串行化）
    		×××

    √表示有，×表示没有

    如果设置为DEFAULT会使用数据库的默认隔离级别。
    SqlServer , Oracle 默认的事务隔离级别是 READ_COMMITED
    Mysql 的默认隔离级别是 REPEATABLE_READ

    八、Spring事务_注解配置声明式事务

    Spring支持使用注解配置声明式事务。用法如下：

    第一种：半注解半配置文件方式

    1.在配置文件applicationContext.xml中注册事务注解驱动

    1.    
    2.     <tx:annotation-driven transaction-manager="transactionManager">tx:annotation-driven>
    3.  
    4.     
    5.     <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    6.         <property name="dataSource" ref="dataSource">property>
    7.     bean>

    2.在需要事务支持的方法或类上加@Transactional注解

    1. @Service("accountService")
    2. //@Transactional:作用于类上时，该类的所有public方法都将具有该类型的事务属性
    3. @Transactional(propagation = Propagation.REQUIRED,isolation = Isolation.DEFAULT)
    4. public class AccountService {
    5.     @Autowired
    6.     private AccountDao accountDao;
    7.  
    8.     /**
    9.      * 转账
    10.      * @param id1     转出人id
    11.      * @param id2     转入人id
    12.      * @param price    金额
    13.      */
    14.     public void transfer(int id1,int id2,double price){
    15. //        转出人减少余额
    16.         Account account1 = accountDao.findById(id1);
    17.         account1.setBalance(account1.getBalance()-price);
    18.         accountDao.update(account1);
    19.  
    20.         int i = 1/0;//设置异常，使得操作中断，造成事务问题
    21.  
    22. //        转入人增加金额
    23.         Account account2 = accountDao.findById(id2);
    24.         account2.setBalance(account2.getBalance()+price);
    25.         accountDao.update(account2);
    26.     }
    27.  
    28.     //作用于方法上时，该方法将都具有该类型的事务属性
    29.     @Transactional(isolation = Isolation.READ_UNCOMMITTED)
    30.     public Account findById(int id){
    31.         return accountDao.findById(id);
    32.     }
    33. }

    测试方法：

    1. @RunWith(SpringJUnit4ClassRunner.class)
    2. //加载配置文件
    3. @ContextConfiguration(locations = "classpath:applicationContext.xml")
    4. public class serviceTest {
    5.     @Autowired
    6.     private AccountService accountService;
    7.  
    8.     @Test
    9.     public void testTransfer(){
    10.         accountService.transfer(1,2,500);
    11.     }
    12. }

    第二种：全注解方式（配置类方式）

    配置类代替xml中的注解事务支持：在配置类上方写 @EnableTranscationManagement 
    1. @Configuration//表名配置类
    2. @ComponentScan("com.itbaizhan")//扫描注解
    3. @EnableTransactionManagement//开启注解事务
    4. public class SpringConfig {
    5. //    创建druid连接池数据源对象
    6.     @Bean
    7.     public DataSource getDataSource(){
    8.         DruidDataSource druidDataSource = new DruidDataSource();
    9.         druidDataSource.setDriverClassName("com.mysql.jdbc.Driver");
    10.         druidDataSource.setUrl("jdbc:mysql:///spring");
    11.         druidDataSource.setUsername("root");
    12.         druidDataSource.setPassword("123456");
    13.         return druidDataSource;
    14.     }
    15.  
    16.     @Bean
    17.     public SqlSessionFactoryBean getSqlSession(DataSource dataSource){
    18.         SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
    19.         sqlSessionFactoryBean.setDataSource(dataSource);
    20.         return sqlSessionFactoryBean;
    21.     }
    22.  
    23.     @Bean
    24.     public MapperScannerConfigurer getMapperScanner(){
    25.         MapperScannerConfigurer mapperScannerConfigurer = new MapperScannerConfigurer();
    26.         mapperScannerConfigurer.setBasePackage("com.itbaizhan.dao");
    27.         return mapperScannerConfigurer;
    28.     }
    29.  
    30.     @Bean
    31.     public DataSourceTransactionManager getTransactionManager(DataSource dataSource){
    32.         DataSourceTransactionManager dataSourceTransactionManager = new DataSourceTransactionManager();
    33.         dataSourceTransactionManager.setDataSource(dataSource);
    34.         return dataSourceTransactionManager;
    35.     }
    36. }

    测试方法：

    1. @RunWith(SpringJUnit4ClassRunner.class)
    2. @ContextConfiguration(classes = SpringConfig.class)//加载配置类
    3. public class serviceTest2 {
    4.     @Autowired
    5.     private AccountService accountService;
    6.  
    7.     @Test
    8.     public void testTransfer(){
    9.         accountService.transfer(1,2,500);
    10.     }
    11. }

    九、知识点整理：

    1.事务指“不可分割的原子操作，要么全部执行，要么全部不执行”。

    2.Spring声明式事务在底层采用了AOP技术

    3.DataSourceTransactionManager 可以管理MyBatis的事务

    4.在Spring中，所有的事务管理器都实现了"PlatformTransactionManager 接口

    5. 中read-only 属性配置只读事务，isolation属性配置隔离级别

    6..在Spring中，事务的默认传播级别为REQUIRED

    7.事务的隔离级别越高，数据出问题的可能性越低，效率也会越低。

    8.在Spring中，配置声明式事务用到的注解为@Transactional

  • 相关阅读:
    【Unity3D】3D 物体概念 ① ( 轴心点概念 | 物体的父子关系 | 子节点相对坐标 )
    PMP考前梳理：敏捷知识的相关要点
    vue3中表格单选
    保护热板法导热仪中计量加热器任意设定温度及其加热电功率的超高精度PID恒定控制
    爬虫数据获取的秘诀，高效稳定让你爬个够
    专业游戏翻译公司怎么选择比较合适
    洛谷-P7910 [CSP-J 2021]-插入排序（详细讲解）
    用C#也能做机器学习？
    Java final关键字具有什么功能呢？
    C# 语言的基本语法结构
  • 原文地址：https://blog.csdn.net/m0_51697147/article/details/126138238