昨天刚写了 可编排策略在交易系统的应用，今天小伙伴就给我提了个需求。
背景
最近由于新业务的需要，需要对原有工单的推单逻辑进行变动。我是想着尽可能不对原有逻辑进行改动，毕竟业务还一直在跑，就开启了一个小模块进行代码的组合。
在设计评审中，我一直强调要设计的灵活些。
校验规则一定要原子化，然后可编排在任何一处场景。校验的的入参和出参必须抽取，并标准化。
直接把我昨天写的文章扔过去了。
然后就差一个状态机了，得我就把框架搭起来。
设计
工单的流转完全可以状态驱动，如果发现两个状态都指向了一个处理逻辑，那就说明，你需要加一个状态。本着这个原则开始设计。
执行策略的实现
首先定义工单状态策略
/**
* 工单状态流转策略
* @Author: yxkong
* @Date: 2022/8/23 11:28 AM
* @version: 1.0
*/
public interface OrderStateStrategy {
/**
* 状态流转前置校验
* @param context
* @return
*/
OrderStateResult check(OrderStateContext context);
/**
* 状态流转统一入口
* 执行的模板
* @param context
* @return
*/
OrderStateResult execute(OrderStateContext context);
/**
* 状态流转处理器，由各个策略实现
* 如果需要重试，在code = -1的时候，retry = true
* @param context
* @return
*/
OrderStateResult handler(OrderStateContext context);
/**
* 状态流转后置处理
* @param context
* @param rst
* @return
*/
boolean after(OrderStateContext context, OrderStateResult rst);
}
进行模板方法封装,将整个公共部分抽取
/**
* 公共处理
* @Author: yxkong
* @Date: 2022/8/23 11:47 AM
* @version: 1.0
*/
public abstract class AbstractOrderStateStrategy implements OrderStateStrategy {
@Override
public OrderStateResult check(OrderStateContext context) {
/**
* 此处公共校验
* 根据工单id查询工单的状态
*/
OrderStateEnum dbStatus = OrderStateEnum.init;
if (context.getCurrentState() != dbStatus){
return new OrderStateResult(null,false,CodeStateEnum.fail,"当前状态不匹配");
}
return new OrderStateResult(CodeStateEnum.succ,"校验通过！");
}
@Override
public OrderStateResult execute(OrderStateContext context) {
OrderStateResult check = check(context);
if (!check.isSucc()){
/**
* 这块埋点,因为什么拦截的
*/
return check ;
}
OrderStateResult handler = handler(context);
//执行后的统一处理
boolean rst = this.after(context, handler);
if (!rst){
/**
* 要保证最终一致性，这里业务已经处理完了
* 记录日志或者，推入消息队列做补偿
*/
}
return handler;
}
@Override
public boolean after(OrderStateContext context, OrderStateResult rst) {
/**
* 统一发送领域事件
* 统一记录日志,失败也需要记录日志
* 处理成功，返回true，处理失败，返回false，需要补偿
*/
return false;
}
}
具体的策略实现
/**
* 关单策略实现
* @Author: yxkong
* @Date: 2022/8/23 12:16 PM
* @version: 1.0
*/
@Service("closeOrderStrategy")
public class CloseOrderStrategyImpl extends AbstractOrderStateStrategy {
@Override
public OrderStateResult handler(OrderStateContext context) {
return null;
}
}
/**
* 推单策略实现
* @Author: yxkong
* @Date: 2022/8/23 11:59 AM
* @version: 1.0
*/
@Service("pushOrderStrategy")
public class PushOrderStrategyImpl extends AbstractOrderStateStrategy {
@Override
public OrderStateResult check(OrderStateContext context) {
/**
* 定制化拦截
* 比如，查询推单开关是否开启,重试的次数
*/
String closeSwitch = "open";
if ("close".equals(closeSwitch)){
return new OrderStateResult(CodeStateEnum.fail,"推单开关关闭，不允许推单");
}
return super.check(context);
}
@Override
public OrderStateResult handler(OrderStateContext context) {
/**
* 推单的处理逻辑
*/
return null;
}
}
/**
* 重新路由策略实现
* @Author: yxkong
* @Date: 2022/8/23 12:10 PM
* @version: 1.0
*/
@Service("reRouteStrategy")
public class ReRouteStrategyImpl extends AbstractOrderStateStrategy {
@Override
public OrderStateResult handler(OrderStateContext context) {
/**
* 路由到具体的机构后，将数据库工单改成推单状态
*/
return new OrderStateResult(OrderStateEnum.pass, CodeStateEnum.succ,"路由成功");
}
}
最后类结构如下：
状态机的实现
状态机接口定义
/**
* 状态机服务
* @Author: yxkong
* @Date: 2022/8/23 5:40 PM
* @version: 1.0
*/
public interface OrderStateMachineService {
/**
* 状态机执行
* @param context
* @return
*/
OrderStateResult execute(OrderStateContext context);
}
状态机实现
/**
* 工单状态机
* @Author: yxkong
* @Date: 2022/8/23 12:32 PM
* @version: 1.0
*/
@Service
public class OrderStateMachineServiceImpl implements OrderStateMachineService {
@Autowired
private Map<String, OrderStateStrategy> map;
/**
* 状态机执行
* @param context
* @return
*/
@Override
public OrderStateResult execute(OrderStateContext context){
OrderStateEnum currentState = context.getCurrentState();
if ( OrderStateEnum.isFinalState(currentState)){
//终态不处理,直接返回
return null;
}
OrderStateMappingEnum mapping = OrderStateMappingEnum.of(currentState.getState());
if (mapping == null){
throw new RuntimeException("暂不支持该状态的处理"+ currentState);
}
//获取对应状态的处理策略
OrderStateStrategy stateStrategy = map.get(mapping.getHandlerBean());
//执行具体的策略
OrderStateResult execute = stateStrategy.execute(context);
//是否需要递归调用
if (execute.isExecute()){
/**
* 一个状态执行完，重新赋值状态
*/
context.setCurrentState(execute.getOrderStatus());
context.setRetry(execute.isRetry());
return this.execute(context);
}
return execute;
}
}
在这里利用spring的DI机制，将同类型的注入到map里，方便使用
同时利用枚举来封装状态与处理器的关系。
枚举类：
/**
* 状态与处理映射
* @author yxkong
*/
public enum OrderStateMappingEnum {
closeOrder(5,"closeOrderStrategy","关单"),
reroute(1,"reRouteStrategy","重新路由"),
retry(2,"retryStrategy", "重试"),
blockOrder(3,"blockOrderStrategy", "卡单");
private int state;
private String handlerBean;
private String desc;
OrderStateMappingEnum(int state, String handlerBean, String desc) {
this.state = state;
this.handlerBean = handlerBean;
this.desc = desc;
}
public int getState() {
return state;
}
public String getHandlerBean() {
return handlerBean;
}
public String getDesc() {
return desc;
}
/**
* 获取枚举
*
* @param state 枚举值
* @return OrderStateMappingEnum
*/
public static OrderStateMappingEnum of(final int state) {
for (final OrderStateMappingEnum s : OrderStateMappingEnum.values()) {
if (Objects.equals(s.state, state)) {
return s;
}
}
return null;
}
}
/**
* 状态枚举
* @Author: yxkong
* @Date: 2022/8/23 11:41 AM
* @version: 1.0
*/
public enum OrderStateEnum {
init(0,"初始化工单"),
waitingClose(8,"等待关闭"),
waitingRoute(2,"等待路由"),
refuse(6,"工单拒绝"),
pass(5,"工单通过");
private int state;
private String desc;
private OrderStateEnum(int state, String desc) {
this.state = state;
this.desc = desc;
}
public static OrderStateEnum of(final int state) {
for (final OrderStateEnum s : OrderStateEnum.values()) {
if (Objects.equals(s.state, state)) {
return s;
}
}
return null;
}
/**
* 是否终态
* @param state
* @return
*/
public static boolean isFinalState(OrderStateEnum state){
return OrderStateEnum.refuse.equals(state) || OrderStateEnum.pass.equals(state);
}
public int getState() {
return state;
}
public String getDesc() {
return desc;
}
}
/**
* 返回code枚举
* @Author: yxkong
* @Date: 2022/8/23 5:56 PM
* @version: 1.0
*/
public enum CodeStateEnum {
succ(1,"成功"),
fail(0,"失败"),
error(-1,"异常");
private int code;
private String desc;
private CodeStateEnum(int code, String desc) {
this.code = code;
this.desc = desc;
}
public static CodeStateEnum of(final int code) {
for (final CodeStateEnum s : CodeStateEnum.values()) {
if (Objects.equals(s.code, code)) {
return s;
}
}
return null;
}
public int getCode() {
return code;
}
public String getDesc() {
return desc;
}
}
上下文与出参
/**
* 工单状态上下文
* @Author: yxkong
* @Date: 2022/8/23 11:28 AM
* @version: 1.0
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class OrderStateContext {
/**工单id*/
private String appId;
/**当前状态*/
private OrderStateEnum currentState;
/**重试*/
private boolean retry;
}
/**
* 状态流转返回结果
*
* @Author: yxkong
* @Date: 2022/8/23 11:30 AM
* @version: 1.0
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class OrderStateResult {
/**执行后的工单状态*/
private OrderStateEnum orderStatus;
/**是否重试*/
private boolean retry ;
/**当前执行状态码 1成功，0失败，-1 异常*/
private CodeStateEnum code;
/**当前执行结果描述*/
private String message;
public OrderStateResult(CodeStateEnum code, String message) {
this.code = code;
this.message = message;
}
public OrderStateResult(OrderStateEnum orderStatus, CodeStateEnum code, String message) {
this.orderStatus = orderStatus;
this.code = code;
this.message = message;
}
/**
* 是否成功
* @return
*/
public boolean isSucc(){
return this.code == CodeStateEnum.succ;
}
/**
* 是否继续执行
* @return
*/
public boolean isExecute(){
if (CodeStateEnum.succ == this.code || (CodeStateEnum.error == this.code && retry)){
return Boolean.TRUE;
}
return Boolean.FALSE;
}
}
整个代码结构如下：
这么一来，我们只需要关心具体的业务逻辑就行了，状态不够就加状态，入口统一，关系映射在一处，也方便排查问题。
这里不像上一篇里的规则，定义以后可以用在多个地方，每个地方，我都可以编排。
这里就是一对一的映射。
原文作者：5ycode；如有侵权，请联系管理员删除。
上一篇：
一道程任务编排服务面试题解析
下一篇：
设计模式在交易系统的应用
请登录后发表评论
登录
全部评论
最新文章
- DeepSeek+ragflow构建企业知识库之工作流，突然觉的dify又香了
- dify1.0.0版本升级及新功能预览
- DeepSeek+ragflow构建企业知识库：突然觉的dify不香了（1）
- DeepSeek官方充值终于开放了，相关工具推荐
- 聊聊dify权限验证的三种方案及实现
- DeepSeek+dify 工作流应用,自然语言查询数据库信息并展示
- DeepSeek+dify知识库，查询数据库的两种方式（api+直连）
- DeepSeek+dify 本地知识库：高级应用Agent+工作流
- 腾讯有Dify团队吗？difySandbox成了腾讯Dify团队开源的
- Deepseek+Dify本地知识库相关问题汇总
