1、什么是状态模式
    状态模式就是在一个对象改变状态的时候就让其改变行为，比如说状态 为1的时候就是到店取外卖，转态为2的时候就是送外卖

    2、状态模式的应用场景

    图片2.png
    对象的行为取决于它的状态；
    操作中含有较多的条件语句（if判断）

    3、具体实现需要
    重构的代码

    1. public class OrderService {
    4.     public String orderState(String state) {
    5.         if (state.equals("0")) {
    6.             return "已经发货";
    7.         }
    8.         if (state.equals("1")) {
    9.             return "正在运送中...";
    10.         }
    11.         if (state.equals("2")) {
    12.             return "正在派送中...";
    13.         }
    14.         if (state.equals("3")) {
    15.             return "已经签收";
    16.         }
    17.         if (state.equals("4")) {
    18.             return "拒绝签收";
    19.         }
    20.         if (state.equals("5")) {
    21.             return "订单交易失败";
    22.         }
    23.         return "未找到对应的状态";
    24.     }
    25. }

    优化后：

    1. @Component
    2. public class SpringUtils implements ApplicationContextAware {
    4.     private static ApplicationContext applicationContext;
    6.     @Override
    7.     public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
    8.         this.applicationContext = applicationContext;
    9.     }
    11.     //获取applicationContext
    12.     public static ApplicationContext getApplicationContext() {
    13.         return applicationContext;
    14.     }
    16.     //通过name获取 Bean.
    17.     public static Object getBean(String name){
    18.         return getApplicationContext().getBean(name);
    19.     }
    21.     //通过class获取Bean.
    22.     public static <T> T getBean(Class<T> clazz){
    23.         return getApplicationContext().getBean(clazz);
    24.     }
    26.     //通过name,以及Clazz返回指定的Bean
    27.     public static <T> T getBean(String name,Class<T> clazz){
    28.         return getApplicationContext().getBean(name, clazz);
    29.     }
    31. }
    35. @RestController
    36. public class OrderController {
    38.     @RequestMapping("/order")
    39.     public String order(String stateBeanId) {
    41.         //1.使用Spring上下文获取bean中对象
    42.         OrderState orderState = SpringUtils.getBean(stateBeanId, OrderState.class);
    43.         // 2.使用上下文切换到不同的状态
    44.         StateContext stateContext = new StateContext(orderState);
    45.         stateContext.switchStateOrder();
    47.         // 如果写多重if判断的话 整个代码流程 耗时比较长   直接Spring中精准定位到策略或者是状态的话 Map get方法的时候底层是数组
    48.         return "success";
    49.     }
    50. }
    53. public class StateContext {
    54.     private OrderState orderState;
    56.     public StateContext(OrderState orderState) {
    57.         this.orderState = orderState;
    58.     }
    60.     public void switchStateOrder() {
    61.         orderState.orderService();
    62.     }
    63. }
    66. public interface OrderState {
    69.     /**
    70.      * 返回都会不一样
    71.      *
    72.      * @return
    73.      */
    74.     public Object orderService();
    76. }
    78. @Slf4j
    79. @Component
    80. public class AlreadySignedOrderState implements OrderState {
    81.     @Override
    82.     public Object orderService() {
    83.         log.info(">> 切换已经签收状态");
    84.         return "切换已经签收状态";
    85.     }
    86. }
    88. @Slf4j
    89. @Component
    90. public class InTransitOrderState implements OrderState {
    91.     @Override
    92.     public String orderService() {
    93.         log.info(">>>切换为正在运送状态...");
    94.         return "success";
    95.     }
    96. }
    99. @Slf4j
    100. @Component
    101. public class ShippedAlreadyOrderState implements OrderState {
    102.     public String orderService() {
    103.         log.info(">>>切换为已经发货状态..");
    104.         return "已经发货..";
    105.     }
    106. }

    4、状态模式与策略模式的区别
    实质上的实现的方式都是相同的，但是状态模式是根据不同的状态改变 行为，而策略模式是根据不同的状态改变的是同一种行为中的不同策略