Spring事务

超、凢脫俗 2024-04-06 13:07 11阅读 0赞

#### 1. 概念 ####

*  什么是事务
    
     *  事务是数据库操作最基本单元，逻辑上一组操作。要么都成功，如果有一个失败所有操作都失败
     *  典型场景：银行转账
        
         *  lucy转账100元给mary
         *  lucy少100，mary多100
 *  事务四个特性（ACID）
    
     *  原子性
     *  一致性
     *  隔离性
     *  持久性

#### 2. 事务操作（搭建事务操作环境） ####

*  service：业务操作
    
     *  创建转账的方法
        
         *  调用dao两个方法
 *  dao：数据库操作，不写业务
    
     *  创建两个方法
        
         *  多钱的方法
         *  少钱的方法
 *  第一步：创建数据库表，添加记录
 *  第二步：创建service，搭建dao，完成对象创建和注入关系
 *  service注入dao，在dao注入JdbcTemplate，在JdbcTemplate注入DataSource

@Repository
    public class UserDaoImpl implements UserDao{
        // 注入JdbcTemplate
        @Autowired
        private JdbcTemplate jdbcTemplate;
    }
    
    
    @Service
    public class UserService {
        // 注入dao
        @Autowired
        private UserDao userDao;
    }
    
    
    <?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"
           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">
    
        
        <context:component-scan base-package="cn.xs"></context:component-scan>
    
        
        <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
            <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
            <property name="url" value="jdbc:mysql://localhost:3306/user_db"></property>
            <property name="username" value="root"></property>
            <property name="password" value="root"></property>
        </bean>
        
        <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        
            <property name="dataSource" ref="dataSource"></property>
        </bean>
    </beans>

*  第三步：在dao创建两个方法：多钱和少钱的方法，在service创建方法（转账方法）
    
     *  **dao**

@Override
    public void addMoney() {
        String sql = "update t_account set money = money + ? where username = ?";
        jdbcTemplate.update(sql, 100, "lucy");
    }
    
    // lucy转账100给mary
    @Override
    public void reduceMoney() {
        String sql = "update t_account set money = money - ? where username = ?";
        jdbcTemplate.update(sql, 100, "mary");
    }

*   *  **service**

// 转帐的方法
    public void accountMoney() {
        // lucy少100
        userDao.reduceMoney();
        // mary多100
        userDao.addMoney();
    }

*  第四步：上面代码，如果正常执行没有问题。但是如果代码执行过程中出现异常，有问题

public void accountMoney() {
        // lucy少100
        userDao.reduceMoney();
        
        // 模拟异常
        int i = 10 / 0;
        
        // mary多100
        userDao.addMoney();
    }

*  上面的问题如何解决？
    
     *  使用事务进行解决
 *  事务操作过程

// 转帐的方法
    public void accountMoney() {
    
        try
        {
            // 第一步 开启事务
    
            // 第二步 进行业务操作
            // lucy少100
            userDao.reduceMoney();
    
            // 模拟异常
            int i = 10 / 0;
    
            // mary多100
            userDao.addMoney();
    
            // 第三步 没有发生异常，提交事务
        }
        catch (Exception e)
        {
            // 第四步 出现异常，事务回滚
        }
    }

#### 3. 事务操作（Spring事务管理） ####

*  事务添加到JavaEE三层结构里面的service层（业务逻辑层）
 *  在Spring里面进行事务管理操作
    
     *  有两种方式
     *  编程式事务管理

*   *   *  声明式事务管理（使用）
 *  声明式事务管理
    
     *  基于注解方式（使用）
     *  基于xml配置文件方式
     *  在Spring进行声明式事务管理，**底层使用AOP原理**
     *  Spring事务管理API
        
         *  提供一个接口，代表事务管理器，这个接口针对不同框架提供不同的实现类\\

#### 4. 事务操作（注解声明式事务管理） ####

1.在Spring配置文件配置事务管理器

<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql://localhost:3306/user_db"></property>
        <property name="username" value="root"></property>
        <property name="password" value="root"></property>
    </bean>
    
    
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        
        <property name="dataSource" ref="dataSource"></property>
    </bean>

2.在Spring配置文件，开启事务注解

*  在Spring配置文件中引入名称空间`tx`

<?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">
    </beans>

开启事务注解

<tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>

在service类上面（获取service类里面方法上面）添加事务注解

*  `@Transactional`，这个注解可以添加到类上面，也可以添加方法上面
 *  如果把这个注解添加类上面，这个类里面所有的方法都添加事务
 *  如果把这个注解添加方法上面，为这个方法添加事务

@Transactional
    @Service
    public class UserService {
    
        // 注入dao
        @Autowired
        private UserDao userDao;
    
        // 转帐的方法
        public void accountMoney() {
            userDao.addMoney();
            // 模拟异常
            int i = 10 / 0;
            userDao.reduceMoney();
        }
    }

