AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Java 实现有限状态机的推荐方案

2021-11-24 571
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 平时工作开发过程中，难免会用到状态机（状态的流转）。如奖学金审批状态流转、请假审批状态流转、竞标状态流转等，都需要根据不同行为转到不同的状态。有什么好的编码方式吗？

一、背景

平时工作开发过程中，难免会用到状态机（状态的流转）。

如奖学金审批状态流转、请假审批状态流转、竞标状态流转等，都需要根据不同行为转到不同的状态。

注: 本文主要讲的是状态机，即状态从一个状态转变为另外一个状态。如果设置 3个人审批才可以从 A状态 转到 B 状态，那么3个人审批是状态转换的条件。如果想实现流程编排，建议使用工作流引擎。

下面是一个简单的模拟状态机：

在这里插入图片描述

有些同学会选择将状态定义为常量，使用 if else 来流转状态，不太优雅。

有些同学会考虑将状态定义为枚举。
但是定义为枚举之后，大多数同学会选择使用 switch 来流转状态：

import lombok.Getter;

public enum State {

    STATE_A("A"),
    STATE_B("B"),
    STATE_C("C"),
    STATE_D("D");

    @Getter
    private final String value;

    State(String value) {
        this.value = value;
    }

    public static State getByValue(String value) {
        for (State state : State.values()) {
            if (state.getValue().equals(value)) {
                return state;
            }
        }
        return null;
    }

    /**
     * 批准后的状态
     */
    public static State getApprovedState(State currentState) {
        switch (currentState) {
            case STATE_A:
                return STATE_B;
            case STATE_B:
                return STATE_C;
            case STATE_C:
                return STATE_D;
            case STATE_D:
            default:
               throw new IllegalStateException("当前已终态");
        }

    }

    /**
     * 拒绝后的状态
     */
    public static State getRejectedState(State currentState) {
        switch (currentState) {
            case STATE_A:
                throw new IllegalStateException("当前状态不支持拒绝");
            case STATE_B:
            case STATE_C:
            case STATE_D:
            default:
                return STATE_A;
        }
    }
}

上面这种写法有几个弊端：

（1） getByValue 每次获取枚举值都要循环一次当前枚举的所有常量，时间复杂度是
O(N)，虽然耗时非常小，但总有些别扭，作为有追求的程序员，应该尽量想办法优化掉。

(2) 总感觉使用 switch-case 实现状态流转，更多的是面向过程的产物。虽然可以实现功能，但没那么“面向对象”，既然 State 枚举就是用来表示状态，如果同意和拒绝可以通过 State 对象的方法获取就会更直观一些。

二、推荐方式

在这里插入图片描述

2.1 自定义的枚举

通常状态流转有两种方向，一种是赞同，一种是拒绝，分别流向不同的状态。

由于本文讨论的是有限状态，我们可以将状态定义为枚举比较契合，除非初态和终态，否则赞同和拒绝都会返回一个状态。

下面只是一个DEMO， 实际编码时可以自由发挥。

该 Demo 的好处是：

1 使用 CACHE 缓存，避免每次通过 value 获取 State 都循环 State 枚举数组

2 定义【同意】和【拒绝】抽象方法，每个 State 通过实现该方法来流转状态。
3 状态的定义和转换都收拢在一个枚举中，更容易维护

虽然代码看似更多一些，但是更“面向对象”一些。

package basic;

import lombok.Getter;

import java.util.Arrays;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;

public enum State {
    /**
     * 定义状态，并实现同意和拒绝的流转
     */
    STATE_A("A") {
        @Override
        State getApprovedState() {
            return STATE_B;
        }

        @Override
        State getRejectedState() {
            throw new IllegalStateException("STATE_A 不支持拒绝");
        }
    },
    STATE_B("B") {
        @Override
        State getApprovedState() {
            return STATE_C;
        }

        @Override
        State getRejectedState() {
            return STATE_A;
        }
    },
    STATE_C("C") {
        @Override
        State getApprovedState() {
            return STATE_D;
        }

        @Override
        State getRejectedState() {
            return STATE_A;
        }
    },
    STATE_D("D") {
        @Override
        State getApprovedState() {
             throw new IllegalStateException("当前已终态");
        }

        @Override
        State getRejectedState() {
            return STATE_A;
        }
    };

