本地消息表的设计与实现
前言
很久没有更新过了，准备开始写一些质量高一些的文章，也会同步到SegmentFault，个人主页：https://segmentfault.com/u/jinhaozhi/articles，近期主要记录下接近一年的核心工作。
背景
- 本地消息表是什么？
一种通过单机事务来保障分布式数据一致性的策略，作用就是在分布式系统中保证上下游的数据最终一致；
- Case（以订单为例）
在任何一个电商系统中，订单都是属于核心链路部分，要求高可用和稳定，但是作为核心链路，对下游的其余依赖也是难以避免的，比如活动、履约（履约可能有完全异步的设计方案，但在我们的业务中不好实现）、结算和售后等，一个本地事务的结构可能如下：
S1是核心链路的服务，某个本地事务包括A，B，C三个步骤，A调用下游服务S2，B调用下游服务S3，这样就有可能出现以下这些异常case:
- A成功了，B失败了，S1的本地事务回滚，但S2并不感知
- A，B成功了，C失败了，S1的本地事务回滚，S2和S3都不感知
- etc...
造成的后果呢就是数据不一致，比如A是活动券核销，S1是订单服务，S2是活动服务，就会出现订单下失败了，但是这张券却用掉了，用户肯定不会买账。
解决方案
解决方案其实很多，列举几种（这里说的劣势并不是说不好，取决于业务场景和实现方式）：
1、阿里开源的分布式事务解决方案seata
优：傻瓜式的使用方式，支持AT和TCC模式（我只用过这两种）
劣：
- 维护全局的状态需要成本，包括集群的通信与等待；
- 会破坏原生的事务，每一次写db操作就会提交一次，侵入严重；
- 稳定性依赖于网络和seata集群；
听了内部负责人的讲座，设计和实现都很精妙，考虑的也很周到，但是第三点对核心链路的业务来说是硬伤，第一点影响也较大，rt基本翻了一倍，最终选择弃用；
2、TCC
思路：下游提供回滚方案，本地事务失败时调用下游回滚接口，同时提供补偿方案，保障回滚成功；TCC是比较经典的分布式事务解决方案，形式有很多，个人觉得劣势也是开发成本太高，需要下游协作，但是使用范围很广泛，也容易扩展；
3、本地消息表
基本思路如图，以服务S1为例，本地事务中并不真正的执行A，B，C操作，事务提交后再去真正的执行A，B，C，同时提供补偿任务，保证A，B，C最后执行成功；
这种本地消息表的实现方案特别适用于核心链路业务，比如订单，将一些外部依赖放到本地事务外面，比如活动券，如果用户有这张券，而且券是可用的，订单业务就不应该被活动业务干扰，换言之，就是这笔订单必须下单成功，就算活动的服务挂了，这笔订单也要成功，但是不可降级的业务逻辑还是要放到本地事务中，比如用户的风控校验，店铺校验，活动券的时效校验等，这些逻辑应该与订单同时成功或同时失败，所以应该放到本地事务中；
还有个最大努力通知方案，详情请参考各大搜索引擎；
具体实现
这里以订单的活动券核销和履约为例，介绍本地消息表的简单实现
表结构（实体类OrderLocalMsg）
msg_type代表消息类型，msg_content记录消息内容，包括参数信息以及对应的订单号等，开发者可以自己定义
消息类型定义
@Getter
@AllArgsConstructor
public enum OrderMsgEnum {
USE_PRIZE(0, "核销消息"),
PERFORMACE(1, "履约消息")
;
private Integer code;
private String desc;
public static OrderMsgEnum of(Integer code) {
return Arrays.stream(OrderMsgEnum.values()).filter(orderMsgEnum -> orderMsgEnum.getCode().equals(code)).findFirst().get();
}这里使用策略模式和注解，可以省去很多难看的if else，扩展起来也会方便很多
注解@MsgType定义
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MsgType {
OrderMsgEnum msgType();
}环境类
该类用于分发策略，在启动时收集具体的策略实现类，TransactionSynchronizationAdapter是spring提供的钩子方法，通过在本地事务中注册钩子函数，实现事务提交后调用钩子函数的逻辑，其实现也非常简单，将注册的适配器（钩子函数的实现）保存到threadLocal中，在事务的commit执行后回调这个钩子函数，spring4以后支持注解的方式@TransactionalEventListener（我用了不生效，原因不明）
@Component
@Slf4j
public class OrderMsgHandlerContext implements ApplicationContextAware {
public Map msgHandlerMap = new HashMap();
private static final int EXECUTOR_CORE_POOL_SIZE = 30;
private static final int EXECUTOR_MAX_POLL_SIZE = 50;
private static final long EXECUTOR_KEEP_ALIVE_TIME_MILLIS = 30000L;
private static ExecutorService executor =
new ThreadPoolExecutor(EXECUTOR_CORE_POOL_SIZE,
EXECUTOR_MAX_POLL_SIZE,
EXECUTOR_KEEP_ALIVE_TIME_MILLIS,
TimeUnit.MILLISECONDS,
new ArrayBlockingQueue<>(100));
//执行操作后删除消息
public boolean exec(OrderLocalMsg msg) {
if (msgHandlerMap.get(msg.getMsgType()).exec(msg)) {
return delete(msg.getMsgType(), msg.getId());
} else {
CatUtils.addCatMetric("执行消息任务失败");
log.error("exec task error, msgType:{}, msg:{}", msg.getMsgType(), JsonUtils.toJson(msg));
return false;
}
}
//插入消息
public OrderLocalMsg add(Integer msgType, T msg) {
AbstractOrderMsgHandler orderMsgHandler = msgHandlerMap.get(msgType);
return orderMsgHandler.add(msg);
}
private boolean delete(Integer msgType, Long id) {
return msgHandlerMap.get(msgType).delete(id);
}
//启动获取策略类
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
Class annotationClass = MsgType.class;
Map beanWithAnnotation = applicationContext.getBeansWithAnnotation(annotationClass);
Set> entitySet = beanWithAnnotation.entrySet();
for (Map.Entry entry : entitySet) {
Class clazz = entry.getValue().getClass();
MsgType declaredAnnotation = clazz.getDeclaredAnnotation(MsgType.class);
if (declaredAnnotation == null) {
log.error("no protocol type annotation!");
}
msgHandlerMap.put(declaredAnnotation.msgType().getCode(), (AbstractOrderMsgHandler) applicationContext.getBean(clazz));
}
}
//钩子函数执行消息任务
public TransactionSynchronizationAdapter getTransactionSynchronizationAdapter(OrderLocalMsg localMsg) {
return new TransactionSynchronizationAdapter() {
@Override
public void afterCommit() {
if (!Objects.isNull(localMsg.getId())) {
exec(localMsg);
}
}
};
}
//钩子函数批量执行消息
public TransactionSynchronizationAdapter getTransactionSynchronizationAdapter(List msgList) {
return new TransactionSynchronizationAdapter() {
@Override
public void afterCommit() {
for (OrderLocalMsg orderLocalMsg : msgList) {
executor.submit(() -> exec(orderLocalMsg));
}
}
};
}
}
抽象策略类定义
@Data
@Component
public abstract class AbstractOrderMsgHandler {
OrderMsgEnum msg;
/**
* 插入一条数据到本地消息表
* @return
*/
public abstract OrderLocalMsg add(T msg);
/**
* 删除一条数据
* @param id
* @return
*/
public abstract boolean delete(Long id);
/**
* 重试任务
* @param orderLocalMsg
* @return
*/
public abstract boolean exec(OrderLocalMsg orderLocalMsg);
}
消息结构定义
以履约消息为例，只截取部分字段，会意就行
@Data
public class PerformanceOrderMsg {
/**
* 购买商家mallId
*/
private Long mallId;
/**
* 支付时间
*/
private Date payTime;
/**
* 订单号
*/
private String orderSn;
/**
* 订单支付金额(单位：分)
*/
private Long amount;
}策略实现类
以订单履约为例
@Component(value = "orderPerformanceMsgHandler")
@Slf4j
@MsgType(msgType = OrderMsgEnum.PERFORMACE)
public class OrderPerformanceMsgHandler extends AbstractOrderMsgHandler {
@Autowired
private OrderLocalMsgRepository repository;
@Autowired
private OrderPerformanceService orderPerformanceService;
@Autowired
private OrderRepository orderRepository;
@Override
public OrderLocalMsg add(PerformanceOrderMsg msg) {
OrderLocalMsg orderLocalMsg = new OrderLocalMsg();
orderLocalMsg.setOrderSn(msg.getOrderSn());
orderLocalMsg.setMsgType(OrderMsgEnum.PERFORMACE.getCode());
orderLocalMsg.setMsgContent(JsonUtils.toJson(msg));
repository.create(orderLocalMsg);
return orderLocalMsg;
}
@Override
public boolean delete(Long id) {
return repository.delete(id);
}
//通过返回true或false来判断操作是否成功，报错不应该抛出去
//操作成功则删除消息，操作失败则依赖补偿任务重试
@Override
public boolean exec(OrderLocalMsg orderLocalMsg) {
if (Objects.isNull(orderLocalMsg) || StringUtils.isEmpty(orderLocalMsg.getMsgContent())) {
log.error("msg is null, or msg content is null!");
return false;
}
PerformanceOrderMsg msgContent = JsonUtils.fromJson(orderLocalMsg.getMsgContent(), PerformanceOrderMsg.class);
OrderPerformanceDto dto = BeanUtils.convert(msgContent, OrderPerformanceDto.class);
try {
orderPerformanceService.performance(dto);
} catch (Exception e) {
log.error("exec type: order performance error, orderSn:{}", msgContent.getOrderSn());
CatUtils.addEvent(CatUtils.SYSTEM_EXCEPTION_TYPE, CatConsts.SERVICE_ORDER_PERFORMANCE_ERROR);
return false;
}
return true;
}
} 补偿任务
@Slf4j
@Component
@EnableScheduling
public class OrderMsgRetryTask {
@Autowired
private OrderMsgHandlerContext context;
@Autowired
private OrderLocalMsgRepository msgRepository;
private static final int EXECUTOR_CORE_POOL_SIZE = 30;
private static final int EXECUTOR_MAX_POLL_SIZE = 50;
private static final long EXECUTOR_KEEP_ALIVE_TIME_MILLIS = 30000L;
private static ExecutorService executor =
new ThreadPoolExecutor(EXECUTOR_CORE_POOL_SIZE,
EXECUTOR_MAX_POLL_SIZE,
EXECUTOR_KEEP_ALIVE_TIME_MILLIS,
TimeUnit.MILLISECONDS,
new ArrayBlockingQueue<>(100));
//cron=xxx，根据业务需要定义任务重试策略
public void doExecute() {
Page page = PageHelper.startPage(1, 100, false);
List msgs = page.doSelectPage(() -> msgRepository.findByExample(new OrderLocalMsgExample())) ;
if (CollectionUtils.isEmpty(msgs)) {
log.info("no order msg in db");
return;
}
msgs.stream().forEach(msg -> executor.submit(() -> context.exec(msg)));
}
}
这就是一个本地消息表的实现方案，使用示例：
/履约消息落库
PerformanceOrderMsg msg = BeanUtils.convert(orderPerformanceDto, PerformanceOrderMsg.class);
OrderLocalMsg localMsg = orderMsgHandlerContext.add(OrderMsgEnum.PERFORMANCE.getCode(), msg);
//afterCommit删除消息
TransactionSynchronizationManager.registerSynchronization(orderMsgHandlerContext.getTransactionSynchronizationAdapter(localMsg));三行代码就能使用，如果消息类型需要扩展，比如新增结算消息，步骤：1、枚举类新增结算消息类型；2、新增枚举消息结构定义；3、新增结算策略类实现；-----个人觉得扩展起来还是很方便的
总结
具体的实现还是要跟着具体的业务逻辑走～欢迎一切交流和撕逼