23种设计模式——责任链模式（Chain of Responsibility Pattern）

✅作者简介：大家好，我是 Meteors., 向往着更加简洁高效的代码写法与编程方式，持续分享Java技术内容。
🍎个人主页：Meteors.的博客
💞当前专栏：设计模式
✨特色专栏：知识分享
🥭本文内容：23种设计模式------责任链模式（Chain of Responsibility Pattern）
📚 ** ps ** ：阅读文章如果有问题或者疑惑，欢迎在评论区提问或指出。

[一. 背景](#一. 背景)

[二. 介绍](#二. 介绍)

[三. 核心组件](#三. 核心组件)

[四. 代码示例](#四. 代码示例)

[五. 特点](#五. 特点)

[六. 适用场景](#六. 适用场景)

[七. 总结](#七. 总结)

一. 背景

我之前是写后端的，如果你之前也做过后端或完整的做过项目，那么对于全局登录拦截（即认证与授权流程）一定不陌生（比如Java 的SpringSecurity框架），它通过一连串的过滤器形成过滤器链，每个过滤器负责处理特定的安全逻辑（如认证、授权、CSRF 防护等），如果当前过滤器不处理或处理完成后，请求会被传递给链中的下一个过滤器，直到请求最终到达目标资源或者被某个过滤器拦截，其实这个本质上就是基于责任链模式（Chain of Responsibility Pattern）来实现的。

二. 介绍

责任链模式是一种行为型设计模式，它允许将请求沿着处理者链进行传递，直到其中一个处理者能够处理该请求为止。这种模式将请求的发送者和接收者解耦，使得多个对象都有机会处理请求。

在责任链模式中：

每个处理者都包含对下一个处理者的引用

如果当前处理者不能处理请求，就将请求传递给下一个处理者

客户端不需要知道具体是哪个处理者处理了请求

三. 核心组件

**Handler（抽象处理者）：**定义处理请求的接口，通常包含一个指向下一个处理者的引用

**ConcreteHandler（具体处理者）：**实现处理请求的方法，如果自己不能处理，则将请求转发给下一个处理者

**Client（客户端）：**创建处理链并发送请求

四. 代码示例

以下是一个简单的示例，展示如何使用责任链模式处理不同级别的日志消息。

java 复制代码

// 抽象处理者
abstract class Logger {
    public static int INFO = 1;
    public static int DEBUG = 2;
    public static int ERROR = 3;

    protected int level;
    protected Logger nextLogger;

    public void setNextLogger(Logger nextLogger) {
        this.nextLogger = nextLogger;
    }

    public void logMessage(int level, String message) {
        if (this.level <= level) {
            write(message);
        }
        if (nextLogger != null) {
            nextLogger.logMessage(level, message);
        }
    }

    abstract protected void write(String message);
}

// 具体处理者 - 控制台日志记录器
class ConsoleLogger extends Logger {
    public ConsoleLogger(int level) {
        this.level = level;
    }

    @Override
    protected void write(String message) {
        System.out.println("Console Logger: " + message);
    }
}

// 具体处理者 - 文件日志记录器
class FileLogger extends Logger {
    public FileLogger(int level) {
        this.level = level;
    }

    @Override
    protected void write(String message) {
        System.out.println("File Logger: " + message);
    }
}

// 具体处理者 - 错误日志记录器
class ErrorLogger extends Logger {
    public ErrorLogger(int level) {
        this.level = level;
    }

    @Override
    protected void write(String message) {
        System.out.println("Error Logger: " + message);
    }
}

// 使用示例
public class ChainPatternDemo {
    private static Logger getChainOfLoggers() {
        Logger errorLogger = new ErrorLogger(Logger.ERROR);
        Logger fileLogger = new FileLogger(Logger.DEBUG);
        Logger consoleLogger = new ConsoleLogger(Logger.INFO);

        errorLogger.setNextLogger(fileLogger);
        fileLogger.setNextLogger(consoleLogger);

        return errorLogger;
    }

    public static void main(String[] args) {
        Logger loggerChain = getChainOfLoggers();

        loggerChain.logMessage(Logger.INFO, "This is an information.");
        System.out.println("---");

        loggerChain.logMessage(Logger.DEBUG, "This is a debug level information.");
        System.out.println("---");

        loggerChain.logMessage(Logger.ERROR, "This is an error information.");
    }
}

五. 特点

责任链模式的优点

降低耦合度：将请求的发送者和接收者解耦

增强灵活性：可以动态地增加或修改处理一个请求的结构

易于扩展：增加新的具体处理者非常方便

符合开闭原则：增加新的请求处理类不影响现有代码

责任链模式的缺点

不能保证请求一定被处理：可能没有具体的处理者处理请求

性能问题：可能会遍历整个链，影响性能

调试困难：处理过程比较复杂时，调试会变得困难

不能保证请求一定被处理：可能没有具体的处理者处理请求

六. 适用场景

有多个对象可以处理同一个请求，具体哪个对象处理该请求在运行时自动确定

在不明确指定接收者的情况下，向多个对象中的一个提交一个请求

可以动态指定一组对象处理请求

七. 总结

责任链模式是一种非常实用的设计模式，在很多框架和系统中都有广泛应用。它提供了一种将请求发送者与处理者解耦的方式，使系统更加灵活和可扩展。

通过合理运用责任链模式，我们可以构建出更清晰、更易维护的代码结构，特别是在处理复杂的业务流程时，这种模式尤其有用。

最后，

其它设计模式会陆续更新，希望文章对你有所帮助！