    @Getter
    private final String value;

    State(String value) {
        this.value = value;
    }

    private static final Map<String, State> CACHE;

    static {
        CACHE = Arrays.stream(State.values()).collect(Collectors.toMap(State::getValue, Function.identity()));
    }

    public static State getByValue(String value) {
        return CACHE.get(value);
    }

    /**
     * 批准后的状态
     */
    abstract State getApprovedState();

    /**
     * 拒绝后的状态
     */
    abstract State getRejectedState();
}
注：这里的抽象方法可以定义参数，枚举中实现方法可以根据参数决定是否执行状态流转。 比如参数可以传入当前已经同意的人数，枚举中可以判断当审批同意的人数大于3时，返回下一个状态。

测试代码

package basic;

import static basic.State.STATE_B;

public class StateDemo {
    public static void main(String[] args) {
        State state = State.STATE_A;

        // 一直赞同
        State approvedState;
        do {
            approvedState = state.getApprovedState();
            System.out.println(state + "-> approved:" + approvedState);
            state = approvedState;
        } while (state != State.STATE_D);


        // 获取某个状态的赞同和拒绝后的状态
        System.out.println("STATE_B approved ->" + STATE_B.getApprovedState());
        System.out.println("STATE_C reject ->" + State.getByValue("C").getRejectedState());
        System.out.println("STATE_D reject ->" + State.getByValue("D").getRejectedState());
    }
}

输出结果：

STATE_A-> approved:STATE_B
STATE_B-> approved:STATE_C
STATE_C-> approved:STATE_D
-----
STATE_B approved ->STATE_C
STATE_C reject ->STATE_A
STATE_D reject ->STATE_A

本质上通过不同的方法调用实现自身的流转，而且赞同和拒绝定义为抽象类，可以“强迫”让状态的定义方明确自己的状态流转。

整体逻辑比较内聚，状态的定义和流转都在 State 类中完成。

2.2 外部枚举

假如该枚举是外部提供，只提供枚举常量的定义，不提供状态流转，怎么办？

我们依然可以采用 switch 的方式实现状态流转:

import static basic.State.*;

public class StateUtils {
    /**
     * 批准后的状态
     */
    public static State getApprovedState(State currentState) {
        switch (currentState) {
            case STATE_A:
                return STATE_B;
            case STATE_B:
                return STATE_C;
            case STATE_C:
                return STATE_D;
            case STATE_D:
            default:
            throw new IllegalStateException("当前已经是终态");
        }

    }

    /**
     * 拒绝后的状态
     */
    public static State getRejectedState(State currentState) {
        switch (currentState) {
            case STATE_A:
                throw new IllegalStateException("当前状态不支持拒绝");
            case STATE_B:
            case STATE_C:
            case STATE_D:
            default:
                return STATE_A;
        }
    }
}

还有更通用、更容易理解的编程方式呢（不用 switch）？

状态机的每次转换是一个 State 到另外一个 State 的映射，每个状态都应该维护赞同和拒绝后的下一个状态。

因此，我们很容易会联想到使用【链表】来存储这种关系 。

由于这里是外部枚举，无法将状态流转在枚举内部完成（定义），就意味着我们还需要自定义状态节点来表示流转，如：

import lombok.Data;

@Data
public class StateNode<T> {

    private T state;

    private StateNode<T> approveNode;

    private StateNode<T> rejectNode;
}

这样构造好链表以后，还需在工具类中要构造 State 到 StateNode 的映射（因为对于外部来说，只应该感知 State 类，不应该再去理解 StateNode ) , 提供赞同和拒绝方法，内部通过拿到赞同和拒绝对应的 StateNode 之后拿到对应的 State 返回即可。

