• 创建型设计模式主要解决“对象的创建”问题
  • 结构型设计模式主要解决“类或对象的组合或组装”问题
  • 行为型设计模式主要解决的就是“类或对象之间的交互”问题

观察者模式

观察者模式也被称为发布订阅模式, 在对象之间定义一个一对多的依赖，当一个对象状态改变的时候，所有依赖的对象都会自动收到通知。

  2. public interface Subject {
  3.   void registerObserver(Observer observer);
  4.   void removeObserver(Observer observer);
  5.   void notifyObservers(Message message);
  6. }
  8. public interface Observer {
  9.   void update(Message message);
  10. }
  12. public class ConcreteSubject implements Subject {
  13.   private List<Observer> observers = new ArrayList<Observer>();
  15.   @Override
  16.   public void registerObserver(Observer observer) {
  17.     observers.add(observer);
  18.   }
  20.   @Override
  21.   public void removeObserver(Observer observer) {
  22.     observers.remove(observer);
  23.   }
  25.   @Override
  26.   public void notifyObservers(Message message) {
  27.     for (Observer observer : observers) {
  28.       observer.update(message);
  29.     }
  30.   }
  32. }
  34. public class ConcreteObserverOne implements Observer {
  35.   @Override
  36.   public void update(Message message) {
  37.     //TODO: 获取消息通知，执行自己的逻辑...
  38.     System.out.println("ConcreteObserverOne is notified.");
  39.   }
  40. }
  42. public class ConcreteObserverTwo implements Observer {
  43.   @Override
  44.   public void update(Message message) {
  45.     //TODO: 获取消息通知，执行自己的逻辑...
  46.     System.out.println("ConcreteObserverTwo is notified.");
  47.   }
  48. }
  50. public class Demo {
  51.   public static void main(String[] args) {
  52.     ConcreteSubject subject = new ConcreteSubject();
  53.     subject.registerObserver(new ConcreteObserverOne());
  54.     subject.registerObserver(new ConcreteObserverTwo());
  55.     subject.notifyObservers(new Message());
  56.   }
  57. }

设计模式要干的事情就是解耦。
创建型模式是将创建和使用代码解耦，结构型模式是将不同功能代码解耦，行为型模式是将不同的行为代码解耦，具体到观察者模式，它是将观察者和被观察者代码解耦。

借助设计模式，我们利用更好的代码结构，将一大坨代码拆分成职责更单一的小类，让其满足开闭原则、高内聚松耦合等特性，以此来控制和应对代码的复杂性，提高代码的可扩展性。

模板模式

模板方法模式在一个方法中定义一个算法骨架，并将某些步骤推迟到子类中实现。模板方法模式可以让子类在不改变算法整体结构的情况下，重新定义算法中的某些步骤。

这里的“算法”，我们可以理解为广义上的“业务逻辑”，并不特指数据结构和算法中的“算法”。这里的算法骨架就是“模板”，包含算法骨架的方法就是“模板方法”，这也是模板方法模式名字的由来。

模板模式有两大作用：复用和扩展。其中，复用指的是，所有的子类可以复用父类中提供的模板方法的代码。扩展指的是，框架通过模板模式提供功能扩展点，让框架用户可以在不修改框架源码的情况下，基于扩展点定制化框架的功能。

  2. public abstract class AbstractClass {
  3.   public final void templateMethod() {
  4.     //...
  5.     method1();
  6.     //...
  7.     method2();
  8.     //...
  9.   }
  11.   protected abstract void method1();
  12.   protected abstract void method2();
  13. }
  15. public class ConcreteClass1 extends AbstractClass {
  16.   @Override
  17.   protected void method1() {
  18.     //...
  19.   }
  21.   @Override
  22.   protected void method2() {
  23.     //...
  24.   }
  25. }
  27. public class ConcreteClass2 extends AbstractClass {
  28.   @Override
  29.   protected void method1() {
  30.     //...
  31.   }
  33.   @Override
  34.   protected void method2() {
  35.     //...
  36.   }
  37. }
  39. AbstractClass demo = ConcreteClass1();
  40. demo.templateMethod();

