Spring学习 Spring事务控制

桃扇骨 2024-02-05 22:50 7阅读 0赞

### 7.1.事务介绍 ###

#### 7.1.1.什么是事务？ ####

当你需要一次执行多条SQL语句时，可以使用事务。通俗一点说，如果这几条SQL语句全部执行成功，则才对数据库进行一次更新，如果有一条SQL语句执行失败，则这几条SQL语句全部不进行执行，这个时候需要用到事务。

刘德华《无间道》：去不了终点，回到原点

回顾一下数据库事务的四大特性ACID：

原子性（Atomicity）
           事务是最小的执行单位，不可再分割
    
    一致性（Consistency）
           事务前后的数据都是正确的
    
    隔离性（Isolation）
          事物之间相互隔离，互不干扰（并发执行的事务彼此无法看到对方的中间状态）
    
    持久性（Durability）
           事务一旦提交不可再回滚

#### 7.1.2.数据库本身控制事物 ####

start transaction；#记录log(老数据)
          //1.本地数据库操作：张三减少金额
          //2.本地数据库操作：李四增加金额
    rollback; #根据log恢复老数据
    或
    commit; #删除log

#### 7.2.3.jdbc中使用事物 ####

**1.获取对数据库的连接**

**2.设置事务不自动提交（默认情况是自动提交的）**

conn.setAutoCommit(false);   //其中conn是第一步获取的随数据库的连接对象。

**3.把想要一次性提交的几个sql语句用事务进行提交**

try{
        
        Statement stmt = null; 
        stmt =conn.createStatement(); 
        stmt.executeUpdate(sql1); 
        int a=6/0;
        stmt.executeUpdate(Sql2); 
        . 
        . 
        . 
        conn.commit();   //使用commit提交事务 
    }

**4.捕获异常，进行数据的回滚（回滚一般写在catch块中）**

catch（Exception e） {
         
       ... 
       conn.rollback(); 
    }

### 7.2.转账案例 ###

#### 7.2.1.拷贝上一章代码 ####

![在这里插入图片描述][2ccbb35720504fd6a180ce1ef91e1b1f.png]

#### 7.2.2.添加转账业务 ####

##### 7.2.2.1.mapper #####

<?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE mapper
            PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
            "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <mapper namespace="com.by.mapper.UserMapper">
        ... ...
    
    	
    	<update id="updateUserOfSub">
    		update t_user set money=money-#{money} where name=#{source}
    	</update>
    
    	<update id="updateUserOfAdd">
    		update t_user set money=money+#{money} where name=#{target}
    	</update>
    </mapper>

public interface UserMapper {
        
    
        ... ...
    
        /**扣钱*/
        void updateUserOfSub(@Param("source") String source, @Param("money") Float money);
        /*加钱*/
        void updateUserOfAdd(@Param("target") String target, @Param("money") Float money);
    }

##### 7.2.2.2.service #####

@Service
    public class UserServiceImpl implements UserService {
        
    
        @Autowired
        private UserMapper userMapper;
    
        /**
         * 转账
         * @param source
         * @param target
         * @param money
         */
        @Override
        public void updateUser(String source, String target, Float money) {
        
            userMapper.updateUserOfSub(source, money);
            int a = 6/0;
            userMapper.updateUserOfAdd(target, money);
        }
    }

##### 7.2.2.3.测试 #####

@RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration("classpath:applicationContext.xml")//加载配置文件
    public class ServiceTest {
        
        @Autowired
        private UserService userService;
        /**
         * 转账业务
         */
        @Test
        public void testUpdate(){
        
            userService.updateUser("张三丰","宋远桥",1F);
        }
    }

1.  此时我们观察数据表里面的变化情况：
    
    ![在这里插入图片描述][43d705f4a4a9461b85e832762db61fae.png]
    
    转账是成功的，但是涉及到业务的问题，如果业务层实现类有其中一个环节出问题，都会导致灾难。
2.  我们先把数据恢复到转账前。
    
    ![在这里插入图片描述][0126b3b0a1d045f0adad8dafddffd58d.png]
    
    现在我们故意模拟转账业务出现问题

