Spring AOP_03

Lemonade22
73 阅读9分钟

携手创作，共同成长！这是我参与「掘金日新计划 · 8 月更文挑战」的第21天，点击查看活动详情

⭐️前面的话⭐️

✉️坚持和努力一定能换来诗与远方！
💭推荐书籍：📚《王道408》，📚《深入理解 Java 虚拟机-周志明》，📚《Java 核心技术卷》
💬算法刷题：✅力扣🌐牛客网
🎈Github
🎈码云Gitee

18 AOP事务管理

18.1 Spring事务简介

  • 事务作用：在数据层保障一系列的数据库操作同成功或同失败
  • Spring事务作用：在数据层或业务层保障一系列的数据库操作同成功或同失败
 # 数据层有事务我们可以理解，为什么业务层也需要处理事务呢?
 ​
 # 举个简单的例子
 转账业务会有两次数据层的调用，一次是加钱一次是减钱
 把事务放在数据层，加钱和减钱就有两个事务，没办法保证加钱和减钱同时成功或者同时失败。
 这个时候就需要将事务放在业务层进行处理。

  • Spring为了管理事务，提供了一个平台事务管理器 PlatformTransactionManager

    • commit 是用来提交事务，rollback 是用来回滚事务。

  • PlatformTransactionManager 只是一个接口，Spring 还为其提供了一个具体的实现

    • 从名称上看，只要给它一个DataSource对象，它就可以帮你在业务层管理事务。其内部采用的是 JDBC 的事务。
    • 所以说如果你持久层采用的是JDBC相关的技术，就可以采用这个事务管理器来管理你的事务。
    • 而 Mybatis 内部采用的就是 JDBC的事务，所以后期Spring整合Mybatis就采用这个DataSourceTransactionManager事务管理器。
 public class DataSourceTransactionManager{
   ...
 }

转账案例-需求分析

通过一个案例来学习下 Spring 是如何来管理事务的。

 需求: 实现任意两个账户间转账操作。如A账户减钱，B账户加钱。
 ​
 # 为了实现上述的业务需求，考虑如下实现: 
 ①：数据层提供基础操作，指定账户减钱（outMoney），指定账户加钱（inMoney）
 ②：业务层提供转账操作（transfer），调用减钱与加钱的操作
 ③：提供2个账号和操作金额执行转账操作
 ④：基于Spring整合MyBatis环境搭建

转账案例-环境搭建

 1.准备数据库表
 2.创建项目导入jar包
 3.根据表创建模型类
 4.创建 Dao接口
 5.创建 Service接口和实现类
 6.添加 jdbc.properties文件
 7.创建 JdbcConfig配置类
 8.创建 MybatisConfig配置类
 9.创建 SpringConfig配置类
 10.编写测试类
  • 数据库表
 create database spring_db character set utf8; 
 use spring_db; 
 ​
 create table tbl_account( 
     id int primary key auto_increment, 
     name varchar(35), 
     money double 
 );
 insert into tbl_account values(1,'Tom',1000); 
 insert into tbl_account values(2,'Jerry',1000); 1
  • 添加依赖
 <dependency>
     <groupId>org.springframework</groupId>
     <artifactId>spring-context</artifactId>
     <version>5.2.10.RELEASE</version>
 </dependency>
 <dependency>
     <groupId>com.alibaba</groupId>
     <artifactId>druid</artifactId>
     <version>1.1.16</version>
 </dependency>
 ​
 <dependency>
     <groupId>org.mybatis</groupId>
     <artifactId>mybatis</artifactId>
     <version>3.5.6</version>
 </dependency>
 ​
 <dependency>
     <groupId>mysql</groupId>
     <artifactId>mysql-connector-java</artifactId>
     <version>5.1.47</version>
 </dependency>
 ​
 <dependency>
     <groupId>org.springframework</groupId>
     <artifactId>spring-jdbc</artifactId>
     <version>5.2.10.RELEASE</version>
 </dependency>
 ​
 <dependency>
     <groupId>org.mybatis</groupId>
     <artifactId>mybatis-spring</artifactId>
     <version>1.3.0</version>
 </dependency>
 ​
 <dependency>
     <groupId>junit</groupId>
     <artifactId>junit</artifactId>
     <version>4.12</version>
     <scope>test</scope>
 </dependency>
 ​
 <dependency>
     <groupId>org.springframework</groupId>
     <artifactId>spring-test</artifactId>
     <version>5.2.10.RELEASE</version>
 </dependency>
  • 实体类
 public class Account implements Serializable {
 ​
     private Integer id;
     private String name;
     private Double money;
     //setter...getter...toString...方法略
 }
  • Dao 接口
 public interface AccountDao {
     @Update("update tbl_account set money = money + #{money} where name = #{name}")
     void inMoney(@Param("name") String name, @Param("money") Double money);
 ​
     @Update("update tbl_account set money = money - #{money} where name = #{name}")
     void outMoney(@Param("name") String name, @Param("money") Double money);
 }
  • Service 接口和实现类
 public interface AccountService {
     /**
      * 转账操作
      * @param out 传出方
      * @param in 转入方
      * @param money 金额
      */
     //配置当前接口方法具有事务
     @Transactional
     public void transfer(String out,String in ,Double money) ;
 }
 ​
 @Service
 public class AccountServiceImpl implements AccountService {
     @Autowired
     private AccountDao accountDao;
 ​
     public void transfer(String out,String in ,Double money) {
         accountDao.outMoney(out,money);
         int i = 1/0;
         accountDao.inMoney(in,money);
     }
 }
  • SpringConfig 配置类
 @Configuration
 @ComponentScan("com.itheima")
 @PropertySource("classpath:jdbc.properties")
 @Import({JdbcConfig.class,MybatisConfig.class})
 //开启注解式事务驱动
 @EnableTransactionManagement
 public class SpringConfig {
 }
  • 测试
 @RunWith(SpringJUnit4ClassRunner.class)
 @ContextConfiguration(classes = SpringConfig.class)
 public class AccountServiceTest {
     @Autowired
     private AccountService accountService;
 ​
     @Test
     public void testTransfer() throws IOException {
         accountService.transfer("Tom","Jerry",100D);
     }
 }

