详解状态模式以及Spring状态机

最新推荐文章于 2024-10-05 13:18:43 发布
最新推荐文章于 2024-10-05 13:18:43 发布
阅读量5k 收藏 49
点赞数 7
分类专栏： 设计模式 文章标签： 状态模式 状态机
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jtshongke/article/details/124326674
版权

详解状态模式以及Spring状态机

前言

讲设计模式之前我们先来了解下设计模式的SOLID原则：

  • S（Single Responsibility Principle）：单一职责原则，接口职责应该单一，不要承担过多的职责。
  • O（Open Closed Principle）：开闭原则，即对扩展开放，对修改关闭。简单来说就是代码的设计要达到：当别人要修改扩展功能的时候，最好能不要修改我们原有代码，而是新增代码来实现空能的扩展。这也是我们设计时要达到的目标。
  • L（Liskov Substitution Principle）：里氏替换原则，子类对象能够替换程序中父类对象出现的任何地方，并且保证原来程序的逻辑行为不变及正确性不被破坏。
  • I（Interface Segregation Principle）：接口隔离原则，类之间的依赖关系应该建立在最小的接口上，它不需要的接口不应该被依赖。
  • D（Dependence Inversion Principle）：依赖倒置原则，应该依赖一个抽象的服务接口，而不是去依赖一个具体的服务，从依赖具体实现转向到依赖抽象接口，倒置过来。

1.什么是状态模式，它能解决什么问题？

状态模式是行为模式的一种，它是指：当一个对象在状态改变时允许改变其行为，也就是说它可以通过改变对象内部的状态来帮助对象控制自己的行为。

阿里巴巴《Java开发手册》中提到：
超过3层的 if-else 的逻辑判断代码可以使用卫语句、策略模式、状态模式来实现。
Java开发手册

状态模式和策略模式很相似，它也能解决多层 if-else 嵌套的问题。但是它们的意图不太一样，策略模式会控制对象使用什么策略，而状态模式会自动改变状态。下面我用一个案例来介绍下状态模式。

2.状态模式实战

如果我们要开发oa系统里面的一个请假模块，功能很简单：员工可以提交请假单，领导来审批该请假单据是通过还是不通过。我们应该怎么开发这么功能呢？
首先我们创建一个请假单的实体类：

public class LeaveBill {

    /**
     * 请假单id
     */
    private long id;

    /**
     * 请假原因
     */
    private String reason;

    /**
     * 单据状态
     */
    private int state;

    public long getId() {
        return id;
    }

    public void setId(long id) {
        this.id = id;
    }

    public String getReason() {
        return reason;
    }

    public void setReason(String reason) {
        this.reason = reason;
    }

    public int getState() {
        return state;
    }

    public void setState(int state) {
        this.state = state;
    }

    public LeaveBill(long id, String reason, int state) {
        this.id = id;
        this.reason = reason;
        this.state = state;
    }
}

下面来看请假单处理类：

    /**
     * 假装这是个数据库
     */
    Map<Long, LeaveBill> database = new ConcurrentHashMap<Long, LeaveBill>() {{
        put(1L, new LeaveBill(1L, "心情不好，申请请假一天", waitLeaderApproval));
        put(2L, new LeaveBill(2L, "家里有事，申请请假", waitLeaderApproval));
    }};

    /**
     * 等待领导审批
     */
    final int waitLeaderApproval = 1;

    /**
     * 审批成功，请假成功
     */
    final int approvalSucceeded = 2;

    /**
     * 万恶的领导不给批假，审批不通过
     */
    final int approvalFailed = 3;

    /**
     * 审批通过
     *
     * @param id 请假单id
     */
    public void pass(long id) {
        // 从数据库中查询请假单
        LeaveBill leaveBill = database.get(id);
        int state = leaveBill.getState();
        if (state == waitLeaderApproval) {
            doPass(leaveBill);
        } else if (state == approvalSucceeded) {
            // 已经审批过不做任何操作
            System.out.println("我什么都没做");
        } else if (state == approvalFailed) {
            System.out.println("已审批未通过，不能再次审批");
        }
    }

    /**
     * 审批不通过
     *
     * @param id 请假单id
     */
    public void failed(long id) {
        // 从数据库中查询请假单
        LeaveBill leaveBill = database.get(id);
        int state = leaveBill.getState();
        if (state == waitLeaderApproval) {
            doFailed(leaveBill);
        } else if (state == approvalSucceeded) {
            System.out.println("已经审批通过的单据还想再给我审批不通过，门也没有！");
        } else if (state == approvalFailed) {
            // 如果已经失败了，就不做操作
            System.out.println("我什么都没做");
        }
    }

    /**
     * 审批通过，不加任何条件判断
     *
     * @param leaveBill 请假单
     */
    public void doPass(LeaveBill leaveBill) {
        // 将状态设置为审批通过
        leaveBill.setState(approvalSucceeded);
        // 更新数据库
        database.put(leaveBill.getId(), leaveBill);
        // 通知申请人
        System.out.println("亲爱的xxx,你的请假单已审批通过");
    }

    /**
     * 审批不通过，不加任何状态判断
     *
     * @param leaveBill 请假单
     */
    public void doFailed(LeaveBill leaveBill) {
        // 将状态设置为审批不通过
        leaveBill.setState(approvalFailed);
        // 更新数据库
        database.put(leaveBill.getId(), leaveBill);
        // 通知申请人审批未通过
        System.out.println("亲爱的xxx,你的请假单未审批通过,未通过原因为：xxx");
    }
}