策略模式

策略模式定义一族算法类，将每个算法分别封装起来，让它们可以互相替换。策略模式可以使算法的变化独立于使用它们的客户端（这里的客户端代指使用算法的代码）。

通过策略模式来移除If/else或switch的分支判断逻辑
示例代码

  1. public class OrderService {
  2.   public double discount(Order order) {
  3.     double discount = 0.0;
  4.     OrderType type = order.getType();
  5.     if (type.equals(OrderType.NORMAL)) { // 普通订单
  6.       //...省略折扣计算算法代码
  7.     } else if (type.equals(OrderType.GROUPON)) { // 团购订单
  8.       //...省略折扣计算算法代码
  9.     } else if (type.equals(OrderType.PROMOTION)) { // 促销订单
  10.       //...省略折扣计算算法代码
  11.     }
  12.     return discount;
  13.   }
  14. }

使用策略模式+工厂方法模式优化后

  1. // 策略的定义
  2. public interface DiscountStrategy {
  3.   double calDiscount(Order order);
  4. }
  5. // 省略NormalDiscountStrategy、GrouponDiscountStrategy、PromotionDiscountStrategy类代码...
  7. // 策略的创建
  8. public class DiscountStrategyFactory {
  9.   private static final Map<OrderType, DiscountStrategy> strategies = new HashMap<>();
  11.   static {
  12.     strategies.put(OrderType.NORMAL, new NormalDiscountStrategy());
  13.     strategies.put(OrderType.GROUPON, new GrouponDiscountStrategy());
  14.     strategies.put(OrderType.PROMOTION, new PromotionDiscountStrategy());
  15.   }
  17.   public static DiscountStrategy getDiscountStrategy(OrderType type) {
  18.     return strategies.get(type);
  19.   }
  20. }
  22. // 策略的使用
  23. public class OrderService {
  24.   public double discount(Order order) {
  25.     OrderType type = order.getType();
  26.     DiscountStrategy discountStrategy = DiscountStrategyFactory.getDiscountStrategy(type);
  27.     return discountStrategy.calDiscount(order);
  28.   }
  29. }

职责链模式

将请求的发送和接收解耦，让多个接收对象都有机会处理这个请求。将这些接收对象串成一条链，并沿着这条链传递这个请求，直到链上的某个接收对象能够处理它为止。

在职责链模式中，多个处理器（也就是刚刚定义中说的“接收对象”）依次处理同一个请求。一个请求先经过 A 处理器处理，然后再把请求传递给 B 处理器，B 处理器处理完后再传递给 C 处理器，以此类推，形成一个链条。链条上的每个处理器各自承担各自的处理职责，所以叫作职责链模式。

也可以有变种, 比如springSecurity, 经过所有的校验器, 只要有一个成功就成功.

示例代码:

  2. public interface IHandler {
  3.   boolean handle();
  4. }
  6. public class HandlerA implements IHandler {
  7.   @Override
  8.   public boolean handle() {
  9.     boolean handled = false;
  10.     //...
  11.     return handled;
  12.   }
  13. }
  15. public class HandlerB implements IHandler {
  16.   @Override
  17.   public boolean handle() {
  18.     boolean handled = false;
  19.     //...
  20.     return handled;
  21.   }
  22. }
  24. public class HandlerChain {
  25.   private List<IHandler> handlers = new ArrayList<>();
  27.   public void addHandler(IHandler handler) {
  28.     this.handlers.add(handler);
  29.   }
  31.   public void handle() {
  32.     for (IHandler handler : handlers) {
  33.       boolean handled = handler.handle();
  34.       if (handled) {
  35.         break;
  36.       }
  37.     }
  38.   }
  39. }
  41. // 使用举例
  42. public class Application {
  43.   public static void main(String[] args) {
  44.     HandlerChain chain = new HandlerChain();
  45.     chain.addHandler(new HandlerA());
  46.     chain.addHandler(new HandlerB());
  47.     chain.handle();
  48.   }
  49. }

