基础框架 spring事务的传播机制与隔离级别

不念不忘少年蓝@ 2022-12-29 09:43 96阅读 0赞

### 基础框架 spring事务的传播机制与隔离级别 ###

*   *  基础框架 spring事务的传播机制与隔离级别
     *   *  一、概念
         *   *  1. 什么是事务
             *  2. 为什么用事务
             *  3. 事务四个特性（ACID）
             *  4. 事务管理分类
         *  二、声明式事务-注解方式
         *   *  1、在 spring 配置文件配置事务管理器
             *  2、 在 spring 配置文件，开启事务注解
             *  3、在 service 类上（ 或者 service 类里面方法上面）添加事务注解
         *  三、@Transactional参数详解
         *   *  注意事项
             *  Transactional参数
             *  1. propagation：7事务传播行为
             *  2. isolation：4种事务隔离级别。
             *  3. timeout：超时时间。
             *  4. readOnly：是否只读。
             *  5. rollbackFor：回滚。
             *  6. noRollbackFor：不会滚。
         *  四、声明式事务-xml方式
         *  五、案例

## 基础框架 spring事务的传播机制与隔离级别 ##

### 一、概念 ###

#### 1. 什么是事务 ####

事务是数据库操作最基本单元，逻辑上一组操作，要么都成功，如果有一个失败所有操  
作都失败。

#### 2. 为什么用事务 ####

举个经典例子，银行转账，A给B转100块钱，这是逻辑上一组操作，但是具体是两个操作，第一步是A减少100块钱，第二步是B增加100块钱，正常情况两部完成各自提交没问题，问题是当A减少100块钱，B还未增加的时候系统挂了，就会导致数据不一致问题，这就是事务要解决的问题。

#### 3. 事务四个特性（ACID） ####

原子性，一致性，隔离性，持久性

#### 4. 事务管理分类 ####

事务管理两种方式：编程式事务管理 和 声明式事务管理  
声明式事务管理：  
（1）基于注解方式（使用）  
（2）基于 xml 配置文件方式

### 二、声明式事务-注解方式 ###

#### 1、在 spring 配置文件配置事务管理器 ####

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

#### 2、 在 spring 配置文件，开启事务注解 ####

<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.xsdhttp://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
    
    
    
    <tx:annotation-driven transactionmanager="transactionManager">< /tx:annotation-driven>

#### 3、在 service 类上（ 或者 service 类里面方法上面）添加事务注解 ####

（1）@Transactional，这个注解添加到类上面，也可以添加方法上面  
（2）如果把这个注解添加类上面，这个类里面所有的方法都添加事务  
（3）如果把这个注解添加方法上面，为这个方法添加事务。

### 三、@Transactional参数详解 ###

#### 注意事项 ####

SpringBoot使用事物
    @RestController
    @EnableTransactionManagement // 开启事务管理
    public class TransactionalController {}
    
    1. @EnableTransactionManagement注解其实在大多数情况下，不是必须的，最好在启动类加上注解管理@EnableTransactionManagement。因为SpringBoot在 TransactionAutoConfiguration类里为我们自动配置启用了@EnableTransactionManagement注解。
    
    2. 一般在service实现类添加注解@Transactional，添加注解的时候可以采用类上添加或者方法上添加，最好芳芳上，因为整个类中可能不是所有方法都需要开启事务，比如查询的方法不需要。
    
    3. Transactional 注解只能应用到 public 可见度的方法上。 如果应用在protected、private或者 package可见度的方法上，也不会报错，不过事务设置不会起作用。
    
    4. 默认情况下，Transactional 注解的事物所管理的方法中。
    	如果方法抛出运行时异常或error，那么会进行事务回滚；
    	如果方法抛出的是非运行时异常，那么不会回滚。
       
    注：SQL异常属于检查异常（有的框架将SQL异常重写为了运行时异常），但是有时我们写SQL时，检查异常并不会提示；而默认情况下，事物对检查异常不会作出回滚处理。
    
    注：在很多时候，我们除了catch一般的异常或自定义异常外，我们还习惯于catch住Exception异常；然后再抛出Exception异常。但是Exception异常属于非运行时异常(即：检查异常)，因为默认是运行时异常时事物才进行回滚，那么这种情况下，是不会回滚的。我们可以在@Transacional注解中，通过rollbackFor = {Exception.class} 来解决这个问题。即：设置当Exception异常或Exception的所有任意子类异常时事物会进行回滚。
    
    注：被catch处理了的异常，不会被事物作为判断依据；如果异常被catch 了，但是又在catch中抛出了新的异常，那么事物会以这个新的异常作 为是否进行回滚的判断依据。