![外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传][e4a772781d6c4bf3a5fca9c17769db06.png]

再来测试：  
![在这里插入图片描述][46d4162c954343d3b82211d705395c1d.png]

业务执行出错，但是！

![在这里插入图片描述][c2c0d4afcc3e4eb8b384979e94dd813c.png]

这是因为：不满足事务的一致性（减钱的事务提交了，加钱的事务没有提交，甚至都没有执行到）。

### 7.2.Spring中事务控制的API介绍 ###

*  说明：
    
     *  JavaEE体系进行分层开发，事务处理位于业务层，Spring提供了分层设计**业务层**的事务处理解决方案。
     *  Spring框架为我们提供了一组事务控制的接口。具体在后面的小节介绍。这组接口是在spring-tx.RELEASE.jar中。
     *  spring的事务控制都是基于AOP的，它既可以使用编程的方式实现，也可以使用配置的方式实现。我们学习的重点是使用配置的方式实现。

#### 7.2.1.PlatformTransactionManager ####

*  此接口是spring的事务管理器，它里面提供了我们常用的操作事务的方法，源代码如下：
    
        public interface PlatformTransactionManager {
               
            
          	//开启事务  
            TransactionStatus getTransaction(TransactionDefinition definition) 
                						throws TransactionException; 
            //提交事务
            void commit(TransactionStatus status) throws TransactionException; 
            
          	//回滚事务
            void rollback(TransactionStatus status) throws TransactionException;   
        }
 *  真正管理事务的对象
    
    ![在这里插入图片描述][0d9debb18b7a49f2b6535c760caa9229.png]
    
    Spring为不同的orm框架提供了不同的PlatformTransactionManager接口实现类：
    
     *  DataSourceTransactionManager：使用Spring JDBC或iBatis 进行持久化数据时使用
     *  HibernateTransactionManager：使用Hibernate版本进行持久化数据时使用

#### 7.2.2.TransactionDefinition ####

*  TransactionDefinition接口包含与事务属性相关的方法，源代码如下：
    
        public interface TransactionDefinition {
              
            int PROPAGATION_REQUIRED = 0;
            int PROPAGATION_SUPPORTS = 1;
            int PROPAGATION_MANDATORY = 2;
            int PROPAGATION_REQUIRES_NEW = 3;
            int PROPAGATION_NOT_SUPPORTED = 4;
            int PROPAGATION_NEVER = 5;
            int PROPAGATION_NESTED = 6;
            int ISOLATION_DEFAULT = -1;
            int ISOLATION_READ_UNCOMMITTED = 1;
            int ISOLATION_READ_COMMITTED = 2;
            int ISOLATION_REPEATABLE_READ = 4;
            int ISOLATION_SERIALIZABLE = 8;
            int TIMEOUT_DEFAULT = -1;
            
            //传播行为
            int getPropagationBehavior();
        	//隔离级别
            int getIsolationLevel();
        
            int getTimeout();
        
            boolean isReadOnly();
        }
    
    TransactionDefinition 接口定义的事务规则包括：**事务隔离级别、事务传播行为、事务超时、事务的只读、回滚规则**属性，同时，Spring 还为我们提供了一个默认的实现类：DefaultTransactionDefinition，该类适用于大多数情况。如果该类不能满足需求，可以通过实现 TransactionDefinition 接口来实现自己的事务定义。

##### 7.2.2.1.事务隔离级别 #####

