订单状态流转状态模式 + 享元模式+模板方法模式

Posted 2022-10-04 java_wxid

文章目录

• • 创建design-demo项目
  • • 创建OrderController
    • 创建OrderService
    • 创建OrderServiceImpl
    • 创建AbstractAuditLogProcessor
    • 创建AuditLog
    • 创建LoginLogProcessor
    • 创建OrderLogProcessor
    • 创建PayLogProcessor
    • 创建Order
    • 创建OrderState
    • 创建OrderStateChangeAction
    • 创建OrderStateMachineConfig
    • 创建OrderStateListener
    • 创建StrategyFacade
    • 创建AddFuncFactory
    • 创建PayFactory
    • 创建StrategyFactory
    • 创建AddFuncDecorator
    • 创建AbstractAddFuncDecorator
    • 创建StrategyEnum
    • 校验是否正常工作

创建design-demo项目

项目代码：https://gitee.com/java_wxid/java_wxid/tree/master/demo/design-demo
项目结构如下（示例）：

创建OrderController

代码如下（示例）：

package com.example.designdemo.controller;

import com.example.designdemo.order.pojo.Order;
import com.example.designdemo.pay.pojo.PayBody;
import com.example.designdemo.service.OrderService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
/**
 * @Author: zhiwei Liao
 * @Date: 2022/9/26 21:29
 * @Description: 订单管理，这里简单写写，主要是设计模式，别抠细节
 */
@RestController
public class OrderController 
    @Autowired
    private OrderService orderService;

    @GetMapping("mkOrder")
    public Order createOrder(@RequestParam Integer oid) 
        return orderService.createOrder(oid);
    

    @PostMapping("/pay")
    public Order payOrder(@RequestBody PayBody payBody)
        return orderService.pay(payBody);
    

    @GetMapping("/send")
    public Order send(@RequestParam Integer oid) 
        return orderService.send(oid);
    

    @GetMapping("/receive")
    public Order receive(@RequestParam Integer oid) 
        return orderService.receive(oid);
    

创建OrderService

代码如下（示例）：

package com.example.designdemo.service;

import com.example.designdemo.order.pojo.Order;
import com.example.designdemo.pay.pojo.PayBody;

/**
 * @Author: zhiwei Liao
 * @Date: 2022/9/25 9:28
 * @Description:
 */
public interface OrderService 

    Order createOrder(Integer oid);

    Order pay(PayBody payBody);

    Order send(Integer oid);

    Order receive(Integer oid);

创建OrderServiceImpl

代码如下（示例）：
package com.example.designdemo.service.impl;

