【设计模式】【第四章】【订单状态流转】【状态模式 + 享元模式+模板方法模式】

订单有限状态机架构设计 有限状态机 有限状态机(Finite-state machine, FSM),是表示有限个状态以及在这些状态之间的转移和动作等行为的数学模型。主要用来是描述对象在它的生命周期内所经历的状态序列,以及如何响应来自外界的各种事件。 状态机可归纳为4个要素,即现态、条件、动作、新态。其中“现态”和“条件”是因,“动作”和“次态”是果。 **现态:**是指当前所处的状态。 **事件:**又称为“条件”。当一个事件发生,将会触发一个动作,或者执行一次状态的迁移。 **动作:**条件满足后执行的动作。动作执 阅读详情

创建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;
    }
}

校验是否正常工作

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

浅谈JAVA工作流的优雅实现方式 今天查找线上问题,看到一个让我脑洞大开的工作流实现方式。以前用过责任链模式,也用过模板模式实现类工作流的方式,但是对比这个工具,逊色不少,不卖关子了,就是Apache Commons Chain,它是Command模式与责任链模式的综合体。 1、Apache Commons Chain 中的角色有:chain、context、command。 2、在我们订单系统有这样的业务,就是退票的时候,会根... 阅读详情

相关推荐

状态模式实战:重构复杂业务逻辑,告别if-else状态爆炸

在软件工程中,对象行为随内部状态变化是常见场景,传统硬编码方式常导致代码臃肿难维护。状态模式通过将状态相关行为封装到独立类中,实现行为与状态解耦,其核心原理是多态委托机制。该模式的技术价值在于提升代码可维护性、可扩展性,并降低状态流转复杂度。典型应用场景包括订单系统、工作流引擎和游戏角色状态管理。本文以电商订单系统为例,展示如何通过状态模式重构代码,其中状态对象管理和状态转换驱动是实践关键,能有效解决状态爆炸问题。

weixin_34037515的博客 470

玩转 Spring 状态机:实现订单状态流转

???? 这是一个或许对你有用的社群???? 一对一交流/面试小册/简历优化/求职解惑,欢迎加入「芋道快速开发平台」知识星球。下面是星球提供的部分资料:《项目实战(视频)》:从书中学,往事上“练”《互联网高频面试题》:面朝简历学习,春暖花开《架构 x 系统设计》:摧枯拉朽,掌控面试高频场景题《精进 Java 学习指南》:系统学习,互联网主流技术栈《必读 Java 源码专栏》:知其然,知其所以然????这是一个或许...

芋艿V 951

C#设计模式--单例模式

普通单例:一进门就把所有家具都准备好(程序启动时就创建实例)懒加载单例:等你要用沙发时才去买沙发(第一次访问时才创建实例)

weixin_53545579的博客 1274

【设计模式系列19】状态模式原理分析及其和策略模式,责任链模式的区别

状态模式原理分析前言什么是状态模式状态模式示例状态模式角色状态模式与责任链模式状态模式与策略模式状态模式应用场景状态模式优缺点总结 前言 状态对于我们开发者而言是相当熟悉的,平常开发中总是离不开对象的状态,比如我们审核流程,就是一个状态不断流转的过程,订单流程也是一个状态不断流转的过程,而状态模式就是为了更好地解决我们状态流转过程中的业务处理逻辑。 什么是状态模式 状态模式(State Pattern)也称为状态机模式(State Machine Pattern),是允许对象在内部状态发生改变的同时改变对象

zwx900102的博客 2609

状态模式 (State Pattern)

解耦价值将与特定状态相关的行为局部化消除庞大的条件判断语句使状态转换显式化扩展性容易添加新状态状态转换逻辑清晰符合开闭原则状态模式是处理复杂状态机的强大工具,特别适合行为随状态变化而显著不同的场景。正确实现可以产生更清晰、更易维护的状态管理代码。

sharpyl的专栏 416

设计模式之状态模式(State)

状态模式(State) 用意:允许一个对象当状态改变时,改变其行为。

【大厂面试杀手锏】订单状态流转场景题:如何用设计模式实现优雅的状态机?

/ 状态接口(核心)// 具体状态实现(以"待支付"为例)@Component@Override// 支付校验逻辑(模拟支付服务调用)// 状态切换} else {throw new IllegalStateException("非法状态转换: UNPAID -> " + nextState);

Leaton的博客 1803

win10删除vmware12后,重新安装失败(遗留注册表问题)解决总结

之前安装过一次VMware虚拟机,后来由于某些已遗忘原因把它卸载了,但是没有卸载完全,为以后安装留下了一些麻烦,现在根据我google很多内容总结后写下了自己的解决办法。 一些我搜的的可以用的VM12的注册码 5A02H-AU243-TZJ49-GTC7K-3C61N ZZ510-DYX47-48ERP-D6XZG-YCKU2 YV5MU-2FX5H-M841P-LZX5X-PYHX8

