49.实战篇：手把手带你实现事务消息！

1、本文2个目的

1、讨论一下消息投递的5种方式

2、带你手写代码，实现事务消息的投递

2、讨论一下消息投递的5种方式

2.1、业务场景

电商中有这样的一个场景：商品下单之后，需给用户送积分，订单表和积分表分别在不同的db中，涉及到分布式事务的问题。

我们通过可靠消息来解决这个问题：

1. 商品下单成功之后送积分的操作，我们使用mq来实现
2. 商品下单成功之后，投递一条消息到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中；如果上面有失败的情况，则调用消息服务取消消息的发送

能想到上面这种方式，已经算是有很大进步了，我们继续分析一下可能存在的问题：

1. 系统中增加了一个消息服务，商品下单操作依赖于该服务，业务对该服务依赖性比较高，当消息服务不可用时，整个业务将不可用。
2. 若step6失败，消息将处于待发送状态，此时业务方需要提供一个回查接口（通过msg_order_id查询）,验证业务是否执行成功；消息服务需新增一个定时任务，对于状态为待发送状态的消息做补偿处理，检查一下业务是否处理成功；从而确定消息是投递还是取消发送
3. 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

1. DROP DATABASE IF EXISTS javacode2018;
2. CREATE DATABASE if NOT EXISTS javacode2018;
4. USE javacode2018;
5. DROP TABLE IF EXISTS t_user;
6. CREATE TABLE t_user(
7. id INT PRIMARY KEY AUTO_INCREMENT,
8. name VARCHAR(256) NOT NULL DEFAULT '' COMMENT '姓名'
9. );
11. DROP TABLE IF EXISTS t_msg;
12. CREATE TABLE t_msg(
13. id INT PRIMARY KEY AUTO_INCREMENT,
14. msg VARCHAR(256) NOT NULL DEFAULT '' COMMENT '消息内容，可以json格式的数据',
15. msg_order_id BIGINT NOT NULL DEFAULT 0 COMMENT '消息订单id',
16. status SMALLINT NOT NULL DEFAULT 0 COMMENT '消息状态,0:待投递，1：已发送，2：取消发送'
17. ) COMMENT '消息表';
19. DROP TABLE IF EXISTS t_msg_order;
20. CREATE TABLE t_msg_order(
21. id INT PRIMARY KEY AUTO_INCREMENT,
22. ref_type BIGINT NOT NULL DEFAULT 0 COMMENT '关联业务类型',
23. ref_id VARCHAR(256) NOT NULL DEFAULT '' COMMENT '关联业务id（ref_type & ref_id 唯一）'
24. ) COMMENT '消息订单表,放在业务库中';
26. alter table t_msg_order add UNIQUE INDEX idx1 (ref_type,ref_id);

3.2、关键java代码

配置类MainConfig11

1. package com.javacode2018.tx.demo11;
3. import org.springframework.context.annotation.Bean;
4. import org.springframework.context.annotation.ComponentScan;
5. import org.springframework.jdbc.core.JdbcTemplate;
6. import org.springframework.jdbc.datasource.DataSourceTransactionManager;
7. import org.springframework.transaction.PlatformTransactionManager;
8. import org.springframework.transaction.annotation.EnableTransactionManagement;
10. import javax.sql.DataSource;
12. /**
13. * 公众号：路人甲Java，工作10年的前阿里P7分享Java、算法、数据库方面的技术干货！
14. * <a href="http://www.itsoku.com">个人博客</a>
15. */
16. @ComponentScan
17. @EnableTransactionManagement
18. public class MainConfig11 {
19. @Bean
20. public DataSource dataSource() {
21. org.apache.tomcat.jdbc.pool.DataSource dataSource = new org.apache.tomcat.jdbc.pool.DataSource();
22. dataSource.setDriverClassName("com.mysql.jdbc.Driver");
23. dataSource.setUrl("jdbc:mysql://localhost:3306/javacode2018?characterEncoding=UTF-8");
24. dataSource.setUsername("root");
25. dataSource.setPassword("root123");
26. dataSource.setInitialSize(5);
27. return dataSource;
28. }
30. //定义一个jdbcTemplate
31. @Bean
32. public JdbcTemplate jdbcTemplate(DataSource dataSource) {
33. return new JdbcTemplate(dataSource);
34. }
36. //定义事务管理器transactionManager
37. @Bean
38. public PlatformTransactionManager transactionManager(DataSource dataSource) {
39. return new DataSourceTransactionManager(dataSource);
40. }
42. }

MsgModel