import com.example.designdemo.order.auditlog.OrderLogProcessor;
import com.example.designdemo.order.auditlog.PayLogProcessor;
import com.example.designdemo.order.pojo.Order;
import com.example.designdemo.order.pojo.OrderState;
import com.example.designdemo.order.pojo.OrderStateChangeAction;
import com.example.designdemo.pay.facade.StrategyFacade;
import com.example.designdemo.pay.pojo.PayBody;
import com.example.designdemo.service.OrderService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.messaging.Message;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.statemachine.StateMachine;
import org.springframework.statemachine.persist.StateMachinePersister;
import org.springframework.stereotype.Service;
import java.util.ArrayList;
import java.util.List;
/**

• @Author: zhiwei Liao

• @Date: 2022/9/26 21:29

• @Description:
  */
  @Service
  public class OrderServiceImpl implements OrderService

  @Autowired
  private StateMachine<OrderState, OrderStateChangeAction> orderStateMachine;

  @Autowired
  private StateMachinePersister<OrderState, OrderStateChangeAction, Order> stateMachinePersister;

  @Autowired
  private PayLogProcessor payLogProcessor;

  @Autowired
  private OrderLogProcessor orderLogProcessor;

  //模拟一个存储
  private List orders = new ArrayList<>();

  public Order createOrder(Integer oid)
  Order order = new Order();
  order.setOrderState(OrderState.ORDER_WAIT_PAY);
  order.setOrderId(oid);
  // 创建的order是不是得入库啊？如果不入库，下次访问的时候，是不是找不到了啊。
  orders.add(order); // 模拟存储到 db
  orderLogProcessor.processAuditLog(“acccount”, “createOrder”, oid.toString());
  return order;
  

  // 将来我们删除或者增加或者修改任何关于付款的模块，无需改动service。
  //不会对调用层产生任何代码的改动。
  // 调用层使用我们的pay 模块，无需关系实现的逻辑，只需要将入参传给我们的pay模块即可。
  public Order pay(PayBody payBody)
  // 书写我们的付款逻辑
  boolean flag = false;
  flag = StrategyFacade.pay(payBody);
  if(flag)
  Order order = (Order) orders.get(0); // 模拟查询db代码
  payLogProcessor.processAuditLog(payBody.getAccount(), “pay”, order.getOrderId().toString());
  Message message = MessageBuilder
  .withPayload(OrderStateChangeAction.PAY_ORDER).setHeader(“order”, order).build();
  //发送消息，发送给谁？和状态机有没有关系啊？ 有
  if(changeStateAction(message,order))
  return order;
  
  //如果是 true，我们要保存到db
  saveToDb(payBody);
  
  return null;
  
  private void saveToDb(PayBody payBody)
  

  public Order send(Integer oid)
  Order order = (Order) orders.get(0); // 模拟查询db代码
  Message message = MessageBuilder
  .withPayload(OrderStateChangeAction.SEND_ORDER).setHeader(“order”, order).build();
  if(changeStateAction(message,order))
  return order;
  
  return null;
  

  public Order receive(Integer oid)
  Order order = (Order) orders.get(0); // 模拟查询db代码
  Message message = MessageBuilder
  .withPayload(OrderStateChangeAction.RECEIVE_ORDER).setHeader(“order”, order).build();
  if(changeStateAction(message,order))
  return order;
  
  return null;
  

  private boolean changeStateAction(Message message, Order order)
  try
  orderStateMachine.start();
  stateMachinePersister.restore(orderStateMachine, order); // 待议
  boolean res = orderStateMachine.sendEvent(message);
  stateMachinePersister.persist(orderStateMachine, order); // 持久
  return res;
  catch (Exception e)
  e.printStackTrace();
  finally
  orderStateMachine.stop();
  
  return false;
  
  

创建AbstractAuditLogProcessor

代码如下（示例）：

package com.example.designdemo.order.auditlog;

import com.example.designdemo.order.auditlog.pojo.AuditLog;

import java.util.Date;
/**
 * @Author: zhiwei Liao
 * @Date: 2022/9/26 21:29
 * @Description:
 */
public abstract class AbstractAuditLogProcessor 
    // 创建我们的 AuditLog (基础部分）
    public final AuditLog buildAuditLog(String account, String action, String orderId)
        AuditLog auditLog = new AuditLog();
        auditLog.setAccount(account);
        auditLog.setAction(action);
        auditLog.setOrderId(orderId);
        auditLog.setDate(new Date());
        return auditLog;
    

    protected abstract AuditLog buildDetails(AuditLog auditLog);

    public final void sendToQueue(AuditLog auditLog) 
        //send toQueue(auditLog)
    

    public final void processAuditLog(String account, String action, String orderId) 
        this.sendToQueue(buildDetails(buildAuditLog(account, action, orderId)));
    

创建AuditLog

代码如下（示例）：
package com.example.designdemo.order.auditlog.pojo;

import java.util.Date;
/**

• @Author: zhiwei Liao

• @Date: 2022/9/26 21:29

• @Description:
  */
  public class AuditLog
  private String account;
  private String action;
  private Date date;
  private String orderId;
  private Object details; //订单创建需要有相关产品信息；
  // 订单支付需要有相关产品信息以及支付方式和支付金额。

  public String getAccount()
  return account;
  

  public void setAccount(String account)
  this.account = account;
  

  public String getAction()
  return action;
  

  public void setAction(String action)
  this.action = action;
  

  public Date getDate()
  return date;
  

  public void setDate(Date date)
  this.date = date;
  

  public String getOrderId()
  return orderId;
  

  public void setOrderId(String orderId)
  this.orderId = orderId;
  

  public Object getDetails()
  return details;
  

  public void setDetails(Object details)
  this.details = details;
  

  @Override
  public String toString()
  return “AuditLog” +
  “account='” + account + ‘’’ +
  “, action='” + action + ‘’’ +
  “, date=” + date +
  “, orderId='” + orderId + ‘’’ +
  “, details=” + details +
  ‘’;
  
  

创建LoginLogProcessor

代码如下（示例）：

package com.example.designdemo.order.auditlog;

