极客时间《设计模式之美》笔记---状态模式

╰半橙微兮° 2022-08-31 12:30 269阅读 0赞

### 文章目录 ###

*  什么是有限状态机？
 *  实现方法一：分支实现法
 *  实现方法二：查表法
 *  实现方法三：状态模式

# 什么是有限状态机？ #

有限状态机，英文翻译是Finite State Machine，缩写为FSM，简称为状态机。状态机有3个组成部分：状态（State）、事件（Event）、动作（Action）。其中，**事件也称为转移条件（Transition Condition）。事件触发状态的转移及动作的执行。不过，动作不是必须的，也可能只转移状态，不执行任何动作**。

“超级马里奥”游戏不知道你玩过没有？在游戏中，马里奥可以变身为多种形态，比如小马里奥（Small Mario）、超级马里奥（Super Mario）、火焰马里奥（Fire Mario）、斗篷马里奥（Cape Mario）等等。在不同的游戏情节下，各个形态会互相转化，并相应的增减积分。比如，初始形态是小马里奥，吃了蘑菇之后就会变成超级马里奥，并且增加100积分。

实际上，马里奥形态的转变就是一个状态机。其中，马里奥的不同形态就是状态机中的“状态”，游戏情节（比如吃了蘑菇）就是状态机中的“事件”，加减积分就是状态机中的“动作”。比如，吃蘑菇这个事件，会触发状态的转移：从小马里奥转移到超级马里奥，以及触发动作的执行（增加100积分）。

为了方便接下来的讲解，我对游戏背景做了简化，只保留了部分状态和事件。简化之后的状态转移如下图所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdXNoZW5neGlfcm9vdA_size_16_color_FFFFFF_t_70]

# 实现方法一：分支实现法 #

package statepattern;
    
    public class MarioStateMachine { 
        private int score;
        private State currentState;
    
        public MarioStateMachine() { 
            this.score = 0;
            this.currentState = State.SMALL;
        }
    
        public void obtainMushRoom() { 
            //TODO
            this.score += 100;
            if (State.SMALL.equals(this.currentState)) { 
                this.currentState = State.SUPER;
            }
        }
    
        public void obtainCape() { 
            //TODO
            this.score += 200;
            if (State.SMALL.equals(this.currentState) || State.SUPER.equals(this.currentState)) { 
                this.currentState = State.CAPE;
            } else { 
                System.out.println("此时状态不可改变！！！");
            }
    
        }
    
        public void obtainFireFlower() { 
            //TODO
            this.score += 300;
            if (State.SMALL.equals(this.currentState) || State.SUPER.equals(this.currentState)) { 
                this.currentState = State.FIRE;
            } else { 
                System.out.println("此时状态不可改变！！！");
            }
        }
        public void meetMonster() { 
            //TODO
            if (State.FIRE.equals(this.currentState)) { 
                this.score -= 300;
                this.currentState = State.SMALL;
            } else if (State.SUPER.equals(this.currentState)) { 
                this.score -= 100;
                this.currentState = State.SMALL;
            } else if (State.CAPE.equals(this.currentState)) { 
                this.score -= 200;
                this.currentState = State.SMALL;
            } else { 
                System.out.println("此时状态不可改变！！！");
            }
        }
        public int getScore() { 
            return this.score;
        }
    
        public State getCurrentState() { 
            return this.currentState;
        }
    }

# 实现方法二：查表法 #

实际上，上面这种实现方法有点类似hard code，对于复杂的状态机来说不适用，而状态机的第二种实现方式查表法，就更加合适了。接下来，我们就一块儿来看下，如何利用查表法来补全骨架代码。

实际上，除了用状态转移图来表示之外，状态机还可以用二维表来表示，如下所示。在这个二维表中，第一维表示当前状态，第二维表示事件，值表示当前状态经过事件之后，转移到的新状态及其执行的动作。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdXNoZW5neGlfcm9vdA_size_16_color_FFFFFF_t_70 1]

public enum Event { 
      GOT_MUSHROOM(0),
      GOT_CAPE(1),
      GOT_FIRE(2),
      MET_MONSTER(3);
    
      private int value;
    
      private Event(int value) { 
        this.value = value;
      }
    
      public int getValue() { 
        return this.value;
      }
    }
    
    public class MarioStateMachine { 
      private int score;
      private State currentState;
    
      private static final State[][] transitionTable = { 
              { SUPER, CAPE, FIRE, SMALL},
              { SUPER, CAPE, FIRE, SMALL},
              { CAPE, CAPE, CAPE, SMALL},
              { FIRE, FIRE, FIRE, SMALL}
      };
    
      private static final int[][] actionTable = { 
              { +100, +200, +300, +0},
              { +0, +200, +300, -100},
              { +0, +0, +0, -200},
              { +0, +0, +0, -300}
      };
    
      public MarioStateMachine() { 
        this.score = 0;
        this.currentState = State.SMALL;
      }
    
      public void obtainMushRoom() { 
        executeEvent(Event.GOT_MUSHROOM);
      }
    
      public void obtainCape() { 
        executeEvent(Event.GOT_CAPE);
      }
    
      public void obtainFireFlower() { 
        executeEvent(Event.GOT_FIRE);
      }
    
      public void meetMonster() { 
        executeEvent(Event.MET_MONSTER);
      }
    
      private void executeEvent(Event event) { 
        int stateValue = currentState.getValue();
        int eventValue = event.getValue();
        this.currentState = transitionTable[stateValue][eventValue];
        this.score += actionTable[stateValue][eventValue];
      }
    
      public int getScore() { 
        return this.score;
      }
    
      public State getCurrentState() { 
        return this.currentState;
      }
      
    }

