责任链模式实战——优化前置业务参数校验

最新推荐文章于 2024-05-20 11:12:55 发布

chenniorange

最新推荐文章于 2024-05-20 11:12:55 发布

阅读量520

点赞数 1

文章标签：责任链模式

本文链接：https://blog.csdn.net/chenniorange/article/details/132927719

版权

责任链模式

1、什么是责任链模式

责任链设计模式是一种行为型设计模式，其主要目的是解耦请求发送者和请求接收者，让多个对象都有机会处理请求，从而避免请求发送者和接收者之间的紧耦合。

责任链模式的核心是一个链式结构，链中每个节点代表一个处理者对象，请求先经过第一个节点处理，如果该节点能够处理请求，则直接返回处理结果；否则，请求继续往下一个节点传递，直到找到能够处理该请求的节点为止。整个过程类似于流水线上的多个工作站，每个工作站负责一项工作，如果自己处理不了，就将工作交给下一个工作站，直到整个工作完成。

举个例子，SpringMvc 中可以定义拦截器，并且可以定义多个。当一个用户发起请求时，顺利的话请求会经过所有拦截器，最终到达业务代码逻辑，SpringMvc 拦截器设计就是使用了责任链模式。

在责任链模式中，多个处理器（参照上述拦截器）依次处理同一个请求。一个请求先经过 A 处理器处理，然后再把请求传递给 B 处理器，B 处理器处理完后再传递给 C 处理器，以此类推，形成一个链条，链条上的每个处理器 各自承担各自的处理职责。

责任链模式中多个处理器形成的处理器链在进行处理请求时，有两种处理方式：

请求会被 所有的处理器都处理一遍，不存在中途终止的情况，参照 MyBatis 拦截器理解。
处理器链执行请求中，某一处理器执行时，如果不符合自制定规则的话，停止流程，并且剩下未执行处理器就不会被执行，参照 SpringMvc 拦截器理解。

2、责任链模式的优缺点

优点：

可以动态地添加、删除和调整处理者对象，从而灵活地构建处理链
避免了请求发送者和接收者之间的紧耦合，增强了系统的灵活性和可扩展性

缺点，如果处理链过长或者处理时间过长，可能会对系统性能产生一定的影响。

3、应用场景

在实际应用中，责任链模式常用于请求的预处理、请求的过滤、请求的分发等场景。例如，可以使用责任链模式来实现权限校验、日志记录、异常处理、请求重试等功能。同时，也可以将责任链模式与其他设计模式结合起来，例如装饰器模式、工厂模式、观察者模式等，从而实现更复杂的功能。

责任链实战

1. 下单前置校验

在电商系统下单接口中，前置校验是非常重要的环节。下面是一个可能的校验步骤列表：

检查商品信息是否存在，包括商品名称、价格、规格等信息。
检查购买数量是否合法，是否超出了最大购买数量或最小购买数量的限制。
检查商品库存是否充足，以确保库存足够满足购买者的需求。
检查购买者的优惠券、积分等是否可以使用，以确保购买者能够享受相应的优惠或积分奖励。
检查收货地址信息是否完整和准确，以确保商品能够顺利地送达给购买者。
检查下单时间是否合法，例如检查购买者是否在限定的时间范围内下单。

对于完成这些前置校验逻辑，一般我们可能的代码思路如下：

public String createOrder(CreateOrderReqDTO xxx) {
    // 检查商品信息是否存在，包括商品名称、价格、规格等信息
  	// 检查购买数量是否合法，是否超出了最大购买数量或最小购买数量的限制
    // 检查商品库存是否充足，以确保库存足够满足购买者的需求
    // 检查购买者的优惠券、积分等是否可以使用，以确保购买者能够享受相应的优惠或积分奖励
    // 检查收货地址信息是否完整和准确，以确保商品能够顺利地送达给购买者
    // 检查下单时间是否合法，例如检查购买者是否在限定的时间范围内下单
    // ......
}

解决前置校验需求需要实现一堆逻辑，常常需要写上几百上千行代码。

为了避免这种代码臃肿的情况，我们可以运用责任链设计模式，对下单验证逻辑进行抽象。

2. 责任链重构

定义一个责任链处理器接口，所有子任务都实现该接口以处理具体的业务逻辑。

同时，为了方便对责任链流程中的任务进行顺序处理，我们需要继承 Spring 框架中的排序接口 Ordered。这将有助于保证责任链中的任务顺序执行。

