设计模式Chain of Responsibility（责任链）

Chain of Responsibility（责任链）模式是一种行为型设计模式，用于处理请求的多个处理者之间的职责分配。它允许请求沿着一条处理链传递，直到有一个处理者能够处理它为止。这种模式可以避免请求发送者和请求处理者之间的紧耦合关系。

主要概念

• Handler（处理者）：定义了处理请求的接口，并实现具体的处理逻辑。如果该处理者无法处理请求，它会将请求传递给链中的下一个处理者。
• ConcreteHandler（具体处理者）：实现了Handler接口，处理请求。如果无法处理请求，它会将请求传递给链中的下一个处理者。
• Client（客户端）：发起请求，并将请求传递给链中的第一个处理者。

主要角色

1. Handler（处理者）：定义了一个接口来处理请求，提供了设置和获取下一个处理者的机制。
2. ConcreteHandler（具体处理者）：实现了Handler接口，处理请求。如果无法处理，则将请求传递给链中的下一个处理者。
3. Client（客户端）：将请求传递给链中的第一个处理者。

示例代码

以下是一个关于日志处理系统的Java示例，演示如何使用责任链模式（Chain of Responsibility）来处理不同级别的日志请求（如错误、警告和信息）。在这个例子中，每个日志处理器（处理者）都能处理特定级别的日志请求，如果它无法处理，则将请求传递给下一个处理器。

1. 定义日志级别

首先，我们定义日志的不同级别：

class LogLevel {
    public static final int INFO = 1;
    public static final int WARNING = 2;
    public static final int ERROR = 3;
}

　　

2. 定义Handler接口

定义处理日志请求的抽象处理器类，包含设置下一个处理器的方法和处理请求的方法。

// 抽象处理器类
abstract class Logger {
    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);
}

　　

3. 具体处理器

每个具体处理器处理特定级别的日志请求。

// 信息级别日志处理器
class InfoLogger extends Logger {
    public InfoLogger(int level) {
        this.level = level;
    }

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

// 警告级别日志处理器
class WarningLogger extends Logger {
    public WarningLogger(int level) {
        this.level = level;
    }

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

　　

4. 构建责任链

客户端代码中，创建日志处理器并构建责任链。

public class ChainOfResponsibilityExample {
    private static Logger getChainOfLoggers() {
        // 创建具体的日志处理器
        Logger errorLogger = new ErrorLogger(LogLevel.ERROR);
        Logger warningLogger = new WarningLogger(LogLevel.WARNING);
        Logger infoLogger = new InfoLogger(LogLevel.INFO);

        // 构建责任链
        errorLogger.setNextLogger(warningLogger);
        warningLogger.setNextLogger(infoLogger);

        return errorLogger;
    }

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

        // 发送不同级别的日志请求
        loggerChain.logMessage(LogLevel.INFO, "This is an informational message.");  // 输出: Info Logger: This is an informational message.
        loggerChain.logMessage(LogLevel.WARNING, "This is a warning message.");      // 输出: Warning Logger: This is a warning message.
        loggerChain.logMessage(LogLevel.ERROR, "This is an error message.");         // 输出: Error Logger: This is an error message.
    }
}

　　

5. 运行结果

运行上述代码时，不同级别的日志消息将由相应的处理器处理：

• 当发送INFO级别的日志请求时，只有InfoLogger会处理它。
• 当发送WARNING级别的日志请求时，WarningLogger会处理它并传递给InfoLogger。
• 当发送ERROR级别的日志请求时，ErrorLogger会处理它并传递给所有其他日志处理器。

• 灵活性：可以根据需要轻松调整处理器的顺序或添加新的处理器。
• 可扩展性：增加新处理器无需修改现有处理器，只需添加到链中即可。
• 职责分离：每个处理器只处理它负责的请求类型，使得系统职责更加清晰