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

原创 于 2025-11-20 09:56:53 发布 · 1k 阅读 · 19 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #开发语言 #人工智能

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. 总结
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(OrderContext context) {
        System.out.println("订单还未发货");
    }

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

// 已发货
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 confirm() {
            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;

    public 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 EnumStateMachineTest {
    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());
                }
            });
    }
}

观察控制台会输出如下：

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

6. 对比三种方案

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

经典状态模式适合复杂业务流程，易于模块化管理
枚举 + Map 注册或枚举直接实现行为，适合小型项目或简单状态流转
在 Java 中，枚举天生是单例的，用它实现状态机既简洁又线程安全

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

如果你在实践过程中有任何疑问或更好的扩展思路，欢迎在评论区留言，最后希望大家 一键三连 给博主一点点鼓励！

AI大模型学习福利

作为一名热心肠的互联网老兵，我决定把宝贵的AI知识分享给大家。 至于能学习到多少就看你的学习毅力和能力了 。我已将重要的AI大模型资料包括AI大模型入门学习思维导图、精品AI大模型学习书籍手册、视频教程、实战学习等录播视频免费分享出来。

一、全套AGI大模型学习路线

AI大模型时代的学习之旅：从基础到前沿，掌握人工智能的核心技能！

因篇幅有限，仅展示部分资料，需要点击文章最下方名片即可前往获取

二、640套AI大模型报告合集

这套包含640份报告的合集，涵盖了AI大模型的理论研究、技术实现、行业应用等多个方面。无论您是科研人员、工程师，还是对AI大模型感兴趣的爱好者，这套报告合集都将为您提供宝贵的信息和启示。

因篇幅有限，仅展示部分资料，需要点击文章最下方名片即可前往获

三、AI大模型经典PDF籍

随着人工智能技术的飞速发展，AI大模型已经成为了当今科技领域的一大热点。这些大型预训练模型，如GPT-3、BERT、XLNet等，以其强大的语言理解和生成能力，正在改变我们对人工智能的认识。 那以下这些PDF籍就是非常不错的学习资源。


因篇幅有限，仅展示部分资料，需要点击文章最下方名片即可前往获

四、AI大模型商业化落地方案

因篇幅有限，仅展示部分资料，需要点击文章最下方名片即可前往获

作为普通人，入局大模型时代需要持续学习和实践，不断提高自己的技能和认知水平，同时也需要有责任感和伦理意识，为人工智能的健康发展贡献力量


 