public interface OrderCreateChainHandler<T> extends Ordered {
    
    /**
     * 执行责任链逻辑
     *
     * @param requestParam 责任链执行入参
     */
    void handler(T requestParam);
}

实现 OrderCreateChainHandler 接口作为责任链处理器，每个具体的实现类负责执行特定的逻辑。

// 订单创建参数必填检验
@Component
public final class OrderCreateParamNotNullChainHandler implements OrderCreateChainHandler<OrderCreateCommand> {
    
    @Override
    public void handler(OrderCreateCommand requestParam) {
	    // 逻辑执行
    }
    
    @Override
    public int getOrder() {
        return 0;
    }
}

// 订单创建参数正确性检验
@Component
public final class OrderCreateParamVerificationChainHandler implements OrderCreateChainHandler<OrderCreateCommand> {
    
    @Override
    public void handler(OrderCreateCommand requestParam) {
	    // 逻辑执行
    }
    
    @Override
    public int getOrder() {
        return 1;
    }
}

// 订单创建商品 SKU 库存验证
@Component
public final class OrderCreateProductSkuStockChainHandler implements OrderCreateChainHandler<OrderCreateCommand> {

    @Override
    public void handler(OrderCreateCommand requestParam) {
	    // 逻辑执行
    }
    
    @Override
    public int getOrder() {
        return 2;
    }
}

创建一个责任链上下文容器，用于存储与责任链相应的子任务。

/*
 实现CommandLineRunner接口，重写run方法
 run方法在Spring容器加载后执行，这里是将Spring容器中所有OrderCreateChainHandler类型的Bean都加载进List
 @Component接口，此类交由Spring容器管理
*/
@Component
public final class OrderCreateChainContext<T> implements CommandLineRunner {
    
    private final List<OrderCreateChainHandler> orderCreateChainHandlerContainer = new ArrayList();
    
    /**
     * 责任链组件执行
     *
     * @param requestParam 请求参数
     */
    public void handler(T requestParam) {
        // 此处根据 Ordered 实际值进行排序处理
        orderCreateChainHandlerContainer.stream()
                .sorted(Comparator.comparing(Ordered::getOrder)).forEach(each -> each.handler(requestParam));
    }
    
    @Override
    public void run(String... args) throws Exception {
      	// 通过 Spring 上下文容器，获取所有 CreateOrderChainContext Bean
        Map<String, OrderCreateChainHandler> chainFilterMap = ApplicationContextHolder.getBeansOfType(OrderCreateChainHandler.class);
      	// 将对应 Bean 放入责任链上下文容器中
        chainFilterMap.forEach((beanName, bean) -> orderCreateChainHandlerContainer.add(bean););
    }
}

通过责任链模式优化，创建订单接口前置校验代码从上千行缩减为一行。

@RequiredArgsConstructor
public class OrderServiceImpl implements OrderService {

    private final OrderCreateChainContext<OrderCreateCommand> orderCreateChainContext;
  
    public String createOrder(OrderCreateCommand requestParam) {
        // 责任链模式: 执行订单创建参数验证
        orderCreateChainContext.handler(requestParam);
    }
}

进一步优化：责任链抽象

当业务使用越来越多的情况下，重复定义OrderCreateChainHandler以及OrderCreateChainContext会增加系统冗余代码量。

试想一下，这还只是有关OrderCreate业务的责任链，一般项目有那么多前置校验需要做，所以加起来的多余代码量是惊人的。

可以考虑将这两个基础类抽象出来，作为基础组件库中的通用组件，供所有系统下的业务使用，从而避免代码冗余。

1. 抽象基础类

定义抽象责任链处理接口

等同于 OrderCreateChainHandler。

public interface AbstractChainHandler<T> extends Ordered {
    
    /**
     * 执行责任链逻辑
     *
     * @param requestParam 责任链执行入参
     */
    void handler(T requestParam);
    
    /**
     * @return 责任链组件标识
     */
    String mark();
}

mark 方法是做什么的？接口增加 mark 方法，以便不同业务使用不同的标识。

假设项目中有两个业务场景：订单下单OrderCreate和用户UserCreate创建都需要责任链模式去验证，mark 就是用来进行分组，在业务中进行调用责任链时传递不同的 mark 方法参数，通过该参数找到对应的一组责任链具体实现类集合。

例如：

我们有个用户注册的业务需要责任链去校验参数，可以定义一个接口实现抽象基础类，重写mark方法。