import com.example.designdemo.order.auditlog.pojo.AuditLog;
import org.springframework.stereotype.Component;
/**
 * @Author: zhiwei Liao
 * @Date: 2022/9/26 21:29
 * @Description:
 */
@Component
public class LoginLogProcessor extends AbstractAuditLogProcessor
    @Override
    protected AuditLog buildDetails(AuditLog auditLog) 
        return auditLog;
    

创建OrderLogProcessor

代码如下（示例）：

package com.example.designdemo.order.auditlog;

import com.example.designdemo.order.auditlog.pojo.AuditLog;
import org.springframework.stereotype.Component;
/**
 * @Author: zhiwei Liao
 * @Date: 2022/9/26 21:29
 * @Description:
 */
@Component
public class OrderLogProcessor extends AbstractAuditLogProcessor
    @Override
    protected AuditLog buildDetails(AuditLog auditLog) 
        String orderId = auditLog.getOrderId();
        String productDetails = "通过 orderId 获取";
        auditLog.setDetails(productDetails);
        System.out.println(auditLog);
        return auditLog;
    

创建PayLogProcessor

代码如下（示例）：

package com.example.designdemo.order.auditlog;

import com.example.designdemo.order.auditlog.pojo.AuditLog;
import org.springframework.stereotype.Component;
/**
 * @Author: zhiwei Liao
 * @Date: 2022/9/26 21:29
 * @Description:
 */
@Component
public class PayLogProcessor extends AbstractAuditLogProcessor
    @Override
    protected AuditLog buildDetails(AuditLog auditLog) 
        String orderId = auditLog.getOrderId();
        String allDetails = "通过 orderId 或者是参数 获取产品信息，金额，支付方式";
        auditLog.setDetails(allDetails);
        System.out.println(auditLog);
        return auditLog;
    

创建Order

代码如下（示例）：

package com.example.designdemo.order.pojo;

/**
 * @Author: zhiwei Liao
 * @Date: 2022/9/26 21:29
 * @Description:状态转化的一个控制机。状态机：初始化状态；配置我们的所有状态之间的转化关系；一些持久化的工作（redis）。
 */
public class Order 
    private Integer orderId;
    private OrderState orderState;//订单状态

    public Integer getOrderId() 
        return orderId;
    

    public void setOrderId(Integer orderId) 
        this.orderId = orderId;
    

    public OrderState getOrderState() 
        return orderState;
    

    public void setOrderState(OrderState orderState) 
        this.orderState = orderState;
    

创建OrderState

代码如下（示例）：

package com.example.designdemo.order.pojo;
/**
 * @Author: zhiwei Liao
 * @Date: 2022/9/26 21:29
 * @Description:订单状态
 */
public enum  OrderState 
    ORDER_WAIT_PAY, // 待支付
    ORDER_WAIT_SEND, // 待发货
    ORDER_WAIT_RECEIVE, // 待收货
    ORDER_FINISH; // 完成订单

创建OrderStateChangeAction

代码如下（示例）：

package com.example.designdemo.order.pojo;
/**
 * @Author: zhiwei Liao
 * @Date: 2022/9/26 21:29
 * @Description:订单状态操作
 */
public enum OrderStateChangeAction 
    PAY_ORDER, // 支付操作
    SEND_ORDER, // 发货操作
    RECEIVE_ORDER; // 收货操作

创建OrderStateMachineConfig

代码如下（示例）：

package com.example.designdemo.order.config;

import com.example.designdemo.order.pojo.Order;
import com.example.designdemo.order.pojo.OrderState;
import com.example.designdemo.order.pojo.OrderStateChangeAction;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.statemachine.StateMachineContext;
import org.springframework.statemachine.StateMachinePersist;
import org.springframework.statemachine.config.EnableStateMachine;
import org.springframework.statemachine.config.StateMachineConfigurerAdapter;
import org.springframework.statemachine.config.builders.StateMachineStateConfigurer;
import org.springframework.statemachine.config.builders.StateMachineTransitionConfigurer;
import org.springframework.statemachine.persist.DefaultStateMachinePersister;
import org.springframework.statemachine.support.DefaultStateMachineContext;
import java.util.EnumSet;
/**
 * @Author: zhiwei Liao
 * @Date: 2022/9/26 21:29
 * @Description:
 */
