设计模式-责任链

之前写代码的时候看到过有审批场景使用了责任链，当时大概看了一下代码实现，今天终于有时间抽出来梳理一下，下面是本文的大纲：

使用场景
审批场景的普遍应用
实际案例：HttpClient中的责任链模式
责任链模式在事件处理、日志记录和过滤器链中的应用
责任链模式实现方式一代码实现
接口和具体处理器类的设计
处理器类的链式结构
客户端使用责任链的示例
责任链模式实现方式二代码实现（简易版）
Spring框架的 @Order 注解的应用
利用 @Order 注解实现的责任链模式
客户端通过构造函数注入实现责任链
HttpClient中的责任链模式（之前遇到过）

使用场景

查了一下大概的使用场景，其实审批场景使用的会比较多，我记得自己第一次看到责任链的时候是在看HttpClient的代码的时候，用了责任链进行请求体的数据传递，只不过当时自己的工程能力还不是特别的完善，因此简单看了个大概就略过了，今天顺便一起梳理了。

1. 当程序需要使用不同方式处理不同种类请求， 而且请求类型和顺序预先未知时， 可以使用责任链模式。该模式能将多个处理者连接成一条链。 接收到请求后， 它会 “询问” 每个处理者是否能够对其进行处理。 这样所有处理者都有机会来处理请求。

2. 当必须按顺序执行多个处理者时， 可以使用该模式。无论你以何种顺序将处理者连接成一条链， 所有请求都会严格按照顺序通过链上的处理者。

3. 如果所需处理者及其顺序必须在运行时进行改变， 可以使用责任链模式。如果在处理者类中有对引用成员变量的设定方法， 你将能动态地插入和移除处理者， 或者改变其顺序。
   

责任链常见的使用场景包括审批流程、事件处理、日志记录、过滤器链等。例如，在一个审批流程中，不同级别的审批人员可以组成一个责任链，每个审批人员处理自己能够处理的审批请求，如果自己无法处理，则将请求传递给下一个审批人员。这样可以动态地调整审批流程，而不需要修改整个系统的代码。

责任链结构

代码实现，方式一

先给一个责任链的实现代码，思路其实还好，有点类似链表的实现方式，每一个类尝试去进行处理，如果处理不了就交给下一个类，每一个类会按照顺序保存下一个类的地址，这是不是有点类似于链表的结构？当然其实审批流的场景也类似链表的结构，什么时候路由到下一个节点什么时候结束这些都可以收敛到类里面。

// 定义处理请求的接口
interface Handler {
    void handleRequest(Request request);
}

// 具体处理器类
class ConcreteHandler1 implements Handler {
    private Handler nextHandler;

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

    @Override
    public void handleRequest(Request request) {
        // 根据具体业务逻辑判断是否能处理请求
        if (request.getType().equals("Type1")) {
            System.out.println("ConcreteHandler1处理请求：" + request.getContent());
        } else {
            // 如果不能处理，则将请求传递给下一个处理器
            if (nextHandler != null) {
                nextHandler.handleRequest(request);
            } else {
                System.out.println("没有处理器能够处理该请求");
            }
        }
    }
}

class ConcreteHandler2 implements Handler {
    private Handler nextHandler;

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

    @Override
    public void handleRequest(Request request) {
        if (request.getType().equals("Type2")) {
            System.out.println("ConcreteHandler2处理请求：" + request.getContent());
        } else {
            if (nextHandler != null) {
                nextHandler.handleRequest(request);
            } else {
                System.out.println("没有处理器能够处理该请求");
            }
        }
    }
}

// 请求类
class Request {
    private String type;
    private String content;

    public Request(String type, String content) {
        this.type = type;
        this.content = content;
    }

    public String getType() {
        return type;
    }

    public String getContent() {
        return content;
    }
}

// 客户端使用责任链
public class ChainOfResponsibilityExample {
    public static void main(String[] args) {
        // 创建具体处理器
        ConcreteHandler1 handler1 = new ConcreteHandler1();
        ConcreteHandler2 handler2 = new ConcreteHandler2();

        // 设置责任链关系
        handler1.setNextHandler(handler2);

        // 创建请求
        Request request1 = new Request("Type1", "请求类型1");
        Request request2 = new Request("Type2", "请求类型2");
        Request request3 = new Request("Type3", "请求类型3");

        // 客户端提交请求
        handler1.handleRequest(request1);
        handler1.handleRequest(request2);
        handler1.handleRequest(request3);
    }
}

代码实现，方式二

另外其实还有一个非常简单的实现思路，我记得之前自己看到的责任链实现是基于@Order注解来实现的，找GPT实现了一版当时的代码case，示例如下，这种实现其实能够解决大部分的问题并且非常的简单

public interface Handler {
    void handleRequest(Request request);
}

@Component
@Order(1)
public class ConcreteHandler1 implements Handler {
    @Override
    public void handleRequest(Request request) {
        System.out.println("ConcreteHandler1处理请求：" + request.getContent());
    }
}

@Component
@Order(2)
public class ConcreteHandler2 implements Handler {
    @Override
    public void handleRequest(Request request) {
        System.out.println("ConcreteHandler2处理请求：" + request.getContent());
    }
}

@Component
public class ChainClient {
    private final List<Handler> handlers;

    @Autowired
    public ChainClient(List<Handler> handlers) {
        this.handlers = handlers;
    }

    public void executeChain(Request request) {
        for (Handler handler : handlers) {
            handler.handleRequest(request);
        }
    }
}

在这个例子中，ConcreteHandler1 和 ConcreteHandler2 使用 @Order 注解标记了它们的执行顺序。客户端类 ChainClient 通过构造函数注入所有的处理器，并按照它们的顺序循环调用 handleRequest 方法，从而触发责任链的执行。

HttpClient的责任链

HttpClient 库在内部使用了责任链模式的一种形式。具体而言，它采用了拦截器（Interceptor）机制，这是责任链的一种实现方式。

拦截器机制在 HttpClient 中的工作方式如下：

请求拦截器： 请求拦截器负责在发送之前修改即将发送的 HTTP 请求。它们可以添加头部信息、修改请求方法，或在请求上执行其他操作。

响应拦截器： 响应拦截器负责在将响应返回给调用者之前处理收到的 HTTP 响应。它们可以从响应中提取信息、处理重定向，或在响应上执行其他操作。

执行拦截器： 执行拦截器负责执行 HTTP 请求并获取响应。它在整个请求生命周期中扮演了至关重要的角色，从请求的创建到响应的处理。

每个拦截器都是责任链的一部分，并且链式执行。

写完之后忽然想起了自己之前稍微整理的一版责任链，当时大概是刚开始学java的时候整理的，自己梳理了一个大概的流程图，提供一下跳转链接

https://blog.csdn.net/xiaocaij_icai/article/details/125578282?spm=1001.2014.3001.5501