*  事务并发时的安全问题
    
    <table> 
     <thead> 
      <tr> 
       <th>问题</th> 
       <th>描述</th> 
       <th>隔离级别</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td>脏读</td> 
       <td>一个事务读取到另一个事务还未提交的数据</td> 
       <td>read-commited</td> 
      </tr> 
      <tr> 
       <td>不可重复读</td> 
       <td>一个事务内多次读取一行数据的内容，其结果不一致</td> 
       <td>repeatable-read</td> 
      </tr> 
      <tr> 
       <td>幻读</td> 
       <td>一个事务内多次读取一张表中的内容，其结果不一致</td> 
       <td>serialized-read</td> 
      </tr> 
     </tbody> 
    </table>
 *  Spring事务隔离级别（比数据库事务隔离级别多一个default）由低到高为：
    
    <table> 
     <thead> 
      <tr> 
       <th>隔离级别</th> 
       <th></th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td>ISOLATION_DEFAULT</td> 
       <td>这是一个platfromtransactionmanager默认的隔离级别，使用数据库默认的事务隔离级别。</td> 
      </tr> 
      <tr> 
       <td>ISOLATION_READ_UNCOMMITTED</td> 
       <td>这是事务最低的隔离级别，会产生脏读，不可重复读和幻像读。</td> 
      </tr> 
      <tr> 
       <td>ISOLATION_READ_COMMITTED</td> 
       <td>这种事务隔离级别可以避免脏读出现，但是可能会出现不可重复读和幻像读。 Oracle数据库默认的隔离级别。</td> 
      </tr> 
      <tr> 
       <td>ISOLATION_REPEATABLE_READ</td> 
       <td>这种事务隔离级别可以防止脏读、不可重复读，但是可能出现幻像读。MySQL数据库默认的隔离级别。</td> 
      </tr> 
      <tr> 
       <td>ISOLATION_SERIALIZABLE</td> 
       <td>这是花费最高代价但是最可靠的事务隔离级别，事务被处理为顺序执行。除了防止脏读、不可重复读外，还避免了幻像读。</td> 
      </tr> 
     </tbody> 
    </table>

##### 7.2.2.2.事务的传播行为 #####

*  什么是事务传播行为？
    
    事务传播行为（propagation behavior）指的就是当一个事务方法被另一个事务方法调用时，这个事务方法应该如何进行。  
    例如：methodA事务方法调用methodB事务方法时，methodB是继续在调用者methodA的事务中运行呢，还是为自己开启一个新事务运行，这就是由methodB的事务传播行为决定的。
 *  Spring定义了七种传播行为：
    
    <table> 
     <thead> 
      <tr> 
       <th>事务传播行为类型</th> 
       <th>说明</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td>PROPAGATION_REQUIRED</td> 
       <td>如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。<strong>这是最常见的选择</strong>。</td> 
      </tr> 
      <tr> 
       <td>PROPAGATION_SUPPORTS</td> 
       <td>支持当前事务，如果当前没有事务，就以非事务方式执行。</td> 
      </tr> 
      <tr> 
       <td>PROPAGATION_MANDATORY</td> 
       <td>使用当前的事务，如果当前没有事务，就抛出异常。</td> 
      </tr> 
      <tr> 
       <td>PROPAGATION_REQUIRES_NEW</td> 
       <td>新建事务，如果当前存在事务，把当前事务挂起。</td> 
      </tr> 
      <tr> 
       <td>PROPAGATION_NOT_SUPPORTED</td> 
       <td>以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。</td> 
      </tr> 
      <tr> 
       <td>PROPAGATION_NEVER</td> 
       <td>以非事务方式执行，如果当前存在事务，则抛出异常。</td> 
      </tr> 
      <tr> 
       <td>PROPAGATION_NESTED</td> 
       <td>如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与REQUIRED类似的操作。</td> 
      </tr> 
     </tbody> 
    </table>

##### 7.2.2.3.事务超时 #####

*  `timeout`事务超时时间： 当前事务所需操作的数据被其他事务占用，则等待。
    
     *  100：自定义等待时间100（秒）。
     *  \-1：由数据库指定等待时间，默认值。（建议）

##### 7.2.2.4.读写性 #####

*  `readonly` 读写性
    
     *  true：只读，可提高查询效率，适合查询
     *  false：可读可写，适合增删改

##### 7.2.2.5.回滚规则 #####

*  TransactionAttribute
    
    TransactionAttribute 的默认实现类是DefaultTransactionAttribute ，它同时继承了DefaultTransactionDefinition。在DefaultTransactionDefinition 的基础上增加了rollbackOn的实现，DefaultTransactionAttribute的实现指定了，当异常类型为unchecked exception 的情况下将回滚事务。

