详解Java中三种状态机实现方式来优雅消灭 if-else 嵌套_开发_开发者

1. 前言

在博主之前【设计模式】的专栏中，介绍过一个状态模式（津津乐道设计模式 - 状态模式详解），并以交通信号灯的实现进行状态模式的演示讲解，实际上状态模式也特别适合处理那些包含大量条件语句（如if-else或switch）的复杂状态转换逻辑。

为什么使用状态模式消除if-else？

在日常 Java 开发中，我们常常遇到这样的情况：

不同的状态有不同的处理逻辑
状态之间会相互切换
不同状态下执行的动作可能完全不同

这时，如果我们用 if-else 或 switch-case 来写，代码很容易变得臃肿难维护：比如下面代码

if (status == 0) {
    // 待支付逻辑
} else if (status == 1) {
    // 已支付逻辑
} else if (status == 2) {
    // 已发货逻辑
} else if (status == 3) {
    // 已收货逻辑
}

这种写法的问题：

逻辑分支多，扩展性差

新增状态时，需要修改原有代码（违反开闭原则）

状态切换逻辑容易分散在各个 if-else 中，不够集中

那么使用状态机（State Machine）也可称状态模式，就可以解决上述这些问题，并具备以下优点：

消除复杂的条件判断语句
提高代码可读性和可维护性
使状态转换逻辑更加清晰
符合开闭原则，易于扩展新状态

2. 复现传统if-else实现的业务场景问题

假设有一个电商订单系统，订单状态有：

待支付（PendingPay）
已支付（Paid）
已发货（Shipped）
已完成（Completed）

订单可以：

从待支付 → 支付 → 发货 → 完成
取消订单（在待支付状态下）

那么可能你的代码就是像这样的：

public class OrderServiceIfElse {
    public void handle(int status, String action) {
        if (status == 0) {
            if ("pay".equals(action)) {
                System.out.println("订单已支付");
            } else if ("cancel".equals(action)) {
                System.out.println("订单已取消");
            }
        } else if (status == 1) {
            if ("ship".equals(action)) {
                System.out.println("订单已发货");
            }
        } else if (status == 2) {
            if ("confirm".equals(action)) {
                System.out.println("订单已完成");
            }
        }
    }
}

又或者是这样的：

public class Order {
    private String state;
   
    public void process() {
        if ("NEW".equals(state)) {
            System.out.println("处理新订单");
            state = "PROCESSING";
        } else if ("PROCESSING".equals(state)) {
            System.out.println("订单处理中");
            state = "SHIPPED";
        } else if ("SHIPPED".equals(state)) {
            System.out.println("订单已发货");
            state = "DELIVERED";
        } else if ("DELIVERED".equals(state)) {
            System.out.println("订单已完成");
        } else {
            throw new IllegalStateException("无效订单状态: " + state);
        }
    }
}

无论是哪一种写法，都会存在以下问题：

当状态增多时，代码变得臃肿难以维护

违反开闭原则，添加新状态需要修改现有代码

状态转换逻辑分散在多个地方

难以跟踪状态转换规则

3. 用状态机模式改造

下面我们使用状态模式重构上述订单处理流程：

3.1 定义状态接口

public interface OrderState {
    void pay(OrderContext context);
    void ship(OrderContext context);
    void confirm(OrderContext context);
    void cancel(OrderContext context);
}

3.2 创建上下文类

public class OrderContext {
    private OrderState state;

    public OrderContext(OrderState state) {
        this.state = state;
    }

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

    public void pay() {
        state.pay(this);
    }

    public void ship() {
        state.ship(this);
    }

    public void confirm() {
        state.confirm(this);
    }

    public void cancel() {
        state.cancel(this);
    }
}

3.3 定义具体状态类

// 待支付
public class PendingPayState implements OrderState {
    @Override
    public void pay(OrderContext context) {
        System.out.println("订单支付成功");
        context.setState(new PaidState());
    }

    @Override
    public void ship(OrderContext context) {
        System.out.println("请先支付订单");
    }

