有限状态机（Finite State Machine，FSM）是一种计算模型，它可以使用有限个状态和它们之间的转移，来描述一个系统在不同状态下的行为。在软件开发中，常常需要使用有限状态机来解决复杂问题，比如网络协议解析、报文处理、游戏逻辑等。

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

有限状态机（Finite State Machine，FSM）是一种计算模型，它可以使用有限个状态和它们之间的转移，来描述一个系统在不同状态下的行为。在软件开发中，常常需要使用有限状态机来解决复杂问题，比如网络协议解析、报文处理、游戏逻辑等。

本文将介绍 Java 实现有限状态机的一些推荐方案，并提供了两条示例说明，供读者参考。

1. Java FSM 框架

在 Java 中，有许多开源的 FSM 框架，它们可以帮助我们快速地实现 FSM。其中，最常用的是 Stateless 框架。

Stateless 是一个轻量级的 FSM 框架，它支持多种状态和转换条件，并允许我们将不同的转换结果映射到不同的操作中。它的主要特点包括：

支持并发状态机；
支持条件和嵌套状态；
采用 Builder 模式进行状态机的构建；
提供了 Fluent API，使状态机的定义更加清晰。

下面是一个简单的示例，演示了如何使用 Stateless 实现一个 TCP 连接状态机：

public enum TcpState {
    CLOSED,
    LISTEN,
    SYN_SENT,
    SYN_RCVD,
    ESTABLISHED,
    FIN_WAIT_1,
    FIN_WAIT_2,
    CLOSE_WAIT,
    CLOSING,
    LAST_ACK,
    TIME_WAIT
}

StateMachine<TcpState, TcpEvent> fsm = StateMachine.<TcpState, TcpEvent>builder()
        .initialState(TcpState.CLOSED)
        .state(TcpState.CLOSED)
            .permit(TcpEvent.OPEN, TcpState.LISTEN)
        .state(TcpState.LISTEN)
            .permit(TcpEvent.SEND, TcpState.SYN_SENT)
        .state(TcpState.SYN_SENT)
            .permit(TcpEvent.RECEIVE_SYN, TcpState.SYN_RCVD)
            .permit(TcpEvent.CLOSE, TcpState.CLOSED)
        .state(TcpState.SYN_RCVD)
            .permit(TcpEvent.SEND_ACK, TcpState.ESTABLISHED)
            .permit(TcpEvent.CLOSE, TcpState.FIN_WAIT_1)
        .state(TcpState.ESTABLISHED)
            .permit(TcpEvent.SEND, TcpState.ESTABLISHED)
            .permit(TcpEvent.RECEIVE, TcpState.ESTABLISHED)
            .permit(TcpEvent.CLOSE, TcpState.FIN_WAIT_1)
        .state(TcpState.FIN_WAIT_1)
            .permit(TcpEvent.RECEIVE_ACK, TcpState.FIN_WAIT_2)
            .permit(TcpEvent.CLOSE, TcpState.CLOSING)
        .state(TcpState.FIN_WAIT_2)
            .permit(TcpEvent.RECEIVE_FIN, TcpState.TIME_WAIT)
            .permit(TcpEvent.RECEIVE_ACK, TcpState.TIME_WAIT)
            .permit(TcpEvent.CLOSE, TcpState.TIME_WAIT)
        .state(TcpState.CLOSE_WAIT)
            .permit(TcpEvent.SEND, TcpState.CLOSE_WAIT)
            .permit(TcpEvent.CLOSE, TcpState.LAST_ACK)
        .state(TcpState.CLOSING)
            .permit(TcpEvent.RECEIVE_ACK, TcpState.TIME_WAIT)
        .state(TcpState.LAST_ACK)
            .permit(TcpEvent.RECEIVE_ACK, TcpState.CLOSED)
        .state(TcpState.TIME_WAIT)
            .permit(TcpEvent.TIMEOUT, TcpState.CLOSED)
        .build();

