设计模式之状态模式

Posted 2021-08-12 二木成林

概述

在软件开发过程中，应用程序中的部分对象可能会根据不同的情况做出不同的行为，我们把这种对象称为有状态的对象，而把影响对象行为的一个或多个动态变化的属性称为状态。当有状态的对象与外部事件产生互动时，其内部状态就会发生改变，从而使其行为也发生改变。如人都有高兴和伤心的时候，不同的情绪有不同的行为，当然外界也会影响其情绪变化。

对这种有状态的对象编程，传统的解决方案是：将这些所有可能发生的情况全都考虑到，然后使用 if-else 或 switch-case 语句来做状态判断，再进行不同情况的处理。但是显然这种做法对复杂的状态判断存在天然弊端，条件判断语句会过于臃肿，可读性差，且不具备扩展性，维护难度也大。且增加新的状态时要添加新的 if-else 语句，这违背了“开闭原则”，不利于程序的扩展。

以上问题如果采用“状态模式”就能很好地得到解决。状态模式的解决思想是：当控制一个对象状态转换的条件表达式过于复杂时，把相关“判断逻辑”提取出来，用各个不同的类进行表示，系统处于哪种情况，直接使用相应的状态类对象进行处理，这样能把原来复杂的逻辑判断简单化，消除了 if-else、switch-case 等冗余语句，代码更有层次性，并且具备良好的扩展力。

例：通过按钮来控制一个电梯的状态，一个电梯有开门状态，关门状态，停止状态，运行状态。每一种状态改变，都有可能要根据其他状态来更新处理。例如，如果电梯门现在处于运行时状态，就不能进行开门操作，而如果电梯门是停止状态，就可以执行开门操作。 其UML类图如下：

 各实现类代码如下：

• ILift.java

/**
 * @author lcl100
 * @create 2021-07-15 21:36
 * @desc 电梯接口
 */
public interface ILift {
    // 定义电梯的四种状态
    public int OPENING_STATE = 1;// 打开状态
    public int CLOSING_STATE = 2;// 关闭状态
    public int RUNNING_STATE = 3;// 运行状态
    public int STOPPING_STATE = 4;// 停止状态

    /**
     * 设置电梯的状态
     *
     * @param state 电梯的状态
     */
    void setState(int state);

    /**
     * 打开电梯
     */
    void open();

    /**
     * 关闭电梯
     */
    void close();

    /**
     * 停止电梯
     */
    void stop();

    /**
     * 运行电梯
     */
    void run();
}

• Lift.java

/**
 * @author lcl100
 * @create 2021-07-15 21:41
 * @desc 电梯实现类
 */
public class Lift implements ILift {
    // 电梯状态
    private int state;

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

    // 打开门的动作
    @Override
    public void open() {
        // 当要打开门时，判断当前电梯的状态，如果电梯是打开状态则不需要再打开，如果电梯是关闭状态则可以打开门，如果...
        switch (this.state) {
            case OPENING_STATE://门已经开了，不能再开门了
                //do nothing
                break;
            case CLOSING_STATE://关门状态，门打开:
                System.out.println("电梯门打开了。。。");
                this.setState(OPENING_STATE);
                break;
            case RUNNING_STATE:
                //do nothing 运行时电梯不能开门
                break;
            case STOPPING_STATE:
                System.out.println("电梯门开了。。。");//电梯停了，可以开门了
                this.setState(OPENING_STATE);// 重置电梯状态
                break;
        }
    }

    @Override
    public void close() {
        // 判断电梯状态，才能决定能否关闭电梯的运行
        switch (this.state) {
            case OPENING_STATE:
                System.out.println("电梯关门了......");// 只有开门状态才能关闭电梯门
                this.setState(CLOSING_STATE);// 关门之后电梯就是关闭状态了
                break;
            case CLOSING_STATE:
                // 已经是关闭状态，不能关门了
                break;
            case RUNNING_STATE:
                // 运行时电梯门是关闭着的，不能关门
                break;
            case STOPPING_STATE:
                // 停止时电梯也是关着的，不能关门
                break;
        }
    }

    @Override
    public void stop() {
        switch (this.state) {
            case OPENING_STATE: //开门的电梯已经是是停止的了(正常情况下)
                //do nothing
                break;
            case CLOSING_STATE://关门时才可以停止
                System.out.println("电梯停止了。。。");
                this.setState(STOPPING_STATE);// 重置电梯状态
                break;
            case RUNNING_STATE://运行时当然可以停止了
                System.out.println("电梯停止了。。。");
                this.setState(STOPPING_STATE);
                break;
            case STOPPING_STATE:
                //do nothing
                break;
        }
    }

    @Override
    public void run() {
        switch (this.state) {
            case OPENING_STATE://电梯不能开着门就走
                //do nothing
                break;
            case CLOSING_STATE://门关了，可以运行了
                System.out.println("电梯开始运行了。。。");
                this.setState(RUNNING_STATE);//现在是运行状态
                break;
            case RUNNING_STATE:
                //do nothing 已经是运行状态了
                break;
            case STOPPING_STATE:
                System.out.println("电梯开始运行了。。。");
                this.setState(RUNNING_STATE);
                break;
        }
    }
}

