1、定义

允许一个对象再其内部状态改变时改变它的行为，对象看起来好像修改了它的类。通俗地说就是啊把所有行为包装在不同的类状态对象里，每一个状态对象都是抽象状态类的一个子类。

2、模式结构

状态（State）模式 - 图1

状态模式由三部分组成：

  • Context（环境）：定义客户端所感兴趣的接口，并且保留一个具体状态类的实例。这个具体状态类的实例就是当前环境对象的现有状态。
  • State（抽象状态）：定义一个接口，用以封装环境（Context）对象的一个特定的状态所对应的行为。
  • ConcreteState（具体状态）:每一个具体状态类都实现了环境（Context）的一个状态所对应的行为。

3、实例

状态（State）模式 - 图2

3.1 State

  1. public interface State {
  3.     /**
  4.      * 电审
  5.      */
  6.     void checkEvent(Context context);
  8.      /**
  9.       * 电商失败
  10.       */
  11.     void checkFailEvent(Context context);
  13.     /**
  14.      * 定价发布
  15.      */
  16.     void makePriceEvent(Context context);
  18.     /**
  19.      * 接单
  20.      */
  21.     void acceptOrderEvent(Context context);
  23.     /**
  24.      * 无人接单失效
  25.      */
  26.     void notPeopleAcceptEvent(Context context);
  28.     /**
  29.      * 付款
  30.      */
  31.     void payOrderEvent(Context context);
  33.     /**
  34.      * 有人接单支付失效
  35.      */
  36.     void orderFailureEvent(Context context);
  38.     /**
  39.      * 反馈
  40.      */
  41.     void feedBackEvent(Context context);
  43.     String getCurrentState(); 
  44. }
  1. public enum StateEnum {
  3.     GENERATE(1, "订单生成"),
  5.     REVIEWED(2, "已审核"),
  7.     PUBLISHED(3, "已发布"),
  9.     NOT_PAY(4, "待付款"),
  11.     PAID(5, "已付款"),
  13.     FEED_BACKED(6, "已完结");
  15.     private int key;
  17.     private String value;
  19.     StateEnum(int key, String value) {
  20.         this.key = key;
  21.         this.value = value;
  22.     }
  24.     public int getKey() {
  25.         return key;
  26.     }
  28.     public String getValue() {
  29.         return value;
  30.     }
  31. }

3.2 ConcreteState

  1. public abstract class AbstractState implements State {
  3.     protected static final RuntimeException NO_ALLOW_EXCEPTION = new RuntimeException("操作流程不允许");
  5.     @Override
  6.     public void checkEvent(Context context) {
  7.         throw NO_ALLOW_EXCEPTION;
  8.     }
  10.     @Override
  11.     public void checkFailEvent(Context context) {
  12.         throw NO_ALLOW_EXCEPTION;
  13.     }
  15.     @Override
  16.     public void makePriceEvent(Context context) {
  17.         throw NO_ALLOW_EXCEPTION;
  18.     }
  20.     @Override
  21.     public void acceptOrderEvent(Context context) {
  22.         throw NO_ALLOW_EXCEPTION;
  23.     }
  25.     @Override
  26.     public void notPeopleAcceptEvent(Context context) {
  27.         throw NO_ALLOW_EXCEPTION;
  28.     }
  30.     @Override
  31.     public void payOrderEvent(Context context) {
  32.         throw NO_ALLOW_EXCEPTION;
  33.     }
  35.     @Override
  36.     public void orderFailureEvent(Context context) { 
  37.         throw NO_ALLOW_EXCEPTION;
  38.     }
  40.     @Override
  41.     public void feedBackEvent(Context context) {
  42.         throw NO_ALLOW_EXCEPTION;
  43.     }
  45.     @Override
  46.     public String getCurrentState() {
  47.         throw NO_ALLOW_EXCEPTION;
  48.     }
  49. }
  1. public class GenerateState extends AbstractState {
  3.     @Override
  4.     public void checkEvent(Context context) {
  5.         context.setState(new ReviewState());
  6.     }
  8.     @Override
  9.     public void checkFailEvent(Context context) {
  10.         context.setState(new FeedBackState());
  11.     }
  13.     @Override
  14.     public String getCurrentState() {
  15.         return StateEnum.GENERATE.getValue();
  16.     }
  17. }
  1. public class ReviewState extends AbstractState {
  3.     @Override
  4.     public void makePriceEvent(Context context) {
  5.         context.setState(new PublishState());
  6.     }
  8.     @Override
  9.     public String getCurrentState() {
  10.         return StateEnum.REVIEWED.getValue();
  11.     }
  12. }
  1. public class PublishState extends AbstractState {
  3.     @Override
  4.     public void acceptOrderEvent(Context context) {
  5.         context.setState(new NotPayState());
  6.     }
  8.     @Override
  9.     public void notPeopleAcceptEvent(Context context) {
  10.         context.setState(new FeedBackState());
  11.     }
  13.     @Override
  14.     public String getCurrentState() {
  15.         return StateEnum.PUBLISHED.getValue();
  16.     }
  17. }
  1. public class NotPayState extends AbstractState {
  3.     @Override
  4.     public void payOrderEvent(Context context) {
  5.         context.setState(new PaidState());
  6.     }
  8.     @Override
  9.     public void feedBackEvent(Context context) {
  10.         context.setState(new FeedBackState());
  11.     }
  13.     @Override
  14.     public String getCurrentState() {
  15.         return StateEnum.NOT_PAY.getValue();
  16.     }
  17. }
  1. public class PaidState extends AbstractState {
  3.     @Override
  4.     public void feedBackEvent(Context context) {
  5.         context.setState(new FeedBackState());
  6.     }
  8.     @Override
  9.     public String getCurrentState() {
  10.         return StateEnum.PAID.getValue();
  11.     }
  12. }
  1. public class FeedBackState extends AbstractState {
  3.     @Override
  4.     public String getCurrentState() {
  5.         return StateEnum.FEED_BACKED.getValue();
  6.     }
  7. }