可以利用spring的IOC在HandlerChain做非常方便的构造方法注入:

  1. @Component
  2. public class HandlerChain {
  3.     private final List<Handler> HANDLERS = new ArrayList<>();
  5.     public HandlerChain(List<Handler> handlers) {
  6.         HANDLERS.addAll(handlers);
  7.     }
  9.     public void handle() {
  10.         for (Handler handler : HANDLERS) {
  11.             if (handler.handle()) {
  12.                 break;
  13.             }
  14.         }
  15.     }
  16. }

职责链模式在Servlet Filter中的应用
Servlet Filter 是 Java Servlet 规范中定义的组件
使用示例

  2. public class LogFilter implements Filter {
  3.   @Override
  4.   public void init(FilterConfig filterConfig) throws ServletException {
  5.     // 在创建Filter时自动调用，
  6.     // 其中filterConfig包含这个Filter的配置参数，比如name之类的（从配置文件中读取的）
  7.   }
  9.   @Override
  10.   public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
  11.     System.out.println("拦截客户端发送来的请求.");
  12.     chain.doFilter(request, response);
  13.     System.out.println("拦截发送给客户端的响应.");
  14.   }
  16.   @Override
  17.   public void destroy() {
  18.     // 在销毁Filter时自动调用
  19.   }
  20. }
  22. // 在web.xml配置文件中如下配置：
  23. <filter>
  24.   <filter-name>logFilter</filter-name>
  25.   <filter-class>com.xzg.cd.LogFilter</filter-class>
  26. </filter>
  27. <filter-mapping>
  28.     <filter-name>logFilter</filter-name>
  29.     <url-pattern>/*</url-pattern>
  30. </filter-mapping>

ApplicationFilterChain 类就是 Tomcat 提供的 FilterChain 的实现类，源码如下所示。

  2. public final class ApplicationFilterChain implements FilterChain {
  3.   private int pos = 0; //当前执行到了哪个filter
  4.   private int n; //filter的个数
  5.   private ApplicationFilterConfig[] filters;
  6.   private Servlet servlet;
  8.   @Override
  9.   public void doFilter(ServletRequest request, ServletResponse response) {
  10.     if (pos < n) {
  11.       ApplicationFilterConfig filterConfig = filters[pos++];
  12.       Filter filter = filterConfig.getFilter();
  13.       filter.doFilter(request, response, this);
  14.     } else {
  15.       // filter都处理完毕后，执行servlet
  16.       servlet.service(request, response);
  17.     }
  18.   }
  20.   public void addFilter(ApplicationFilterConfig filterConfig) {
  21.     for (ApplicationFilterConfig filter:filters)
  22.       if (filter==filterConfig)
  23.          return;
  25.     if (n == filters.length) {//扩容
  26.       ApplicationFilterConfig[] newFilters = new ApplicationFilterConfig[n + INCREMENT];
  27.       System.arraycopy(filters, 0, newFilters, 0, n);
  28.       filters = newFilters;
  29.     }
  30.     filters[n++] = filterConfig;
  31.   }
  32. }

职责链模式在Spring Interceptor中的应用
Servlet Filter 是 Servlet 规范的一部分，实现依赖于 Web 容器。Spring Interceptor 是 Spring MVC 框架的一部分，由 Spring MVC 框架来提供实现。客户端发送的请求，会先经过 Servlet Filter，然后再经过 Spring Interceptor，
使用示例

  2. public class LogInterceptor implements HandlerInterceptor {
  4.   @Override
  5.   public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
  6.     System.out.println("拦截客户端发送来的请求.");
  7.     return true; // 继续后续的处理
  8.   }
  10.   @Override
  11.   public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
  12.     System.out.println("拦截发送给客户端的响应.");
  13.   }
  15.   @Override
  16.   public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
  17.     System.out.println("这里总是被执行.");
  18.   }
  19. }
  21. //在Spring MVC配置文件中配置interceptors
  22. <mvc:interceptors>
  23.    <mvc:interceptor>
  24.        <mvc:mapping path="/*"/>
  25.        <bean class="com.xzg.cd.LogInterceptor" />
  26.    </mvc:interceptor>
  27. </mvc:interceptors>

HandlerExecutionChain 的源码如下

  2. public class HandlerExecutionChain {
  3.  private final Object handler;
  4.  private HandlerInterceptor[] interceptors;
  6.  public void addInterceptor(HandlerInterceptor interceptor) {
  7.   initInterceptorList().add(interceptor);
  8.  }
  10.  boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response) throws Exception {
  11.   HandlerInterceptor[] interceptors = getInterceptors();
  12.   if (!ObjectUtils.isEmpty(interceptors)) {
  13.    for (int i = 0; i < interceptors.length; i++) {
  14.     HandlerInterceptor interceptor = interceptors[i];
  15.     if (!interceptor.preHandle(request, response, this.handler)) {
  16.      triggerAfterCompletion(request, response, null);
  17.      return false;
  18.     }
  19.    }
  20.   }
  21.   return true;
  22.  }
  24.  void applyPostHandle(HttpServletRequest request, HttpServletResponse response, ModelAndView mv) throws Exception {
  25.   HandlerInterceptor[] interceptors = getInterceptors();
  26.   if (!ObjectUtils.isEmpty(interceptors)) {
  27.    for (int i = interceptors.length - 1; i >= 0; i--) {
  28.     HandlerInterceptor interceptor = interceptors[i];
  29.     interceptor.postHandle(request, response, this.handler, mv);
  30.    }
  31.   }
  32.  }
  34.  void triggerAfterCompletion(HttpServletRequest request, HttpServletResponse response, Exception ex)
  35.    throws Exception {
  36.   HandlerInterceptor[] interceptors = getInterceptors();
  37.   if (!ObjectUtils.isEmpty(interceptors)) {
  38.    for (int i = this.interceptorIndex; i >= 0; i--) {
  39.     HandlerInterceptor interceptor = interceptors[i];
  40.     try {
  41.      interceptor.afterCompletion(request, response, this.handler, ex);
  42.     } catch (Throwable ex2) {
  43.      logger.error("HandlerInterceptor.afterCompletion threw exception", ex2);
  44.     }
  45.    }
  46.   }
  47.  }
  48. }

那在项目开发中，类似权限这样的访问控制功能，我们该选择三者（AOP、Servlet Filter、Spring Interceptor）中的哪个来实现呢？有什么参考标准吗？

三者应用范围不同: web filter 作用于容器，应用范围影响最大；spring interceptor 作用于框架，范围影响适中；aop 作用于业务逻辑，精细化处理，范围影响最小。

状态模式

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

状态机示例:
设计模式: 行为型(上) - 图1
骨架代码:

  2. public enum State {
  3.   SMALL(0),
  4.   SUPER(1),
  5.   FIRE(2),
  6.   CAPE(3);
  8.   private int value;
  10.   private State(int value) {
  11.     this.value = value;
  12.   }
  14.   public int getValue() {
  15.     return this.value;
  16.   }
  17. }
  19. public class MarioStateMachine {
  20.   private int score;
  21.   private State currentState;
  23.   public MarioStateMachine() {
  24.     this.score = 0;
  25.     this.currentState = State.SMALL;
  26.   }
  28.   public void obtainMushRoom() {
  29.     //TODO
  30.   }
  32.   public void obtainCape() {
  33.     //TODO
  34.   }
  36.   public void obtainFireFlower() {
  37.     //TODO
  38.   }
  40.   public void meetMonster() {
  41.     //TODO
  42.   }
  44.   public int getScore() {
  45.     return this.score;
  46.   }
  48.   public State getCurrentState() {
  49.     return this.currentState;
  50.   }
  51. }
  53. public class ApplicationDemo {
  54.   public static void main(String[] args) {
  55.     MarioStateMachine mario = new MarioStateMachine();
  56.     mario.obtainMushRoom();
  57.     int score = mario.getScore();
  58.     State state = mario.getCurrentState();
  59.     System.out.println("mario score: " + score + "; state: " + state);
  60.   }
  61. }

状态机实现方式一：分支逻辑法

  2. public class MarioStateMachine {
  3.   private int score;
  4.   private State currentState;
  6.   public MarioStateMachine() {
  7.     this.score = 0;
  8.     this.currentState = State.SMALL;
  9.   }
  11.   public void obtainMushRoom() {
  12.     if (currentState.equals(State.SMALL)) {
  13.       this.currentState = State.SUPER;
  14.       this.score += 100;
  15.     }
  16.   }
  18.   public void obtainCape() {
  19.     if (currentState.equals(State.SMALL) || currentState.equals(State.SUPER) ) {
  20.       this.currentState = State.CAPE;
  21.       this.score += 200;
  22.     }
  23.   }
  25.   public void obtainFireFlower() {
  26.     if (currentState.equals(State.SMALL) || currentState.equals(State.SUPER) ) {
  27.       this.currentState = State.FIRE;
  28.       this.score += 300;
  29.     }
  30.   }
  32.   public void meetMonster() {
  33.     if (currentState.equals(State.SUPER)) {
  34.       this.currentState = State.SMALL;
  35.       this.score -= 100;
  36.       return;
  37.     }
  39.     if (currentState.equals(State.CAPE)) {
  40.       this.currentState = State.SMALL;
  41.       this.score -= 200;
  42.       return;
  43.     }
  45.     if (currentState.equals(State.FIRE)) {
  46.       this.currentState = State.SMALL;
  47.       this.score -= 300;
  48.       return;
  49.     }
  50.   }
  52.   public int getScore() {
  53.     return this.score;
  54.   }
  56.   public State getCurrentState() {
  57.     return this.currentState;
  58.   }
  59. }

状态机实现方式二：查表法
设计模式: 行为型(上) - 图2

  2. public enum Event {
  3.   GOT_MUSHROOM(0),
  4.   GOT_CAPE(1),
  5.   GOT_FIRE(2),
  6.   MET_MONSTER(3);
  8.   private int value;
  10.   private Event(int value) {
  11.     this.value = value;
  12.   }
  14.   public int getValue() {
  15.     return this.value;
  16.   }
  17. }
  19. public class MarioStateMachine {
  20.   private int score;
  21.   private State currentState;
  23.   private static final State[][] transitionTable = {
  24.           {SUPER, CAPE, FIRE, SMALL},
  25.           {SUPER, CAPE, FIRE, SMALL},
  26.           {CAPE, CAPE, CAPE, SMALL},
  27.           {FIRE, FIRE, FIRE, SMALL}
  28.   };
  30.   private static final int[][] actionTable = {
  31.           {+100, +200, +300, +0},
  32.           {+0, +200, +300, -100},
  33.           {+0, +0, +0, -200},
  34.           {+0, +0, +0, -300}
  35.   };
  37.   public MarioStateMachine() {
  38.     this.score = 0;
  39.     this.currentState = State.SMALL;
  40.   }
  42.   public void obtainMushRoom() {
  43.     executeEvent(Event.GOT_MUSHROOM);
  44.   }
  46.   public void obtainCape() {
  47.     executeEvent(Event.GOT_CAPE);
  48.   }
  50.   public void obtainFireFlower() {
  51.     executeEvent(Event.GOT_FIRE);
  52.   }
  54.   public void meetMonster() {
  55.     executeEvent(Event.MET_MONSTER);
  56.   }
  58.   private void executeEvent(Event event) {
  59.     int stateValue = currentState.getValue();
  60.     int eventValue = event.getValue();
  61.     this.currentState = transitionTable[stateValue][eventValue];
  62.     this.score += actionTable[stateValue][eventValue];
  63.   }
  65.   public int getScore() {
  66.     return this.score;
  67.   }
  69.   public State getCurrentState() {
  70.     return this.currentState;
  71.   }
  73. }

状态机实现方式三：状态模式

  2. public interface IMario { //所有状态类的接口
  3.   State getName();
  4.   //以下是定义的事件
  5.   void obtainMushRoom();
  6.   void obtainCape();
  7.   void obtainFireFlower();
  8.   void meetMonster();
  9. }
  11. public class SmallMario implements IMario {
  12.   private MarioStateMachine stateMachine;
  14.   public SmallMario(MarioStateMachine stateMachine) {
  15.     this.stateMachine = stateMachine;
  16.   }
  18.   @Override
  19.   public State getName() {
  20.     return State.SMALL;
  21.   }
  23.   @Override
  24.   public void obtainMushRoom() {
  25.     stateMachine.setCurrentState(new SuperMario(stateMachine));
  26.     stateMachine.setScore(stateMachine.getScore() + 100);
  27.   }
  29.   @Override
  30.   public void obtainCape() {
  31.     stateMachine.setCurrentState(new CapeMario(stateMachine));
  32.     stateMachine.setScore(stateMachine.getScore() + 200);
  33.   }
  35.   @Override
  36.   public void obtainFireFlower() {
  37.     stateMachine.setCurrentState(new FireMario(stateMachine));
  38.     stateMachine.setScore(stateMachine.getScore() + 300);
  39.   }
  41.   @Override
  42.   public void meetMonster() {
  43.     // do nothing...
  44.   }
  45. }
  47. public class SuperMario implements IMario {
  48.   private MarioStateMachine stateMachine;
  50.   public SuperMario(MarioStateMachine stateMachine) {
  51.     this.stateMachine = stateMachine;
  52.   }
  54.   @Override
  55.   public State getName() {
  56.     return State.SUPER;
  57.   }
  59.   @Override
  60.   public void obtainMushRoom() {
  61.     // do nothing...
  62.   }
  64.   @Override
  65.   public void obtainCape() {
  66.     stateMachine.setCurrentState(new CapeMario(stateMachine));
  67.     stateMachine.setScore(stateMachine.getScore() + 200);
  68.   }
  70.   @Override
  71.   public void obtainFireFlower() {
  72.     stateMachine.setCurrentState(new FireMario(stateMachine));
  73.     stateMachine.setScore(stateMachine.getScore() + 300);
  74.   }
  76.   @Override
  77.   public void meetMonster() {
  78.     stateMachine.setCurrentState(new SmallMario(stateMachine));
  79.     stateMachine.setScore(stateMachine.getScore() - 100);
  80.   }
  81. }
  83. // 省略CapeMario、FireMario类...
  85. public class MarioStateMachine {
  86.   private int score;
  87.   private IMario currentState; // 不再使用枚举来表示状态
  89.   public MarioStateMachine() {
  90.     this.score = 0;
  91.     this.currentState = new SmallMario(this);
  92.   }
  94.   public void obtainMushRoom() {
  95.     this.currentState.obtainMushRoom();
  96.   }
  98.   public void obtainCape() {
  99.     this.currentState.obtainCape();
  100.   }
  102.   public void obtainFireFlower() {
  103.     this.currentState.obtainFireFlower();
  104.   }
  106.   public void meetMonster() {
  107.     this.currentState.meetMonster();
  108.   }
  110.   public int getScore() {
  111.     return this.score;
  112.   }
  114.   public State getCurrentState() {
  115.     return this.currentState.getName();
  116.   }
  118.   public void setScore(int score) {
  119.     this.score = score;
  120.   }
  122.   public void setCurrentState(IMario currentState) {
  123.     this.currentState = currentState;
  124.   }
  125. }

实际上，上面的代码还可以继续优化，我们可以将状态类设计成单例，毕竟状态类中不包含任何成员变量。在这里，我们可以通过函数参数将 MarioStateMachine 传递进状态类。

  2. public interface IMario {
  3.   State getName();
  4.   void obtainMushRoom(MarioStateMachine stateMachine);
  5.   void obtainCape(MarioStateMachine stateMachine);
  6.   void obtainFireFlower(MarioStateMachine stateMachine);
  7.   void meetMonster(MarioStateMachine stateMachine);
  8. }
  10. public class SmallMario implements IMario {
  11.   private static final SmallMario instance = new SmallMario();
  12.   private SmallMario() {}
  13.   public static SmallMario getInstance() {
  14.     return instance;
  15.   }
  17.   @Override
  18.   public State getName() {
  19.     return State.SMALL;
  20.   }
  22.   @Override
  23.   public void obtainMushRoom(MarioStateMachine stateMachine) {
  24.     stateMachine.setCurrentState(SuperMario.getInstance());
  25.     stateMachine.setScore(stateMachine.getScore() + 100);
  26.   }
  28.   @Override
  29.   public void obtainCape(MarioStateMachine stateMachine) {
  30.     stateMachine.setCurrentState(CapeMario.getInstance());
  31.     stateMachine.setScore(stateMachine.getScore() + 200);
  32.   }
  34.   @Override
  35.   public void obtainFireFlower(MarioStateMachine stateMachine) {
  36.     stateMachine.setCurrentState(FireMario.getInstance());
  37.     stateMachine.setScore(stateMachine.getScore() + 300);
  38.   }
  40.   @Override
  41.   public void meetMonster(MarioStateMachine stateMachine) {
  42.     // do nothing...
  43.   }
  44. }
  46. // 省略SuperMario、CapeMario、FireMario类...
  48. public class MarioStateMachine {
  49.   private int score;
  50.   private IMario currentState;
  52.   public MarioStateMachine() {
  53.     this.score = 0;
  54.     this.currentState = SmallMario.getInstance();
  55.   }
  57.   public void obtainMushRoom() {
  58.     this.currentState.obtainMushRoom(this);
  59.   }
  61.   public void obtainCape() {
  62.     this.currentState.obtainCape(this);
  63.   }
  65.   public void obtainFireFlower() {
  66.     this.currentState.obtainFireFlower(this);
  67.   }
  69.   public void meetMonster() {
  70.     this.currentState.meetMonster(this);
  71.   }
  73.   public int getScore() {
  74.     return this.score;
  75.   }
  77.   public State getCurrentState() {
  78.     return this.currentState.getName();
  79.   }
  81.   public void setScore(int score) {
  82.     this.score = score;
  83.   }
  85.   public void setCurrentState(IMario currentState) {
  86.     this.currentState = currentState;
  87.   }
  88. }

针对状态机，今天我们总结了三种实现方式。

  • 第一种实现方式叫分支逻辑法。

利用 if-else 或者 switch-case 分支逻辑，参照状态转移图，将每一个状态转移原模原样地直译成代码。对于简单的状态机来说，这种实现方式最简单、最直接，是首选。

  • 第二种实现方式叫查表法。

对于状态很多、状态转移比较复杂的状态机来说，查表法比较合适。通过二维数组来表示状态转移图，能极大地提高代码的可读性和可维护性。

  • 第三种实现方式叫状态模式。

对于状态并不多、状态转移也比较简单，但事件触发执行的动作包含的业务逻辑可能比较复杂的状态机来说，我们首选这种实现方式。

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