@Configuration
@EnableStateMachine(name="orderStateMachine")
public class OrderStateMachineConfig extends StateMachineConfigurerAdapter<OrderState, OrderStateChangeAction> 
    public void configure(StateMachineStateConfigurer<OrderState, OrderStateChangeAction> states) throws Exception 
        states.withStates().initial(OrderState.ORDER_WAIT_PAY)
                .states(EnumSet.allOf(OrderState.class));
    

    public void configure(StateMachineTransitionConfigurer<OrderState, 
    								OrderStateChangeAction> transitions) throws Exception 
        transitions.withExternal().source(OrderState.ORDER_WAIT_PAY)
                .target(OrderState.ORDER_WAIT_SEND)
                .event(OrderStateChangeAction.PAY_ORDER)
                .and()
                .withExternal().source(OrderState.ORDER_WAIT_SEND)
                .target(OrderState.ORDER_WAIT_RECEIVE)
                .event(OrderStateChangeAction.SEND_ORDER)
                .and()
                .withExternal().source(OrderState.ORDER_WAIT_RECEIVE)
                .target(OrderState.ORDER_FINISH)
                .event(OrderStateChangeAction.RECEIVE_ORDER);
    

    // 配置状态机持久化
    @Bean
    public DefaultStateMachinePersister machinePersister() 
        return new DefaultStateMachinePersister<>(new StateMachinePersist<Object, Object, Order>() 

            @Override
            public void write(StateMachineContext<Object, Object> stateMachineContext, Order order) throws Exception 
                //持久化操作。可以通过任何形式进行持久化。redis 、 mongodb、mysql，ecache
            

            @Override
            public StateMachineContext<Object, Object> read(Order order) throws Exception 
                // 本来是应该从持久化组件里进行读取的。但是没做持久化
                return new DefaultStateMachineContext(order.getOrderState(), null, null, null);
            
        );
    

创建OrderStateListener

代码如下（示例）：

package com.example.designdemo.order.listener;

import com.example.designdemo.order.pojo.Order;
import com.example.designdemo.order.pojo.OrderState;
import com.example.designdemo.order.pojo.OrderStateChangeAction;
import org.springframework.messaging.Message;
import org.springframework.statemachine.annotation.OnTransition;
import org.springframework.statemachine.annotation.WithStateMachine;
import org.springframework.stereotype.Component;

/**
 * @Author: zhiwei Liao
 * @Date: 2022/9/26 21:29
 * @Description:监听器是监听到 action 后进行状态的一个变更。
 */
@Component("orderStateListener")
@WithStateMachine(name="orderStateMachine")
public class OrderStateListener 
    @OnTransition(source = "ORDER_WAIT_PAY", target = "ORDER_WAIT_SEND")
    public boolean payToSend(Message<OrderStateChangeAction> message)
        Order order = (Order) message.getHeaders().get("order");
        order.setOrderState(OrderState.ORDER_WAIT_SEND);
        return true;
    
    @OnTransition(source = "ORDER_WAIT_SEND", target = "ORDER_WAIT_RECEIVE")
    public boolean sendToReceive(Message<OrderStateChangeAction> message)
        Order order = (Order) message.getHeaders().get("order");
        order.setOrderState(OrderState.ORDER_WAIT_RECEIVE);
        return true;
    
    @OnTransition(source = "ORDER_WAIT_RECEIVE", target = "ORDER_FINISH")
    public boolean receiveToFinish(Message<OrderStateChangeAction> message)
        Order order = (Order) message.getHeaders().get("order");
        order.setOrderState(OrderState.ORDER_FINISH);
        return true;
    

创建StrategyFacade

代码如下（示例）：

package com.example.designdemo.pay.facade;

import com.example.designdemo.pay.additionalDecorator.AddFuncDecorator;
import com.example.designdemo.pay.context.PayContext;
import com.example.designdemo.pay.factory.AddFuncFactory;
import com.example.designdemo.pay.factory.PayFactory;
import com.example.designdemo.pay.strategy.PayStrategy;
import com.example.designdemo.pay.factory.StrategyFactory;
import com.example.designdemo.pay.pojo.PayBody;
import com.example.designdemo.pay.strategyEnum.StrategyEnum;

/**
 * @Author: zhiwei Liao
 * @Date: 2022/9/25 11:27
 * @Description: 门面模式，最终只暴露门面即可，门面就是我们的超级封装
 */