1. package com.javacode2018.tx.demo11;
3. import lombok.*;
5. /**
6. * 公众号：路人甲Java，工作10年的前阿里P7分享Java、算法、数据库方面的技术干货！
7. * <a href="http://www.itsoku.com">个人博客</a>
8. */
9. @Getter
10. @Setter
11. @Builder
12. @NoArgsConstructor
13. @AllArgsConstructor
14. @ToString
15. public class MsgModel {
16. private Long id;
17. //消息内容
18. private String msg;
19. //消息订单id
20. private Long msg_order_id;
21. //消息状态,0:待投递，1：已发送，2：取消发送
22. private Integer status;
23. }

MsgOrderModel

1. package com.javacode2018.tx.demo11;
3. import lombok.*;
5. /**
6. * 公众号：路人甲Java，工作10年的前阿里P7分享Java、算法、数据库方面的技术干货！
7. * <a href="http://www.itsoku.com">个人博客</a>
8. */
9. @Getter
10. @Setter
11. @Builder
12. @NoArgsConstructor
13. @AllArgsConstructor
14. public class MsgOrderModel {
15. private Long id;
16. //关联业务类型
17. private Integer ref_type;
18. //关联业务id（ref_type & ref_id 唯一）
19. private String ref_id;
20. }

MsgOrderService

提供了对t_msg_order表的一些操作，2个方法，一个用来插入数据，一个用来查询。

1. package com.javacode2018.tx.demo11;
3. import org.springframework.beans.factory.annotation.Autowired;
4. import org.springframework.jdbc.core.BeanPropertyRowMapper;
5. import org.springframework.jdbc.core.JdbcTemplate;
6. import org.springframework.stereotype.Component;
7. import org.springframework.transaction.annotation.Transactional;
9. import java.util.List;
10. import java.util.Objects;
12. /**
13. * 公众号：路人甲Java，工作10年的前阿里P7分享Java、算法、数据库方面的技术干货！
14. * <a href="http://www.itsoku.com">个人博客</a>
15. */
16. @Component
17. public class MsgOrderService {
18. @Autowired
19. private JdbcTemplate jdbcTemplate;
21. /**
22. * 插入消息订单
23. *
24. * @param ref_type
25. * @param ref_id
26. * @return
27. */
28. @Transactional
29. public MsgOrderModel insert(Integer ref_type, String ref_id) {
30. MsgOrderModel msgOrderModel = MsgOrderModel.builder().ref_type(ref_type).ref_id(ref_id).build();
31. //插入消息
32. this.jdbcTemplate.update("insert into t_msg_order (ref_type,ref_id) values (?,?)",
33. ref_type,
34. ref_id
35. );
36. //获取消息订单id
37. msgOrderModel.setId(this.jdbcTemplate.queryForObject("SELECT LAST_INSERT_ID()", Long.class));
38. return msgOrderModel;
39. }
41. /**
42. * 根据消息id获取消息
43. *
44. * @param id
45. * @return
46. */
47. public MsgOrderModel getById(Long id) {
48. List<MsgOrderModel> list = this.jdbcTemplate.query("select * from t_msg_order where id = ? limit 1", new BeanPropertyRowMapper<MsgOrderModel>(MsgOrderModel.class), id);
49. return Objects.nonNull(list) && !list.isEmpty() ? list.get(0) : null;
50. }
52. }

MsgService

消息服务，提供了对t_msg表的一些操作以及消息投递的一些方法

方法	说明
addMsg	添加消息，消息会落库，处于待发送状态
confirmSendMsg	确定投递消息，事务成功后可以调用
cancelSendMsg	取消投递消息，事务回滚可以调用

代码：