    @Override
    public void confirm(OrderContext context) {
        System.out.println("请先支付订单");
    }

    @Override
    public void cancel(OrderContext context) {
        System.out.println("订单已取消");
    }
}

// 已支付
public class PaidState implements OrderState {
    @Override
    public void pay(OrderContext context) {
        System.out.println("订单已支付，请勿重复支付");
    }

    @Override
    public void ship(OrderContext context) {
        System.out.println("订单已发货");
        context.setState(new ShippedState());
    }

    @Override
    public void confirm(OrderContexpythont context) {
        System.out.println("订单还未发货");
    }

    @Override
    public void cancel(OrderContext context) {
        System.out.println("已支付订单不能取消");
  gBClwIS  }
}

// 已发货
public class ShippedState implements OrderState {
    @Override
    public void pay(OrderContext context) {
        System.out.println("订单已支付");
    }

    @Override
    public void ship(OrderContext context) {
        System.out.println("订单已经发货");
    }

    @Override
    public void confirm(OrderContext context) {
        System.out.println("订单已完成");
        context.setState(new CompletedState());
    }

    @Override
    public void cancel(OrderContext context) {
        System.out.println("发货后不能取消订单");
    }
}

// 已完成
public class CompletedState implements OrderState {
    @Override
    public void pay(OrderContext context) {
        System.out.println("订单已完成，无法支付");
    }

    @Override
    public void ship(OrderContext context) {
        System.out.println("订单已完成，无法发货");
    }

    @Override
    public void confirm(OrderContext context) {
        System.out.println("订单已完成");
    }

    @Override
    public void cancel(OrderContext context) {
        System.out.println("订单已完成，无法取消");
    }
}

3.4 测试使用

public class StateMachineTest {
    public static void main(String[] args) {
        // 初始状态：待支付
        OrderContext order = new OrderContext(new PendingPayState());

        order.pay();     // 支付
        order.ship();    // 发货
        order.confirm(); // 确认收货

		//分别输出
		//订单支付成功
		//订单已发货
		//订单已完成
    }
}

4. 枚举 + Map的轻量状态机实现

这里博主再升级一下使用枚举 + Map 的轻量状态机实现，这种写法相比经典状态模式，代码量更少，适合状态数不多、且状态逻辑相对简单的场景

这种写法的核心思想是：

用枚举类定义所有状态

每个状态实现自己的行为逻辑

通过 Map 注册状态与处理逻辑的映射关系

直接通过当前状态对象来执行对应方法，避免 if-else

4.1 定义状态枚举

public enum OrderStateEnum {
    PENDING_PAY {
        @Override
        public OrderStateEnum pay() {
            System.out.println("订单支付成功");
            return PAID;
        }

        @Override
        public OrderStateEnum ship() {
            System.out.println("请先支付订单");
            return this;
        }

        @Override
        public OrderStateEnum confirm() {
            System.out.println("请先支付订单");
            return this;
        }

        @Override
        public OrderStateEnum cancel() {
            System.out.println("订单已取消");
            return this;
        }
    },
    PAID {
        @Override
        public OrderStateEnum pay() {
            System.out.println("订单已支付，请勿重复支付");
            return this;
        }

        @Override
        public OrderStateEnum ship() {
            System.out.println("订单已发货");
            return SHIPPED;
        }

        @Override
        public OrderStateEnum confirjavascriptm() {
            System.out.println("订单还未发货");
            return this;
        }

        @Override
        public OrderStateEnum cancel() {
            System.out.println("已支付订单不能取消");
            return this;
        }
    },
    SHIPPED {
        @Override
        public OrderStateEnum pay() {
            System.out.println("订单已支付");
            return this;
        }

        @Override
        public OrderStateEnum ship() {
            System.out.println("订单已经发货");
            return this;
        }

        @Override
        public OrderStateEnum confirm() {
            System.out.println("订单已完成");
            return COMPLETED;
        }

        @Override
        public OrderStateEnum cancel() {
            System.out.println("发货后不能取消订单");
            return this;
        }
    },
    COMPLETED {
        @Override
        public OrderStateEnum pay() {
            System.out.println("订单已完成，无法支付");
            return this;
        }

        @Override
        public OrderStateEnum ship() {
            System.out.println("订单已完成，无法发货");
            return this;
        }

        @Override
        public OrderStateEnum confirm() {
            System.out.println("订单已完成");
            return this;
        }

        @Override
        public OrderStateEnum cancel() {
            System.out.println("订单已完成，无法取消");
            return this;
        }
    };