![在这里插入图片描述][0ab495b5aa4d436cafd065900cee816f.png]

*  `rollbackOn` 回滚规则，可省略或设置 rollbackOn=“Exception”
 *  如果事务中抛出 RuntimeException,则自动回滚
    
     *  如果事务中抛出 CheckException，不会自动回滚

#### 7.3.3.TransactionStatus ####

*  PlatformTransactionManager.getTransaction(…) 方法返回一个 TransactionStatus 对象，该对象代表一个新的或已经存在的事务，源代码如下：
    
        public  interface TransactionStatus{
              
           boolean isNewTransaction();
           void setRollbackOnly();
           boolean isRollbackOnly();
        }

### 7.4.改造转账案例 ###

#### 7.4.1.applicationContext.xml ####

<bean class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
            <property name="dataSource" ref="dataSource"/>
        </bean>
        
        <bean class="org.springframework.transaction.support.DefaultTransactionDefinition">
            <property name="propagationBehaviorName" value="PROPAGATION_REQUIRED"/>
            <property name="readOnly" value="false"></property>
        </bean>

#### 7.4.2.service ####

@Service
    public class UserServiceImpl implements UserService {
        
    
        @Autowired
        private UserMapper userMapper;
        @Autowired
        private TransactionDefinition txDefinition;
        @Autowired
        private PlatformTransactionManager txManager;
        /**
         * 转账
         * @param source
         * @param target
         * @param money
         */
        @Override
        public void updateUser(String source, String target, Float money) {
        
            // 获取一个事务
            TransactionStatus txStatus = txManager.getTransaction(txDefinition);
            try {
        
    
                userMapper.updateUserOfSub(source, money);
                int a = 6/0;
                userMapper.updateUserOfAdd(target, money);
                //提交事务
                txManager.commit(txStatus);
            }catch (Exception e){
        
                //回滚事务
                txManager.rollback(txStatus);
                e.printStackTrace();
            }
        }
    }

#### 7.4.3.测试 ####

*  事务回滚：
    
    ![在这里插入图片描述][4546d0f30d55493eab27ce5f986baf8a.png]
 *  满足执行：
    
    ![在这里插入图片描述][7d78f8de87ea406fbcba1be9fefc59aa.png]
 *  我们现在虽然实现了事务控制，但是代码非常的臃肿，我们可以使用动态代理简化代码

### 7.3.动态代理控制事务 ###

#### 7.3.1.factory ####

我们创建一个工厂，专门用来给 Service 创建代理对象，如下：

package com.by.factory;
    
    import com.by.service.UserService;
    import com.by.service.UserServiceImpl;
    import org.hamcrest.Factory;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Component;
    import org.springframework.transaction.PlatformTransactionManager;
    import org.springframework.transaction.TransactionDefinition;
    import org.springframework.transaction.TransactionStatus;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    
    /**
     * bean工厂
     */
    @Component
    public class BeanFactory {
        
        @Autowired
        private UserService userService;
        @Autowired
        private TransactionDefinition txDefinition;
        @Autowired
        private PlatformTransactionManager txManager;
    
        /**
         * 获得UserServiceImpl对象
         *
         * @return
         */
        public UserService getUserService() {
        
            return (UserService) Proxy.newProxyInstance(
                userService.getClass().getClassLoader(),
                userService.getClass().getInterfaces(),
                new InvocationHandler() {
        
                        public Object invoke(Object proxy, Method method, Object[] args)
                            											throws Throwable {
        
                            //开启事务
                            TransactionStatus txStatus = 
                                txManager.getTransaction(txDefinition);
                            try {
        
                                method.invoke(userService, args);
                                //提交事务
                                txManager.commit(txStatus);
                            } catch (Exception e) {
        
                                //回滚事务
                                txManager.rollback(txStatus);
                                e.printStackTrace();
                            }
                            return null;
                        }
                    });
        }
    }

#### 7.3.2.applicationContext.xml ####

<bean id="proxyService" factory-bean="beanFactory" factory-method="getUserService"></bean>