Jeason的博客 2万+

java设计模式之状态模式

一、定义与类型: 》定义:允许一个对象在其内部状态改变时,改变它的行为。也就是说一个对象的状态改变时,其行为会改变。或者说 它的行为不跟者改变,而是状态之间的转化。用于解决当控制一个对象的状态转换的逻辑比较复杂时,这样就可以把状态判断的逻辑转移到表示不同状态的一系列类当中。比如在看视频时,可以开始、暂停、播放等多种形式。 》类型:行为型; 二、适用场景: 》一个对象存在多个状态(不同状态...

智欣约的博客 384

传输线的特征阻抗

信号源内阻与所接传输线的特性阻抗大小相等且相位相同,或传输线的特性阻抗与所接负载阻抗的大小相等且相位相同,分别称为传输线的输入端或输出端处于阻抗匹配状态,简称为阻抗匹配。否则,便称为阻抗失配。有时也直接叫做匹配或失配。指一个电路输入端的等效阻抗。在输入端上加上一个电压源U,测量输入端的电流I,则输入阻抗Rin就是U/I。可以把输入端想象成一个电阻的两端,这个电阻的阻值,就是输入阻抗。- 对于电压驱动的电路,输入阻抗越大,则对电压源的负载就越轻,因而就越容易驱动,也不会对信号源有影响;

学海无涯的专栏 4467

国密USB Key开发实战:SKF库调用全流程解析(附代码示例)

本文详细解析了国密USB Key开发中SKF库的调用全流程,涵盖从设备枚举、应用容器遍历到数字签名与验证的核心步骤。通过实战代码示例,深入探讨了SKF库的层次化模型、SM2签名实现细节以及纯软件验签方案,为开发电子签章、安全登录等合规应用提供了一套完整的调用开发指南。

oo7890的博客 530

202. 享元模式

摘要:享元模式是一种结构型设计模式,通过共享对象内部状态(如字体、颜色)与分离外部状态(如位置)来优化内存使用。该模式适用于存在大量相似对象的场景(如文本编辑器、游戏开发),通过工厂管理共享对象,显著减少内存占用。其优点是降低对象创建开销、提高性能,但会增加系统复杂度并需注意线程安全问题。设计模式可分为创建型、结构型(含享元)和行为型三大类,各自解决不同领域的软件设计问题。

weixin_43484713的博客 924

U型槽微带贴片天线:从理论公式到带宽扩展实战

本文深入探讨了U型槽微带贴片天线的设计与带宽扩展实战。针对传统微带天线带宽窄的痛点,详细解析了通过引入U型槽形成双谐振点以拓宽带宽的原理,并提供了从MATLAB理论计算、ANSYS HFSS仿真建模到参数优化的一站式工程指南。文章还分享了多种带宽扩展组合技巧及仿真与实测避坑经验,助力射频工程师设计出高性能的宽带微带天线。

weixin_29168153的博客 455

设计模式之状态模式:优雅管理对象行为变化

Context(上下文):维护当前状态实例State(抽象状态):定义状态接口ConcreteState(具体状态):实现特定状态行为状态模式是管理复杂状态转换的利器,特别适合行为随状态改变而显著变化的场景。通过将每种状态封装为独立类,代码变得清晰可维护。在实际应用中,可以结合备忘录模式实现状态历史记录,或与观察者模式实现状态变更通知,构建更强大的系统架构。

wenbin_java的博客 1068

多目标跟踪中使用trackeval评估dancetrack运行结果

trackeval使用

qq_46144849的博客 1783

从零搭建宝兰德BES单机版:分离式安装、环境变量配置到控制台访问的避坑指南

本文详细介绍了从零搭建宝兰德BES单机版的完整流程,包括分离式安装、环境变量配置和控制台访问的避坑指南。针对中间件安装部署中的常见问题,提供了账号规划、JDK配置、实例创建和防火墙设置等实用解决方案,帮助开发者和运维人员高效完成BES中间件的部署工作。

weixin_32576389的博客 375

Java设计模式全解析:23种模式的理论与实践指南

本文系统解析Java 23种设计模式,分为创建型、结构型和行为型三大类。创建型模式(单例、工厂方法等)封装对象创建过程,实现实例化与使用解耦;结构型模式(适配器、代理等)优化类与对象组合关系;行为型模式(观察者、责任链等)规范对象交互逻辑。重点分析了单例模式的核心特点与实现方式,工厂方法模式的产品创建解耦机制,以及抽象工厂模式的产品族管理策略。每种模式均给出UML类图、适用场景、优缺点对比和实际应用示例,帮助开发者构建优雅可维护的代码体系。

J_liaty的博客 846

Go基础:一文掌握Go语言网络编程

Go语言凭借强大的标准库和原生并发支持,非常适合网络编程开发。文章介绍了Go语言在网络编程中的核心概念和应用场景,包括TCP、UDP和HTTP等协议的具体实现方法。主要内容包括:1)网络编程核心概念(Listener、Conn、Addr等);2)TCP服务器/客户端的实现流程与示例代码;3)UDP无连接通信的实现方式;4)利用net/http包构建HTTP服务。文章通过详细的代码示例展示了如何利用Go的Goroutine和Channel特性高效处理网络连接,并强调了连接管理的最佳实践。