事务管理

上述转账案例，正常结果：Tom的账户会减少100，Jerry的账户会加100。

但是如果在转账的过程中出现了异常，如：

 public void transfer(String out,String in ,Double money) {
     accountDao.outMoney(out,money);
     int i = 1/0;
     accountDao.inMoney(in,money);
 }

①：程序正常执行时，账户金额A减B加，没有问题。

②：程序出现异常后，转账失败。但是异常之前操作成功，异常之后操作失败，整体业务失败。

当程序出问题后我们需要让事务进行回滚，而且这个事务应该是加在业务层上，Spring的事务管理就是用来解决这类问题的。

步骤1：在需要被事务管理的方法上添加注解 @Transactional
 @Service
 public class AccountServiceImpl implements AccountService {
 ​
     @Autowired
     private AccountDao accountDao;
     @Transactional
     public void transfer(String out,String in ,Double money) {
         accountDao.outMoney(out,money);
         int i = 1/0;
         accountDao.inMoney(in,money);
     }
 }

 # @Transactional可以写在接口类上、接口方法上、实现类上和实现类方法上
 ​
 写在接口类上，该接口的 所有实现类的所有方法 都会有事务
 写在接口方法上，该接口的 所有实现类的该方法 都会有事务
 写在实现类上，该类中的 所有方法 都会有事务
 写在实现类方法上，该 方法上 有事务
 ​
 # 建议写在 实现类或实现类的方法上
步骤2：在JdbcConfig 类中配置事务管理器
  • 事务管理器要根据使用技术进行选择，Mybatis框架使用的是JDBC事务，可以直接使用 DataSourceTransactionManager
 public class JdbcConfig {
     ...
     //配置事务管理器，mybatis使用的是jdbc事务
     @Bean
     public PlatformTransactionManager transactionManager(DataSource dataSource){
         DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
         transactionManager.setDataSource(dataSource);
         return transactionManager;
     }
 }
步骤3：开启事务注解 @EnableTransactionManagement
 @Configuration
 @ComponentScan("com.itheima")
 @PropertySource("classpath:jdbc.properties")
 @Import({JdbcConfig.class,MybatisConfig.class})
 //开启注解式事务驱动
 @EnableTransactionManagement
 public class SpringConfig {
 }
步骤4：运行测试类
  • 会发现在转账的业务出现错误后，事务就可以控制回滚，保证数据的正确性。

18.2 Spring事务角色

重点要理解两个概念，分别是事务管理员和事务协调员。

 事务管理员：发起事务方，在Spring中通常指代业务层开启事务的方法
 事务协调员：加入事务方，在Spring中通常指代数据层方法，也可以是业务层方法
  1. 未开启Spring事务之前:

 AccountDao的outMoney因为是修改操作，会开启一个事务T1
 AccountDao的inMoney因为是修改操作，会开启一个事务T2
 AccountService的transfer没有事务，
 - 运行过程中如果没有抛出异常，则T1和T2都正常提交，数据正确
 - 如果在两个方法中间抛出异常，T1因为执行成功提交事务，T2因为抛异常不会被执行
 - 就会导致数据出现错误
  1. 开启Spring的事务管理后

 transfer上添加了@Transactional注解，在该方法上就会有一个事务T
 ​
 AccountDao的outMoney方法的事务T1加入到transfer的事务T中
 AccountDao的inMoney方法的事务T2加入到transfer的事务T中
 ​
 这样就保证他们在同一个事务中，当业务层中出现异常，整个事务就会回滚，保证数据的准确性。