1. package com.javacode2018.tx.demo11;
4. import org.springframework.beans.factory.annotation.Autowired;
5. import org.springframework.jdbc.core.BeanPropertyRowMapper;
6. import org.springframework.jdbc.core.JdbcTemplate;
7. import org.springframework.stereotype.Component;
8. import org.springframework.transaction.annotation.Propagation;
9. import org.springframework.transaction.annotation.Transactional;
11. import java.util.List;
12. import java.util.Objects;
14. /**
15. * 公众号：路人甲Java，工作10年的前阿里P7分享Java、算法、数据库方面的技术干货！
16. * <a href="http://www.itsoku.com">个人博客</a>
17. */
18. @Component
19. public class MsgService {
21. //添加一条消息(独立的事务中执行)
22. @Transactional(propagation = Propagation.REQUIRES_NEW)
23. public Long addMsg(String msg, Long msg_order_id, boolean isSend) {
24. MsgModel msgModel = MsgModel.builder().msg(msg).msg_order_id(msg_order_id).status(0).build();
25. //先插入消息
26. Long msg_id = this.insert(msgModel).getId();
27. if (isSend) {
28. //如果需要投递，则调用投递的方法
29. this.confirmSendMsg(msg_id);
30. }
31. return msg_id;
32. }
34. /**
35. * 确认消息投递(不需要事务)
36. *
37. * @param msg_id 消息id
38. */
39. @Transactional(propagation = Propagation.NOT_SUPPORTED)
40. public void confirmSendMsg(Long msg_id) {
41. MsgModel msgModel = this.getById(msg_id);
42. //向mq中投递消息
43. System.out.println(String.format("投递消息：%s", msgModel));
44. //将消息状态置为已投递
45. this.updateStatus(msg_id, 1);
46. }
48. /**
49. * 取消消息投递(不需要事务)
50. *
51. * @param msg_id 消息id
52. */
53. @Transactional(propagation = Propagation.NOT_SUPPORTED)
54. public void cancelSendMsg(Long msg_id) {
55. MsgModel msgModel = this.getById(msg_id);
56. System.out.println(String.format("取消投递消息：%s", msgModel));
57. //将消息状态置为取消投递
58. this.updateStatus(msg_id, 2);
59. }
61. @Autowired
62. private JdbcTemplate jdbcTemplate;
64. /**
65. * 插入消息
66. *
67. * @param msgModel
68. * @return
69. */
70. private MsgModel insert(MsgModel msgModel) {
71. //插入消息
72. this.jdbcTemplate.update("insert into t_msg (msg,msg_order_id,status) values (?,?,?)",
73. msgModel.getMsg(),
74. msgModel.getMsg_order_id(),
75. msgModel.getStatus());
76. //获取消息id
77. msgModel.setId(this.jdbcTemplate.queryForObject("SELECT LAST_INSERT_ID()", Long.class));
78. System.out.println("插入消息：" + msgModel);
79. return msgModel;
80. }
82. /**
83. * 根据消息id获取消息
84. *
85. * @param id
86. * @return
87. */
88. private MsgModel getById(Long id) {
89. List<MsgModel> list = this.jdbcTemplate.query("select * from t_msg where id = ? limit 1", new BeanPropertyRowMapper<MsgModel>(MsgModel.class), id);
90. return Objects.nonNull(list) && !list.isEmpty() ? list.get(0) : null;
91. }
93. /**
94. * 更新消息状态
95. *
96. * @param id
97. * @param status
98. */
99. private void updateStatus(long id, int status) {
100. this.jdbcTemplate.update("update t_msg set status = ? where id = ?", status, id);
101. }
103. }

消息投递器MsgSender

消息投递器，给业务方使用，内部只有一个方法，用来发送消息。

若上下文没有事务，则消息落地之后立即投递；若存在事务，则消息投递分为2步走：消息先落地，事务执行完毕之后再确定是否投递，用到了事务扩展点：TransactionSynchronization，事务执行完毕之后会回调TransactionSynchronization接口中的afterCompletion方法，在这个方法中确定是否投递消息。对事务扩展点TransactionSynchronization不熟悉的建议先看一下这篇文章：Spring系列第47篇：spring事务源码解析

1. package com.javacode2018.tx.demo11;
3. import org.springframework.beans.factory.annotation.Autowired;
4. import org.springframework.stereotype.Component;
5. import org.springframework.transaction.support.TransactionSynchronization;
6. import org.springframework.transaction.support.TransactionSynchronizationAdapter;
7. import org.springframework.transaction.support.TransactionSynchronizationManager;
10. /**
11. * 公众号：路人甲Java，工作10年的前阿里P7分享Java、算法、数据库方面的技术干货！
12. * <a href="http://www.itsoku.com">个人博客</a>
13. * 消息发送器，所有使用者调用send方法发送消息
14. */
15. @Component
16. public class MsgSender {
17. @Autowired
18. private MsgOrderService msgOrderService;
19. @Autowired
20. private MsgService msgService;
22. //发送消息
23. public void send(String msg, int ref_type, String ref_id) {
24. MsgOrderModel msgOrderModel = this.msgOrderService.insert(ref_type, ref_id);
26. Long msg_order_id = msgOrderModel.getId();
27. //TransactionSynchronizationManager.isSynchronizationActive 可以用来判断事务同步是否开启了
28. boolean isSynchronizationActive = TransactionSynchronizationManager.isSynchronizationActive();
29. /**
30. * 若事务同步开启了，那么可以在事务同步中添加事务扩展点，则先插入消息，暂不发送，则在事务扩展点中添加回调
31. * 事务结束之后会自动回调扩展点TransactionSynchronizationAdapter的afterCompletion()方法
32. * 咱们在这个方法中确定是否投递消息
33. */
34. if (isSynchronizationActive) {
35. final Long msg_id = this.msgService.addMsg(msg, msg_order_id, false);
36. TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
37. @Override
38. public void afterCompletion(int status) {
39. //代码走到这里时，事务已经完成了（可能是回滚了、或者是提交了）
40. //看一下消息关联的订单是否存在，如果存在，说明事务是成功的，业务是执行成功的，那么投递消息
41. if (msgOrderService.getById(msg_order_id) != null) {
42. System.out.println(String.format("准备投递消息,{msg_id:%s}", msg_id));
43. //事务成功：投递消息
44. msgService.confirmSendMsg(msg_id);
45. } else {
46. System.out.println(String.format("准备取消投递消息，{msg_id:%s}", msg_id));
47. //事务是不：取消投递消息
48. msgService.cancelSendMsg(msg_id);
49. }
50. }
51. });
52. } else {
53. //无事务的，直接插入并投递消息
54. this.msgService.addMsg(msg, msg_order_id, true);
55. }
56. }
57. }

