【设计模式】状态模式以及开源状态机框架的实践

最新推荐文章于 2024-07-27 18:05:15 发布
最新推荐文章于 2024-07-27 18:05:15 发布
阅读量689 收藏
点赞数
分类专栏： 设计模式 开源项目介绍 文章标签： 设计模式 状态模式 开源
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42985872/article/details/130442092
版权

一、业务背景

营销自动化平台支持多种不同类型运营活动策略（比如：短信推送策略、微信图文推送策略、App Push推送策略），每种活动类型都有各自不同的执行流程和活动状态。比如短信活动的活动执行流程如下：
在这里插入图片描述

整个短信活动经历了 未开始 → 数据准备中 → 数据已就绪 → 活动推送中→ 活动结束 多个状态变更流程。不仅如此， 我们发现在活动业务逻辑处理过程中，都有以下类似的特点:

每增加一种新的活动业务类型，就要新增相应的活动状态以及处理状态变更的逻辑；

当一个类型的活动业务流程有修改时，可能需要对原先的状态转移过程进行变更;

当每个业务都各自编写自己的状态转移的业务代码时，核心业务逻辑和控制逻辑耦合性会非常强，扩展性差，成本也很高。

针对系统状态的流转管理，计算机领域有一套标准的理论方案模型——有限状态机。

二、理解状态机

2.1 状态机定义

有限状态机（Finite-State Machine , 缩写：FSM），简称状态机。是表示有限个状态以及这些状态之间的转移和触发动作的模型。

状态是描述系统对象在某个时刻所处的状况。

转移指示状态变更，一般是通过外部事件为条件触发状态的转移。

动作是对给定状态下要进行的操作。

简而言之，状态机是由事件、状态、动作三大部分组成。三者的关系是：事件触发状态的转移，状态的转移触发后续动作的执行。其中动作不是必须的，也可以只进行状态转移，不进行任何操作。

在这里插入图片描述

2.2 状态机的实现方式

2.2.1 基于条件判断的实现

这是最直接的一种实现方式，所谓条件判断就是通过使用 if-else 或 switch-case 分支判断进行硬编码实现。对于前面短信活动，基于条件判断方式的代码实例如下：

/**
  * 短信活动状态枚举
  */
public enum ActivityState {
    NOT_START(0), //活动未开始
    DATA_PREPARING(1), //数据准备中
    DATA_PREPARED(2), //数据已就绪
    DATA_PUSHING(3), //活动推送中
    FINISHED(4); //活动结束
}
 
/**
  * 短信活动状态机
  */
public class ActivityStateMachine {
    //活动状态
    private ActivityState currentState;
    public ActivityStateMachine() {
        this.currentState = ActivityState.NOT_START;
    }
    /**
     * 活动时间开始
     */
    public void begin() {
        if (currentState.equals(ActivityState.NOT_START)) {
            this.currentState = ActivityState.DATA_PREPARING;
            //发送通知给运营人员
            notice();
        }
        // do nothing or throw exception ...
    }
 
    /**
     * 数据计算完成
     */
    public void finishCalData() {
        if (currentState.equals(ActivityState.DATA_PREPARING)) {
            this.currentState = ActivityState.DATA_PREPARED;
            //发送通知给运营人员
            notice();
        }
        // do nothing or throw exception ...
    }
 
     /**
     * 活动推送开始
     */
    public void beginPushData() {
        //省略
    }
     /**
     * 数据推送完成
     */
    public void finishPushData() {
        //省略
    }
}

通过条件分支判断来控制状态的转移和动作的触发，上述的 if 判断条件也可以换成 switch 语句，以当前状态为分支来控制该状态下可以执行的操作。

适用场景
适用于业务状态个数少或者状态间跳转逻辑比较简单的场景。

缺陷
当触发事件和业务状态之间对应关系不是简单的一对一时，就需要嵌套多个条件分支判断，分支逻辑会变得异常复杂；当状态流程有变更时，也需要改动分支逻辑，不符合开闭原则，代码可读性和扩展性非常差。

2.2.2 基于状态模式的实现

了解设计模式的童鞋，很容易就可以把状态机和状态模式这两个概念联系起来，状态模式其实可以作为状态机的一种实现方式。主要实现思路是通过状态模式将不同状态的行为进行分离，根据状态变量的变化，来调用不同状态下对应的不同方法。代码示例如下：

/**
   * 活动状态接口
   */
