行为型-职责链模式（Chain of Responsibility Pattern）

介绍

职责链模式是一种行为型设计模式，它允许多个对象在处理请求时，每个对象都有机会处理请求，从而避免了请求发送者和接收者之间的直接耦合。通过将处理请求的对象按照其处理能力的顺序连接成一条链，请求将沿着链传递，直到有一个对象能够处理它。

在职责链模式中，通常使用一个抽象处理者（Handler）来定义处理请求的方法。每个具体的处理者类都实现了这个抽象处理者，并包含一个指向下一个处理者的引用。当请求到达一个处理者时，它可以选择处理请求或将它传递给下一个处理者。这样，请求将依次通过每个处理者，直到有一个处理者能够处理它。

优点:

• 解耦发送者和接收者：职责链模式将请求的发送者和接收者解耦，使得发送者无需知道请求将由哪个接收者处理，从而提高了系统的灵活性和可扩展性。
• 可动态配置链：通过增加或移除处理者，可以灵活地配置职责链，改变请求的处理顺序和条件，从而满足不同的需求。
• 简化对象的互动：发送者只需要将请求传递给第一个处理者，而无需关心请求最终由谁处理。
• 易于扩展：可以很容易地新增处理者类来扩展职责链，而无需修改现有的代码。

缺点:

• 请求一定会被处理：如果使用职责链模式时没有合适的处理者能够处理请求，那么请求可能会一直传递下去，直到到达链的末尾。这可能会导致请求得不到处理，或者产生不可预料的结果。
• 对请求的顺序敏感：由于职责链模式是按照链中处理者的顺序依次处理请求的，因此请求的顺序可能会影响处理结果。

使用场景：

• 有多个对象可以处理请求，并且处理者可能随时变化。
• 有多个对象可以处理请求，但是发送者不知道哪个对象能够处理。
• 需要动态地指定处理请求的顺序或条件。
• 请求的处理过程需要对发送者和接收者进行解耦。

示例

下面我们通过一个示例来说明职责链模式的使用。假设我们正在开发一个电商网站，用户可以购买各种商品。在下单过程中，我们需要进行库存检查、优惠券验证和支付操作。这个过程中，每个操作都可以独立进行，并且可能会进行顺序调整。

首先，我们定义一个抽象处理者接口OrderHandler，用于处理下单请求：

public interface OrderHandler {
    void handleOrder(Order order);
}

然后，实现具体的处理者类InventoryHandler、CouponHandler和PaymentHandler：

public class InventoryHandler implements OrderHandler {
    private OrderHandler nextHandler;

    public void setNextHandler(OrderHandler nextHandler) {
        this.nextHandler = nextHandler;
    }

    @Override
    public void handleOrder(Order order) {
        // 进行库存检查
        if (checkInventory(order)) {
            System.out.println("库存检查通过");
            // 调用下一个处理者
            nextHandler.handleOrder(order);
        } else {
            System.out.println("库存不足，下单失败");
        }
    }

    private boolean checkInventory(Order order) {
        // 检查库存
        // 省略具体代码
        return true;
    }
}

public class CouponHandler implements OrderHandler {
    private OrderHandler nextHandler;

    public void setNextHandler(OrderHandler nextHandler) {
        this.nextHandler = nextHandler;
    }

    @Override
    public void handleOrder(Order order) {
        // 进行优惠券验证
        if (validateCoupon(order)) {
            System.out.println("优惠券验证通过");
            // 调用下一个处理者
            nextHandler.handleOrder(order);
        } else {
            System.out.println("优惠券无效，下单失败");
        }
    }

    private boolean validateCoupon(Order order) {
        // 验证优惠券
        // 省略具体代码
        return true;
    }
}

public class PaymentHandler implements OrderHandler {
    private OrderHandler nextHandler;

    public void setNextHandler(OrderHandler nextHandler) {
        this.nextHandler = nextHandler;
    }

    @Override
    public void handleOrder(Order order) {
        // 进行支付操作
        if (processPayment(order)) {
            System.out.println("支付成功");
            // 调用下一个处理者
            nextHandler.handleOrder(order);
        } else {
            System.out.println("支付失败");
        }
    }

    private boolean processPayment(Order order) {
        // 处理支付
        // 省略具体代码
        return true;
    }
}

在实现类中，每个处理者都包含一个指向下一个处理者的引用，并在处理请求时调用下一个处理者。如果当前处理者无法处理请求，它会将请求传递给下一个处理者。

最后，我们可以创建一个具体的订单对象，并使用处理者链来处理订单：

public class Order {
    // 订单信息
}

public class OrderProcessor {
    private OrderHandler orderHandler;

    public OrderProcessor() {
        // 构建处理者链
        OrderHandler inventoryHandler = new InventoryHandler();
        OrderHandler couponHandler = new CouponHandler();
        OrderHandler paymentHandler = new PaymentHandler();

        // 设置处理者的顺序
        inventoryHandler.setNextHandler(couponHandler);
        couponHandler.setNextHandler(paymentHandler);

        orderHandler = inventoryHandler;
    }

    public void processOrder(Order order) {
        // 调用处理者链的第一个处理者来处理订单
        orderHandler.handleOrder(order);
    }
}

public class ChainOfResponsibilityExample {
    public static void main(String[] args) {
        // 创建订单
        Order order = new Order();

        // 创建订单处理器
        OrderProcessor orderProcessor = new OrderProcessor();

        // 处理订单
        orderProcessor.processOrder(order);
    }
}