责任链模式（Chain of Responsibility Pattern）也是一种极为常见的设计模式，如 Servlet 规范中的过滤器、Spring 中多个 AOP 的链式处理、OA 系统多级主管流程审批等等，这些都是责任链模式的实际业务场景应用。

第15篇·电商系统基于责任链模式实现订单多重优惠算价 - 图1

1. 定义

责任链模式是一种行为型设计模式，它的定义是：“使多个对象都有机会处理请求，从而避免了请求的发送者和接受者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有对象处理它为止。”

从责任链模式的定义来看，如果接收者中只要有一个对象处理成功了，那么请求就会返回了，然而责任链模式还有一种变体形式，就像 Servlet 规范中的过滤器一样，责任链上的每一个对象都会对请求进行处理，直到整个责任链都处理完毕。

2. 类图

在责任链模式中，有这样几种角色：

  • 抽象处理者（Handler）：定义了一个处理请求的接口，同时会定义抽象操作方法以及后继处理节点
  • 具体处理者（Concrete Handler）：抽象处理接口的实现类，同时它会包含一个控制方法用以判断本具体处理类是否能够处理本次请求，如果可以则处理，如果不能则会转交给它的后继节点进行处理

责任链模式的类图如下：

第15篇·电商系统基于责任链模式实现订单多重优惠算价 - 图2

3. 示例

今天就以电商系统中订单多重优惠价格计算的场景来跟大家聊聊责任链模式的实践。电商系统中，商家为了让消费者有一种“占到便宜”的感觉，这往往会将商品标价设置为一个高于商品实际售卖价格的数值，然后向用户赠送一些优惠券，于是消费者可能就会为了使用优惠券而下定决心买下商品。

真是黑心商家！

用户在选购商品时，可能会存在多重优惠，如平台优惠（如淘宝双11全平台满200-30）、店铺优惠（如安踏专卖店每满100-20）以及用户自己领取的红包、积分、或其他无门槛优惠券等，最终用户进行付款时将是使用了以上优惠后的最终价格，这个过程就是优惠算价，其具体流程如下：

第15篇·电商系统基于责任链模式实现订单多重优惠算价 - 图3

同时，某些商品可能由于自身不在店铺优惠范围之内而跳过店铺优惠计算过程。

这就是需求的大概描述，接下来就是代码实现了。

首先定义抽象处理者，所有的优惠计算都需要继承该抽象类。同时定义订单类，其代码如下：

  1. public abstract class Discount {
  2.     // 后继节点
  3.     private Discount next;
  5.     // 本优惠需要进行计算
  6.     abstract boolean match(Order order);
  8.     // 计算价格
  9.     abstract void calculatePrice(Order order);
  11.     void doCalculate(Order order) {
  12.         System.out.println("责任链 " + this.getClass().getSimpleName() + " 开始处理");
  13.         // 如果满足计算条件才进行优惠叠加
  14.         if (this.match(order)) {
  15.             calculatePrice(order);
  16.         }
  17.         System.out.println("责任链 " + this.getClass().getSimpleName() + " 处理结束");
  18.         if (this.next != null) {
  19.             this.next.doCalculate(order);
  20.         }
  21.     }
  23.         // 省略 setter/getter 方法
  24. }
  26. public class Order {
  27.     // 订单码
  28.     private String code;
  29.     // 价格
  30.     private double price;
  31.     // 支付价格
  32.     private Double paidPrice;
  33.     // 满足平台优惠
  34.     private boolean satisfyPlatformDiscount;
  35.     // 满足店铺优惠
  36.     private boolean satisfyShopDiscount;
  37.     // 满足红包优惠
  38.     private boolean satisfyRedPacketDiscount;
  40.     public Order(String code, double price, boolean satisfyPlatformDiscount, boolean satisfyShopDiscount, boolean satisfyRedPacketDiscount) {
  41.         this.code = code;
  42.         this.price = price;
  43.         this.satisfyPlatformDiscount = satisfyPlatformDiscount;
  44.         this.satisfyShopDiscount = satisfyShopDiscount;
  45.         this.satisfyRedPacketDiscount = satisfyRedPacketDiscount;
  46.     }
  48.     // 省略 setter/getter 方法
  49. }

这里在抽象处理者类图的基础上新增了一个 match 方法，用来在整个责任链中控制是否需要执行本级优惠计算。订单类的 boolean 类型属性决定了 match 方法的结果。