fsm.fire(TcpEvent.OPEN);
fsm.fire(TcpEvent.SEND);
fsm.fire(TcpEvent.RECEIVE_SYN);
fsm.fire(TcpEvent.SEND_ACK);
fsm.fire(TcpEvent.RECEIVE);
fsm.fire(TcpEvent.CLOSE);

在上述代码中，我们首先定义了一个 TCP 状态机的状态和转移条件，然后通过 StateMachine 的 fire 方法来触发状态的转换。

2. Java 实现 FSM：状态模式

除了使用框架之外，我们还可以通过状态模式来实现 FSM。状态模式是一种设计模式，它将不同的状态抽象成独立的类，通过不同的状态类来表示不同的状态，并由一个上下文类来控制状态的转移。

下面是一个示例，演示了如何使用状态模式来实现一个咖啡机状态机：

public class CoffeeMachineContext {
    private CoffeeMachineState state;

    public CoffeeMachineContext() {
        state = new NoCoinState();
    }

    public void insertCoin() {
        state = state.insertCoin(this);
    }

    public void returnCoin() {
        state = state.returnCoin(this);
    }

    public void turnCrank() {
        state = state.turnCrank(this);
    }

    public void dispense() {
        state = state.dispense(this);
    }

    // other methods
}

public interface CoffeeMachineState {
    CoffeeMachineState insertCoin(CoffeeMachineContext context);

    CoffeeMachineState returnCoin(CoffeeMachineContext context);

    CoffeeMachineState turnCrank(CoffeeMachineContext context);

    CoffeeMachineState dispense(CoffeeMachineContext context);
}

public class NoCoinState implements CoffeeMachineState {
    @Override
    public CoffeeMachineState insertCoin(CoffeeMachineContext context) {
        System.out.println("Inserting coin...");
        return new HasCoinState();
    }

    @Override
    public CoffeeMachineState returnCoin(CoffeeMachineContext context) {
        System.out.println("You haven't inserted a coin");
        return this;
    }

    @Override
    public CoffeeMachineState turnCrank(CoffeeMachineContext context) {
        System.out.println("You turned, but there's no coin");
        return this;
    }

    @Override
    public CoffeeMachineState dispense(CoffeeMachineContext context) {
        System.out.println("You need to pay first");
        return this;
    }
}

public class HasCoinState implements CoffeeMachineState {
    @Override
    public CoffeeMachineState insertCoin(CoffeeMachineContext context) {
        System.out.println("You can't insert another coin");
        return this;
    }

    @Override
    public CoffeeMachineState returnCoin(CoffeeMachineContext context) {
        System.out.println("Coin returned");
        return new NoCoinState();
    }

    @Override
    public CoffeeMachineState turnCrank(CoffeeMachineContext context) {
        System.out.println("You turned...");
        return new DispensingState();
    }

    @Override
    public CoffeeMachineState dispense(CoffeeMachineContext context) {
        System.out.println("You need to turn the crank");
        return this;
    }
}

public class DispensingState implements CoffeeMachineState {
    @Override
    public CoffeeMachineState insertCoin(CoffeeMachineContext context) {
        System.out.println("Please wait, we're already giving you a coffee");
        return this;
    }

    @Override
    public CoffeeMachineState returnCoin(CoffeeMachineContext context) {
        System.out.println("Sorry, you already turned the crank");
        return this;
    }

    @Override
    public CoffeeMachineState turnCrank(CoffeeMachineContext context) {
        System.out.println("Turning twice doesn't get you another coffee");
        return this;
    }

    @Override
    public CoffeeMachineState dispense(CoffeeMachineContext context) {
        System.out.println("A coffee is dispensed");
        return new NoCoinState();
    }
}

在上述代码中，我们定义了 CoffeeMachineContext 类作为状态的上下文，具有四个方法分别表示不同操作；定义了 CoffeeMachineState 接口表示不同状态，并实现了三个不同的状态：NoCoinState、HasCoinState 和 DispensingState。