# 实现方法三：状态模式 #

但是在查表法的代码实现中，事件触发的动作只是简单的积分加减，所以，我们用一个int类型的二维数组actionTable就能表示，二维数组中的值表示积分的加减值。但是，如果要执行的动作并非这么简单，而是一系列复杂的逻辑操作（**比如加减积分、写数据库，还有可能发送消息通知等等），我们就没法用如此简单的二维数组来表示了**。这也就是说，查表法的实现方式有一定局限性。

虽然分支逻辑的实现方式不存在这个问题，但它又存在前面讲到的其他问题，比如分支判断逻辑较多，导致代码可读性和可维护性不好等。实际上，针对分支逻辑法存在的问题，我们可以使用状态模式来解决。

状态模式通过将事件触发的状态转移和动作执行，拆分到不同的状态类中，来避免分支判断逻辑。我们还是结合代码来理解这句话。

利用状态模式，我们来补全MarioStateMachine类，补全后的代码如下所示。

其中，**IMario是状态的接口，定义了所有的事件。SmallMario、SuperMario、CapeMario、FireMario是IMario接口的实现类，分别对应状态机中的4个状态。原来所有的状态转移和动作执行的代码逻辑，都集中在MarioStateMachine类中，现在，这些代码逻辑被分散到了这4个状态类中**。

public interface IMario {  //所有状态类的接口
      State getName();
      //以下是定义的事件
      void obtainMushRoom();
      void obtainCape();
      void obtainFireFlower();
      void meetMonster();
    }
    
    public class SmallMario implements IMario { 
      private MarioStateMachine stateMachine;
    
      public SmallMario(MarioStateMachine stateMachine) { 
        this.stateMachine = stateMachine;
      }
    
      @Override
      public State getName() { 
        return State.SMALL;
      }
    
      @Override
      public void obtainMushRoom() { 
        stateMachine.setCurrentState(new SuperMario(stateMachine));
        stateMachine.setScore(stateMachine.getScore() + 100);
      }
    
      @Override
      public void obtainCape() { 
        stateMachine.setCurrentState(new CapeMario(stateMachine));
        stateMachine.setScore(stateMachine.getScore() + 200);
      }
    
      @Override
      public void obtainFireFlower() { 
        stateMachine.setCurrentState(new FireMario(stateMachine));
        stateMachine.setScore(stateMachine.getScore() + 300);
      }
    
      @Override
      public void meetMonster() { 
        // do nothing...
      }
    }
    
    public class SuperMario implements IMario { 
      private MarioStateMachine stateMachine;
    
      public SuperMario(MarioStateMachine stateMachine) { 
        this.stateMachine = stateMachine;
      }
    
      @Override
      public State getName() { 
        return State.SUPER;
      }
    
      @Override
      public void obtainMushRoom() { 
        // do nothing...
      }
    
      @Override
      public void obtainCape() { 
        stateMachine.setCurrentState(new CapeMario(stateMachine));
        stateMachine.setScore(stateMachine.getScore() + 200);
      }
    
      @Override
      public void obtainFireFlower() { 
        stateMachine.setCurrentState(new FireMario(stateMachine));
        stateMachine.setScore(stateMachine.getScore() + 300);
      }
    
      @Override
      public void meetMonster() { 
        stateMachine.setCurrentState(new SmallMario(stateMachine));
        stateMachine.setScore(stateMachine.getScore() - 100);
      }
    }
    
    // 省略CapeMario、FireMario类...
    
    public class MarioStateMachine { 
      private int score;
      private IMario currentState; // 不再使用枚举来表示状态
    
      public MarioStateMachine() { 
        this.score = 0;
        this.currentState = new SmallMario(this);
      }
    
      public void obtainMushRoom() { 
        this.currentState.obtainMushRoom();
      }
    
      public void obtainCape() { 
        this.currentState.obtainCape();
      }
    
      public void obtainFireFlower() { 
        this.currentState.obtainFireFlower();
      }
    
      public void meetMonster() { 
        this.currentState.meetMonster();
      }
    
      public int getScore() { 
        return this.score;
      }
    
      public State getCurrentState() { 
        return this.currentState.getName();
      }
    
      public void setScore(int score) { 
        this.score = score;
      }
    
      public void setCurrentState(IMario currentState) { 
        this.currentState = currentState;
      }
    }