jike007gt
关注
java实现有限状态机(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
05-26 1075
java实现有限状态机(附完整源码)
Java架构-状态机如何实现
weixin_54542328的博客
10-28 1969
先来解释什么是“状态”（ State ）。现实事物是有不同状态的，例如一个自动门，就有 open 和 closed 两种状态。我们通常所说的状态机是有限状态机，也就是被描述的事物的状态的数量是有限个，例如自动门的状态就是两个 open 和 closed。状态机，也就是 State Machine ，不是指一台实际机器，而是指一个数学模型。说白了，一般就是指一张状态转换图。例如，根据自动门的运行规则，我们可以抽象出下面这么一个图。
如何在Java中实现高效的状态机：从有限状态机到复杂状态管理
微赚淘客系统开发者博客
08-19 1150
本文将介绍如何在Java中实现高效的状态机，从基本的有限状态机（Finite State Machine, FSM）到更复杂的状态管理系统。在复杂项目中，如果状态机的逻辑更加复杂，建议使用第三方库来管理状态机。从基本的有限状态机到复杂的状态管理，通过灵活运用状态模式和外部库，开发者可以在复杂系统中轻松管理各种状态转换和逻辑。当应用程序中的状态管理变得更加复杂时，例如需要处理多个并发状态或嵌套状态，基本的有限状态机可能无法满足需求。通过将状态的行为封装到不同的状态类中，可以有效地管理复杂的状态和转换。
2021-10-08
qq_43645280的博客
10-08 687
使用Spring状态机实现订单状态流转 文章目录使用Spring状态机实现订单状态流转前言一、什么是电商订单状态流转？二、准备知识1.简化配置2.状态配置3. 配置转换案例 前言 状态机是状态模式的一种应用，相当于上下文角色的一个升级版。在工作流或游戏等各种系统中有大量使用，如各种工作流引擎，它几乎是状态机的子集和实现，封装状态的变化规则。状态机可以帮助开发者简化状态控制的开发过程，让状态机结构更加层次化。Spring 提供了一个很好的解决方案，Spring Statemachine（状态机）是应用程序开
Java中状态机
iaoyou1的博客
08-27 5279
状态机（State Machine）是一种数学模型，用于描述对象或系统在不同状态之间的转移和行为。它由一组状态、转移条件和动作组成，可以根据输入条件从一个状态转移到另一个状态，并执行相应的动作。离散性：状态机是离散的，它的状态和转移是离散的，不涉及连续变化。易于理解和建模：状态机可以直观地描述对象或系统的行为，使得人们能够更好地理解和建模复杂的逻辑。可扩展性：状态机可以轻松地添加新的状态和转移，以适应需求的变化。
58、QP-nano 技术详解：从代码结构到状态机实现
最新发布
butter的博客
07-20 88
本文详细解析了 QP-nano 实时框架的核心特性与实现机制，涵盖其代码结构、中断锁定策略、状态机实现、活动对象管理以及系统时钟滴答处理等内容。QP-nano 是一个轻量级的嵌入式实时框架，适用于多种硬件平台，支持分层状态机、事件驱动模型以及多任务调度。文章还提供了应用建议、开发流程、性能优化方案以及常见问题解答，帮助开发者更好地理解和使用 QP-nano 进行高效嵌入式系统开发。
有限状态机原理与实现详解
这样的设计允许程序员以声明式方式定义状态机，而非用大量 if-else 或 switch-case 语句硬编码逻辑，显著提升了代码的可读性和扩展性。同时，高级状态机框架还支持嵌套状态（Hierarchical State Machine）、并行状态...
12、状态机实现技术与应用详解
butter的博客
06-04 38
本文深入探讨了状态机的多种实现技术及其应用场景，重点包括计算器状态机和时间炸弹状态机的设计与实现。内容涵盖状态机基础概念、事件与转换机制、UML状态机的特性，以及嵌套开关语句、状态表和面向对象的状态设计模式三种主流实现方式的比较。文章通过详细示例代码解析了不同技术的原理、优缺点及适用场景，为开发者提供了状态机设计的全面指导。
C语言实现状态机的原理与代码详解
在软件工程中，尤其是资源受限的嵌入式环境中，使用状态机可以有效替代复杂的多重嵌套if-else或switch-case语句，使程序结构更加清晰、逻辑更易追踪、调试更为便捷。以一个简单的自动售货机为例，它可能具有“待机”...
Java状态机
m0_65013257的博客
02-18 1915
我们可以定义一个状态机，并声明两个变量，一个用来记录状态变化的记录，一个用来记录要经过下一个状态需要的源状态与事件。在生成一个状态机的过程，我们将记录他需要变化的所有的状态，事件以及转换。过渡类的内容为@Data/*** 起始状态*//*** 动作*//*** 目标状态*/
【java有限状态机选型】
qq_260179415的博客
12-22 4452
今天跟大家分享一个关于“状态机”的话题。状态属性在我们的现实生活中无处不在。比如经典的电商场景会有一系列的订单状态(待支付、待发货、已发货、超时、关闭）；某个活动会有活动状态（待提交、审核中、审核成功、审核拒绝、已失效、带参与、已参与、未参与）等等。上述场景有一个共同问题：根据不同触发条件执行不同处理动作最后落地不同的状态。}那我们最容易能想到的自然是if-else方案。那if-else方案会有什么问题呢？维护成本增加（复杂的业务流程，if.else代码几乎无法维护）
支付系统核心逻辑 — — 状态机（Java&Golang版本）
weixin_45565886的博客
04-13 3547
支付系统核心逻辑 — — 状态机（Java&Golang版本）
自动状态机学习及java实现
osnot的专栏
02-15 1481
介绍AC自动机论文的java实现及思路。
Java学习之 状态机 机制
xlj_bear的博客
10-18 947
在现代软件开发中，业务流程的复杂性不断增加，如何有效地管理不同状态之间的转换成为了一个重要课题。状态机（State Machine）是一种有效的工具，能够帮助我们清晰地定义和管理这些状态及其转移，尤其在Java开发中，其应用广泛。本文将探讨Java状态机的定义、应用场景及如何解决并发问题。状态机是一种设计模式，用于表示计算机系统的状态以及状态之间的转移。状态机由多个状态、事件和状态转移规则构成，能够清晰地描述系统在不同状态下的行为。
java设计模式学习之【状态模式】
qq_33129875的博客
12-27 2800
这篇教程不仅提供了状态模式的理论基础，还通过具体的Java代码示例展示了如何实现和应用这种模式。简单理解，通俗易懂
Java状态机实战一：接口定义
小DuDu的博客
03-19 562
状态机（State Machine），全称为有限状态机（Finite State Machine, FSM），是一种数学模型，描述了系统在不同状态之间的转移规则。状态（State）：系统可能处于的某个具体情况。事件（Event）或输入（Input）：触发状态变化的外部或内部因素。转换（Transition）：状态如何根据事件变化。初始状态（Initial State）：系统的起始状态。终止状态（Final State，可选）：系统可能的结束状态。状态定义接口/*** 状态抽象接口*/
Java实现状态机样例解析与应用
weixin_36382073的博客
05-17 1307
状态机设计模式是一种广泛应用于软件工程中的模式，特别是在复杂业务逻辑处理上，它能够有效地管理对象在不同状态之间的转换和与之相关的行为。其核心思想是将系统的行为定义为一系列的状态转换，每一个状态只关心与其相关的行为，使得系统逻辑更加清晰，易于扩展和维护。设计模式的状态机可以是有限状态机（Finite State Machine，FSM）或者行为状态机（Behavioral State Machine），它们在实现上会略有差异，但其基本原理相同，即通过状态和事件的交互来驱动系统行为。
一个轻量实用的Java状态机框架--Cola-StateMachine
热门推荐
qq_36551991的博客
01-17 1万+
详解Java状态机框架--Cola-StateMachine
状态机 实现 java
weixin_32101177的博客
08-12 381
状态机在Java中的实现 状态机是一种数学模型，用于描述系统的状态以及状态之间的转换。它通常由状态（States）、事件（Events）和转换（Transitions）三部分构成。状态机在计算机科学中应用广泛，特别是在编程语言设计、图形用户界面、网络协议等领域。本文将探讨如何在Java中实现状态机，并提供一个具体的代码示例...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值