interface IActivityState {
    ActivityState getName();
    //触发事件
    void begin();
    void finishCalData();
    void beginPushData();
    void finishPushData();
}
 
 /**
   * 具体状态类—活动未开始状态
   */
public class ActivityNotStartState implements IActivityState {
    private ActivityStateMachine stateMachine;
    public ActivityNotStartState(ActivityStateMachine stateMachine) {
        this.stateMachine = stateMachine;
    }
 
    @Override
    public ActivityState getName() {
        return ActivityState.NOT_START;
    }
 
    @Override
    public void begin() {
        stateMachine.setCurrentState(new ActivityDataPreparingState(stateMachine));
        //发送通知
        notice();
    }
 
    @Override
    public void finishCalData() {
        // do nothing or throw exception ...
    }
    @Override
    public void beginPushData() {
        // do nothing or throw exception ...
    }
    @Override
    public void finishPushData() {
        // do nothing or throw exception ...
    }
}
 
 /**
   * 具体状态类—数据准备中状态
   */
public class ActivityDataPreparingState implements IActivityState {
    private ActivityStateMachine stateMachine;
    public ActivityNotStartState(ActivityStateMachine stateMachine) {
        this.stateMachine = stateMachine;
    }
 
    @Override
    public ActivityState getName() {
        return ActivityState.DATA_PREPARING;
    }
    @Override
    public void begin() {
        // do nothing or throw exception ...
    }
    public void finishCalData() {
        stateMachine.setCurrentState(new ActivityDataPreparedState(stateMachine));
        //TODO:发送通知
    }
   @Override
    public void beginPushData() {
        // do nothing or throw exception ...
    }
    @Override
    public void finishPushData() {
        // do nothing or throw exception ...
    }
}
    ...(篇幅原因，省略其他具体活动类)
 
 
 /**
   * 状态机
   */
public class ActivityStateMachine {
    private IActivityState currentState;
    public ActivityStateMachine(IActivityState currentState) {
        this.currentState = new ActivityNotStartState(this);
    }
    public void setCurrentState(IActivityState currentState) {
        this.currentState = currentState;
    }
    public void begin() {
        currentState.begin();
    }
    public void finishCalData() {
        currentState.finishCalData();
    }
    public void beginPushData() {
        currentState.beginPushData();
    }
    public void finishPushData() {
        currentState.finishCalData();
    }
}

状态模式定义了状态-行为的对应关系, 并将各自状态的行为封装在对应的状态类中。我们只需要扩展或者修改具体状态类就可以实现对应流程状态的需求。

适用场景

适用于业务状态不多且状态转移简单的场景，相比于前面的if/switch条件分支法，当业务状态流程新增或修改时，影响粒度更小，范围可控，扩展性更强。

三、开源状态机框架

3.1 Spring State Machine

enum ActivityState {
    NOT_START(0),
    DATA_PREPARING(1),
    DATA_PREPARED(2),
    DATA_PUSHING(3),
    FINISHED(4);
 
    private int state;
    private ActivityState(int state) {
        this.state = state;
    }
}
 
enum ActEvent {
    ACT_BEGIN, FINISH_DATA_CAL,FINISH_DATA_PREPARE,FINISH_DATA_PUSHING
}
 
@Configuration
@EnableStateMachine
public class StatemachineConfigurer extends EnumStateMachineConfigurerAdapter<ActivityState, ActEvent> {
    @Override
    public void configure(StateMachineStateConfigurer<ActivityState, ActEvent> states)
            throws Exception {
                states
                .withStates()
                .initial(ActivityState.NOT_START)
                .states(EnumSet.allOf(ActivityState.class));
    }
    @Override
    public void configure(StateMachineTransitionConfigurer<ActivityState, ActEvent> transitions)
            throws Exception {
                transitions
                .withExternal()
                .source(ActivityState.NOT_START).target(ActivityState.DATA_PREPARING)
                .event(ActEvent.ACT_BEGIN).action(notice())
                .and()
                .withExternal()
                .source(ActivityState.DATA_PREPARING).target(ActivityState.DATA_PREPARED)
                .event(ActEvent.FINISH_DATA_CAL).action(notice())
                .and()
                .withExternal()
                .source(ActivityState.DATA_PREPARED).target(ActivityState.DATA_PUSHING)
                .event(ActEvent.FINISH_DATA_PREPARE).action(notice())
                .and()
                .withExternal()
                .source(ActivityState.DATA_PUSHING).target(ActivityState.FINISHED)
                .event(ActEvent.FINISH_DATA_PUSHING).action(notice())
                .and() ;
    }
    @Override
    public void configure(StateMachineConfigurationConfigurer<ActivityState, ActEvent> config)
            throws Exception {
        config.withConfiguration()
                .machineId("ActivityStateMachine");
    }
    public Action<ActivityState, ActEvent> notice() {
        return context -> System.out.println("【变更前状态】:"+context.getSource().getId()+";【变更后状态】:"+context.getTarget().getId());
    }
 