#### Transactional参数 ####

<table> 
 <thead> 
  <tr> 
   <th>Transactional参数</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>propagation</td> 
   <td>事务的传播行为，默认值为 REQUIRED。</td> 
  </tr> 
  <tr> 
   <td>isolation</td> 
   <td>事务的隔离度，默认值采用 DEFAULT</td> 
  </tr> 
  <tr> 
   <td>timeout</td> 
   <td>事务的超时时间，默认值为-1，不超时。如果设置了超时时间(单位秒)，那么如果超过该时间限制了但事务还没有完成，则自动回滚事务。</td> 
  </tr> 
  <tr> 
   <td>readOnly</td> 
   <td>指定事务是否为只读事务，默认值为 false；为了忽略那些不需要事务的方法，比如读取数据，可以设置 read-only 为 true。</td> 
  </tr> 
  <tr> 
   <td>rollbackFor</td> 
   <td>回滚，用于指定能够触发事务回滚的异常类型，如果有多个异常类型需要指定，各类型之间可以通过逗号分隔。{Exception.class, RunTimeException.class,……}</td> 
  </tr> 
  <tr> 
   <td>noRollbackFor</td> 
   <td>不会滚 ,抛出 no-rollback-for 指定的异常类型，不回滚事务。{xxx1.class, xxx2.class,……}</td> 
  </tr> 
 </tbody> 
</table>

#### 1. propagation：7事务传播行为 ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NTgzNjU1_size_16_color_FFFFFF_t_70][spring7种事务传播机制][spring7]

#### 2. isolation：4种事务隔离级别。 ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NTgzNjU1_size_16_color_FFFFFF_t_70 1]

#### 3. timeout：超时时间。 ####

（1）事务需要在一定时间内提交，如果不提交进行回滚  
（2）默认值是-1，设置时间以秒为单位进行计算。

#### 4. readOnly：是否只读。 ####

（1）读：查询操作。写：添加修改删除操作  
（2）readOnly默认值是false，表示可以查询，可以添加删除修改操作。  
（3）设置readOnly值是true，表示只能查询操作。

#### 5. rollbackFor：回滚。 ####

（1）设置出现哪些异常进行事务回滚。

#### 6. noRollbackFor：不会滚。 ####

（1）设置出现哪些异常不进行事务回滚。

### 四、声明式事务-xml方式 ###

1、在 spring 配置文件中进行配置
    第一步 配置事务管理器
    第二步 配置通知第三步 配置切入点和切面
    
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    
    <property name="dataSource" ref="dataSource"></property>
    </bean>
    
    <tx:advice id="txadvice">
    
    <tx:attributes>
    
    <tx:method name="accountMoney" propagation="REQUIRED"/>
    
    </tx:attributes>
    </tx:advice>
    
    <aop:config>
    
    <aop:pointcut id="pt" expression="execution(* com.atguigu.spring5.service.UserService.*(..))"/>
    
    <aop:advisor advice-ref="txadvice" pointcut-ref="pt"/>
    </aop:config>

### 五、案例 ###

package com.spring.dao;
    
    /** * 用户DAO * * @author zrj * @date 2020/12/20 * @since V1.0 **/
    public interface UserDao { 
        /** * 多钱 */
        void addMoney();
    
        /** * 少钱 */
        void reduceMoney();
    }