为了看起来简单，这里我用一个 map 来作为数据库。

简单测试：

@Test
    public void test() {
        // 1.2 审批通过
        pass(1L);
        System.out.println("=========================================");
        // 2.2 审批未通过
        failed(1L);
    }

输出结果：

亲爱的xxx,你的请假单已审批通过
=========================================
已经审批通过的单据还想再给我审批不通过，门也没有！

比如说这个时候添加了一个需求，需要一个保存草稿的功能，就是请假单我可以先保存个草稿，下次再提交。那请假单是不是要多个待提交的状态呢？那就又要添加一堆 if-else 逻辑了。

更改后的代码如下：

public class LeaveService2 {
    /**
     * 假装这是个数据库
     */
    Map<Long, LeaveBill> database = new ConcurrentHashMap<Long, LeaveBill>() {{
        put(1L, new LeaveBill(1L, "心情不好，申请请假一天", waitLeaderApproval));
        put(2L, new LeaveBill(2L, "家里有事，申请请假", waitLeaderApproval));
    }};

    /**
     * 添加 待提交 状态
     */
    final int waitSubmit = 0;

    /**
     * 等待领导审批
     */
    final int waitLeaderApproval = 1;

    /**
     * 审批成功，请假成功
     */
    final int approvalSucceeded = 2;

    /**
     * 万恶的领导不给批假，审批未通过
     */
    final int approvalFailed = 3;

    /**
     * 新增提交方法
     */
    public void submit(long id) {
        // 从数据库中查询请假单
        LeaveBill leaveBill = database.get(id);
        int state = leaveBill.getState();
        if (state == waitSubmit) {
            doSubmit(leaveBill);
        } else if (state == waitLeaderApproval) {
            System.out.println("已提交审批的单据不能再次提交");
        } else if (state == approvalSucceeded) {
            System.out.println("已审批通过的单据不能再次提交");
        } else if (state == approvalFailed) {
            System.out.println("已审批未通过的单据不能再次提交");
        }
    }

    /**
     * 审批通过
     *
     * @param id 请假单id
     */
    public void pass(long id) {
        // 从数据库中查询请假单
        LeaveBill leaveBill = database.get(id);
        int state = leaveBill.getState();
        if (state == waitSubmit) {
            System.out.println("未提交的单据不能审批");
        } else if (state == waitLeaderApproval) {
            doPass(leaveBill);
        } else if (state == approvalSucceeded) {
            // 已经审批过不做任何操作
            System.out.println("我什么都没做");
        } else if (state == approvalFailed) {
            System.out.println("已审批未通过，不能再次审批");
        }
    }

