state模式

场景 （1）销售出库单，状态需要从新建、待审批、已审批、已完成，四个状态之间流转，流转到每个状态的时候，都需要执行那个状态对应的一个逻辑

1.状态模式

  1. package com.example.demo.pattern.state;
  2. /**
  3.  * @author chenchao
  4.  * @date 2021/11/9
  5.  */
  6. public class StatePatternDemo {
  8.     public static void main(String[] args) {
  9.         Context context = new Context(new NewState());
  10.         context.execute(1); 
  11.         context.execute(2); 
  12.         context.execute(3); 
  14.         // 适合场景，数据有状态，状态就一定会流转，从状态1变成状态2
  15.         // 将不同的状态要执行的代码逻辑封装在不同的state类中
  16.         // 有一个context类，负责根据传入的参数，决定这份数据的状态流转到什么状态
  17.         // 同时负责执行那个新状态的代码逻辑
  19.         // 适合的场景太明显了，只要有状态，都按照标准的状态模式来实现，改进
  20.         // 不同的状态逻辑放不同的state类
  21.         // 有一个类负责状态之间的流转以及状态逻辑的执行
  23.         // 对于有状态的场景，按照面向对象的思想来设计，而不是说，在一堆代码里面
  24.         // if 开始执行那个状态的一堆逻辑，else if，开始执行另外一个状态的一堆逻辑，屎一样的代码
  25.         // 代码很清晰，可读性很好，可维护性很好
  26.     }
  28.     public interface State {
  30.         void execute();
  32.     }
  34.     public static class NewState implements State {
  36.         public void execute() {
  37.             System.out.println("执行销售出库单新建状态的逻辑");  
  38.         }
  40.     }
  42.     public static class ApprovingState implements State {
  44.         public void execute() {
  45.             System.out.println("执行销售出库单待审批状态的逻辑");  
  46.         }
  48.     }
  50.     public static class ApprovedState implements State {
  52.         public void execute() {
  53.             System.out.println("执行销售出库单已审批状态的逻辑");  
  54.         }
  56.     }
  58.     public static class FinishedState implements State {
  60.         public void execute() {
  61.             System.out.println("执行销售出库单已完成状态的逻辑");  
  62.         }
  64.     }
  66.     public static class Context {
  68.         private State state;
  70.         public Context(State state) {
  71.             this.state = state;
  72.             this.state.execute();
  73.         }
  75.         public void execute(int stateType) {
  76.             if(stateType == 1) {
  77.                 this.state = new ApprovingState();
  78.                 this.state.execute();
  79.             } else if(stateType == 2) {
  80.                 this.state = new ApprovedState();
  81.                 this.state.execute();
  82.             } else if(stateType == 3) {
  83.                 this.state = new FinishedState();
  84.                 this.state.execute();
  85.             }
  86.         }
  88.     }
  90. }

2.说明

其实状态模式，就是维护多种不同的状态，每种状态下可以去执行一些特殊的逻辑。然后由一个Context类负责根据请求参数调用，来维护这些状态之间的切换，形成一个状态机的概念。

状态模式里，非常重要的一点就是将状态之间流转的逻辑，封装在Context类里面。本来可能需要调用方自己维护复杂的状态流转逻辑，流转到不同的状态之后，执行状态对应的代码逻辑。