然后定义三个具体处理者类，其代码如下：

  1. public class PlatformDiscountCalculator extends Discount {
  3.     @Override
  4.     public boolean match(Order order) {
  5.         return order.isSatisfyPlatformDiscount();
  6.     }
  8.     @Override
  9.     public void calculatePrice(Order order) {
  10.         double price = order.getPaidPrice() == null ? order.getPrice() : order.getPaidPrice();
  11.         price = price - 20;
  12.         order.setPaidPrice(price);
  13.         System.out.printf("订单[%s]满足平台优惠，便宜20元，计算完成后价格为[%s]\n", order.getCode(), order.getPaidPrice());
  14.     }
  15. }
  17. public class ShopDiscountCalculator extends Discount {
  19.     @Override
  20.     public boolean match(Order order) {
  21.         return order.isSatisfyShopDiscount();
  22.     }
  24.     @Override
  25.     public void calculatePrice(Order order) {
  26.         double price = order.getPaidPrice() == null ? order.getPrice() : order.getPaidPrice();
  27.         price = price - 10;
  28.         order.setPaidPrice(price);
  29.         System.out.printf("订单[%s]满足店铺优惠，便宜10元，计算完成后价格为[%s]\n", order.getCode(), order.getPaidPrice());
  30.     }
  31. }
  33. public class RedPacketDiscountCalculator extends Discount {
  35.     @Override
  36.     public boolean match(Order order) {
  37.         return order.isSatisfyRedPacketDiscount();
  38.     }
  40.     @Override
  41.     public void calculatePrice(Order order) {
  42.         double price = order.getPaidPrice() == null ? order.getPrice() : order.getPaidPrice();
  43.         price = price - 5;
  44.         order.setPaidPrice(price);
  45.         System.out.printf("订单[%s]满足红包优惠，便宜5元，计算完成后价格为[%s]\n", order.getCode(), order.getPaidPrice());
  46.     }
  47. }

然后编写测试代码：

public class Test {

    public static void main(String[] args) {
        Order order = new Order("DS20220207001", 100, true, false, true);

        Discount platformDiscountCalculator = new PlatformDiscountCalculator();
        Discount redPacketDiscountCalculator = new RedPacketDiscountCalculator();
        Discount shopDiscountCalculator = new ShopDiscountCalculator();

        platformDiscountCalculator.setNext(shopDiscountCalculator);
        shopDiscountCalculator.setNext(redPacketDiscountCalculator);

        platformDiscountCalculator.doCalculate(order);
    }
}

输出结果为：

责任链 PlatformDiscountCalculator 开始处理
订单[DS20220207001]满足平台优惠，便宜20元，计算完成后价格为[80.0]
责任链 PlatformDiscountCalculator 处理结束
责任链 ShopDiscountCalculator 开始处理
责任链 ShopDiscountCalculator 处理结束
责任链 RedPacketDiscountCalculator 开始处理
订单[DS20220207001]满足红包优惠，便宜5元，计算完成后价格为[75.0]
责任链 RedPacketDiscountCalculator 处理结束

在实际业务场景的处理中，我们通常使用配置的形式（可能是订单的属性）来判断订单是否需要进行平台、店铺等优惠的叠加，同时体现在责任链模式中的业务可能有：

  • 如果订单价格低于 100 元，本优惠计算器不进行处理
  • 优惠计算器的先后可以定义在配置文件中，同时可以通过反射等手段进行动态选择

4. 使用场景

责任链模式的使用场景是：

  • 有多个对象可以处理同一个请求，具体由哪个对象处理是在运行时确定的。
    • 例如，有 ABC 三个处理者可以处理一个请求，请求 a 需要 AC 两个处理者处理，请求 b 需要 BC 两个处理者处理，同时两个处理者之间可能有前后依赖关系，这时候就可以使用责任链模式
  • 在不确定请求处理者的时候，向同一类型的处理者中的一个发送请求

5. 小结

本文讲述了责任链模式，它的定义是——使多个对象都有机会处理请求，从而避免了请求的发送者和接受者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有对象处理它为止。

责任链模式的优点是：

  • 将请求与处理解耦，请求方无需知道具体处理者以及其结构
  • 满足开闭原则，如果需要新增处理节点，只需要新增一个具体处理者类即可
  • 满足单一职责原则以及 KISS 原则，每个具体处理者有明确的职责范围

责任链模式的缺点是：

  • 性能问题，如果责任链非常长，从头节点处理到尾节点可能需要很长时间
  • 有些责任链会采用递归形式实现，会增大调试的难度以及代码的易理解程度

6. 参考资料

最后，本文收录于个人语雀知识库: 我所理解的后端技术，欢迎来访。