18.3 Spring事务属性

事务配置

上面这些属性都可以在@Transactional注解的参数上进行设置。

 readOnly：true只读事务，false读写事务，增删改要设为false,查询设为true。
 timeout:设置超时时间单位秒，在多长时间之内事务没有提交成功就自动回滚，-1表示不设置超时时间。
 rollbackFor:当出现指定异常进行事务回滚
 noRollbackFor:当出现指定异常不进行事务回滚
 ​
 isolation设置事务的隔离级别
 - DEFAULT :默认隔离级别, 会采用数据库的隔离级别
 - READ_UNCOMMITTED : 读未提交
 - READ_COMMITTED : 读已提交
 - REPEATABLE_READ : 重复读取
 - SERIALIZABLE: 串行化

并不是所有的异常都会回滚事务，如下

 public void transfer(String out, String in, Double money) throws IOException {
     try {
         accountDao.outMoney(out, money);
         // int i = 1 / 0;  //这个异常事务会回滚
         if (true) {
             throw new IOException();  //这个异常事务就不会回滚
         }
         accountDao.inMoney(in, money);
     } finally {
         logService.log(out, in, money);
     }
 }

出现这个问题的原因是，Spring的事务只会对Error异常和RuntimeException异常及其子类进行事务回滚，其他的异常类型是不会回滚的，对应 IOException 不符合上述条件所以不回滚

案例：转账业务追加日志案例（引出事务的传播行为）

 # 需求
 需求：实现任意两个账户间转账操作，并对每次转账操作在数据库进行留痕。即A账户减钱，B账户加钱，数据库记录日志。
 ​
 # 分析
 ① 基于转账操作案例添加日志模块，实现数据库中记录日志
 ② 业务层转账操作（transfer），调用减钱、加钱与记录日志功能
 ​
 # 实现预期效果
 无论转账操作是否成功，均进行转账操作的日志留痕

 步骤1:创建日志表
 步骤2:添加LogDao接口
 步骤3:添加LogService接口与实现类
 步骤4:在转账的业务中添加记录日志

 @Service
 public class AccountServiceImpl implements AccountService {
     @Autowired
     private AccountDao accountDao;
     @Autowired
     private LogService logService;
 ​
     public void transfer(String out, String in, Double money) throws IOException {
         try {
             accountDao.outMoney(out, money);
             //int i = 1 / 0;  //这个异常事务会回滚
             //if (true) {
             //    throw new IOException();  //这个异常事务就不会回滚
             //}
             accountDao.inMoney(in, money);
         } finally {
             logService.log(out, in, money);
         }
     }
 }

  • 结果如下

    • 当程序正常运行，tbl_account 表中转账成功，tbl_log 表中日志记录成功
  • 当转账业务之间出现异常（int i =1/0）,转账失败，tbl_account成功回滚，但是tbl_log表未添加数据
  • 存在问题：日志的记录与转账操作隶属同一个事务，同成功同失败
  • 实现效果预期改进：无论转账操作是否成功，日志必须保留

事务传播行为 🎈

  • 事务传播行为：事务协调员对事务管理员所携带事务的处理态度。（propagation 属性）

 # 分析
 log方法、inMoney方法和outMoney方法都属于增删改，分别有事务T1,T2,T3
 transfer因为加了@Transactional注解，也开启了事务T
 前面我们讲过Spring事务会把T1,T2,T3都加入到事务T中
 所以当转账失败后，所有的事务都回滚，导致日志没有记录下来
 ​
 # 这和我们的需求不符，这个时候我们就想能不能让log方法单独是一个事务呢?
 # 要想解决这个问题，就需要用到事务传播行为
设置传播行为解决问题
 // 修改logService改变事务的传播行为
 @Service
 public class LogServiceImpl implements LogService {
     @Autowired
     private LogDao logDao;
 ​
     //propagation设置事务属性：传播行为设置为当前操作需要新事务
     @Transactional(propagation = Propagation.REQUIRES_NEW)
     public void log(String out,String in,Double money ) {
         logDao.log("转账操作由"+out+"到"+in+",金额："+money);
     }
 }

运行后，就能实现我们想要的结果，不管转账是否成功，都会记录日志。

事务传播行为的可选值
  • 根据业务逻辑选择。

老版比较乱，是层层深入；新版注重总结，易理解

\

avatar
文章
阅读
粉丝