状态机+策略在工单流转里的使用

分类：菜鸟笔记作者：f80407515

昨天刚写了 可编排策略在交易系统的应用，今天小伙伴就给我提了个需求。

背景

最近由于新业务的需要，需要对原有工单的推单逻辑进行变动。我是想着尽可能不对原有逻辑进行改动，毕竟业务还一直在跑，就开启了一个小模块进行代码的组合。

在设计评审中，我一直强调要设计的灵活些。

校验规则一定要原子化，然后可编排在任何一处场景。校验的的入参和出参必须抽取，并标准化。

直接把我昨天写的文章扔过去了。

然后就差一个状态机了，得我就把框架搭起来。

设计

工单的流转完全可以状态驱动，如果发现两个状态都指向了一个处理逻辑，那就说明，你需要加一个状态。本着这个原则开始设计。

执行策略的实现

首先定义工单状态策略

/**
 * 工单状态流转策略
 * @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,"路由成功");
    }
}

最后类结构如下：

image-20220823181005766

状态机的实现

状态机接口定义

/**
 * 状态机服务
 * @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;
    }
}

整个代码结构如下：

image-20220823182045689

这么一来，我们只需要关心具体的业务逻辑就行了，状态不够就加状态，入口统一，关系映射在一处，也方便排查问题。

这里不像上一篇里的规则，定义以后可以用在多个地方，每个地方，我都可以编排。

这里就是一对一的映射。

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。

javajava状态机策略模式

相关推荐

如何学习编程？新手菜鸟如何学编程？
学习编程是顺着互联网的发展潮流，是一件好事。新手如何学习编程？其实不难，不过在学习编程之前你得先了解你的目的是什么？这个很重要，因为目的决定你的发展方向、决定你的发展速度。
it行业都是什么工作？it行业主要做什么？
IT行业是什么工作做什么？IT行业的工作有：产品策划类、页面设计类、前端与移动、开发与测试、营销推广类、数据运营类、运营维护类、游戏相关类等，根据不同的分类下面有细分了不同的岗位。
女生学Java好就业吗？女生适合学Java编程吗？
女生学Java好就业吗？女生适合学Java编程吗？目前有不少女生学习Java开发，但要结合自身的情况，先了解自己适不适合去学习Java，不要盲目的选择不适合自己的Java培训班进行学习。只要肯下功夫钻研，多看、多想、多练
mysql-connect-confused
Can’t connect to local MySQL server through socket \'/var/lib/mysql/mysql.sock问题 1.进入mysql路径
oracle基本命令
oracle基本命令 一、登录操作 1.管理员登录 # 管理员登录 sqlplus / as sysdba 2.普通用户登录
shell判断服务是否启动
一、背景 因为项目中需要通北京网络，所以需要连vpn，但是服务器有时候会断掉，所以写个shell脚本每五分钟去判断是否连接，于是就有下面的shell脚本。
SQL BETWEEN 操作符
BETWEEN 操作符选取介于两个值之间的数据范围内的值。这些值可以是数值、文本或者日期。
​​windows上传ipa到开发者中心app store的方法
假如你已经使用过苹果开发者中心上架app，你肯定知道在苹果开发者中心的web界面，无法直接提交ipa文件，而是需要使用第三方工具，将ipa文件上传到构建版本，开...
SQL 入门篇之什么是别名？
下面的 SQL 语句指定了两个别名，一个是 name 列的别名，一个是 country 列的别名。**提示：**如果列名称包含空格，要求使用双引号或方括号：
windows上传ipa文件到app store的方法​
在使用H5混合开发的app打包后，需要将ipa文件上传到appstore进行发布，就需要去苹果开发者中心进行发布。​
SQL AND & OR 运算符
+----+--------------+---------------------------+-------+---------+
C++ 数组
数组的声明并不是声明一个个单独的变量，比如 number0、number1、...、number99，而是声明一个数组变量，比如 numbers，然后使用 nu...
最全iOS 应用上架流程提交到AppStore
第一步：到appuploader官网下载辅助工具和iCloud驱动，使用前面创建的AppID登录。
SQL ALTER TABLE 语句
如需删除表中的列，请使用下面的语法（请注意，某些数据库系统不允许这种在数据库表中删除列的方式）：
dism操作巨慢
前不久在制作win11pe，制作了一版，1.26GB，太大了，不满意，想再裁剪下，发现这次dism mount正常，commit或discard巨慢，以前都很快...
三种方法卸载Symantec Endpoint Protection 赛门铁克
赛门铁克各个版本概览：https://knowledge.broadcom.com/external/article?legacyId=tech163829
python3.6、python3.10用什么版本的pip
实测Python 3.6.6用pip 21.3.1，再高就报错了，Python 3.10.7用pip 22.3.1是可以的
博通和诺顿
Broadcom Corporation （博通公司，股票代号AVGO）是全球领先的有线和无线通信半导体公司。其产品实现向家庭、 办公室和移动环境以及在这些环境...
高版本c4d在低版本windows系统上打开后不显示窗格
发现个问题，server2016上安装了c4d这些版本，低版本的正常显示窗格，但红色圈出的高版本c4d打开后不显示窗格，
基础网络windows不要使用TAT、如何卸载TAT
TAT：https://cloud.tencent.com/document/product/1340
pythonJavaScriptjavaHTMLPHPreactjsC#AndroidCSSNode.jssqlrpython-3.xMysqLjQueryc++pandasFlutterangularIOSdjangolinuxswifttypescript路由器JSON路由器设置无线路由器h3c华三华三路由器设置华三路由器电脑软件教程arraysdocker软件图文教程Cvue.jslaravelspring-boot