package com.spring.dao;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.jdbc.core.JdbcTemplate;
    import org.springframework.stereotype.Repository;
    
    /** * 用户DAO实现类 * * @author zrj * @date 2020/12/20 * @since V1.0 **/
    @Repository
    public class UserDaoImpl implements UserDao { 
    
        @Autowired
        private JdbcTemplate jdbcTemplate;
    
        /** * lucy转账100给mary * 少钱 */
        @Override
        public void reduceMoney() { 
            String sql = "update t_account set money=money-? where username=?";
            jdbcTemplate.update( sql, 100, "lucy" );
        }
    
        /** * 多钱 */
        @Override
        public void addMoney() { 
            String sql = "update t_account set money=money+? where username=?";
            jdbcTemplate.update( sql, 100, "mary" );
        }
    }

package com.spring.service;
    
    import com.spring.dao.UserDao;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.jdbc.datasource.DataSourceTransactionManager;
    import org.springframework.stereotype.Service;
    import org.springframework.transaction.TransactionDefinition;
    import org.springframework.transaction.TransactionStatus;
    import org.springframework.transaction.annotation.Transactional;
    import org.springframework.transaction.support.DefaultTransactionDefinition;
    
    /** * 用户service * * @author zrj * @date 2020/12/20 * @since V1.0 **/
    @Service
    public class UserService { 
        @Autowired
        private UserDao userDao;
    
        @Autowired
        private DataSourceTransactionManager transactionManager;
    
        /** * 1.编程式事务管理 * 手动处理事务，异常事务回滚 */
        @Transactional
        public void transferAccounts() { 
            // 开启事务
            DefaultTransactionDefinition def = new DefaultTransactionDefinition();
            def.setName( "SomeTxName" );
            def.setPropagationBehavior( TransactionDefinition.PROPAGATION_REQUIRED );
    
            TransactionStatus status = transactionManager.getTransaction( def );
            try { 
                userDao.reduceMoney();
    
                //模拟异常
                int i = 10 / 0;
    
                //mary多100
                userDao.addMoney();
    
                // 提交事务
                transactionManager.commit( status );
            } catch (Exception ex) { 
                // 事务回滚
                transactionManager.rollback( status );
                throw ex;
            }
        }
    
        /** * 2. 声明式事务，注解方式 * 配置文件需要创建事务，开启事务 * 方法异常事务回滚，如果捕获异常tryCatch则不会抛出异常，不会回滚 */
    
        @Transactional(rollbackFor = Exception.class)
        public void accountMoney() { 
            //lucy少100
            userDao.reduceMoney();
    
            //模拟异常
            int i = 10 / 0;
    
            //mary多100
            userDao.addMoney();
        }
    
        /** * 3. 声明式事务，xml配置方式 */
        public void accountMoneyXml() { 
            //lucy少100
            userDao.reduceMoney();
    
            //模拟异常
            int i = 10 / 0;
    
            //mary多100
            userDao.addMoney();
        }
    
        /** * 4. 声明式事务，Config配置方式 */
        @Transactional
        public void accountMoneyConfig() { 
            //lucy少100
            userDao.reduceMoney();
    
            //模拟异常
            //int i = 10 / 0;
    
            //mary多100
            userDao.addMoney();
        }
    }

package com.spring.config;
    
    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;
    
    /** * spring配置类 * * @author zrj * @date 2020/12/21 * @since V1.0 **/
    @Configuration //配置类
    @ComponentScan(basePackages = "com.spring") //组件扫描
    @EnableTransactionManagement //开启事务
    public class TxConfig { 
    
        /** * 创建数据库连接池 * @return */
        @Bean
        public DruidDataSource getDruidDataSource() { 
            DruidDataSource dataSource = new DruidDataSource();
            dataSource.setDriverClassName( "com.mysql.jdbc.Driver" );
            dataSource.setUrl( "jdbc:mysql:///user_db" );
            dataSource.setUsername( "root" );
            dataSource.setPassword( "123456" );
            return dataSource;
        }
    
        /** * 创建JdbcTemplate对象 * @param dataSource * @return */
        @Bean
        public JdbcTemplate getJdbcTemplate(DataSource dataSource) { 
            //到ioc容器中根据类型找到dataSource
            JdbcTemplate jdbcTemplate = new JdbcTemplate();
            //注入dataSource
            jdbcTemplate.setDataSource( dataSource );
            return jdbcTemplate;
        }
    
        /** * 创建事务管理器 * @param dataSource * @return */
        @Bean
        public DataSourceTransactionManager getDataSourceTransactionManager(DataSource dataSource) { 
            DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
            transactionManager.setDataSource( dataSource );
            return transactionManager;
        }
    }