public class StrategyFacade 

    // 定义一个map，将对应关系提前初始化好。
    // 双十一的时候，有大量的用户进行下单（千万级），就会造成千万级的pay接口的调用。
    // 很可惜，这部分代码里边有两个 new 关键字（new PayContext(payStrategy) 和 new AddFuncDecorator）。
    // 如果瞬时见。有几十万的并发进来，那么会创建几十万个 context对象和 addFunc对象，造成 年轻代的eden区的频繁对象创建
    // 虽然说调用完就进行了对象的垃圾收集，但是这么多的访问对象进来会造成，minorgc。
    // 1. 单例模式吗？PayContext创建是基于payStrategy，不止一种paycontext啊，用单例不行呀。 AddFuncDecorator 是基于PayContext
    // 创建的，PayContext 不止一种，AddFuncDecorator 也不止一种。
    // 2. 享元模式。享元模式是单例模式的一种思想升级。单例模式，针对的是同一种对象，没有任何不同的细节。而享元模式，针对多个对象。
    // 多个对象：同一种class，但是里边的属性有些许不同。PayContext是同一种对象吧？是的； PayContext 是不是有细节上的不同呢？是的，
    // payStrategy不同； 那么我们是否可以知道这个PayContext的种类数量呢？是的，目前有三种。 享元模式能够对这可控数量的有不同细节的
    //同一种class对象进行共享，保证我们的程序不频繁的创建对象。
    public static Boolean pay(PayBody payBody) 
        //获取我们的 策略枚举
        StrategyEnum strategyEnum = getStrategyEnum(payBody.getType());
        if(strategyEnum == null) 
            return false;
        
        //获取我们的策略对象
        PayStrategy payStrategy = StrategyFactory.getPayStrategy(strategyEnum);
        //生成我们的策略上下文
        PayContext context = PayFactory.getPayContext(payStrategy); // 享元模式解决高并发下频繁创建对象的问题
        // 装饰一下 context，。立马多了一个功能
        // 我看这行代码啊，就不顺眼。代理模式搞他。
        AddFuncDecorator addFuncDecorator = (AddFuncDecorator) AddFuncFactory.getAddFunc(context); // 享元模式解决高并发下频繁创建对象的问题
        //进行扣款
        return addFuncDecorator.execute(payBody);
    

    private static StrategyEnum getStrategyEnum(int type) 
        switch (type) 
            case 0:
                return StrategyEnum.ZfbPayStrategy;
            case 1:
                return StrategyEnum.WxPayStrategy;
            case 2:
                return StrategyEnum.BankPayStrategy;
            default:
                return null;
        
    

创建AddFuncFactory

代码如下（示例）：

package com.example.designdemo.pay.factory;

import com.example.designdemo.pay.additionalDecorator.AbstractAddFuncDecorator;
import com.example.designdemo.pay.additionalDecorator.AddFuncDecorator;
import com.example.designdemo.pay.context.PayContext;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @Author: zhiwei Liao
 * @Date: 2022/9/25 20:53
 * @Description:
 */
public class AddFuncFactory 
    // 工厂的目的是生产 AddFuncDecorator； 生产几个啊？ 多个：享元
    // key 应该是能够和 AbstractAddFuncDecorator 做成对应的东西。
    // 这个map最多保存是三个对象。
    public final static Map<PayContext, AbstractAddFuncDecorator> maps = new ConcurrentHashMap<>();

    public static AbstractAddFuncDecorator getAddFunc(PayContext payContext) 
        if(maps.get(payContext) == null) 
            AddFuncDecorator addFuncDecorator = new AddFuncDecorator(payContext);
            maps.put(payContext, addFuncDecorator);
        
        return maps.get(payContext);
    

创建PayFactory

代码如下（示例）：

package com.example.designdemo.pay.factory;


import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import com.example.designdemo.pay.context.PayContext;
import com.example.designdemo.pay.strategy.PayStrategy;

/**
 * @author zhiweiLiao<zhiwei.liao @ sgs.com>
 * @Description 享元模式解决高并发下频繁创建对象的问题
 * @Date create in 2022/9/28 0028 13:57
 */
public class PayFactory 

    public final static Map<PayStrategy, PayContext> maps = new ConcurrentHashMap<>();

    public static PayContext getPayContext(PayStrategy payStrategy) 
        if(maps.get(payStrategy) == null) 
            PayContext payContext = new PayContext(payStrategy);
            maps.put(payStrategy, payContext);
        
        return maps.get(payStrategy);
    