    public abstract OrderStateEnum pay();
    public abstract OrderStateEnum ship();
    public abstract OrderStateEnum confirm();
    public abstract OrderStateEnum cancel();
}

这里的设计是：

每个状态用一个枚举常量表示

每个枚举常量实现自己的状态切换逻辑

方法返回新的状态枚举，实现状态流转

4.2 配置上下文类

public class OrderContextEnum {
    private OrderStateEnum state;

    publ编程ic OrderContextEnum(OrderStateEnum state) {
        this.state = state;
    }

    public void pay() {
        state = state.pay();
    }

    public void ship() {
        state = state.ship();
    }

    public void confirm() {
        state = state.confirm();
    }

    public void cancel() {
        state = state.cancel();
    }
}

4.3 测试使用

public class EnumStat编程客栈eMachineTest {
    public static void main(String[] args) {
        OrderContextEnum order = new OrderContextEnum(OrderStateEnum.PENDING_PAY);

        order.pay();     // 支付
        order.ship();    // 发货
        order.confirm(); // 确认收货
    }
}

5. 使用 Spring StateMachine 实现订单状态机

Spring StateMachine 是 Spring 官方提供的状态机框架，支持可配置状态流转、事件驱动、监听器回调等功能，特别适合业务流程复杂、状态多变的场景。

5.1 依赖引入

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

5.2 定义状态与事件枚举

// 订单状态
public enum OrderState {
    PENDING_PAY, // 待支付
    PAID,        // 已支付
    SHIPPED,     // 已发货
    COMPLETED    // 已完成
}

// 触发事件
public enum OrderEvent {
    PAY,         // 支付
    SHIP,        // 发货
    CONFIRM,     // 确认收货
    CANCEL       // 取消订单
}

5.3 配置状态机

import org.springframework.context.annotation.Configuration;
import org.springframework.statemachine.config.EnableStateMachine;
import org.springframework.statemachine.config.EnumStateMachineConfigurerAdapter;
import org.springframework.statemachine.config.builders.StateMachineStateConfigurer;
import org.springframework.statemachine.config.builders.StateMachineTransitionConfigurer;
import org.springframework.statemachine.config.builders.StateMachineConfigurationConfigurer;
import org.springframework.statemachine.listener.StateMachineListenerAdapter;
import org.springframework.statemachine.state.State;

import java.util.EnumSet;

@Configuration
@EnableStateMachine
public class OrderStateMachineConfig extends EnumStateMachineConfigurerAdapter<OrderState, OrderEvent> {

    @Override
    public void configure(StateMachineStateConfigurer<OrderState, OrderEvent> states) throws Exception {
        states
            .withStates()
            .initial(OrderState.PENDING_PAY)  // 初始状态
            .states(EnumSet.allOf(OrderState.class)); // 所有状态
    }

    @Override
    public void configure(StateMachineTransitionConfigurer<OrderState, OrderEvent> transitions) throws Exception {
        transitions
            .withExternal()
                .source(OrderState.PENDING_PAY).target(OrderState.PAID).event(OrderEvent.PAY)
            .and()
            .withExternal()
                .source(OrderState.PAID).target(OrderState.SHIPPED).event(OrderEvent.SHIP)
            .and()
            .withExternal()
                .source(OrderState.SHIPPED).target(OrderState.COMPLETED).event(OrderEvent.CONFIRM)
            .and()
            .withExternal()
                .source(OrderState.PENDING_PAY).target(OrderState.PENDING_PAY).event(OrderEvent.CANCEL);
    }