实际上，上面的代码还可以继续优化，我们可以将状态类设计成单例，毕竟状态类中不包含任何成员变量。但是，当将状态类设计成单例之后，我们就无法通过构造函数来传递MarioStateMachine了，而状态类又要依赖MarioStateMachine，那该如何解决这个问题呢？

public interface IMario { 
      State getName();
      void obtainMushRoom(MarioStateMachine stateMachine);
      void obtainCape(MarioStateMachine stateMachine);
      void obtainFireFlower(MarioStateMachine stateMachine);
      void meetMonster(MarioStateMachine stateMachine);
    }
    
    public class SmallMario implements IMario { 
      private static final SmallMario instance = new SmallMario();
      private SmallMario() { }
      public static SmallMario getInstance() { 
        return instance;
      }
    
      @Override
      public State getName() { 
        return State.SMALL;
      }
    
      @Override
      public void obtainMushRoom(MarioStateMachine stateMachine) { 
        stateMachine.setCurrentState(SuperMario.getInstance());
        stateMachine.setScore(stateMachine.getScore() + 100);
      }
    
      @Override
      public void obtainCape(MarioStateMachine stateMachine) { 
        stateMachine.setCurrentState(CapeMario.getInstance());
        stateMachine.setScore(stateMachine.getScore() + 200);
      }
    
      @Override
      public void obtainFireFlower(MarioStateMachine stateMachine) { 
        stateMachine.setCurrentState(FireMario.getInstance());
        stateMachine.setScore(stateMachine.getScore() + 300);
      }
    
      @Override
      public void meetMonster(MarioStateMachine stateMachine) { 
        // do nothing...
      }
    }
    
    // 省略SuperMario、CapeMario、FireMario类...
    
    public class MarioStateMachine { 
      private int score;
      private IMario currentState;
    
      public MarioStateMachine() { 
        this.score = 0;
        this.currentState = SmallMario.getInstance();
      }
    
      public void obtainMushRoom() { 
        this.currentState.obtainMushRoom(this);
      }
    
      public void obtainCape() { 
        this.currentState.obtainCape(this);
      }
    
      public void obtainFireFlower() { 
        this.currentState.obtainFireFlower(this);
      }
    
      public void meetMonster() { 
        this.currentState.meetMonster(this);
      }
    
      public int getScore() { 
        return this.score;
      }
    
      public State getCurrentState() { 
        return this.currentState.getName();
      }
    
      public void setScore(int score) { 
        this.score = score;
      }
    
      public void setCurrentState(IMario currentState) { 
        this.currentState = currentState;
      }
    }

**实际上，像游戏这种比较复杂的状态机，包含的状态比较多，我优先推荐使用查表法，而状态模式会引入非常多的状态类，会导致代码比较难维护。相反，像电商下单、外卖下单这种类型的状态机，它们的状态并不多，状态转移也比较简单，但事件触发执行的动作包含的业务逻辑可能会比较复杂，所以，更加推荐使用状态模式来实现。**

*  第一种实现方式叫分支逻辑法。利用if-else或者switch-case分支逻辑，参照状态转移图，将每一个状态转移原模原样地直译成代码。对于简单的状态机来说，这种实现方式最简单、最直接，是首选。
 *  第二种实现方式叫查表法。对于状态很多、状态转移比较复杂的状态机来说，查表法比较合适。通过二维数组来表示状态转移图，能极大地提高代码的可读性和可维护性。
 *  第三种实现方式叫状态模式。对于状态并不多、状态转移也比较简单，但事件触发执行的动作包含的业务逻辑可能比较复杂的状态机来说，我们首选这种实现方式。

在工作的时候，设置了一个超级复杂的状态转换机，现在想想其实它是属于**状态很多、状态转移比较复杂，没有事件触发会执行业务逻辑，只会进行状态的变动，每种状态会被允许做一些对应的操作**的情况，**应该使用查表法来表示，目前使用的是状态模式，在做改动的时候还是非常难操作，有很多地方都不太好把握住**。类比到下图中的 / 就应该是：

DrillTaskStatusEnum transferredStatus = state.transfer(drillTaskInstrumentEnum);
            if (transferredStatus == DrillTaskStatusEnum.UNDEFINED) { 
                throw new DrillStatusTransferException("修改任务状态失败，当前状态 = " + currentStatus + ", 不支持操作 = " + drillTaskInstrumentEnum.getDesc() + ", taskId = " + taskId);
            }

未定义状态，报错即可！！！  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdXNoZW5neGlfcm9vdA_size_16_color_FFFFFF_t_70 1]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdXNoZW5neGlfcm9vdA_size_16_color_FFFFFF_t_70]: /images/20220829/bf584e68077e4fb798aee194e13bfc92.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdXNoZW5neGlfcm9vdA_size_16_color_FFFFFF_t_70 1]: /images/20220829/67f8eb752a90494093b0f1e354305407.png