• Test.java

/**
 * @author lcl100
 * @create 2021-07-15 21:52
 * @desc 测试类
 */
public class Test {
    public static void main(String[] args) {
        ILift lift = new Lift();
        lift.setState(Lift.CLOSING_STATE);// 设置电梯的状态是关闭状态

        lift.open();// 开门
        lift.close();// 关门
        lift.run();// 运行
        lift.stop();// 停止
    }
}

问题分析：

• 使用了大量的switch…case这样的判断（if…else也是一样)，使程序的可阅读性变差。

• 扩展性很差。如果新加了断电的状态，我们需要修改上面判断逻辑

状态（State）模式的定义：对有状态的对象，把复杂的“判断逻辑”提取到不同的状态对象中，允许状态对象在其内部状态发生改变时改变其行为。

结构

状态模式包含以下主要角色。

1. 环境类（Context）角色：也称为上下文，它定义了客户端需要的接口，内部维护一个当前状态，并负责具体状态的切换。
2. 抽象状态（State）角色：定义一个接口，用以封装环境对象中的特定状态所对应的行为，可以有一个或多个行为。
3. 具体状态（Concrete State）角色：实现抽象状态所对应的行为，并且在需要的情况下进行状态切换。

其UML结构图如下：

 各实现类代码如下：

• AbstractState.java

/**
 * @author lcl100
 * @create 2021-07-15 22:06
 * @desc 抽象状态类
 */
public abstract class AbstractState {
    /**
     * 封装环境对象中的特定状态所对应的行为
     * @param context 环境状态
     */
    abstract void Handle(Context context);
}

• ConcreteStateA.java

/**
 * @author lcl100
 * @create 2021-07-15 22:11
 * @desc 具体状态类A
 */
public class ConcreteStateA extends AbstractState {
    @Override
    void Handle(Context context) {
        System.out.println("当前状态是 A.");
        context.setState(new ConcreteStateB());
    }
}

• ConcreteStateB.java

/**
 * @author lcl100
 * @create 2021-07-15 22:13
 * @desc 具体状态类B
 */
public class ConcreteStateB extends AbstractState {

    @Override
    void Handle(Context context) {
        System.out.println("当前状态是 B.");
        context.setState(new ConcreteStateA());
    }
}

• Context.java

/**
 * @author lcl100
 * @create 2021-07-15 22:07
 * @desc 环境类
 */
public class Context {
    private AbstractState state;

    Context() {
        // 定义环境的初始状态
        this.state = new ConcreteStateA();// 即设置一个初始状态，可以任意一个初始状态
    }

    // 设置新状态
    public void setState(AbstractState state) {
        this.state = state;
    }

    // 读取当前环境中的状态
    public AbstractState getState() {
        return state;
    }

    // 对请求进行处理
    public void Handle() {
        state.Handle(this);
    }
}

• Test.java

/**
 * @author lcl100
 * @create 2021-07-15 22:19
 * @desc 测试类
 */
public class Test {
    public static void main(String[] args) {
        Context context=new Context();// 创建环境，已经在构造方法内初始化了状态，即已有默认状态
        context.Handle();// 处理请求
        context.Handle();// 处理请求
        context.Handle();// 处理请求
        context.Handle();// 处理请求
    }
}

案例实现

对上述电梯的案例使用状态模式进行改进。类图如下：

各实现代码如下：

• AbstractLiftState.java

/**
 * @author lcl100
 * @create 2021-07-15 22:41
 * @desc 抽象状态类
 */
public abstract class AbstractLiftState {
    // 定义一个环境角色类，也就是封装状态的变化引起的功能变化
    protected Context context;

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

    // 电梯开门动作
    public abstract void open();

    // 电梯关闭动作
    public abstract void close();

    // 电梯运行动作
    public abstract void run();

    // 电梯停止动作
    public abstract void stop();
}

• ClosingState.java

/**
 * @author lcl100
 * @create 2021-07-15 23:01
 * @desc 关闭状态类
 */
public class ClosingState extends AbstractLiftState {
    @Override
    public void open() {
        //电梯门关了再打开，逗你玩呢，那这个允许呀
        super.context.setState(Context.OPENING_STATE);
        super.context.open();
    }

    @Override
    public void close() {
        // 电梯门关闭，这是关闭状态要实现的动作
        System.out.println("电梯门关闭...");
    }

    @Override
    public void run() {
        // 电梯门关了再运行，这是可以的
        super.context.setState(Context.RUNNING_STATE);
        super.context.run();
    }

    @Override
    public void stop() {
        //电梯门关着，我就不按楼层
        super.context.setState(Context.STOPPING_STATE);
        super.context.stop();
    }
}

• OpeningState.java

/**
 * @author lcl100
 * @create 2021-07-15 22:44
 * @desc 开启状态类
 */