    @Override
    public void configure(StateMachineConfigurationConfigurer<OrderState, OrderEvent> config) throws Exception {
        config
            .withConfiguration()
            .listener(new StateMachineListenerAdapter<>() {
                @Override
                public void stateChanged(State<OrderState, OrderEvent> from, State<OrderState, OrderEvent> to) {
                    System.out.println("状态切换: " 
                        + (from == null ? "无" : from.getId()) 
                        + " -> " + to.getId());
                }
            });
    }
}

5.4 测试代码

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.statemachine.StateMachine;
import org.springframework.stereotype.Component;

@Component
public class OrderStateMachineTest implements CommandLineRunner {

    @Autowired
    private StateMachine<OrderState, OrderEvent> stateMachine;

    @Override
    public void run(String... args) throws Exception {
        stateMachine.start();

        stateMachine.sendEvent(OrderEvent.PAY);
        stateMachine.sendEvent(OrderEvent.SHIP);
        stateMachine.sendEvent(OrderEvent.CONFIRM);

        stateMachine.stop();
    }
}

观察控制台会输出如下：

状态切换: 无 -> PENDING_PAY
状态切换: PENDING_PAY -> PAID
状态切换: PAID -> SHIPPED
状态切换: SHIPPED -> COMPLETED

6. 对比三种方案

实现方式	优点	缺点	适用场景
经典状态模式	结构清晰，面向对象	类文件多，状态多时管理复杂	状态多、逻辑复杂的 OO 场景
枚举状态机	简洁，集中管理	状态多时枚举类太长	状态少、逻辑简单
Spring StateMachine	功能强大，可配置化	需要额外依赖，学习成本高	大型系统、状态规则经常变动

经典状态模式适合复杂业务流程，易于模块化管理

枚举 + Map 注册或枚举直接实现行为，适合小型项目或简单状态流转

在 Java 中，枚举天生是单例的，用它实现状态机既简洁又线程安全

7. 总结

本文博主详细介绍了使用状态模式消除if-else, 通过经典状态模式、枚举状态机、Spring StateMachine 三种方式，从纯手写模式 → 枚举模式 → 框架模式的完整对比，进行了相关代码演示。当小伙伴们发现自己在编写大量条件语句来处理对象状态时，考虑使用状态模式重构您的代码。

到此这篇关于详解Java中三种状态机实现方式来优雅消灭 if-else 嵌套的文章就介绍到这了,更多相关Java状态机内容请搜索编程客栈(www.devze.com)以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程客栈(www.devze.com)！

详解Java中三种状态机实现方式来优雅消灭 if-else 嵌套

目录

1. 前言

2. 复现传统if-else实现的业务场景问题

3. 用状态机模式改造

3.1 定义状态接口

3.2 创建上下文类

3.3 定义具体状态类

3.4 测试使用

4. 枚举 + Map的轻量状态机实现

4.1 定义状态枚举

4.2 配置上下文类

4.3 测试使用

5. 使用 Spring StateMachine 实现订单状态机

5.1 依赖引入

5.2 定义状态与事件枚举

5.3 配置状态机

5.4 测试代码

6. 对比三种方案

7. 总结

精彩评论

关注公众号

热门标签

图文推荐

详解Java中三种状态机实现方式来优雅消灭 if-else 嵌套

目录

1. 前言

2. 复现传统if-else实现的业务场景问题

3. 用状态机模式改造

3.1 定义状态接口

3.2 创建上下文类

3.3 定义具体状态类

3.4 测试使用

4. 枚举 + Map的轻量状态机实现

4.1 定义状态枚举

4.2 配置上下文类

4.3 测试使用

5. 使用 Spring StateMachine 实现订单状态机

5.1 依赖引入

5.2 定义状态与事件枚举

5.3 配置状态机

5.4 测试代码

6. 对比三种方案

7. 总结

更多 开发 相关资讯：

精彩评论

关注公众号

热门标签

图文推荐

更多开发相关资讯：