    /**
     * 审批不通过
     *
     * @param id 请假单id
     */
    public void failed(long id) {
        // 从数据库中查询请假单
        LeaveBill leaveBill = database.get(id);
        int state = leaveBill.getState();
        if (state == waitSubmit) {
            System.out.println("未提交的单据不能审批");
        } else if (state == waitLeaderApproval) {
            doFailed(leaveBill);
        } else if (state == approvalSucceeded) {
            System.out.println("已经审批通过的单据还想再给我审批不通过，门也没有！");
        } else if (state == approvalFailed) {
            // 如果已经失败了，就不做操作
            System.out.println("我什么都没做");
        }
    }

    /**
     * 提交审批，不加任何条件判断
     *
     * @param leaveBill 请假单
     */
    public void doSubmit(LeaveBill leaveBill) {
        // 将状态设置为审批通过
        leaveBill.setState(waitLeaderApproval);
        // 更新数据库
        database.put(leaveBill.getId(), leaveBill);
        // 通知申请人
        System.out.println("亲爱的xxx,你的请假单已提交成功");
    }
    
    /**
     * 审批通过，不加任何条件判断
     *
     * @param leaveBill 请假单
     */
    public void doPass(LeaveBill leaveBill) {
        // 将状态设置为审批通过
        leaveBill.setState(approvalSucceeded);
        // 更新数据库
        database.put(leaveBill.getId(), leaveBill);
        // 通知申请人
        System.out.println("亲爱的xxx,你的请假单已审批通过");
    }

    /**
     * 审批不通过，不加任何状态判断
     *
     * @param leaveBill 请假单
     */
    public void doFailed(LeaveBill leaveBill) {
        // 将状态设置为审批不通过
        leaveBill.setState(approvalFailed);
        // 更新数据库
        database.put(leaveBill.getId(), leaveBill);
        // 通知申请人审批未通过
        System.out.println("亲爱的xxx,你的请假单未审批通过,未通过原因为：xxx");
    }

    @Test
    public void test() {
        // 1.2 审批通过
        pass(1L);
        System.out.println("=========================================");
        // 2.2 审批未通过
        failed(1L);
    }
}

新增了 waitSubmit 状态，新增了 submit 方法，每个方法里面都加了 waitSubmit 的判断逻辑。

那我上面写的这段代码有什么问题呢？你可以暂停下来思考一下。

上文代码缺点：

  1. 状态混乱，各种 if-else 判断，状态转换不明显
  2. 可扩展性差，如果加状态，又要在每个方法里面都加入if else逻辑，没有遵守开放-关闭原则（对扩展开放，对修改关闭）
  3. 没有把会改变的那部分代码包起来，没有遵守”封装变化“原则

那我们用状态模式我们应该怎么解决这个问题呢？我们应该把会变得那部分代码封装起来，将每一种状态都单独抽成一个类，将每个状态的行为都放在各自的类中，那么每个状态只需要实现它自己的动作就可以了，也就是将操作委托给当前状态的状态对象。这样我们添加新的状态时，添加一个对应的状态类，然后实现具体的操作就好了。这就是状态模式。

状态模式的UML图如下：

这里对其中的类做下解释：

  • State：可以是抽象类或者接口，在这个接口/抽象类 中定义每个动作的方法
  • ConcreteStateA、ConcreteStateB：State 具体的实现类，对应某一种状态的实现
  • Context：串联所有状态的封装类，封装的目的是为了让内部状态的变化不被调用类知晓（迪米特法则）

下面我按照状态模式来改造下代码：

首先建一个抽象类 LeaveState，里面包含了 Context 和所有方法。

由于这里面没有需要统一进行处理的操作，所以你将抽象类改为接口也是完全OK的

public abstract class LeaveState {

    protected Context context;

    public void setContext(Context context) {
        this.context = context;
    }

    public abstract void pass(long id);

    public abstract void failed(long id);
}

将所有的状态都抽成一个类，然后继承抽象类 LeaveState。

待领导审批状态：

public class WaitLeaderApprovalState extends LeaveState {
    @Override
    public void pass(long id) {
        // 修改要处理的状态类
        super.context.setState(super.context.APPROVAL_SUCCEEDED);
        // 动作委派
        super.context.getState().pass(id);
    }

    @Override
    public void failed(long id) {
        // 修改要处理的状态类
        super.context.setState(super.context.APPROVAL_FAILED);
        // 委派给要处理的状态类
        super.context.getState().failed(id);
    }
}

审批成功状态：

public class ApprovalSucceededState extends LeaveState {