#### 7.2.3.service ####

#### 7.2.4.测试 ####

@RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration("classpath:applicationContext.xml")
    public class ServiceTest {
        
        @Autowired
        @Qualifier("proxyService")//注入代理对象
        private UserService userService;
    
        @Test
        public void testUpdate(){
        
            userService.updateUser("张三丰","宋远桥",1F);
        }
    }

*  事务回滚：

![在这里插入图片描述][23bde99124dd4f74968825fb024c1c65.png]

### 7.4.Spring AOP控制事务 ###

#### 7.4.1.导入schema约束 ####

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:context="http://www.springframework.org/schema/context"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           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
           https://www.springframework.org/schema/aop/spring-aop.xsd">
        
        
    </beans>

#### 7.4.2.配置增强 ####

<tx:advice id="txAdvice" transaction-manager="transactionManager">
            
            <tx:attributes>
            
            <tx:method name="*" read-only="false" propagation="REQUIRED"/>
            <tx:method name="select*" read-only="true" propagation="SUPPORTS"/>
            <tx:method name="get*" read-only="true" propagation="SUPPORTS"/>
           </tx:attributes>
        </tx:advice>

#### 7.4.3.配置切点 ####

<aop:config>
            
            <aop:pointcut expression="execution(* com.by.service.*.*(..))" id="pointcut"/>
        </aop:config>

#### 7.4.4.配置切面 ####

<aop:config>
            
            <aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut"></aop:advisor>
        </aop:config>

#### 7.4.5.factory ####

删除bean工程

#### 7.4.6.测试 ####

*  事务回滚：
    
    ![在这里插入图片描述][f4693bd610674ee782dbaca3e1fb3a79.png]
 *  问题一：如果我们把方法名称改了，那么事务还会回滚吗？
    
     *  修改applicationContext.xml：
    
    ![在这里插入图片描述][6328e569ed90418daa9c218e18635de9.png]
    
     *  修改service：
    
    ![33e1a6017be442c4b2e47ee50ee7e2ed.png][]
 *  问题二：如果我们把异常捕捉了，那么事务还会回滚吗？
    
    ![347af7bd66ea429f80198bc1b4daa667.png][]

[2ccbb35720504fd6a180ce1ef91e1b1f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/30/6c556f9d498e4ed2beb981155aeff98e.png
[43d705f4a4a9461b85e832762db61fae.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/30/13add8994e5a47c09d2416c9afab0855.png
[0126b3b0a1d045f0adad8dafddffd58d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/30/94d6540f8af24191a4beac028ff99eaf.png
[e4a772781d6c4bf3a5fca9c17769db06.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/30/6056f604e91d4e8a8a98249e9e5cf588.png
[46d4162c954343d3b82211d705395c1d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/30/6a87329f3e7d494fb1372aa6deb7e86b.png
[c2c0d4afcc3e4eb8b384979e94dd813c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/30/186ba882b79b481898661648536e0705.png
[0d9debb18b7a49f2b6535c760caa9229.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/30/5c6a65b319894fff93757b9d2b5bbd01.png
[0ab495b5aa4d436cafd065900cee816f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/30/2edb3f34277441b68c5f2a39209c6090.png
[4546d0f30d55493eab27ce5f986baf8a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/30/7b356432c1a94fd7aca4d309e30e9449.png
[7d78f8de87ea406fbcba1be9fefc59aa.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/30/d5afa55317164252bd21bf95e30d6cc0.png
[23bde99124dd4f74968825fb024c1c65.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/30/4467589f127c41aeade18a9a80d922e4.png
[f4693bd610674ee782dbaca3e1fb3a79.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/30/d82c419441a247b4af488c682992a66c.png
[6328e569ed90418daa9c218e18635de9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/30/931b1f5c17b34327b7481fef8ce83baa.png
[33e1a6017be442c4b2e47ee50ee7e2ed.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/30/7952990d521b4ea6931f86ec43977397.png
[347af7bd66ea429f80198bc1b4daa667.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/30/122b04d98b5149df8ed38e1bc96dccd0.png