   //测试类
   class DemoApplicationTests {
    @Autowired
    private StateMachine<ActivityState, ActEvent> stateMachine;
 
    @Test
    void contextLoads() {
        stateMachine.start();
        stateMachine.sendEvent(ActEvent.ACT_BEGIN);
        stateMachine.sendEvent(ActEvent.FINISH_DATA_CAL);
        stateMachine.sendEvent(ActEvent.FINISH_DATA_PREPARE);
        stateMachine.sendEvent(ActEvent.FINISH_DATA_PUSHING);
        stateMachine.stop();
    }
}

通过重写配置模板类的三个configure方法，通过流式Api形式完成状态初始化、状态转移的流程以及状态机的声明，实现Java内部DSL的状态机。外部使用状态机通过sendEvent事件触发，推动状态机的自动流转。

缺陷
Spring Statemachine 在每个 statemachine 实例内部保存了当前状态机上下文相关的属性，也就是说是有状态的（这一点从触发状态机流转只需事件作为参数也可以看出来），所以使用单例模式的状态机实例不是线程安全的。要保证线程安全性只能每次通过工厂模式创建一个新的状态机实例，这种方式在高并发场景下，会影响系统整体性能。

3.2 Cola State Machine

/**
 * 状态机工厂类
 */
public class StatusMachineEngine {
    private StatusMachineEngine() {
    }
    private static final Map<OrderTypeEnum, String> STATUS_MACHINE_MAP = new HashMap();
 
    static {
        //短信推送状态
        STATUS_MACHINE_MAP.put(ChannelTypeEnum.SMS, "smsStateMachine");
        //PUSH推送状态
        STATUS_MACHINE_MAP.put(ChannelTypeEnum.PUSH, "pushStateMachine");
        //......
    }
 
    public static String getMachineEngine(ChannelTypeEnum channelTypeEnum) {
        return STATUS_MACHINE_MAP.get(channelTypeEnum);
    }
 
   /**
     * 触发状态转移
     * @param channelTypeEnum
     * @param status 当前状态
     * @param eventType 触发事件
     * @param context 上下文参数
     */
    public static void fire(ChannelTypeEnum channelTypeEnum, String status, EventType eventType, Context context) {
        StateMachine orderStateMachine = StateMachineFactory.get(STATUS_MACHINE_MAP.get(channelTypeEnum));
        //推动状态机进行流转，具体介绍本期先省略
        orderStateMachine.fireEvent(status, eventType, context);
    }
 
/**
 * 短信推送活动状态机初始化
 */
@Component
public class SmsStateMachine implements ApplicationListener<ContextRefreshedEvent> {
 
    @Autowired
    private  StatusAction smsStatusAction;
    @Autowired
    private  StatusCondition smsStatusCondition;
 
    //基于DSL构建状态配置，触发事件转移和后续的动作
    @Override
    public void onApplicationEvent(ContextRefreshedEvent contextRefreshedEvent) {
        StateMachineBuilder<String, EventType, Context> builder = StateMachineBuilderFactory.create();
        builder.externalTransition()
                .from(INIT)
                .to(NOT_START)
                .on(EventType.TIME_BEGIN)
                .when(smsStatusAction.checkNotifyCondition())
                .perform(smsStatusAction.doNotifyAction());
        builder.externalTransition()
                .from(NOT_START)
                .to(DATA_PREPARING)
                .on(EventType.CAL_DATA)
                .when(smsStatusCondition.doNotifyAction())
                .perform(smsStatusAction.doNotifyAction());
        builder.externalTransition()
                .from(DATA_PREPARING)
                .to(DATA_PREPARED)
                .on(EventType.PREPARED_DATA)
                .when(smsStatusCondition.doNotifyAction())
                .perform(smsStatusAction.doNotifyAction());
        ...(省略其他状态)
        builder.build(StatusMachineEngine.getMachineEngine(ChannelTypeEnum.SMS));
    }
 