    @Override
    public void pass(long id) {
        // 从数据库中查询请假单
        LeaveBill leaveBill = super.context.database.get(id);
        // 将状态设置为审批通过
        leaveBill.setState(super.context.approvalSucceeded);
        // 更新数据库
        super.context.database.put(leaveBill.getId(), leaveBill);
        // 通知申请人
        System.out.println("亲爱的xxx,你的请假单已审批通过");
    }

    @Override
    public void failed(long id) {
        System.out.println("已经审批通过的单据还想再给我审批不通过，门也没有！");
    }
}

审批失败状态：

public class ApprovalFailedState extends LeaveState {
    @Override
    public void pass(long id) {
        System.out.println("已审批未通过，不能再次审批");
    }

    @Override
    public void failed(long id) {
        // 从数据库中查询请假单
        LeaveBill leaveBill = super.context.database.get(id);
        // 将状态设置为审批未通过
        leaveBill.setState(super.context.approvalFailed);
        // 更新数据库
        super.context.database.put(leaveBill.getId(), leaveBill);
        System.out.println("您好，您的请假单审批未通过");
    }
}

状态上下文封装类：

public class Context {

    public Map<Long, LeaveBill> database = new ConcurrentHashMap<Long, LeaveBill>() {{
        put(1L, new LeaveBill(1L, "心情不好，申请请假一天", waitLeaderApproval));
        put(2L, new LeaveBill(2L, "家里有事，申请请假", waitLeaderApproval));
    }};

    /**
     * 等待领导审批
     */
    final int waitLeaderApproval = 1;

    /**
     * 审批成功，请假成功
     */
    final int approvalSucceeded = 2;

    /**
     * 万恶的领导不给批假，审批未通过
     */
    final int approvalFailed = 3;

    protected final WaitLeaderApprovalState WAIT_LEADER_APPROVAL = new WaitLeaderApprovalState();

    protected final ApprovalSucceededState APPROVAL_SUCCEEDED = new ApprovalSucceededState();

    protected final ApprovalFailedState APPROVAL_FAILED = new ApprovalFailedState();

    private LeaveState state;


    public LeaveState getState() {
        return state;
    }

    public void setState(LeaveState state) {
        this.state = state;
        // 将当前环境通知到各个类中
        this.state.setContext(this);
    }
}

这个类里面包含了所有的状态类，

测试：

@Test
public void test(){
    Context context = new Context();
    context.setState(context.WAIT_LEADER_APPROVAL);
    context.getState().pass(1L);
    context.getState().failed(1L);
}

结果：

亲爱的xxx,你的请假单已审批通过
已经审批通过的单据还想再给我审批不通过，门也没有！

那么此时，保存 草稿的需求来了，我们应该怎么改动呢？

  1. 在 LeaveState 中添加 submit() 方法
  2. 添加待提交的状态类 WaitSubmitState，继承 LeaveState 并实现里面的抽象方法。
  3. 给 LeaveState 所有的子类添加 submit() 方法的实现。
  4. Context 类中添加 WaitSubmitState 的依赖。

各个类改动的代码如下（为了看起来简洁，这里只贴做了新增的代码，原来的代码就不贴了）：

LeaveState：

public abstract class LeaveState {
    // ...
    public abstract void submit(long id);
}

WaitSubmitState:

public class WaitSubmitState extends LeaveState {

    @Override
    public void submit(long id) {
        // 从数据库中查询请假单
        LeaveBill leaveBill = super.context.database.get(id);
        // 将状态设置为待领导审批
        leaveBill.setState(super.context.waitLeaderApproval);
        // 更新数据库
        super.context.database.put(leaveBill.getId(), leaveBill);
        super.context.setState(super.context.WAIT_LEADER_APPROVAL);
        // 通知申请人
        System.out.println("亲爱的xxx,你的请假单提交审批");
    }

    @Override
    public void pass(long id) {
        System.out.println("请假单未提交不能审批");
    }

    @Override
    public void failed(long id) {
        System.out.println("请假单未提交不能审批");
    }
}

Context:

public class Context {
    /**
     * 待提交
     */
    final int waitSubmit = 0;

    protected final WaitSubmitState WAIT_SUBMIT = new WaitSubmitState();
}