bean1

<?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:component-scan base-package="com.atguigu"></context:component-scan>
    
        
        <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">
            <property name="url" value="jdbc:mysql:///user_db" />
            <property name="username" value="root" />
            <property name="password" value="123456" />
            <property name="driverClassName" value="com.mysql.jdbc.Driver" />
        </bean>
    
        
        <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
            
            <property name="dataSource" ref="dataSource"></property>
        </bean>
    
        
        <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
            
            <property name="dataSource" ref="dataSource"></property>
        </bean>
    
        
        <tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>
    </beans>

bean2

<?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:component-scan base-package="com.spring"></context:component-scan>
    
        
        <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">
            <property name="url" value="jdbc:mysql:///user_db"/>
            <property name="username" value="root"/>
            <property name="password" value="123456"/>
            <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        </bean>
    
        
        <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
            
            <property name="dataSource" ref="dataSource"></property>
        </bean>
    
        
        <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
            
            <property name="dataSource" ref="dataSource"></property>
        </bean>
    
        
        <tx:advice id="txadvice">
            
            <tx:attributes>
                
                <tx:method name="accountMoneyXml" propagation="REQUIRED"/>
                
            </tx:attributes>
        </tx:advice>
    
        
        <aop:config>
            
            <aop:pointcut id="pt" expression="execution(* com.spring.service.UserService.*(..))"/>
            
            <aop:advisor advice-ref="txadvice" pointcut-ref="pt"/>
        </aop:config>
    </beans>

package com.spring.test;
    
    import com.spring.config.TxConfig;
    import com.spring.service.UserService;
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.annotation.AnnotationConfigApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    /** * spring事务测试类 * * @author zrj * @date 2020/12/21 * @since V1.0 **/
    public class SpringTransactionalTest { 
    
        /** * 编程式事务测试 */
        @Test
        public void transferAccountsTest() { 
    
            ApplicationContext context = new ClassPathXmlApplicationContext( "bean1.xml" );
            UserService userService = context.getBean( "userService", UserService.class );
            userService.transferAccounts();
        }
    
        /** * 声明式事务测试，注解方式 */
        @Test
        public void accountMoneyTest() { 
    
            ApplicationContext context = new ClassPathXmlApplicationContext( "bean1.xml" );
            UserService userService = context.getBean( "userService", UserService.class );
            userService.accountMoney();
        }
    
        /** * 声明式事务测试，xml配置方式 */
        @Test
        public void accountMoneyXmlTest() { 
    
            ApplicationContext context = new ClassPathXmlApplicationContext( "bean2.xml" );
            UserService userService = context.getBean( "userService", UserService.class );
            userService.accountMoneyXml();
        }
    
        /** * 声明式事务测试，注解方式，配置类 */
        @Test
        public void accountMoneyConfigTest() { 
    
            ApplicationContext context = new AnnotationConfigApplicationContext( TxConfig.class );
            UserService userService = context.getBean( "userService", UserService.class );
            userService.accountMoneyConfig();
        }
    
    
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NTgzNjU1_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20201221231642967.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NTgzNjU1,size_16,color_FFFFFF,t_70
[spring7]: /images/20221120/8aea2cc5415c48afb428110ab5dbd65d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NTgzNjU1_size_16_color_FFFFFF_t_70 1]: /images/20221120/c1af7e3880bd441e8add053a53119be1.png