3.3、测试（3种场景）

3.3.1、场景1：业务成功，消息投递成功

UserService

下面的register方法是有事务的，内部会插入一条用户信息，然后会投递一条消息

1. package com.javacode2018.tx.demo11;
3. import org.springframework.beans.factory.annotation.Autowired;
4. import org.springframework.jdbc.core.JdbcTemplate;
5. import org.springframework.stereotype.Component;
6. import org.springframework.transaction.annotation.Propagation;
7. import org.springframework.transaction.annotation.Transactional;
9. /**
10. * 公众号：路人甲Java，工作10年的前阿里P7分享Java、算法、数据库方面的技术干货！
11. * <a href="http://www.itsoku.com">个人博客</a>
12. */
13. @Component
14. public class UserService {
15. @Autowired
16. private JdbcTemplate jdbcTemplate;
17. //消息投递器
18. @Autowired
19. private MsgSender msgSender;
21. /**
22. * 模拟用户注册成功，顺便发送消息
23. */
24. @Transactional
25. public void register(Long user_id, String user_name) {
26. //先插入用户
27. this.jdbcTemplate.update("insert into t_user(id,name) VALUES (?,?)", user_id, user_name);
28. System.out.println(String.format("用户注册：[user_id:%s,user_name:%s]", user_id, user_name));
29. //发送消息
30. String msg = String.format("[user_id:%s,user_name:%s]", user_id, user_name);
31. //调用投递器的send方法投递消息
32. this.msgSender.send(msg, 1, user_id.toString());
33. }
35. }

测试类

1. package com.javacode2018.tx.demo11;
3. import org.junit.Before;
4. import org.junit.Test;
5. import org.springframework.context.annotation.AnnotationConfigApplicationContext;
6. import org.springframework.jdbc.core.JdbcTemplate;
8. /**
9. * 公众号：路人甲Java，工作10年的前阿里P7分享Java、算法、数据库方面的技术干货！
10. * <a href="http://www.itsoku.com">个人博客</a>
11. */
12. public class Demo11Test {
14. private AnnotationConfigApplicationContext context;
15. private UserService userService;
16. private JdbcTemplate jdbcTemplate;
18. @Before
19. public void before() {
20. this.context = new AnnotationConfigApplicationContext(MainConfig11.class);
21. userService = context.getBean(UserService.class);
22. this.jdbcTemplate = context.getBean("jdbcTemplate", JdbcTemplate.class);
23. jdbcTemplate.update("truncate table t_user");
24. jdbcTemplate.update("truncate table t_msg");
25. jdbcTemplate.update("truncate table t_msg_order");
26. }
28. @Test
29. public void test1() {
30. this.userService.register(1L, "路人");
31. }
33. }

运行输出

1. 用户注册：[user_id:1,user_name:路人]
2. 插入消息：MsgModel(id=1, msg=[user_id:1,user_name:路人], msg_order_id=1, status=0)
3. 准备投递消息,{msg_id:1}
4. 投递消息：MsgModel(id=1, msg=[user_id:1,user_name:路人], msg_order_id=1, status=0)

3.3.2、场景2：业务失败，消息取消投递

UserService中添加代码

手动抛出异常，让事务回滚。

1. /**
2. * 模拟用户注册失败，咱们通过弹出异常让事务回滚，结果也会导致消息发送被取消
3. *
4. * @param user_id
5. * @param user_name
6. */
7. @Transactional
8. public void registerFail(Long user_id, String user_name) {
9. this.register(user_id, user_name);
10. throw new RuntimeException("故意失败!");
11. }