WaitLeaderApprovalState：

public class WaitLeaderApprovalState extends LeaveState {
    @Override
    public void submit(long id) {
        System.out.println("待审批状态不能再次提交");
    }
}

ApprovalSucceededState：

public class ApprovalSucceededState extends LeaveState {

    @Override
    public void submit(long id) {
        System.out.println("已审批通过，不能提交");
    }
}

ApprovalFailedState：

public class ApprovalFailedState extends LeaveState {

    @Override
    public void submit(long id) {
        System.out.println("已审批失败，不能再次提交");
    }
}

我们做的这些操作基本都没有更改原来方法的逻辑，而是添加了新的方法，这就符合了开闭原则。以后再添加别的状态，比如 待经理审批、待老板审批等都可以按这种方式来做改动。

通过上面的案例我们来总结下状态模式的优缺点：

优点是：状态模式将每个状态的行为都收敛到了它自己的类中，将容易产生问题的if语句删除，以方便日后的维护，并且代码更容易阅读和理解。让每一个状态“对修改关闭”，对扩展开放。
缺点：

  1. 创建的类多了，每个状态都要对应一个类。
  2. 新增的状态如果有对应的处理方法，则每个子类都要实现该处理方法。

3.状态模式和状态机

我们说的状态机一般是指有限状态机，它是一种计算机模型，它是指有限个状态之间的转换。而状态模式是一种设计模式，它们两个不是同一个东西，
很多文章经常都把这两个词混淆使用，也完全可以理解。因为当你要用状态模式实现一个功能的时候，这个功能结构肯定不适合被称为"状态模式"，而更适合称为"状态机"。可以理解成状态机是状态模式的一种应用。

4.Spring StateMachine (Spring 状态机)

本节中我会使用 Spring StateMachine 来完成请假单审批的功能，你可以做个对比。

首先在 pom.xml 中引入 Spring StateMachine：

<dependency>
    <groupId>org.springframework.statemachine</groupId>
    <artifactId>spring-statemachine-core</artifactId>
</dependency>

将请假单状态定义为枚举：

public enum LeaveStateEnum {

    /**
     * 待提交
     */
    WAIT_SUBMIT,

    /**
     * 等待领导审批
     */
    WAIT_LEADER_APPROVAL,

    /**
     * 审批成功，请假成功
     */
    APPROVAL_SUCCEEDED,

    /**
     * 万恶的领导不给批假，审批未通过
     */
    APPROVAL_FAILED
}

将状态转换的动作定义为枚举类：

public enum LeaveStateEvent {
    /**
     * 提交审批
     */
    SUBMIT,

    /**
     * 审批通过
     */
    PASS,

    /**
     * 审批不通过
     */
    FAILED
}

状态机配置类：

@Configuration
@EnableStateMachine
public class StateMachineConfig extends EnumStateMachineConfigurerAdapter<LeaveStateEnum, LeaveStateEvent> {

    @Override
    public void configure(StateMachineStateConfigurer<LeaveStateEnum, LeaveStateEvent> states) throws Exception {
        // 初始化状态
        states.withStates().initial(LeaveStateEnum.WAIT_SUBMIT).states(EnumSet.allOf(LeaveStateEnum.class));
    }

    @Override
    public void configure(StateMachineTransitionConfigurer<LeaveStateEnum, LeaveStateEvent> transitions) throws Exception {
        // 定义各个状态之间转换时对应的动作（事件）
        transitions.withExternal().source(LeaveStateEnum.WAIT_SUBMIT).target(LeaveStateEnum.WAIT_LEADER_APPROVAL).event(LeaveStateEvent.SUBMIT).and().withExternal().source(LeaveStateEnum.WAIT_LEADER_APPROVAL).target(LeaveStateEnum.APPROVAL_SUCCEEDED).event(LeaveStateEvent.PASS).and().withExternal().source(LeaveStateEnum.WAIT_LEADER_APPROVAL).target(LeaveStateEnum.APPROVAL_FAILED).event(LeaveStateEvent.FAILED);
    }

    @Override
    public void configure(StateMachineConfigurationConfigurer<LeaveStateEnum, LeaveStateEvent> config) throws Exception {
        // 设置状态机id
        config.withConfiguration().machineId("leaveStateMachine");
    }
}