数据知道的博客 5516

为什么学习设计模式?

设计模式的学习常常被贴上“枯燥”“抽象”的标签,但它更像一本软件开发的“烹饪食谱”——不是要求你死记硬背,而是教会你如何用更巧妙的方式组合代码的“食材”,最终做出一道既美味(功能完善)又美观(易于维护)的“佳肴”。当你发现代码不再是一碰就碎的玻璃城堡,而是可以随需求起舞的柔性架构时,那种成就感,或许就是工程师最美的浪漫。设计模式的学习是你追求“优质代码”的开始,也是你迈进底层核心开发的必经之路。这些模式不是束缚创造力的条条框框,而是前人总结的“最佳组装方案”,帮我们避免重复踩坑,让代码既有。

sdgfafg_25的博客 1225

RK3588 部署 YOLOv5s 实战:多线程加速从 16FPS 飙升到 120FPS(含性能优化)

因为RK3588包含了3个NPU核心,支持3个核心同时工作、双核合作、以及单核工作。我们可以使用线程池来加速。线程池是一种长街的并发编程模型,它用于管理和复用线程,以提高多线程程序的性能和效率。线程池通常包含以下主要组件:1、任务队列:任务队列用于存储待执行的任务。这些任务可以是函数、方法或其他需要多线程环境中执行的操作。2、线程池管理:线程池管理器负责创建、销毁和管理线程。它会监视任务队列中的任务,根据需要创建线程,执行任务,并在任务完成后将线程放回池中以供重用。

FJN110的博客 100

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

Dante Cloud状态模式:对象状态转换的逻辑封装

Dante Cloud是国内首个支持阻塞式和响应式服务并行的微服务云原生基座,采用领域驱动模型(DDD)设计思想,以「高质量代码、低安全漏洞」为核心,在架构设计中广泛应用了设计模式来提升代码质量和可维护性。状态模式作为一种行为型设计模式,在Dante Cloud中用于封装对象的状态转换逻辑,使对象在不同状态下表现出不同的行为。 ## 状态模式的核心价值:简化复杂状态逻辑 状态模式通过将对象的状

gitblog_00185的博客 360

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

状态模式是行为型设计模式的一种,其核心思想是允许一个对象在其内部状态改变时改变它的行为

状态模式是行为型设计模式的一种,其核心思想是允许一个对象在其内部状态改变时改变它的行为,对象看起来似乎修改了它的类。状态模式将与特定状态相关的行为封装到不同的状态类中,通过多态实现状态变化时的行为切换,避免了大量的条件判断语句。 ### 核心特点 封装了状态转换规则,将不同状态的行为分离到不同的类中 消除了大量的if-else或switch条件判断语句,提高了代码的可读性和可维护性 状态类职责单一,符合单一职责原则 新增状态不需要修改原有代码,符合开闭原则 状态转换逻辑清晰,易于理解和维护 #

[Blog][Domain] programb.blog.youkuaiyun.com 422

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

蓝牙模块HM-10手册

蓝牙模块HM-10手册,该手册对蓝牙模块HM-10进行了详细的介绍和使用方法以及一些AT指令。

为什么学习设计模式

设计模式的学习常常被贴上“枯燥”“抽象”的标签,但它更像一本软件开发的“烹饪食谱”——不是要求你死记硬背,而是教会你如何用更巧妙的方式组合代码的“食材”,最终做出一道既美味(功能完善)又美观(易于维护)的“佳肴”。设计模式的学习是你追求“优质代码”的开始,也是你迈进底层核心开发的必经之路。这种思维让开发者从“实现功能”进阶到“设计系统”,是从“码农”到“工程师”的关键跃迁。需要查看往期设计模式文章的,可以在个人主页中的集合中查看,可关注我,持续更新中。团队成员会立刻心领神会,就像乐队成员听到指挥的节拍器。

持 开源思想,撰 必胜所学,望 勤学者,无难处 627
上一篇: 【设计模式】【第三章】【平台积分红包发放场景】【装饰者模式】
下一篇: 【设计模式】【第五章】【开具增值税发票】【建造者模式 + 原型模式】
Java程序员廖志伟
Java程序员廖志伟 优质创作者: Java技术领域 优质创作者: Java技术领域 领域专家: 后端开发技术领域 领域专家: 后端开发技术领域
博客等级 码龄8年 2万+粉丝 1902原创
评论 6
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Java程序员廖志伟

赏我包辣条呗

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值