public class OpeningState extends AbstractLiftState {
    @Override
    public void open() {
        // 处于开启状态，那么表示电梯正处于开启状态，不能再开启了
        System.out.println("电梯门开启...");
    }

    @Override
    public void close() {
        // 当前处于开门状态，那么就可以执行关门动作，关闭门
        // 修改门的状态
        super.context.setState(Context.CLOSING_STATE);
        // 动作委托给ClosingState子类执行这个动作
        super.context.getState().close();
    }

    @Override
    public void run() {
        // 电梯门不能处于开启运行，必须关门才能上下运行，所以这里什么也不要做
    }

    @Override
    public void stop() {
        // 处于开门状态，说明此时电梯已经停止了
    }
}

• RunningState.java

/**
 * @author lcl100
 * @create 2021-07-15 22:52
 * @desc 运行状态类
 */
public class RunningState extends AbstractLiftState{
    @Override
    public void open() {
        // 现在处于运行状态，居然想打开电梯门，不能开，所以什么也不执行
    }

    @Override
    public void close() {
        // 电梯门关闭，这是可以的，但虽然可以关闭，但这个动作不归我执行
    }

    @Override
    public void run() {
        // 这是在运行状态下要实现的方法
        System.out.println("电梯正在运行...");
    }

    @Override
    public void stop() {
        // 现在处于运行状态，当然可以停止电梯，不可能一直运行下去
        super.context.setState(Context.STOPPING_STATE);
        super.context.stop();
    }
}

• StoppingState.java

/**
 * @author lcl100
 * @create 2021-07-15 22:56
 * @desc 停止状态类
 */
public class StoppingState extends AbstractLiftState {
    @Override
    public void open() {
        // 处于停止状态，当然可以打开电梯门
        super.context.setState(Context.OPENING_STATE);// 修改状态
        super.context.getState().open();// 动作委托给CloseState来执行，也就是委托给了ClosingState子类来执行这个动作
    }

    @Override
    public void close() {
        //虽然可以关门，但这个动作不归我执行
        //状态修改
        super.context.setState(Context.CLOSING_STATE);
        //动作委托为CloseState来执行，也就是委托给了ClosingState子类执行这个动作
        super.context.getState().close();
    }

    @Override
    public void run() {
        //停止状态再跑起来，正常的很
        //状态修改
        super.context.setState(Context.RUNNING_STATE);
        //动作委托为CloseState来执行，也就是委托给了ClosingState子类执行这个动作
        super.context.getState().run();
    }

    @Override
    public void stop() {
        //停止状态是怎么发生的呢？当然是停止方法执行了
        System.out.println("电梯停止了...");
    }
}

• Context.java

/**
 * @author lcl100
 * @create 2021-07-15 23:04
 * @desc 环境角色类
 */
public class Context {
    // 定义出所有的电梯状态
    public final static OpeningState OPENING_STATE = new OpeningState();// 开门状态，这时候电梯门只能关闭
    public final static ClosingState CLOSING_STATE = new ClosingState();// 关闭状态，这时候电梯可以运行、停止和开门
    public final static RunningState RUNNING_STATE = new RunningState();// 运行状态，这时候只能停止
    public final static StoppingState STOPPING_STATE = new StoppingState();// 停止状态，这时候电梯可以开门、运行

    // 定义一个当前电梯状态
    private AbstractLiftState state;

    public void setState(AbstractLiftState state) {
        this.state = state;// 当前环境改变
        this.state.setContext(this);// 把当前环境通知到各个实现类中
    }

    public AbstractLiftState getState() {
        return state;
    }

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

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

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

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

• Test.java

/**
 * @author lcl100
 * @create 2021-07-15 23:11
 * @desc 测试类
 */
public class Test {
    public static void main(String[] args) {
        Context context = new Context();
        context.setState(new ClosingState());// 设置初始状态

        context.open();
        context.close();
        context.run();
        context.stop();
    }
}

优缺点

状态模式是一种对象行为型模式，其主要优点如下。

1. 结构清晰，状态模式将与特定状态相关的行为局部化到一个状态中，并且将不同状态的行为分割开来，满足“单一职责原则”。
2. 将状态转换显示化，减少对象间的相互依赖。将不同的状态引入独立的对象中会使得状态转换变得更加明确，且减少对象间的相互依赖。
3. 状态类职责明确，有利于程序的扩展。通过定义新的子类很容易地增加新的状态和转换。

状态模式的主要缺点如下。

1. 状态模式的使用必然会增加系统的类与对象的个数。
2. 状态模式的结构与实现都较为复杂，如果使用不当会导致程序结构和代码的混乱。
3. 状态模式对开闭原则的支持并不太好，对于可以切换状态的状态模式，增加新的状态类需要修改那些负责状态转换的源码，否则无法切换到新增状态，而且修改某个状态类的行为也需要修改对应类的源码。

适用场景：

• 当一个对象的行为取决于它的状态，并且它必须在运行时根据状态改变它的行为时，就可以考虑使用状态模式。
• 一个操作中含有庞大的分支结构，并且这些分支决定于对象的状态时。