职责链设计模式

职责链设计模式（Chain of Responsibility Design Pattern）是一种行为设计模式，使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合。这些对象被链接成一条链，沿着这条链传递请求，直到有一个对象处理它为止。

关键角色

1. 处理者（Handler）：定义一个处理请求的接口，并实现设置下一个处理者的方法。
2. 具体处理者（Concrete Handler）：继承处理者接口，实现具体的处理请求的逻辑。如果不能处理请求，就传递给下一个处理者。
3. 客户端（Client）：创建具体处理者的实例，并设置它们的链接关系，然后将请求发送给链上的第一个处理者。

实现步骤

1. 定义处理者接口：
   包含处理请求的方法和设置下一个处理者的方法。
2. 实现具体处理者类：
   继承处理者接口，实现具体的处理逻辑。
3. 创建处理者链：
   在客户端代码中，实例化具体处理者，并设置它们之间的链接关系。

示例代码

以下是一个简单的示例，实现职责链模式。

package com.example.study.pattern;

import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

@Slf4j
@SpringBootTest
class ApplicationTests {

    @Test
    void contextLoads() {

        // 创建具体处理者对象
        PurchaseHandler manager = new Manager();
        PurchaseHandler director = new Director();
        PurchaseHandler ceo = new CEO();

        // 设置处理者链
        manager.setNextHandler(director);
        director.setNextHandler(ceo);

        // 发送购买请求
        PurchaseRequest request1 = new PurchaseRequest(500);
        PurchaseRequest request2 = new PurchaseRequest(3000);
        PurchaseRequest request3 = new PurchaseRequest(10000);

        manager.processRequest(request1);
        manager.processRequest(request2);
        manager.processRequest(request3);

    }

    // 创建一个处理者接口
    interface PurchaseHandler {
        void processRequest(PurchaseRequest request);
        void setNextHandler(PurchaseHandler nextHandler);
    }

    // 创建具体处理者类
    class Manager implements PurchaseHandler {
        private PurchaseHandler nextHandler;

        @Override
        public void processRequest(PurchaseRequest request) {
            if (request.getAmount() <= 1000) {
                System.out.println("Manager approved the purchase request for " + request.getAmount());
            } else if (nextHandler != null) {
                nextHandler.processRequest(request);
            }
        }

        @Override
        public void setNextHandler(PurchaseHandler nextHandler) {
            this.nextHandler = nextHandler;
        }
    }

    class Director implements PurchaseHandler {
        private PurchaseHandler nextHandler;

        @Override
        public void processRequest(PurchaseRequest request) {
            if (request.getAmount() <= 5000) {
                System.out.println("Director approved the purchase request for " + request.getAmount());
            } else if (nextHandler != null) {
                nextHandler.processRequest(request);
            }
        }

        @Override
        public void setNextHandler(PurchaseHandler nextHandler) {
            this.nextHandler = nextHandler;
        }
    }

    class CEO implements PurchaseHandler {
        @Override
        public void processRequest(PurchaseRequest request) {
            System.out.println("CEO approved the purchase request for " + request.getAmount());
        }

        @Override
        public void setNextHandler(PurchaseHandler nextHandler) {
            // CEO是处理者链的最后一个处理者，无需设置下一个处理者
        }
    }

    // 创建购买请求类
    class PurchaseRequest {
        private double amount;

        public PurchaseRequest(double amount) {
            this.amount = amount;
        }

        public double getAmount() {
            return amount;
        }
    }
}

运行结果

优点

1. 松散耦合：请求发送者和处理者解耦，请求者无需知道谁处理了请求。
2. 灵活性：可以在运行时动态增加或修改处理者链。
3. 责任分担：每个处理者只需处理自己负责的部分，简化了复杂任务的处理。

使用场景

1. 事件处理：在GUI应用程序中，处理鼠标和键盘事件时，可以使用职责链模式，依次传递事件给各个组件，直到某个组件处理该事件。
2. 审批流程：在企业应用中，例如请假审批流程，不同的管理层级按照顺序审批。
3. 日志记录：在日志框架中，不同的日志处理器（如文件、控制台、远程服务器等）可以组成链条，依次处理日志请求。