创建StrategyFactory

代码如下（示例）：

package com.example.designdemo.pay.factory;

import com.example.designdemo.pay.strategy.PayStrategy;
import com.example.designdemo.pay.strategyEnum.StrategyEnum;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @Author: zhiwei Liao
 * @Date: 2022/9/25 10:53
 * @Description: 策略工厂 工厂类依靠策略枚举返回策略类 后面都不需要修改了，因为它是一个无状态的 使用饿汉单例模式创建
 */

public class StrategyFactory 

    private static final Map<String, PayStrategy> strategyMaps = new ConcurrentHashMap();

    public static PayStrategy getPayStrategy(StrategyEnum strategyEnum)
        PayStrategy payStrategy = strategyMaps.get(strategyEnum.getValue());
        try 
            payStrategy = (PayStrategy) Class.forName(strategyEnum.getValue()).newInstance();
            strategyMaps.put(strategyEnum.getValue(), payStrategy);
         catch (Exception e) 
            //异常信息打印
        
        return payStrategy;
    

创建AddFuncDecorator

代码如下（示例）：

package com.example.designdemo.pay.additionalDecorator;

import com.example.designdemo.pay.context.AbstractPayContext;
import com.example.designdemo.pay.pojo.PayBody;

/**
 * @Author: zhiwei Liao
 * @Date: 2022/9/25 20:53
 * @Description:abstractPayContext 不是共享的，因为有的小伙伴选择 zfb 支付，有的小伙伴选择wx支付，等等。。。
 */
public class AddFuncDecorator extends AbstractAddFuncDecorator
    public AddFuncDecorator(AbstractPayContext abstractPayContext) 
        super(abstractPayContext);
    

    // 新活儿
    @Override
    public void additionalFunction(PayBody payBody)  // 共享的，跟支付策略没有任何关系
        String product = payBody.getProduct();
        // 从db里边获取 product的详细信息。
        // 从配置中心（redis缓存）里获取产品的更新策略。
        // 根据策略更新用户平台币 或（和） 发放红包。
        System.out.println("更新平台币成功，发送红包到用户优惠券模块成功。");
    

    @Override
    public Boolean execute(PayBody payBody)  // 算共享的。共享的调用逻辑
        Boolean result = super.execute(payBody); //老活儿
        this.additionalFunction(payBody); // 新活儿. 新活儿的各种重试，失败补偿
        return result;
    

创建AbstractAddFuncDecorator

代码如下（示例）：

package com.example.designdemo.pay.additionalDecorator;


import com.example.designdemo.pay.context.AbstractPayContext;
import com.example.designdemo.pay.pojo.PayBody;
/**
 * @Author: zhiwei Liao
 * @Date: 2022/9/25 20:53
 * @Description:
 */
public abstract class AbstractAddFuncDecorator extends AbstractPayContext 
    // 这是我们的装饰器类。专门干装修的。 专门添加新功能的（平台币，红包）
    // 装饰的是谁啊？ 我作为一个称职的装饰器，我必须得知道装饰的是谁，不然我咋干活儿啊。
    private AbstractPayContext abstractPayContext = null;

    public AbstractAddFuncDecorator(AbstractPayContext abstractPayContext) 
        this.abstractPayContext = abstractPayContext;
    

    // 开始干活儿
    //1. 老活儿。 支付。但是我又不能修改支付代码，也不能修改支付逻辑。
    @Override
    public Boolean execute(PayBody payBody) 
        return abstractPayContext.execute(payBody);
    

    //2. 老活儿不合适，没你装饰器照样能execute。 新活儿：平台币，红包）
    public abstract void additionalFunction(PayBody payBody);

创建StrategyEnum

代码如下（示例）：

package com.example.designdemo.pay.strategyEnum;
/**
 * @Author: zhiwei Liao
 * @Date: 2022/9/25 10:56
 * @Description: 准备使用反射
 */

public enum StrategyEnum 

    ZfbPayStrategy("com.example.designdemo.pay.strategy.ZfbPayStrategy"),
    WxPayStrategy("com.example.designdemo.pay.strategy.WxPayStrategy"),
    BankPayStrategy("com.example.designdemo.pay.strategy.BankPayStrategy");

    String value = "";

    StrategyEnum(String value)
        this.value = value;
    

    public String getValue()
        return this.value;
    

校验是否正常工作