目录
- 1. 说明
- 2. 应用场景
- 3. 结构图
- 4. 构成
- 5. 适用性
- 6. 优点
- 7. 缺点
- 8. java示例
1. 说明
- 1.使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。
- 2.将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。
- 3.责任链模式（Chain of Responsibility Pattern）是一种行为设计模式。
- 4.它为请求的发送者和接收者之间解耦提供了一种相对松散的耦合方式，使得多个对象都有机会处理这个请求，或者将这个请求传递给链中的下一个对象。
- 5.这种模式将多个处理者对象连成一条链，并沿着这条链传递请求，直到有一个对象处理它为止。
- 6.这种模式给予请求传递的灵活性，并且使得对象不需要知道链的结构。
2. 应用场景
- 1.多个对象可以处理一个请求，但具体由哪个对象处理在运行时决定。
- 2.在不明确指定接收者的情况下，向多个对象中的一个提交一个请求。
- 3.可动态指定一组对象处理请求。
3. 结构图
4. 构成
- 1.抽象处理者（Handler）：定义一个处理请求的接口，通常包含一个或多个指向下一个处理者的引用（即链中的下一个节点）和一个处理请求的接口方法。(可选)实现后继链。
- 2.具体处理者（Concrete Handler）：实现了抽象处理者角色定义的接口，主要负责处理它负责的请求，或者将请求转发给链中的下一个处理者，以及可以访问链中下一个处理者的引用。处理它所负责的请求;可访问它的后继者;如果可处理该请求，就处理它，否则将该请求转发给后继者。
- 3.客户端（Client）：创建处理链，并向链中的第一个处理者对象提交请求。向链上的具体处理者(ConcreteHandler)对象提交请求。
5. 适用性
- 1.有多个的对象可以处理一个请求，哪个对象处理该请求运行时刻自动确定。
- 2.想在不明确指定接收者的情况下向多个对象中的一个提交一个请求。
- 3.可处理一个请求的对象集合应被动态指定。
6. 优点
- 1.降低耦合度：将请求的发送者和接收者解耦。
- 2.简化对象：使得对象不需要知道链的结构。
- 3.增强给请求分配职责的灵活性：通过改变链内的成员或调动它们的次序，允许动态地新增或者删除处理者。
- 4.增加新的处理类很容易：无须修改现有代码，符合开闭原则。
7. 缺点
- 1.不能保证请求一定被处理：如果没有处理者处理该请求，请求就会一直传递下去，直到链的末尾。
- 2.系统性能会受到一定影响：因为请求在链中传递，每个处理者都需要对请求进行判断，增加了系统响应时间。
- 3.调试复杂：链中处理者众多，增加了系统复杂性，可能难以追踪和调试。
8. java示例
package com.learning.responsibility.example;
// 日志处理器接口
public interface Logger {
void log(LogMessage message);
void setNextLogger(Logger nextLogger);
}
package com.learning.responsibility.example;
// 日志级别枚举
public enum LogLevel {
INFO, DEBUG, ERROR
}
package com.learning.responsibility.example;
// 日志消息类
public class LogMessage {
private LogLevel level;
private String message;
public LogMessage(LogLevel level, String message) {
this.level = level;
this.message = message;
}
public LogLevel getLevel() {
return level;
}
public String getMessage() {
return message;
}
}
package com.learning.responsibility.example;
// 抽象日志处理器类
public abstract class AbstractLogger implements Logger {
protected int level;
protected Logger nextLogger;
@Override
public void setNextLogger(Logger nextLogger) {
this.nextLogger = nextLogger;
}
protected void writeToLog(String message) {
System.out.println("日志级别：" + level + ", 日志内容：" + message);
}
@Override
public void log(LogMessage message) {
if (this.level <= message.getLevel().ordinal()) {
write(message);
}
if (nextLogger != null) {
nextLogger.log(message);
}
}
abstract protected void write(LogMessage message);
}
package com.learning.responsibility.example;
// INFO日志处理器
public class InfoLogger extends AbstractLogger {
public InfoLogger(int level) {
this.level = level;
}
@Override
protected void write(LogMessage message) {
if (message.getLevel() == LogLevel.INFO) {
writeToLog(message.getMessage());
}
}
}
package com.learning.responsibility.example;
// DEBUG日志处理器
public class DebugLogger extends AbstractLogger {
public DebugLogger(int level) {
this.level = level;
}
@Override
protected void write(LogMessage message) {
if (message.getLevel() == LogLevel.DEBUG) {
writeToLog(message.getMessage());
}
}
}
package com.learning.responsibility.example;
// ERROR日志处理器
public class ErrorLogger extends AbstractLogger {
public ErrorLogger(int level) {
this.level = level;
}
@Override
protected void write(LogMessage message) {
if (message.getLevel() == LogLevel.ERROR) {
writeToLog(message.getMessage());
}
}
}
package com.learning.responsibility.example;
public class Client {
public static void main(String[] args) {
Logger loggerChain = null; // 创建日志处理器链
Logger infoLogger = new InfoLogger(LogLevel.INFO.ordinal());
Logger debugLogger = new DebugLogger(LogLevel.DEBUG.ordinal());
Logger errorLogger = new ErrorLogger(LogLevel.ERROR.ordinal());
// 设置链
infoLogger.setNextLogger(debugLogger);
debugLogger.setNextLogger(errorLogger);
loggerChain = infoLogger;
// 发送日志消息
loggerChain.log(new LogMessage(LogLevel.INFO, "info级别日志"));
loggerChain.log(new LogMessage(LogLevel.DEBUG, "debug级别日志"));
loggerChain.log(new LogMessage(LogLevel.ERROR, "error级别日志"));
}
}
- 9.示例截图