通过 @EnableStateMachine 注解用来启用 Spring StateMachine 状态机功能。

配置状态机对应的动作处理方法：

@WithStateMachine(name = "leaveStateMachine")
@Configuration
public class StateMachineEventConfig {

    public Map<Long, LeaveBill> database = new ConcurrentHashMap<Long, LeaveBill>() {{
        put(1L, new LeaveBill(1L, "心情不好，申请请假一天", LeaveStateEnum.WAIT_SUBMIT.ordinal()));
        put(2L, new LeaveBill(2L, "家里有事，申请请假", LeaveStateEnum.WAIT_SUBMIT.ordinal()));
    }};

    @OnTransition(source = "WAIT_SUBMIT", target = "WAIT_LEADER_APPROVAL")
    public void submit(Message<LeaveStateEvent> msg) {
        Long leaveId = (Long) msg.getHeaders().get("leaveId");
        // 从数据库中查询请假单
        LeaveBill leaveBill = database.get(leaveId);
        // 将状态设置为待领导审批
        leaveBill.setState(LeaveStateEnum.WAIT_LEADER_APPROVAL.ordinal());
        // 更新数据库
        database.put(leaveBill.getId(), leaveBill);
        // 通知申请人
        System.out.println("亲爱的xxx,你的请假单已提交审批");
    }

    @OnTransition(source = "WAIT_LEADER_APPROVAL", target = "APPROVAL_SUCCEEDED")
    public void pass(Message<LeaveStateEvent> msg) {
        Long leaveId = (Long) msg.getHeaders().get("leaveId");
        // 从数据库中查询请假单
        LeaveBill leaveBill = database.get(leaveId);
        // 将状态设置为审批通过
        leaveBill.setState(LeaveStateEnum.APPROVAL_SUCCEEDED.ordinal());
        // 更新数据库
        database.put(leaveBill.getId(), leaveBill);
        // 通知申请人
        System.out.println("亲爱的xxx,你的请假单已审批通过");
    }

    @OnTransition(source = "WAIT_LEADER_APPROVAL", target = "APPROVAL_FAILED")
    public void failed(Message<LeaveStateEvent> msg) {
        Long leaveId = (Long) msg.getHeaders().get("leaveId");
        // 从数据库中查询请假单
        LeaveBill leaveBill = database.get(leaveId);
        // 将状态设置为审批未通过
        leaveBill.setState(LeaveStateEnum.APPROVAL_FAILED.ordinal());
        // 更新数据库
        database.put(leaveBill.getId(), leaveBill);
        System.out.println("您好，您的请假单审批未通过");
    }
}

@OnTransition 中 source 指定原始状态，target 指定目标状态，当事件触发时将会被监听到从而调用该方法。

单元测试：

@RunWith(SpringRunner.class)
@SpringBootTest
public class StateTest {
    @Autowired
    private StateMachine<LeaveStateEnum, LeaveStateEvent> stateMachine;

    @Test
    public void test() throws Exception {
        stateMachine.start();
        stateMachine.sendEvent(MessageBuilder.withPayload(LeaveStateEvent.SUBMIT).setHeader("leaveId", 1L).build());
        stateMachine.sendEvent(MessageBuilder.withPayload(LeaveStateEvent.PASS).setHeader("leaveId", 1L).build());
    }
}

可以通过 Message来传递参数。

结果如下：

亲爱的xxx,你的请假单已提交审批
亲爱的xxx,你的请假单已审批通过

可以看到使用 Spring StateMachine 之后，我们只需要配置各个状态之间的流转以及对应的状态，就可以实现相应的功能了。在实际应用中，我们的系统一般不会只有一个状态机在运行，可以通过 StateMachineBuilder 来构建多个状态机，如果你有兴趣可以去Spring官网研究下，这里不再做赘述。

5.小结

本文通过请假审批的案例来讲解了状态模式：它可以通过改变对象内部的状态来帮助对象控制自己的行为。状态模式将每个状态的行为都收敛到了它自己的类中，将容易产生问题的if语句删除，以方便日后的维护，并且代码更容易阅读和理解。让每一个状态“对修改关闭”，对扩展开放。在项目中我们可以使用 Spring StateMachine 来帮助我们更简单的应用状态模式。当然，如果 Spring StateMachine 不能满足你的需求，你也可以根据状态模式的思想来自定义一个自己的状态机。