   //调用端
   public class Client {
     public static void main(String[] args){
          //构建活动上下文
          Context context = new Context(...);
         // 触发状态流转
          StatusMachineEngine.fire(ChannelTypeEnum.SMS, INIT, EventType.SUBMIT, context);
      }
   }
}

Cola Statemachine 是阿里COLA开源框架里面的一款状态机框架，和前面两者最大的不同就是：无状态的设计——触发状态机流转时需要把当前状态作为入参，状态机实例中不需要保留当前状态上下文消息，只有一个状态机实例，也就直接保证了线程安全性和高性能。
在这里插入图片描述

四、项目地址

https://gitee.com/charles_ruan/state-machine

秋装什么
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
游戏服务器之AI设计——有限状态机
littleschemer的博客
01-06 4188
游戏世界里有各种各样的AI行为，例如怪物砍人，玩家自动挂机等等。一个游戏好不好玩，很重要一点就是游戏的A质量，毕竟PVE占玩家游戏时间很大比重。当然，游戏AI设计难度非常大。本文介绍如何使用有限状态机实现简单的游戏AI逻辑。
QEP_FSM有限状态机框架
aoyousihaiqiuqihuang的博客
10-23 2230
文介绍一种新的有限状态机的实现方法QEP, 是一种基于事件的状态处理方式，本文介绍该状态机框架的C语言实现方式。QEP是QP框架的一个组件，这里简单介绍一下QP框架。QP(Quantum Platform, 量子平台，简称QP,)是一个用于实时嵌入式系统的软件框架，QP是轻量级的、开源的、基于层次式状态机的、事件驱动的平台。
【Unity3D日常开发】有限状态机的简单实现
CSDN博客专家，Unity3D高级软件工程师，《Unity 3D从入门到实战》作者。
07-28 4628
推荐阅读 CSDN主页 GitHub开源地址 Unity3D插件分享 简书地址 我的个人博客 QQ群：1040082875 一、前言 Hello，大家好，我是☆恬静的小魔龙☆，正所谓学而不思则罔，思而不学则殆，最近项目开发中，人物的动作特别多，用状态机去切换感觉太麻烦，然后切换的效果也并不理想。 比如下面的状态机： 每次“走→站立→跑”，都一些卡顿，没有那么丝滑，所以就想学习一下FSM（有限状态机）。 二、有限状态机 什么是有限状态机： 如其名有限状态机，就是可以枚举出有限个状态，然后状态直接可.
推荐开源项目：StatefulJ——轻量级事件驱动状态机框架
gitblog_00001的博客
06-05 323
推荐开源项目：StatefulJ——轻量级事件驱动状态机框架 项目地址:https://gitcode.com/statefulj/statefulj 1. 项目介绍 StatefulJ 是一个专为Java设计的轻量级开源框架，它提供了一个简单且无依赖的事件驱动有限状态机（FSM）实现。此外，还有一套基于Spring Data的完整框架，使您能够方便地在应用程序中集成和定义状态机。 2. 项目技术...
c语言设计模式代码完整实现-状态机模式
jenie的专栏
06-01 6493
模式介绍 状态（state）模式是C语言实现相当常用的模式，也是能够在C语言***现出来的最显性的模式之一。在面向对象里，状态模式允许一个对象在内部状态改变的时候改变其行为。 状态用法很多，最常见的是状态机，分为无限状态机和有限状态机。 有限状态机finite-state machine，FSM，输入集合和输出集合都是有限的，并只有有限数目的状态。一般说到状态机即是对有限状态机的简称。 无限状态机infinite-state machine，ISM，输入和输出集合无线，状态数目无限的状态...
C语言_有限状态机（FSM）
aoyousihaiqiuqihuang的博客
09-04 6888
C语言_有限状态机（FSM） 基本介绍 许多小型或复杂的应用程序都使用有限状态机 (FSM)，C 语言中的有限状态机是嵌入式系统的流行设计模式之一，有限状态机使开发变得容易和顺利。 有很多设备使用事件基态，如咖啡机、自动售货机、POS 设备、门锁系统等。一些 POS 设备使用事件表，在事件表中使用事件处理程序注册事件，通过相关条件触发事件的执行。 本文中，使用C语言创建一个简易的ATM状态机。 ATM 机的状态可以通过即将发生的事件进行更改。ATM状态机包含以下几个状态： Idle State Card
状态机简介：理解和实现编程中的状态转换
fudaihb的博客
04-23 3097
状态机（State Machine）是一种数学模型和计算机科学中的抽象概念，它描述了对象在其生命周期中的状态如何根据输入或事件而转换。简单来说，状态机是一个可以表示对象状态及其状态之间转换的框架或图形表示。 在日常生活和软件开发中，我们经常会遇到需要管理和跟踪对象或系统状态的情况。例如，自动售货机、电梯控制系统、游戏角色状态等都可以通过状态机来清晰、高效地描述和管理。
状态机选型简记
少爷
05-03 2934
背景 业务中涉及到一些关于单据的操作，每种单据单据都会有自己的状态，单据的一些行为受限于当前订单的状态，单据的状态直接用常量表示，业务进行前的检查部分通过if判断来检测当前单据是否可以流转到目标状态。 痛点 业务发展的比较快，某些单据状态不停的增加，每一次增加都需要改动业务中使用到状态的相关代码，更糟的的是这些代码可能遍布于多个类的多个方法中（散弹枪一样），不仅增加发布的风险也同时增加了...
springboot状态机模式
qq_41604890的博客
02-03 2404
状态机模式 框架 实现 状态扭转
实现一个状态机引擎，教你看清DSL的本质
热门推荐
我的新书《代码精进之路：从码农到工匠》
03-20 4万+
最近在一个项目中，因为涉及很多状态的流转，我们选择使用状态机引擎来表达状态流转。因为状态机DSL（Domain Specific Languages）带来的表达能力，相比较于if-else的代码，要更优雅更容易理解。另一方面，状态机很简单，不像流程引擎那么华而不实。 一开始我们选用了一个开源的状态机引擎，但我觉得不好用，就自己写了一个能满足我们要求的简洁版状态机，这样比较KISS（Keep It ...
状态机的理解与使用【开发实践】
qq_40656637的博客
04-07 1502
状态机
为Linux应用构造有限状态机
03-03
本文介绍如何构建基于状态机的软件系统，以及如何利用Linux下的工具来自动生成实用的状态机框架。一、什么是状态机有限状态机是一种用来进行对象行为建模的工具，其作用主要是描述对象在它的生命周期内所经历的状态...
Android、Java、设计模式、面试题.zip
10-03
对于Java，面试题可能涉及异常处理策略、集合框架的使用场景、多线程问题，以及如何实现设计模式。对于设计模式，面试官可能会要求解释各种模式的用途，以及在实际项目中如何应用它们。 总之，Android、Java和设计...
mystatemachine_QT_状态机_
09-30
在本文中，我们将深入探讨如何使用QT库中的状态机框架来设计和实现一个简单的按键状态机。这个状态机有三个状态，每个状态对应于按键的不同行为。我们将从基本的QT概念开始，逐步解析代码，解释状态机的工作原理，并...
qpc ：一个开源的状态机实现
03-22
QP 框架系列基于 Active Object （actor） 设计模式，它本质上支持并自动强制执行 以下并发编程的最佳实践： 保持数据隔离并绑定到活动对象的线程。线程应该 隐藏（封装）他们的私人数据和其他资源，而不是 与系统...
自动机：用于Arduino的React式状态机框架
01-28
"自动机：用于Arduino的React式状态机框架" 提供了一个强大的工具，帮助开发者更方便地管理和组织程序逻辑。这个框架基于反应式编程的概念，使得代码结构清晰，易于理解和维护。 自动机（Automaton）是一种抽象计算...
设计模式实战：日志系统的设计与实现
qq_40254606的博客
07-26 649
通过本项目，我们综合应用了单例模式、适配器模式和桥接模式，解决了日志系统的设计需求。通过这些模式，我们实现了系统模块的解耦和灵活扩展，使得代码结构更加清晰、易于维护。
【设计模式】建造者模式
weixin_61144851的博客
07-23 925
这些设计模式提供了一种在创建对象的同时隐藏创建逻辑的方式，而不是使用 new 运算符直接实例化对象。这使得程序在判断针对某个给定实例需要创建哪些对象时更加灵活。：这些模式关注对象之间的组合和关系，旨在解决如何构建灵活且可复用的类和对象结构。：这些模式关注对象之间的通信和交互，旨在解决对象之间的责任分配和算法的封装。
设计模式-单例模式
最新发布
weixin_51722520的博客
07-27 74
单例设计模式
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值