Demo11Test添加用例

1. @Test
2. public void test2() {
3. this.userService.registerFail(1L, "张三");
4. }

运行输出

弹出了异常，信息比较多，我们截了关键的部分，如下，可以看出事务被回滚了，消息被取消投递了。

1. 用户注册：[user_id:1,user_name:张三]
2. 插入消息：MsgModel(id=1, msg=[user_id:1,user_name:张三], msg_order_id=1, status=0)
3. 准备取消投递消息，{msg_id:1}
4. 取消投递消息：MsgModel(id=1, msg=[user_id:1,user_name:张三], msg_order_id=1, status=0)
6. java.lang.RuntimeException: 故意失败!
8. at com.javacode2018.tx.demo11.UserService.registerFail(UserService.java:44)
9. at com.javacode2018.tx.demo11.UserService$$FastClassBySpringCGLIB$$5dd21f5c.invoke(<generated>)

3.3.3、嵌套事务

事务发送是跟随当前所在的事务的，当前事务提交了，消息一定会被投递出去，当前事务是不，消息会被取消投递。

下面看嵌套事务的代码

UserService中添加代码

注意下面方法的事务传播行为是：REQUIRES_NEW，当前如果有事务，会重启一个事务。

1. //事务传播属性是REQUIRES_NEW,会在独立的事务中运行
2. @Transactional(propagation = Propagation.REQUIRES_NEW)
3. public void registerRequiresNew(Long user_id, String user_name) {
4. this.register(user_id, user_name);
5. }

添加一个类UserService1

1. package com.javacode2018.tx.demo11;
3. import org.springframework.beans.factory.annotation.Autowired;
4. import org.springframework.stereotype.Component;
5. import org.springframework.transaction.annotation.Transactional;
7. /**
8. * 公众号：路人甲Java，工作10年的前阿里P7分享Java、算法、数据库方面的技术干货！
9. * <a href="http://www.itsoku.com">个人博客</a>
10. */
11. @Component
12. public class UserService1 {
13. @Autowired
14. private UserService userService;
16. @Autowired
17. private MsgSender msgSender;
19. //嵌套事务案例
20. @Transactional
21. public void nested() {
22. this.msgSender.send("消息1", 2, "1");
23. //registerRequiresNew事务传播属性是REQUIRES_NEW:会在一个新事务中运行
24. this.userService.registerRequiresNew(1L, "张三");
25. //registerFail事务传播属性是默认的，会在当前事务中运行，registerFail弹出异常会导致当前事务回滚
26. this.userService.registerFail(2L, "李四");
27. }
28. }

nested 是外围方法，这个方法上有@Transactional，运行的时候会开启一个事务，内部3行代码：

@1：发送消息，会在当前事务中执行

@2：registerRequiresNew事务传播行为是REQUIRES_NEW，所以会重启一个事务

@3：registerFail事务传播行为是默认的REQUIRED，会参与到nested()开启的事务中运行，registerFail方法内部会抛出一个异常，最终会导致外部方法事务回滚。

上面方法需要投递3条消息，而@1和@3投递的消息由于事务回滚会导致消息被回滚，而@2在独立的事务中执行，@2的消息会投递成功，下面来看看执行结果，是不是和分析的一致。

Demo11Test添加用例

1. @Test
2. public void test3() {
3. UserService1 userService1 = this.context.getBean(UserService1.class);
4. userService1.nested();
5. }

运行输出

1. 插入消息：MsgModel(id=1, msg=消息1, msg_order_id=1, status=0)
2. 用户注册：[user_id:1,user_name:张三]
3. 插入消息：MsgModel(id=2, msg=[user_id:1,user_name:张三], msg_order_id=2, status=0)
4. 准备投递消息,{msg_id:2}
5. 投递消息：MsgModel(id=2, msg=[user_id:1,user_name:张三], msg_order_id=2, status=0)
6. 用户注册：[user_id:2,user_name:李四]
7. 插入消息：MsgModel(id=3, msg=[user_id:2,user_name:李四], msg_order_id=3, status=0)
8. 准备取消投递消息，{msg_id:1}
9. 取消投递消息：MsgModel(id=1, msg=消息1, msg_order_id=1, status=0)
10. 准备取消投递消息，{msg_id:3}
11. 取消投递消息：MsgModel(id=3, msg=[user_id:2,user_name:李四], msg_order_id=3, status=0)
13. java.lang.RuntimeException: 故意失败!
15. 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、案例源码

1. git地址：
2. https://gitee.com/javacode2018/spring-series
4. 本文案例对应源码：
5. spring-series\lesson-002-tx\src\main\java\com\javacode2018\tx\demo11