伪代码如下：

public class StateUtils{

// 构造 StateNode 链表，和构造 cache Map 略
private Map<State, StateNode<State>> cache ;

    public State getApproveState(State current){
        StateNode<State> node = cache.get(current);
        return node == null? null: return node.getApproveNode().getState();
    }

public State getRejectState(State current){
        StateNode<State> node = cache.get(current);
        return node == null? null: return node.getRejectNode().getState();
    }

}

整体比较曲折，不如直接将赞同和拒绝定义在 State 枚举内更直观。

下面给出一种 “状态链模式” 的解决方案。

赞同和拒绝底层分别使用两个 Map 存储。

为了更好地表达每次状态的方向（即 Map 中的 key 和 value），每一个映射定义为 from 和 to 。

为了避免只有 from 没有 to ，定义一个中间类型 SemiData，只有调用 to 之后才可以继续链式编程下去，最终构造出状态链。

以下结合 Map 的数据结构，结合升级版的 Builder 设计模式，实现链式编程：

package basic;

import java.util.HashMap;
import java.util.Map;

public class StateChain<T> {

    private final Map<T, T> chain;

    private StateChain(Map<T, T> chain) {
        this.chain = chain;
    }


    public T getNextState(T t) {
        return chain.get(t);
    }

    public static <V> Builder<V> builder() {
        return new Builder<V>();
    }


    static class Builder<T> {

        private final Map<T, T> data = new HashMap<>();


        public SemiData<T> from(T state) {
            return new SemiData<>(this, state);
        }


        public StateChain<T> build() {
            return new StateChain<T>(data);
        }

        public static class SemiData<T> {
            private final T key;
            private final Builder<T> parent;

            private SemiData(Builder<T> builder, T key) {
                this.parent = builder;
                this.key = key;
            }

            public Builder<T> to(T value) {
                parent.data.put(key, value);
                return parent;
            }
        }
    }

}

使用案例：

package basic;

import static basic.State.*;

public class StateUtils {

    private static final StateChain<State> APPROVE;
    private static final StateChain<State> REJECT;

    static {
        APPROVE = StateChain.<State>builder().from(STATE_A).to(STATE_B).from(STATE_B).to(STATE_C).from(STATE_C).to(STATE_D).build();
        
        REJECT = StateChain.<State>builder().from(STATE_B).to(STATE_A).from(STATE_C).to(STATE_A).from(STATE_D).to(STATE_A).build();
    }

    /**
     * 批准后的状态
     */
    public static State getApprovedState(State currentState) {
         State next = APPROVE.getNextState(currentState);
         if(next == null){
            throw new IllegalStateException("当前已经终态");
         }
         return next;
    }

    /**
     * 拒绝后的状态
     */
    public static State getRejectedState(State currentState) {
        State next =  REJECT.getNextState(currentState);
         if(next == null){
            throw new IllegalStateException("当前状态不支持驳回");
         }
         return next;
    }
}

测试方法

import static basic.State.STATE_B;

public class StateDemo {

    public static void main(String[] args) {
        State state = State.STATE_A;

        // 一直赞同
        State approvedState;
        do {
            approvedState = StateUtils.getApprovedState(state);
            System.out.println(state + "-> approved:" + approvedState);
            state = approvedState;
        } while (state != State.STATE_D);
        
        System.out.println("-------");

        // 获取某个状态的赞同和拒绝后的状态
        System.out.println("STATE_B approved ->" + StateUtils.getApprovedState(STATE_B));
        System.out.println("STATE_C reject ->" + StateUtils.getRejectedState(State.getByValue("C")));
        System.out.println("STATE_D reject ->" + StateUtils.getRejectedState(State.getByValue("D")));
    }
}

输出结果

STATE_A-> approved:STATE_B
STATE_B-> approved:STATE_C
STATE_C-> approved:STATE_D
----
STATE_B approved ->STATE_C
STATE_C reject ->STATE_A
STATE_D reject ->STATE_A