3.3 Context

  1. public class Context implements State {
  3.     private State state;
  5.     @Override
  6.     public void checkEvent(Context context) {
  7.         state.checkEvent(this);
  8.         getCurrentState();
  9.     }
  11.     @Override
  12.     public void checkFailEvent(Context context) {
  13.         state.checkFailEvent(this);
  14.         getCurrentState();
  15.     }
  17.     @Override
  18.     public void makePriceEvent(Context context) {
  19.         state.makePriceEvent(this);
  20.         getCurrentState();
  21.     }
  23.     @Override
  24.     public void acceptOrderEvent(Context context) {
  25.         state.acceptOrderEvent(this);
  26.         getCurrentState();
  27.     }
  29.     @Override
  30.     public void notPeopleAcceptEvent(Context context) {
  31.         state.notPeopleAcceptEvent(this);
  32.         getCurrentState();
  33.     }
  35.     @Override
  36.     public void payOrderEvent(Context context) {
  37.         state.payOrderEvent(this);
  38.         getCurrentState();
  39.     }
  41.     @Override
  42.     public void orderFailureEvent(Context context) {
  43.         state.orderFailureEvent(this);
  44.         getCurrentState();
  45.     }
  47.     @Override
  48.     public void feedBackEvent(Context context) {
  49.         state.feedBackEvent(this);
  50.         getCurrentState();
  51.     }
  53.     @Override
  54.     public String getCurrentState() {
  55.         System.out.println("当前状态：" + state.getCurrentState());
  56.         return state.getCurrentState();
  57.     }
  59.     public State getState() {
  60.         return state;
  61.     }
  63.     public void setState(State state) { 
  64.         this.state = state;
  65.     }
  66. }

3.4 客户端调用

  1. public class Client {
  3.     public static void main(String[] args) {
  5.         Context context = new Context();
  6.         context.setState(new PublishState());
  8.         context.acceptOrderEvent(context);
  10.         context.payOrderEvent(context);
  12.         try {
  13.             context.checkFailEvent(context);
  14.             System.out.println("流程正常。。。");
  15.         } catch (Exception e) {
  16.             System.out.println(e.getMessage());
  17.         }
  18.     }
  19. }

4、适用场景

  • 一个对象的行为取决于它的状态，并且它必须在运行时刻根据状态来改变它的行为。
  • 一个操作中包含大量分支的条件语句，且这些分支依赖于该对象的状态，同时状态分支还有可能继续增加。

5、优缺点

5.1 优点
  • 封装了状态的转换规则，在状态模式中可以将状态的转换代码封装在环境类或者具体状态类中，可以对状态转换代码进行集中管理，而不是分散在一个个业务方法中。
  • 将所有与某个状态有关的行为放到一个类中，只需要注入一个不同的状态对象即可使环境对象拥有不同的行为。
  • 允许状态转换逻辑与状态对象合成一体，而不是提供一个巨大的条件语句块，状态模式可以让我们避免使用庞大的条件语句来将业务方法和状态转换代码交织在一起。
  • 可以让多个环境对象共享一个状态对象，从而减少系统中对象的个数。

5.2 缺点
  • 状态模式的使用必然会增加系统中类和对象的个数，导致系统运行开销增大。
  • 状态模式的结构与实现都较为复杂，如果使用不当将导致程序结构和代码的混乱，增加系统设计的难度。
  • 状态模式对“开闭原则”的支持并不太好，增加新的状态类增加修改那些负责状态转换的源代码，否则无法转换到新增状态；而且修改某个状态类的行为也需修改对应类的源代码。