public interface UserRegisterCreateChainFilter<T extends UserRegisterReqDTO> extends AbstractChainHandler<UserRegisterReqDTO> {

    @Override
    default String mark() {
        return "我是UserRegiseter业务的前置校验责任链";
    }
}

定义抽象责任链上下文

等同于 OrderCreateChainContext。

可以看到保存责任链处理类的容器从 List 改为了 Map，这样可以方便扩展更多的不同业务责任链子类。

通过实现 CommandLineRunner 接口在 SpringBoot 启动完成后，执行钩子函数将所有实现责任链抽象接口的实现类进行注册到责任链上下文中。

public final class AbstractChainContext<T> implements CommandLineRunner {
    
    private final Map<String, List<AbstractChainHandler>> abstractChainHandlerContainer = Maps.newHashMap();
    
    /**
     * 责任链组件执行
     *
     * @param requestParam 请求参数
     */
    public void handler(String mark, T requestParam) {
        abstractChainHandlerContainer.get(mark).stream()
                .sorted(Comparator.comparing(Ordered::getOrder)).forEach(each -> each.handler(requestParam));
    }
    
    @Override
    public void run(String... args) throws Exception {
        // 获取 Spring IOC 容器中所有 AbstractChainHandler 接口实现
        Map<String, AbstractChainHandler> chainFilterMap = ApplicationContextHolder.getBeansOfType(AbstractChainHandler.class);
        chainFilterMap.forEach((beanName, bean) -> {
            List<AbstractChainHandler> abstractChainHandlers = abstractChainHandlerContainer.get(bean.mark());
            if (abstractChainHandlers == null) {
                abstractChainHandlers = new ArrayList();
            }
            abstractChainHandlers.add(bean);
            // 根据 mark 标识将责任链模式分类，放入责任链容器上下文中
            abstractChainHandlerContainer.put(bean.mark(), abstractChainHandlers);
        });
    }
}

2. 抽象业务接口

上面我们已经讨论过AbstractChainHandler接口的子接口实现(UserRegisterCreateChainFilter)。

现在，让我们继续探讨责任链子类的编写。实际上，改动并不多，只需要将之前的 OrderCreateChainHandler 实现接口改为 OrderCreateChainFilter 即可。

// 订单创建参数必填检验
@Component
public final class OrderCreateParamNotNullChainHandler implements OrderCreateChainFilter<OrderCreateCommand> {
    
    @Override
    public void handler(OrderCreateCommand requestParam) {
    	// 逻辑执行
    }
    
    @Override
    public int getOrder() {
        return 0;
    }
}

// 订单创建参数正确性检验
@Component
public final class OrderCreateParamVerificationChainHandler implements OrderCreateChainFilter<OrderCreateCommand> {
    
    @Override
    public void handler(OrderCreateCommand requestParam) {
    	// 逻辑执行
    }
    
    @Override
    public int getOrder() {
        return 1;
    }
}

// 订单创建商品 SKU 库存验证
@Component
public final class OrderCreateProductSkuStockChainHandler implements OrderCreateChainFilter<OrderCreateCommand> {

    @Override
    public void handler(OrderCreateCommand requestParam) {
    	// 逻辑执行
    }
    
    @Override
    public int getOrder() {
        return 2;
    }
}

3. 业务使用

在具体业务场景中使用时，与之前相比并没有太大的差别。除了增加了 Mark 标识外，没有进行其他变更。

@RequiredArgsConstructor
public class OrderServiceImpl implements OrderService {

    private final AbstractChainContext<OrderCreateCommand> abstractChainContext;
  
    public String createOrder(OrderCreateCommand requestParam) {
        // 责任链模式: 执行订单创建参数验证
        abstractChainContext.handler(OrderChainMarkEnum.ORDER_CREATE_FILTER.name(), requestParam);
    }
}

chenniorange

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
2
评论
责任链模式实战——优化前置业务参数校验

等同于。/*** 执行责任链逻辑* @param requestParam 责任链执行入参*//*** @return 责任链组件标识*/mark方法是做什么的？接口增加mark方法，以便不同业务使用不同的标识。假设项目中有两个业务场景：订单下单OrderCreate和用户UserCreate创建都需要责任链模式去验证，mark就是用来进行分组，在业务中进行调用责任链时传递不同的mark方法参数，通过该参数找到对应的一组责任链具体实现类集合。
复制链接

扫一扫