这种方式更加灵活，可定义多条状态链，实现每个链的状态各自流转。而且性能非常好。

巧妙地将状态的转换定义和 Map 的定义合二为一，既能够表意（from,to 比较明确），又能获得很好的性能（获取赞同和拒绝后的状态转化为
通过 key 取 Map 中的 value ），还有不错的编程体验（链式编程）。

以上只是 DEMO，实际编码时，可自行优化。

可能还有一些开源的包提供状态机的功能，但核心原理大同小异。

三、总结

本文结合自己的理解，给出一种推荐的有限状态机的写法。

给出了自有状态枚举和外部状态枚举的解决方案，希望对大家有帮助。

通过本文，大家也可以看出，简单的问题深入思考，也可以得到不同的解法。

希望大家不要满足现有方案，可以灵活运用所学来解决实践问题。

创作不易，如果本文对你有帮助，欢迎点赞、收藏加关注，你的支持和鼓励，是我创作的最大动力。
在这里插入图片描述
文章标签：
Java
程序员
缓存
存储
设计模式
明明如月
目录
相关文章
程序员小海绵
|
5天前
|
存储 缓存 安全
【Java面试题汇总】多线程、JUC、锁篇（2023版）
线程和进程的区别、CAS的ABA问题、AQS、哪些地方使用了CAS、怎么保证线程安全、线程同步方式、synchronized的用法及原理、Lock、volatile、线程的六个状态、ThreadLocal、线程通信方式、创建方式、两种创建线程池的方法、线程池设置合适的线程数、线程安全的集合？ConcurrentHashMap、JUC
程序员小海绵
22 3
【Java面试题汇总】多线程、JUC、锁篇（2023版）
2的n次方_
|
16天前
|
监控 Java 调度
【Java学习】多线程&JUC万字超详解
本文详细介绍了多线程的概念和三种实现方式，还有一些常见的成员方法，CPU的调动方式，多线程的生命周期，还有线程安全问题，锁和死锁的概念，以及等待唤醒机制，阻塞队列，多线程的六种状态，线程池等
2的n次方_
78 6
【Java学习】多线程&JUC万字超详解
帅政的oss
|
1天前
|
Java
深入理解Java中的多线程编程
本文将探讨Java多线程编程的核心概念和技术，包括线程的创建与管理、同步机制以及并发工具类的应用。我们将通过实例分析，帮助读者更好地理解和应用Java多线程编程，提高程序的性能和响应能力。
帅政的oss
15 4
游客zllgslqrsw3f6
|
9天前
|
Java 调度 开发者
Java并发编程：深入理解线程池
在Java的世界中，线程池是提升应用性能、实现高效并发处理的关键工具。本文将深入浅出地介绍线程池的核心概念、工作原理以及如何在实际应用中有效利用线程池来优化资源管理和任务调度。通过本文的学习，读者能够掌握线程池的基本使用技巧，并理解其背后的设计哲学。
游客zllgslqrsw3f6
36 13
游客7ofzsdfcat7ls
|
9天前
|
缓存 监控 Java
Java中的并发编程：理解并应用线程池
在Java的并发编程中，线程池是提高应用程序性能的关键工具。本文将深入探讨如何有效利用线程池来管理资源、提升效率和简化代码结构。我们将从基础概念出发，逐步介绍线程池的配置、使用场景以及最佳实践，帮助开发者更好地掌握并发编程的核心技巧。
游客7ofzsdfcat7ls
22 10
天下无贼001
|
5天前
|
Java 调度 开发者
Java中的多线程基础及其应用
【9月更文挑战第13天】本文将深入探讨Java中的多线程概念，从基本理论到实际应用，带你一步步了解如何有效使用多线程来提升程序的性能。我们将通过实际代码示例，展示如何在Java中创建和管理线程，以及如何利用线程池优化资源管理。无论你是初学者还是有经验的开发者，这篇文章都将为你提供有价值的见解和技巧，帮助你更好地理解和应用多线程编程。
天下无贼001
9 1
八百标兵奔北坡
|
11天前
|
缓存 监控 Java
java中线程池的使用
java中线程池的使用
八百标兵奔北坡
15 7
游客7v53mftipku2u
|
10天前
|
算法 Java 数据处理
Java并发编程：解锁多线程的力量
在Java的世界里，掌握并发编程是提升应用性能和响应能力的关键。本文将深入浅出地探讨如何利用Java的多线程特性来优化程序执行效率，从基础的线程创建到高级的并发工具类使用，带领读者一步步解锁Java并发编程的奥秘。你将学习到如何避免常见的并发陷阱，并实际应用这些知识来解决现实世界的问题。让我们一起开启高效编码的旅程吧！
游客7v53mftipku2u
10 1
智物科技库
|
15天前
|
存储 Java 程序员
优化Java多线程应用：是创建Thread对象直接调用start()方法？还是用个变量调用？
这篇文章探讨了Java中两种创建和启动线程的方法，并分析了它们的区别。作者建议直接调用 `Thread` 对象的 `start()` 方法，而非保持强引用，以避免内存泄漏、简化线程生命周期管理，并减少不必要的线程控制。文章详细解释了这种方法在使用 `ThreadLocal` 时的优势，并提供了代码示例。作者洛小豆，文章来源于稀土掘金。
智物科技库
20 6
shuj
|
12天前
|
Java 开发者
Java中的多线程编程基础与实战
【9月更文挑战第6天】本文将通过深入浅出的方式，带领读者了解并掌握Java中的多线程编程。我们将从基础概念出发，逐步深入到代码实践，最后探讨多线程在实际应用中的优势和注意事项。无论你是初学者还是有一定经验的开发者，这篇文章都能让你对Java多线程有更全面的认识。
shuj
16 1