*  思考：servie之前的try-catch代码，测试的时候没有注释掉，Spring的事务管理失效了。注释掉之后，Spring的事务管理成功了

#### 5. 事务操作（注解式事务管理参数配置） ####

`propagation()`：事务传播行为

*  当一个事务方法被另外一个事务方法调用时候，这个事务方法如何进行
 *  事务的传播行为可以由传播属性指定。Spring定义了7种类传播行为
 *  `REQUIRED`：如果有事务在运行，当前的方法就在这个事务内运行。否则，就启动一个新的事务，并在自己的事务内运行
 *  `REQUIRED_NEW`：当前的方法必须启动新事务，并在它自己的事务内运行。如果有事务正在运行，应该将它挂起
 *  `SUPPORTS`：如果有事务在运行，当前的方法就在这个事务内运行。否在，它可以不运行在事务中
 *  `NOT_SUPPORT`
 *  `MANDATORY`
 *  `NEVER`
 *  `NEXTED`
 *  `isolation()`：事务隔离级别
 *  事务有特性成为隔离性，多事务操作之间不会产生影响。
 *  不考虑隔离性会产生三个读问题：脏读，不可重复读，虚（幻）读
 *  脏读：一个未提交事务读取到另一个未提交事务的数据
 *  这是一个致命的问题
 *  不可重复读：一个未提交事务读取到另一个提交事务修改数据
 *  虚读：一个未提交事务读到另一提交事务添加的数据
 *  通过设置事务隔离级别，解决读的问题

<table style="width:644px;"> 
 <tbody> 
  <tr> 
   <th style="width:256px;">隔离级别</th> 
   <th style="width:139px;">脏读</th> 
   <th style="width:124px;">不可重复读</th> 
   <th style="width:122px;">虚读</th> 
  </tr> 
  <tr> 
   <td style="width:256px;">READ UNCOMMITTED（读未提交）</td> 
   <td style="width:139px;">有</td> 
   <td style="width:124px;">有</td> 
   <td style="width:122px;">有</td> 
  </tr> 
  <tr> 
   <td style="width:256px;">READ COMMITTED（读已提交）</td> 
   <td style="width:139px;">无</td> 
   <td style="width:124px;">有</td> 
   <td style="width:122px;">有</td> 
  </tr> 
  <tr> 
   <td style="width:256px;">REPEATABLE READ（可重复读）</td> 
   <td style="width:139px;">无</td> 
   <td style="width:124px;">无</td> 
   <td style="width:122px;">有</td> 
  </tr> 
  <tr> 
   <td style="width:256px;">SERIALIZABLE（串行化）</td> 
   <td style="width:139px;">无</td> 
   <td style="width:124px;">无</td> 
   <td style="width:122px;">无</td> 
  </tr> 
  <tr> 
   <td style="width:256px;"></td> 
   <td style="width:139px;"></td> 
   <td style="width:124px;"></td> 
   <td style="width:122px;"></td> 
  </tr> 
  <tr> 
   <td style="width:256px;"></td> 
   <td style="width:139px;"></td> 
   <td style="width:124px;"></td> 
   <td style="width:122px;"></td> 
  </tr> 
  <tr> 
   <td style="width:256px;"></td> 
   <td style="width:139px;"></td> 
   <td style="width:124px;"></td> 
   <td style="width:122px;"></td> 
  </tr> 
 </tbody> 
</table>

@Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.REPEATABLE_READ)
    @Service
    public class UserService {
    }

*  Oracle默认`READ COMMITTED`，Mysql默认`REPEATABLE READ`
 *  `timeout()`：超时时间
    
     *  事务需要在一定时间内进行提交，如果不提交进行回滚
     *  默认值：`-1`
     *  设置时间是以秒为单位
 *  `readOnly()`：是否只读
    
     *  读：查询操作。写：添加修改删除操作
     *  默认值：false
     *  设置`readOnly = true`，只能查询
 *  `rollbackFor()`：回滚
    
     *  设置出现哪些异常进行事务回滚
 *  `noRollbackFor()`：不回滚
    
     *  设置哪些异常不进行事务回滚

#### 5. 事务操作（XML声明式事务管理） ####

在Spring配置文件中进行配置

*  第一步：配置事务管理器

<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql://localhost:3308/user_db"></property>
        <property name="username" value="root"></property>
        <property name="password" value="root"></property>
    </bean>
    
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        
        <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(* cn.xs.spring5.service.UserService.*(..))"/>
        
        <aop:advisor advice-ref="txadvice" pointcut-ref="pt"></aop:advisor>
    </aop:config>

#### 6. 事务操作（完全注解声明式事务管理） ####

*  创建配置类，使用配置类代替xml配置文件

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