Java设计模式之责任链模式-CSDN博客

本文链接：https://blog.csdn.net/qq_27656927/article/details/141589649

责任链模式（Chain of Responsibility Pattern）

1. 概述

责任链模式是一种行为型设计模式，它使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递请求，直到有对象处理它为止。责任链模式的核心思想是将请求的处理职责沿着对象链传递，而不明确指定具体哪个对象处理。

2. 适用场景

多个对象可以处理同一个请求：但具体哪个对象处理该请求是在运行时确定的。
需要动态指定处理对象：在不明确指定接收者的情况下，将请求传递给多个对象中的一个。
希望避免将请求的发送者与接收者耦合在一起：通过链式结构，将请求的处理责任传递下去。

3. 结构

Handler（抽象处理者）：定义了处理请求的接口，通常包含一个指向下一个处理者的引用。
ConcreteHandler（具体处理者）：实现 Handler 接口，处理它所负责的请求。如果可以处理该请求，则处理；否则，将请求转发给下一个处理者。
Client（客户端）：创建并配置处理链，向链上的处理者提交请求。

4. 示例代码

假设我们在开发一个简单的日志系统，根据日志的级别（如INFO、DEBUG、ERROR）将日志消息传递给不同的处理器。我们可以使用责任链模式，根据日志的级别来选择适当的处理器。

1. 定义抽象处理者

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);
        }
    }

    protected abstract void write(String message);
}

2. 实现具体处理者

class ConsoleLogger extends Logger {
    public ConsoleLogger(int level) {
        this.level = level;
    }

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

class ErrorLogger extends Logger {
    public ErrorLogger(int level) {
        this.level = level;
    }

    @Override
    protected void write(String message) {
        System.out.println("Error 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);
    }
}

3. 配置责任链

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.");
        loggerChain.logMessage(Logger.DEBUG, "This is a debug level information.");
        loggerChain.logMessage(Logger.ERROR, "This is an error information.");
    }
}

4. 运行结果

Standard Console::Logger: This is an information.
File::Logger: This is a debug level information.
Standard Console::Logger: This is a debug level information.
Error Console::Logger: This is an error information.
File::Logger: This is an error information.
Standard Console::Logger: This is an error information.

5. 分析

灵活的请求处理：责任链模式允许多个处理器处理请求，客户端无需知道哪个处理器最终会处理请求。
职责分离：每个处理器只处理自己负责的部分，其余部分传递给下一个处理器。
动态组合：可以根据需要动态地改变链的结构和处理顺序。

6. 优缺点

优点：
- 降低耦合度：请求发送者与处理者解耦，发送者不需要知道具体哪个处理者会处理请求。
- 动态组合：可以灵活地修改责任链的结构，增加或减少处理器。
- 职责分离：将请求处理的各个步骤分散到不同的处理者中，符合单一职责原则。
缺点：
- 可能无处理结果：如果链上的所有处理者都不能处理该请求，那么该请求将被丢弃。
- 性能问题：责任链过长可能会影响系统性能，因为请求会依次传递给链上的每一个处理者。