目录
- 一、简介
- 二、责任链模式
- 2.1、处理器接口
- 2.2、具体处理器类
- 2.3、使用
- 三、优点与缺点
一、简介
责任链模式（Chain of Responsibility Pattern）是一种行为设计模式，允许你将请求沿着处理者链进行传递，直到有一个处理者能够处理该请求为止。这种模式解耦了发送者和接收者之间的关系，允许多个对象对请求进行处理，但发送者无需知道请求的处理过程和最终哪个对象处理了它。
在责任链模式中，请求通常沿着一个对象链传递，每个处理者对象都包含了自己的处理逻辑和对下一个处理者的引用。当收到请求时，处理者可以选择自行处理、部分处理或将请求传递给链中的下一个处理者。该模式通常包含以下角色：
- Handler（抽象处理者）： 定义了处理请求的接口，通常包含一个指向下一个处理者的引用。
- ConcreteHandler（具体处理者）： 实现抽象处理者接口，在接收到请求后，如果能够处理则处理请求，否则将请求传递给下一个处理者。
责任链模式能够动态地建立请求的处理链，可以灵活地添加、移除或调整处理者对象，根据需求自由组合处理链。这样可以避免请求发送者和接收者之间的直接耦合，提高了系统的灵活性和可维护性。
二、责任链模式
当涉及责任链模式时，可以创建一个处理器接口 Logger 和具体的处理器类 DebugLogger、InfoLogger、WarningLogger、ErrorLogger 和 FatalLogger。每个处理器类都可以处理相应级别的日志，如果不能处理，则将日志传递给下一个处理器
2.1、处理器接口
// 处理器接口
public interface Logger {
void setNextLogger(Logger nextLogger);
void logMessage(int level, String message);
}
2.2、具体处理器类
DebugLogger
public class DebugLogger implements Logger {
private Logger nextLogger;
@Override
public void setNextLogger(Logger nextLogger) {
this.nextLogger = nextLogger;
}
@Override
public void logMessage(int level, String message) {
if (level <= 1) {
System.out.println("Debug Logger: " + message);
} else if (nextLogger != null) {
nextLogger.logMessage(level, message);
}
}
}
InfoLogger
public class InfoLogger implements Logger {
private Logger nextLogger;
@Override
public void setNextLogger(Logger nextLogger) {
this.nextLogger = nextLogger;
}
@Override
public void logMessage(int level, String message) {
if (level <= 2) {
System.out.println("Info Logger: " + message);
} else if (nextLogger != null) {
nextLogger.logMessage(level, message);
}
}
}
WarningLogger
public class WarningLogger implements Logger {
private Logger nextLogger;
@Override
public void setNextLogger(Logger nextLogger) {
this.nextLogger = nextLogger;
}
@Override
public void logMessage(int level, String message) {
if (level <= 3) {
System.out.println("Warning Logger: " + message);
} else if (nextLogger != null) {
nextLogger.logMessage(level, message);
}
}
}
ErrorLogger
public class ErrorLogger implements Logger {
private Logger nextLogger;
@Override
public void setNextLogger(Logger nextLogger) {
this.nextLogger = nextLogger;
}
@Override
public void logMessage(int level, String message) {
if (level <= 4) {
System.out.println("Error Logger: " + message);
} else if (nextLogger != null) {
nextLogger.logMessage(level, message);
}
}
}
FatalLogger
public class FatalLogger implements Logger {
private Logger nextLogger;
@Override
public void setNextLogger(Logger nextLogger) {
this.nextLogger = nextLogger;
}
@Override
public void logMessage(int level, String message) {
if (level <= 5) {
System.out.println("Fatal Logger: " + message);
} else if (nextLogger != null) {
nextLogger.logMessage(level, message);
}
}
}
2.3、使用
// 测试类
public class ChainOfResponsibilityExample {
public static void main(String[] args) {
Logger debugLogger = new DebugLogger();
Logger infoLogger = new InfoLogger();
Logger warningLogger = new WarningLogger();
Logger errorLogger = new ErrorLogger();
Logger fatalLogger = new FatalLogger();
// 构建责任链
debugLogger.setNextLogger(infoLogger);
infoLogger.setNextLogger(warningLogger);
warningLogger.setNextLogger(errorLogger);
errorLogger.setNextLogger(fatalLogger);
// 测试责任链
debugLogger.logMessage(2, "This is an info message.");
debugLogger.logMessage(4, "This is an error message.");
debugLogger.logMessage(5, "This is a fatal message.");
}
}
运行结果：
Info Logger: This is an info message.
Error Logger: This is an error message.
Fatal Logger: This is a fatal message.
在这个示例中，我们创建了多个具体的处理器类来处理不同级别的日志。通过构建责任链，每个处理器类中实现了处理逻辑，并且能够将日志传递给下一个处理器，直至最终处理。在测试类中，演示了发送不同级别的日志请求，并观察责任链的处理过程。
三、优点与缺点
责任链模式有一些优点和缺点，让我们来看一下：
优点
- 降低耦合度： 将请求发送者和接收者解耦，发送者无需知道请求的处理者，也不需要知道请求是如何被处理以及谁来处理。
- 灵活性和可扩展性：可以动态地调整、增加或删除处理者对象，也可以改变它们之间的顺序，以满足不同的处理需求。
- 单一职责原则： 每个具体处理者都专注于自己的处理逻辑，使得系统更加符合单一职责原则。
缺点
- 请求处理不保证被执行：如果请求没有被任何处理者处理，可能会出现未处理的情况，这需要在设计时考虑清楚。
- 性能问题：如果责任链太长或者处理者逻辑过于复杂，可能会影响性能。同时，递归地向下传递请求可能会影响性能。
责任链模式适合处理对象之间存在多种处理方式的情况，但在使用时需要注意权衡，避免责任链过长、过于复杂，以及处理者责任划分不清晰等问题。