好了，这篇文章就到这里了，感谢大家的观看！如有错误，请及时指正！欢迎大家关注我的公众号：贾哇技术指南。

参考

历史文章回顾

分布式事务解决方案汇总

Java各种内存溢出异常实践

详解JVM运行时数据区

Java线程启动流程

贾哇技术指南
关注
专栏目录
【微服务】spring状态机模式使用详解
congge
03-31 4898
spring状态机模式使用详解
spring 状态机_Spring StateMachine，教你快速实现一个状态机
weixin_35871519的博客
01-25 5066
点击上方“占小狼的博客”，选择“设为星标”来源：http://t.cn/RIxCXiOSpring StateMachine框架可能对于大部分使用Spring的开发者来说还比较生僻，它的主要功能是帮助开发者简化状态机的开发过程，让状态机结构更加层次化。快速入门依照之前的风格，我们通过一个简单的示例来对Spring StateMachine有一个初步的认识。假设我们需要实现一个订单的相关流...
玩转Spring状态机
京东科技开发者
06-24 625
思考：针对状态机的特点，还有其他思路实现一个状态机吗？下面是一些常规思路，如果还有其他方法欢迎在评论区留言。1. 消息队列方式订单状态的流转可以通过MQ发布一个事件，消费者根据业务条件把订单状态进行流转，可以根据不同的事件发送到不同的Topic。2. 定时任务驱动每隔一段时间启动一下job，根据特定的状态从数据库中拿对应的订单记录，然后判断订单是否有条件到达下一个状态。3. 规则引擎方式。
深入理解Spring Statemachine：在Spring中实现状态机
最新发布
weixin_36047538的博客
10-05 1589
本文还有配套的精品资源，点击获取 简介：Spring Statemachine框架通过提供状态机抽象，简化了在Spring环境中实现和管理复杂工作流程及业务逻辑的过程。本文深入探讨了Spring Statemachine的核心概念、功能及应用，包括状态和转换的结构化定义、事件驱动的状态变迁、持久化支持以及集成Spring生态系统。通过实例分析，展示了其在多个领域的实际应用，...
Spring之状态机讲解
上善若泪
05-30 3528
先来解释什么是状态（ State ）。现实事物是有不同状态的，例如一个自动门，就有open和closed两种状态。我们通常所说的状态机是有限状态机，也就是被描述的事物的状态的数量是有限个，例如自动门的状态就是两个open和closed。状态机，也就是，不是指一台实际机器，而是指一个数学模型。说白了，一般就是指一张状态转换图。状态机的全称是有限状态自动机，自动两个字也是包含重要含义的。给定一个状态机，同时给定它的当前状态以及输入，那么输出状态时可以明确的运算出来的。
设计模式-行为模式-状态模式 以及spring 状态机
weixin_43866043的博客
02-22 821
状态模式用于解决系统中复杂对象的状态转换以及不同状态下行为的封装问题 系统中某个对象存在多个状态，这些状态之间可以进行转换，而且对象在不同状态下行为不相同时可以使用状态模式。状态模式将一个对象的状态从该对象中分离出来，封装到专门的状态类中，使得对象状态可以灵活变化，对于客户端而言，无须关心对象状态的转换以及对象所处的当前状态，无论对于何种状态的对象，客户端都可以一致处理 状态模式定义如下： 状态模式(State Pattern)：允许一个对象在其内部状态改变时改变它的行为，对象看起来似乎修改了它的类 Con
spring状态机
xiaolegeaizy的博客
07-06 2453
由状态机的几个要素我们也可以知道，在一个复杂的业务流程过程中，有多种数据状态，多种处理动作，以及多种维度的角色。一个状态机定义以后，在某个状态下就只接收固定的Event，也就是执行指定的操作，这样流程就能按照预期定义的那样流转，不会出现乱入的情况，执行了一些在某状态下不允许执行的操作，也就是说，状态的流转都是在控制范围，不会超出预设的状态空间。在百科的解释中，我们可以提炼出状态机的几个要素：存储状态，逻辑电路，预先设定的状态转移路径，外部来的信号，内置的特定操作等。-对象内部状态不同会有不同的行为。
Spring boot自定义http反馈状态码详解
08-30
Spring Boot 自定义 HTTP 反馈状态码详解 在 Spring Boot 中，自定义 HTTP 反馈状态码是一种非常有用的技术，通过这种技术，我们可以自定义 HTTP 状态码，以便更好地表达应用程序的状态。下面，我们将详细介绍如何...
彻底搞懂Spring状态机原理，实现订单与物流解耦
2401_83915664的博客
04-21 1038
System.out.println(“跳转到登录页面!”);创建上下文角色AppContext类。最后编写客户端测试代码。context.comment(“评论: 好文章，360个赞!”);运行结果如下图所示。3　使用状态机实现订单状态流转控制状态机是状态模式的一种应用，相当于上下文角色的一个升级版。在工作流或游戏等各种系统中有大量使用，如各种工作流引擎，它几乎是状态机的子集和实现，封装状态的变化规则。Spring也提供了一个很好的解决方案。
使用Spring StateMachine框架实现状态机
2401_84048445的博客
04-19 1214
手绘了下图所示的kafka知识大纲流程图（xmind文件不能上传，导出图片展现），但都可提供源文件给每位爱学习的朋友《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）**手绘了下图所示的kafka知识大纲流程图（xmind文件不能上传，导出图片展现），但都可提供源文件给每位爱学习的朋友[外链图片转存中…(img-plBvCsxx-1713524824138)]
【大模型】Spring AI对接ChatGpt使用详解
congge
05-19 7075
spring ai使用详细介绍
spring 状态机
qq_44663816的博客
06-12 831
先来解释什么是“状态”（ State ）。现实事物是有不同状态的，例如一个自动门，就有 open 和 closed 两种状态。我们通常所说的状态机是有限状态机，也就是被描述的事物的状态的数量是有限个，例如自动门的状态就是两个 open 和 closed。先来解释什么是“状态”（ State ）。现实事物是有不同状态的，例如一个自动门，就有 open 和 closed 两种状态。我们通常所说的状态机是有限状态机，也就是被描述的事物的状态的数量是有限个，例如自动门的状态就是两个 open 和 closed。
Spring状态机
cxl0_0的博客
01-19 2238
spring statemachine框架的作用在于提供一个项目业务切入的视角，关注点不在于具体的业务数据，而是状态流程。
Spring中的状态机
big_title的博客
05-25 594
有限状态机（Finite-state machine,FSM），又称有限状态自动机，简称状态机，是表示有限个状态以及在这些状态之间的转移和动作等行为的数学模型。FSM是一种算法思想，简单而言，有限状态机由一组状态、一个初始状态、输入和根据输入及现有状态转换为下一个状态的转换函数组成。其作用主要是描述对象在它的生命周期内所经历的状态序列，以及如何响应来自外界的各种事件。
Spring 状态机
HaSaKing的博客
09-04 989
Spring 状态机是 Spring 框架的一部分，用于构建和管理状态机。状态机可以帮助你管理对象的生命周期、处理业务流程或实现复杂的工作流。Spring 状态机提供了一种声明性和可扩展的方式来定义状态、事件及其转换规则。创建枚举类OrderState和OrderEvent。
[java - springBoot] [状态模式使用及业务应用]
ChessC的博客
02-09 1625
背景： 当前CI构建调度层这边，状态追踪与回写是比较重要的一环。当前大致状态有distribute / building / error / missing / abort / exception / completed等，配合Quartz框架进行状态捕获。之前的代码写的比较乱， 状态间符合转化执行的关系，因此考虑状态模式来进行重构。此处写个示例代码及使用。 关于状态模式的使用场景及概念介绍，此处不进行阐述，可参阅其余博客。 代码示例： 1.抽象状态类 public abstract class
Spring积累(7)：Spring状态机
mingyuli的博客
12-28 672
·
Spring Boot集成LDAP管理用户示例：接收与发送状态机详解
"本文档是关于LPC系列微控制器在Spring Boot中使用LDAP进行用户信息统一管理的一个示例，同时详细介绍了LPC1700的以太网模块的接收和发送状态机的工作机制。" 在Spring Boot应用程序中，利用LDAP（轻量级目录访问...
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值