设计模式Chain of Responsibility(责任链)

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

主要概念

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

主要角色

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

示例代码

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

1. 定义日志级别

首先,我们定义日志的不同级别:

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

  

2. 定义Handler接口

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// 抽象处理器类
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. 具体处理器

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
// 信息级别日志处理器
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. 构建责任链

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
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会处理它并传递给所有其他日志处理器。
  • 灵活性:可以根据需要轻松调整处理器的顺序或添加新的处理器。
  • 可扩展性:增加新处理器无需修改现有处理器,只需添加到链中即可。
  • 职责分离:每个处理器只处理它负责的请求类型,使得系统职责更加清晰
posted @   我爱麻辣香锅  阅读(9)  评论(0编辑  收藏  举报
相关博文:
阅读排行:
· 10亿数据,如何做迁移?
· 清华大学推出第四讲使用 DeepSeek + DeepResearch 让科研像聊天一样简单!
· 推荐几款开源且免费的 .NET MAUI 组件库
· 易语言 —— 开山篇
· Trae初体验
点击右上角即可分享
微信分享提示