热门文章

最新文章

  • 1
    Java设计模式(一)----单例模式
  • 2
    Spring框架（SpringBoot）中redis报错（Could not get a resource from the pool、java.net.SocketTimeoutException）
  • 3
    SpringBoot运行出现 Lookup method resolution failed； nested exception is java.lang.IllegalStateException
  • 4
    Java编程(位运算符)
  • 5
    【万字长文】Java面试八股文：深入剖析常见问题与解答
  • 6
    Java编程基础阶段笔记 day01 Java语言概述
  • 7
    JVM深入学习：Java解析Class文件过程解析
  • 8
    Java读取XML与xls文件
  • 9
    Java基础05 实施接口
  • 10
    Java多线程之ReentrantReadWriteLock
  • 1
    Java集合的分类有哪些？
    74
  • 2
    java基于云部署的SaaS医院云HIS系统源码 心理CT、B超 lis、电子病历
    86
  • 3
    Java 并发编程的探索与实践
    48
  • 4
    Maven 构建 Java 项目
    54
  • 5
    18：面向切面编程-Java Spring
    71
  • 6
    17：缓存机制-Java Spring
    82
  • 7
    16：事务-Java Spring
    48
  • 8
    15：MyBatis对象关系与映射结构-Java Spring
    87
  • 9
    Java串口通信：从十六进制字符串到字节数组的正确转换与发送
    210
  • 10
    Java中如何使用Socket类检测端口是否存在
    79

    • 相关课程

    更多
  • Java高级开发
  • Java 虚拟机原理
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java高级编程
  • 「大师课」搞定 Java 开发基础

    • 相关电子书

    更多
  • Java 8 简明教程
  • Java高级特性入门（二）
  • JAVA 应用排查全景图

    • 相关实验场景

    更多
  • 阿里云平台上进行Java程序的编译与运行
  • 使用Java面向对象编写网络通信程序应用
  • Python网络通信程序典型应用
  • 手动部署Java Web环境（Alibaba Cloud Linux 2）
  • 搭建Java Web开发环境（Anolis OS）
  • RocketMQ中使用Java客户端发送消息和消费的应用
    • 下一篇
    基于LNMP搭建WordPress