spring成神之路第四十九篇：通过 Spring 事务实现 MQ 中的事务消息
1、本文2个目的
1、讨论一下消息投递的5种方式
2、带你手写代码，实现事务消息的投递
2、讨论一下消息投递的5种方式
2.1、业务场景
电商中有这样的一个场景：商品下单之后，需给用户送积分，订单表和积分表分别在不同的db中，涉及到分布式事务的问题。
我们通过可靠消息来解决这个问题：
- 商品下单成功之后送积分的操作，我们使用mq来实现
- 商品下单成功之后，投递一条消息到mq，积分系统消费消息，给用户增加积分
我们主要讨论一下，商品下单及投递消息到mq的操作，如何实现？每种方式优缺点？
2.2、方式一
过程
- step1：开启本地事务
- step2：生成购物订单
- step3：投递消息到mq
- step4：提交本地事务
这种方式是将发送消息放在了事务提交之前。
可能存在的问题
- step3发生异常：导致step4失败，商品下单失败，直接影响到商品下单业务
- step4发生异常，其他step成功：商品下单失败，消息投递成功，给用户增加了积分
2.3、方式二
下面我们换种方式，我们将发送消息放到事务之后进行。
过程
- step1：开启本地事务
- step2：生成购物订单
- step3：提交本地事务
- step4：投递消息到mq
可能会出现的问题
step4发生异常，其他step成功：导致商品下单成功，投递消息失败，用户未增加积分
上面两种是比较常见的做法，也是最容易出错的。
2.4、方式三
- step1：开启本地事务
- step2：生成购物订单
- step3：本地库中插入一条需要发送消息的记录t_msg_record
- step3：提交本地事务
- step5：新增一个定时器，轮询t_msg_record，将待发送的记录投递到mq中
这种方式借助了数据库的事务，业务和消息记录作为了一个原子操作，业务成功之后，消息日志必定是存在的。解决了前两种方式遇到的问题。如果我们的业务系统比较单一，可以采用这种方式。
对于微服务化的情况，上面这种方式不是太好，每个服务都需要上面的操作；也不利于扩展。
2.5、方式四
增加一个消息服务及消息库，负责消息的落库、将消息发送投递到mq。
- step1：开启本地事务
- step2：生成购物订单
- step3：当前事务库插入一条日志：生成一个唯一的业务id（msg_order_id），将msg_order_id和订单关联起来保存到当前事务所在的库中
- step4：调用消息服务：携带msg_order_id，将消息先落地入库，此时消息的状态为待发送状态，返回消息id(msg_id)
- step5：提交本地事务
- step6：如果上面都成功，调用消息服务，将消息投递到mq中；如果上面有失败的情况，则调用消息服务取消消息的发送
能想到上面这种方式，已经算是有很大进步了，我们继续分析一下可能存在的问题：
- 系统中增加了一个消息服务，商品下单操作依赖于该服务，业务对该服务依赖性比较高，当消息服务不可用时，整个业务将不可用。
- 若step6失败，消息将处于待发送状态，此时业务方需要提供一个回查接口（通过msg_order_id查询）,验证业务是否执行成功；消息服务需新增一个定时任务，对于状态为待发送状态的消息做补偿处理，检查一下业务是否处理成功；从而确定消息是投递还是取消发送
- step4依赖于消息服务，如果消息服务性能不佳，会导致当前业务的事务提交时间延长，容易产生死锁，并导致并发性能降低。我们通常是比较忌讳在事务中做远程调用处理的，远程调用的性能和时间往往不可控，会导致当前事务变为一个大事务，从而引发其他故障。
2.6、方式五
在以上方式中，我们继续改进，进而出现了更好的一种方式：
- step1：生成一个全局唯一业务消息id（bus_msg_id)，调用消息服务，携带bus_msg_id，将消息先落地入库，此时消息的状态为待发送状态，返回消息id（msg_id）
- step2：开启本地事务
- step3：生成购物订单
- step4：当前事务库插入一条日志（将step3中的业务和bus_msg_id关联起来）
- step5：提交本地事务
- step6：分2种情况：如果上面都成功，调用消息服务，将消息投递到mq中；如果上面有失败的情况，则调用消息服务取消消息的发送
若step6失败，消息将处于待发送状态，此时业务方需要提供一个回查接口（通过bus_msg_id查询）,验证业务是否执行成功；
消息服务需新增一个定时任务，对于状态为待发送状态的消息做补偿处理，检查一下业务是否处理成功；从而确定消息是投递还是取消发送。
方式五和方式四对比，比较好的一个地方：将调用消息服务，消息落地操作，放在了事务之外进行，这点小的改进其实算是一个非常好的优化，减少了本地事务的执行时间，从而可以提升并发量，阿里有个消息中间件RocketMQ就支持方式5这种，大家可以去用用。
下面我们通过代码来实现方式4。
3、方式4代码实现
3.1、准备数据库
3张表：
t_user：业务库中的用户表，一会用来模拟用户注册，注册成功之后投递消息。
t_msg_order：消息订单表，这个表放在业务库中，业务操作中若需要发送消息，则在业务操作的事务中同时向t_msg_order表插入一条数据，若业务操作成功，那么t_msg_order表肯定也会成功插入一条数据，发送消息的时候携带上t_msg_order的id，消息服务可以通过这个id去业务库回查t_msg_order中的记录，如果记录存在，则说明业务操作成功了。
t_msg：消息表，所有发送的消息信息放在这个表中，主要字段有：消息内容，msg_order_id：来源于t_msg_order表的id
DROP DATABASE IF EXISTS javacode2018; CREATE DATABASE if NOT EXISTS javacode2018; USE javacode2018; DROP TABLE IF EXISTS t_user; CREATE TABLE t_user( id INT PRIMARY KEY AUTO_INCREMENT, name VARCHAR(256) NOT NULL DEFAULT '' COMMENT '姓名' ); DROP TABLE IF EXISTS t_msg; CREATE TABLE t_msg( id INT PRIMARY KEY AUTO_INCREMENT, msg VARCHAR(256) NOT NULL DEFAULT '' COMMENT '消息内容，可以json格式的数据', msg_order_id BIGINT NOT NULL DEFAULT 0 COMMENT '消息订单id', status SMALLINT NOT NULL DEFAULT 0 COMMENT '消息状态,0:待投递，1：已发送，2：取消发送' ) COMMENT '消息表'; DROP TABLE IF EXISTS t_msg_order; CREATE TABLE t_msg_order( id INT PRIMARY KEY AUTO_INCREMENT, ref_type BIGINT NOT NULL DEFAULT 0 COMMENT '关联业务类型', ref_id VARCHAR(256) NOT NULL DEFAULT '' COMMENT '关联业务id（ref_type & ref_id 唯一）' ) COMMENT '消息订单表,放在业务库中'; alter table t_msg_order add UNIQUE INDEX idx1 (ref_type,ref_id);
3.2、关键java代码
配置类MainConfig11
package com.javacode2018.tx.demo11; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.ComponentScan; import org.springframework.jdbc.core.JdbcTemplate; import org.springframework.jdbc.datasource.DataSourceTransactionManager; import org.springframework.transaction.PlatformTransactionManager; import org.springframework.transaction.annotation.EnableTransactionManagement; import javax.sql.DataSource; /** * 公众号：路人甲Java，工作10年的前阿里P7分享Java、算法、数据库方面的技术干货！ * <a href="http://www.itsoku.com">个人博客</a> */ @ComponentScan @EnableTransactionManagement public class MainConfig11 { @Bean public DataSource dataSource() { org.apache.tomcat.jdbc.pool.DataSource dataSource = new org.apache.tomcat.jdbc.pool.DataSource(); dataSource.setDriverClassName("com.mysql.jdbc.Driver"); dataSource.setUrl("jdbc:mysql://localhost:3306/javacode2018?characterEncoding=UTF-8"); dataSource.setUsername("root"); dataSource.setPassword("root123"); dataSource.setInitialSize(5); return dataSource; } //定义一个jdbcTemplate @Bean public JdbcTemplate jdbcTemplate(DataSource dataSource) { return new JdbcTemplate(dataSource); } //定义事务管理器transactionManager @Bean public PlatformTransactionManager transactionManager(DataSource dataSource) { return new DataSourceTransactionManager(dataSource); } }
MsgModel
package com.javacode2018.tx.demo11; import lombok.*; /** * 公众号：路人甲Java，工作10年的前阿里P7分享Java、算法、数据库方面的技术干货！ * <a href="http://www.itsoku.com">个人博客</a> */ @Getter @Setter @Builder @NoArgsConstructor @AllArgsConstructor @ToString public class MsgModel { private Long id; //消息内容 private String msg; //消息订单id private Long msg_order_id; //消息状态,0:待投递，1：已发送，2：取消发送 private Integer status; }
MsgOrderModel
package com.javacode2018.tx.demo11; import lombok.*; /** * 公众号：路人甲Java，工作10年的前阿里P7分享Java、算法、数据库方面的技术干货！ * <a href="http://www.itsoku.com">个人博客</a> */ @Getter @Setter @Builder @NoArgsConstructor @AllArgsConstructor public class MsgOrderModel { private Long id; //关联业务类型 private Integer ref_type; //关联业务id（ref_type & ref_id 唯一） private String ref_id; }
MsgOrderService
提供了对t_msg_order表的一些操作，2个方法，一个用来插入数据，一个用来查询。
package com.javacode2018.tx.demo11; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.jdbc.core.BeanPropertyRowMapper; import org.springframework.jdbc.core.JdbcTemplate; import org.springframework.stereotype.Component; import org.springframework.transaction.annotation.Transactional; import java.util.List; import java.util.Objects; /** * 公众号：路人甲Java，工作10年的前阿里P7分享Java、算法、数据库方面的技术干货！ * <a href="http://www.itsoku.com">个人博客</a> */ @Component public class MsgOrderService { @Autowired private JdbcTemplate jdbcTemplate; /** * 插入消息订单 * * @param ref_type * @param ref_id * @return */ @Transactional public MsgOrderModel insert(Integer ref_type, String ref_id) { MsgOrderModel msgOrderModel = MsgOrderModel.builder().ref_type(ref_type).ref_id(ref_id).build(); //插入消息 this.jdbcTemplate.update("insert into t_msg_order (ref_type,ref_id) values (?,?)", ref_type, ref_id ); //获取消息订单id msgOrderModel.setId(this.jdbcTemplate.queryForObject("SELECT LAST_INSERT_ID()", Long.class)); return msgOrderModel; } /** * 根据消息id获取消息 * * @param id * @return */ public MsgOrderModel getById(Long id) { List<MsgOrderModel> list = this.jdbcTemplate.query("select * from t_msg_order where id = ? limit 1", new BeanPropertyRowMapper<MsgOrderModel>(MsgOrderModel.class), id); return Objects.nonNull(list) && !list.isEmpty() ? list.get(0) : null; } }
MsgService
消息服务，提供了对t_msg表的一些操作以及消息投递的一些方法
| 方法 | 说明 |
|---|---|
| addMsg | 添加消息，消息会落库，处于待发送状态 |
| confirmSendMsg | 确定投递消息，事务成功后可以调用 |
| cancelSendMsg | 取消投递消息，事务回滚可以调用 |
代码：
package com.javacode2018.tx.demo11; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.jdbc.core.BeanPropertyRowMapper; import org.springframework.jdbc.core.JdbcTemplate; import org.springframework.stereotype.Component; import org.springframework.transaction.annotation.Propagation; import org.springframework.transaction.annotation.Transactional; import java.util.List; import java.util.Objects; /** * 公众号：路人甲Java，工作10年的前阿里P7分享Java、算法、数据库方面的技术干货！ * <a href="http://www.itsoku.com">个人博客</a> */ @Component public class MsgService { //添加一条消息(独立的事务中执行) @Transactional(propagation = Propagation.REQUIRES_NEW) public Long addMsg(String msg, Long msg_order_id, boolean isSend) { MsgModel msgModel = MsgModel.builder().msg(msg).msg_order_id(msg_order_id).status(0).build(); //先插入消息 Long msg_id = this.insert(msgModel).getId(); if (isSend) { //如果需要投递，则调用投递的方法 this.confirmSendMsg(msg_id); } return msg_id; } /** * 确认消息投递(不需要事务) * * @param msg_id 消息id */ @Transactional(propagation = Propagation.NOT_SUPPORTED) public void confirmSendMsg(Long msg_id) { MsgModel msgModel = this.getById(msg_id); //向mq中投递消息 System.out.println(String.format("投递消息：%s", msgModel)); //将消息状态置为已投递 this.updateStatus(msg_id, 1); } /** * 取消消息投递(不需要事务) * * @param msg_id 消息id */ @Transactional(propagation = Propagation.NOT_SUPPORTED) public void cancelSendMsg(Long msg_id) { MsgModel msgModel = this.getById(msg_id); System.out.println(String.format("取消投递消息：%s", msgModel)); //将消息状态置为取消投递 this.updateStatus(msg_id, 2); } @Autowired private JdbcTemplate jdbcTemplate; /** * 插入消息 * * @param msgModel * @return */ private MsgModel insert(MsgModel msgModel) { //插入消息 this.jdbcTemplate.update("insert into t_msg (msg,msg_order_id,status) values (?,?,?)", msgModel.getMsg(), msgModel.getMsg_order_id(), msgModel.getStatus()); //获取消息id msgModel.setId(this.jdbcTemplate.queryForObject("SELECT LAST_INSERT_ID()", Long.class)); System.out.println("插入消息：" + msgModel); return msgModel; } /** * 根据消息id获取消息 * * @param id * @return */ private MsgModel getById(Long id) { List<MsgModel> list = this.jdbcTemplate.query("select * from t_msg where id = ? limit 1", new BeanPropertyRowMapper<MsgModel>(MsgModel.class), id); return Objects.nonNull(list) && !list.isEmpty() ? list.get(0) : null; } /** * 更新消息状态 * * @param id * @param status */ private void updateStatus(long id, int status) { this.jdbcTemplate.update("update t_msg set status = ? where id = ?", status, id); } }
消息投递器MsgSender
消息投递器，给业务方使用，内部只有一个方法，用来发送消息。
若上下文没有事务，则消息落地之后立即投递；若存在事务，则消息投递分为2步走：消息先落地，事务执行完毕之后再确定是否投递，用到了事务扩展点：TransactionSynchronization，事务执行完毕之后会回调TransactionSynchronization接口中的afterCompletion方法，在这个方法中确定是否投递消息。对事务扩展点TransactionSynchronization不熟悉的建议先看一下这篇文章：Spring系列第47篇：spring事务源码解析
package com.javacode2018.tx.demo11; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import org.springframework.transaction.support.TransactionSynchronization; import org.springframework.transaction.support.TransactionSynchronizationAdapter; import org.springframework.transaction.support.TransactionSynchronizationManager; /** * 公众号：路人甲Java，工作10年的前阿里P7分享Java、算法、数据库方面的技术干货！ * <a href="http://www.itsoku.com">个人博客</a> * 消息发送器，所有使用者调用send方法发送消息 */ @Component public class MsgSender { @Autowired private MsgOrderService msgOrderService; @Autowired private MsgService msgService; //发送消息 public void send(String msg, int ref_type, String ref_id) { MsgOrderModel msgOrderModel = this.msgOrderService.insert(ref_type, ref_id); Long msg_order_id = msgOrderModel.getId(); //TransactionSynchronizationManager.isSynchronizationActive 可以用来判断事务同步是否开启了 boolean isSynchronizationActive = TransactionSynchronizationManager.isSynchronizationActive(); /** * 若事务同步开启了，那么可以在事务同步中添加事务扩展点，则先插入消息，暂不发送，则在事务扩展点中添加回调 * 事务结束之后会自动回调扩展点TransactionSynchronizationAdapter的afterCompletion()方法 * 咱们在这个方法中确定是否投递消息 */ if (isSynchronizationActive) { final Long msg_id = this.msgService.addMsg(msg, msg_order_id, false); TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() { @Override public void afterCompletion(int status) { //代码走到这里时，事务已经完成了（可能是回滚了、或者是提交了） //看一下消息关联的订单是否存在，如果存在，说明事务是成功的，业务是执行成功的，那么投递消息 if (msgOrderService.getById(msg_order_id) != null) { System.out.println(String.format("准备投递消息,{msg_id:%s}", msg_id)); //事务成功：投递消息 msgService.confirmSendMsg(msg_id); } else { System.out.println(String.format("准备取消投递消息，{msg_id:%s}", msg_id)); //事务是不：取消投递消息 msgService.cancelSendMsg(msg_id); } } }); } else { //无事务的，直接插入并投递消息 this.msgService.addMsg(msg, msg_order_id, true); } } }
3.3、测试（3种场景）
3.3.1、场景1：业务成功，消息投递成功
UserService
下面的register方法是有事务的，内部会插入一条用户信息，然后会投递一条消息
package com.javacode2018.tx.demo11; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.jdbc.core.JdbcTemplate; import org.springframework.stereotype.Component; import org.springframework.transaction.annotation.Propagation; import org.springframework.transaction.annotation.Transactional; /** * 公众号：路人甲Java，工作10年的前阿里P7分享Java、算法、数据库方面的技术干货！ * <a href="http://www.itsoku.com">个人博客</a> */ @Component public class UserService { @Autowired private JdbcTemplate jdbcTemplate; //消息投递器 @Autowired private MsgSender msgSender; /** * 模拟用户注册成功，顺便发送消息 */ @Transactional public void register(Long user_id, String user_name) { //先插入用户 this.jdbcTemplate.update("insert into t_user(id,name) VALUES (?,?)", user_id, user_name); System.out.println(String.format("用户注册：[user_id:%s,user_name:%s]", user_id, user_name)); //发送消息 String msg = String.format("[user_id:%s,user_name:%s]", user_id, user_name); //调用投递器的send方法投递消息 this.msgSender.send(msg, 1, user_id.toString()); } }
测试类
package com.javacode2018.tx.demo11; import org.junit.Before; import org.junit.Test; import org.springframework.context.annotation.AnnotationConfigApplicationContext; import org.springframework.jdbc.core.JdbcTemplate; /** * 公众号：路人甲Java，工作10年的前阿里P7分享Java、算法、数据库方面的技术干货！ * <a href="http://www.itsoku.com">个人博客</a> */ public class Demo11Test { private AnnotationConfigApplicationContext context; private UserService userService; private JdbcTemplate jdbcTemplate; @Before public void before() { this.context = new AnnotationConfigApplicationContext(MainConfig11.class); userService = context.getBean(UserService.class); this.jdbcTemplate = context.getBean("jdbcTemplate", JdbcTemplate.class); jdbcTemplate.update("truncate table t_user"); jdbcTemplate.update("truncate table t_msg"); jdbcTemplate.update("truncate table t_msg_order"); } @Test public void test1() { this.userService.register(1L, "路人"); } }
运行输出
用户注册：[user_id:1,user_name:路人] 插入消息：MsgModel(id=1, msg=[user_id:1,user_name:路人], msg_order_id=1, status=0) 准备投递消息,{msg_id:1} 投递消息：MsgModel(id=1, msg=[user_id:1,user_name:路人], msg_order_id=1, status=0)
3.3.2、场景2：业务失败，消息取消投递
UserService中添加代码
手动抛出异常，让事务回滚。
/** * 模拟用户注册失败，咱们通过弹出异常让事务回滚，结果也会导致消息发送被取消 * * @param user_id * @param user_name */ @Transactional public void registerFail(Long user_id, String user_name) { this.register(user_id, user_name); throw new RuntimeException("故意失败!"); }
Demo11Test添加用例
@Test public void test2() { this.userService.registerFail(1L, "张三"); }
运行输出
弹出了异常，信息比较多，我们截了关键的部分，如下，可以看出事务被回滚了，消息被取消投递了。
用户注册：[user_id:1,user_name:张三] 插入消息：MsgModel(id=1, msg=[user_id:1,user_name:张三], msg_order_id=1, status=0) 准备取消投递消息，{msg_id:1} 取消投递消息：MsgModel(id=1, msg=[user_id:1,user_name:张三], msg_order_id=1, status=0) java.lang.RuntimeException: 故意失败! at com.javacode2018.tx.demo11.UserService.registerFail(UserService.java:44) at com.javacode2018.tx.demo11.UserService$$FastClassBySpringCGLIB$$5dd21f5c.invoke(<generated>)
3.3.3、嵌套事务
事务发送是跟随当前所在的事务的，当前事务提交了，消息一定会被投递出去，当前事务是不，消息会被取消投递。
下面看嵌套事务的代码
UserService中添加代码
注意下面方法的事务传播行为是：REQUIRES_NEW，当前如果有事务，会重启一个事务。
//事务传播属性是REQUIRES_NEW,会在独立的事务中运行 @Transactional(propagation = Propagation.REQUIRES_NEW) public void registerRequiresNew(Long user_id, String user_name) { this.register(user_id, user_name); }
添加一个类UserService1
package com.javacode2018.tx.demo11; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import org.springframework.transaction.annotation.Transactional; /** * 公众号：路人甲Java，工作10年的前阿里P7分享Java、算法、数据库方面的技术干货！ * <a href="http://www.itsoku.com">个人博客</a> */ @Component public class UserService1 { @Autowired private UserService userService; @Autowired private MsgSender msgSender; //嵌套事务案例 @Transactional public void nested() { this.msgSender.send("消息1", 2, "1"); //registerRequiresNew事务传播属性是REQUIRES_NEW:会在一个新事务中运行 this.userService.registerRequiresNew(1L, "张三"); //registerFail事务传播属性是默认的，会在当前事务中运行，registerFail弹出异常会导致当前事务回滚 this.userService.registerFail(2L, "李四"); } }
nested 是外围方法，这个方法上有@Transactional，运行的时候会开启一个事务，内部3行代码：
@1：发送消息，会在当前事务中执行
@2：registerRequiresNew事务传播行为是REQUIRES_NEW，所以会重启一个事务
@3：registerFail事务传播行为是默认的REQUIRED，会参与到nested()开启的事务中运行，registerFail方法内部会抛出一个异常，最终会导致外部方法事务回滚。
上面方法需要投递3条消息，而@1和@3投递的消息由于事务回滚会导致消息被回滚，而@2在独立的事务中执行，@2的消息会投递成功，下面来看看执行结果，是不是和分析的一致。
Demo11Test添加用例
@Test public void test3() { UserService1 userService1 = this.context.getBean(UserService1.class); userService1.nested(); }
运行输出
插入消息：MsgModel(id=1, msg=消息1, msg_order_id=1, status=0) 用户注册：[user_id:1,user_name:张三] 插入消息：MsgModel(id=2, msg=[user_id:1,user_name:张三], msg_order_id=2, status=0) 准备投递消息,{msg_id:2} 投递消息：MsgModel(id=2, msg=[user_id:1,user_name:张三], msg_order_id=2, status=0) 用户注册：[user_id:2,user_name:李四] 插入消息：MsgModel(id=3, msg=[user_id:2,user_name:李四], msg_order_id=3, status=0) 准备取消投递消息，{msg_id:1} 取消投递消息：MsgModel(id=1, msg=消息1, msg_order_id=1, status=0) 准备取消投递消息，{msg_id:3} 取消投递消息：MsgModel(id=3, msg=[user_id:2,user_name:李四], msg_order_id=3, status=0) java.lang.RuntimeException: 故意失败! at com.javacode2018.tx.demo11.UserService.registerFail(UserService.java:44)
大家细看一下结果，和分析的是一致的。
3.4、小结
事务消息分2步走，先落库，此时消息待投递，等到事务执行完毕之后，再确定是否投递，用到的关键技术点是事务扩展接口：TransactionSynchronization，事务执行完毕之后会自动回调接口中的afterCompletion方法。
遗留的一个问题：消息补偿操作
当事务消息刚落地，此时处于待投递状态，系统刚好down机了，此时系统恢复之后，需要有个定时器来处理这种消息，拿着消息中的msg_order_id去业务库查一下订单是否存在，如果存在，则投递消息，否则取消投递，这个留给大家去实现。
4、总结
好了，今天的内容就到此就讲完了，我们一块来总结回顾一下，你需要重点掌握的内容。
1、消息投递的5种方式的推演，要熟练掌握其优缺点
2、方式4中事务消息的代码实现，需要大家掌握
消息服务使用频率挺高的，通常作为系统中的基础服务使用，大家可以尝试一下开发一个独立的消息服务，提供给其他服务使用。
欢迎留言和我分享你的想法，如果有收获，也欢迎你把这篇文章分享给你的朋友，谢谢！
5、案例源码
git地址： https://gitee.com/javacode2018/spring-series 本文案例对应源码： spring-series\lesson-002-tx\src\main\java\com\javacode2018\tx\demo11
路人甲java所有案例代码以后都会放到这个上面，大家watch一下，可以持续关注动态。
来源：https://mp.weixin.qq.com/s?__biz=MzA5MTkxMDQ4MQ==&mid=2648937788&idx=2&sn=21030dc8fff11dfdfb6d005cb8a8d526&scene=21#wechat_redirect
