java设计模式：04-01-责任链模式

责任链模式（Chain of Responsibility Pattern）

责任链模式（Chain of Responsibility Pattern）是一种行为型设计模式，它允许多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递请求，直到有对象处理它为止。

责任链模式的应用场景

• 审批流程：在审批流程中，不同级别的管理者对请求进行审批，低级别无法处理的请求会传递给高级别的管理者。
• 事件处理系统：在事件处理系统中，事件从一个处理器传递到另一个处理器，直到有处理器处理该事件。
• 日志记录系统：不同的日志记录器处理不同级别的日志信息，低级别的日志记录器无法处理的日志信息会传递给高级别的日志记录器。

责任链模式的实现方式

1. 基本责任链模式

思想：将多个处理对象连成一条链，并沿着这条链传递请求，直到有对象处理它。

实现方式：

// 抽象处理者
abstract class Handler {
    protected Handler successor;

    public void setSuccessor(Handler successor) {
        this.successor = successor;
    }

    public abstract void handleRequest(int request);
}

// 具体处理者1
class ConcreteHandler1 extends Handler {
    public void handleRequest(int request) {
        if (request < 10) {
            System.out.println("ConcreteHandler1 handled request: " + request);
        } else if (successor != null) {
            successor.handleRequest(request);
        }
    }
}

// 具体处理者2
class ConcreteHandler2 extends Handler {
    public void handleRequest(int request) {
        if (request >= 10 && request < 20) {
            System.out.println("ConcreteHandler2 handled request: " + request);
        } else if (successor != null) {
            successor.handleRequest(request);
        }
    }
}

// 具体处理者3
class ConcreteHandler3 extends Handler {
    public void handleRequest(int request) {
        if (request >= 20) {
            System.out.println("ConcreteHandler3 handled request: " + request);
        } else if (successor != null) {
            successor.handleRequest(request);
        }
    }
}

// 客户端代码
public class ChainOfResponsibilityPattern {
    public static void main(String[] args) {
        Handler handler1 = new ConcreteHandler1();
        Handler handler2 = new ConcreteHandler2();
        Handler handler3 = new ConcreteHandler3();

        handler1.setSuccessor(handler2);
        handler2.setSuccessor(handler3);

        int[] requests = {2, 14, 22, 18, 3, 27};

        for (int request : requests) {
            handler1.handleRequest(request);
        }
    }
}

优点：

• 减少耦合：请求的发送者和接收者解耦。
• 增强灵活性：可以动态地改变链内的成员或调整链的顺序。
• 职责分离：每个处理者只需要处理自己负责的那部分请求。

缺点：

• 请求处理可能无结果：如果链内没有合适的处理者，请求可能会落空。
• 性能开销：链的长度可能会影响请求的处理时间。

2. 使用职责链模式处理日志记录

思想：不同级别的日志记录器处理不同级别的日志信息。

实现方式：

// 抽象日志记录器
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);
}

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

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

// 调试级别日志记录器
class DebugLogger extends Logger {
    public DebugLogger(int level) {
        this.level = level;
    }

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

// 错误级别日志记录器
class ErrorLogger extends Logger {
    public ErrorLogger(int level) {
        this.level = level;
    }

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

// 客户端代码
public class ChainOfResponsibilityLogger {
    private static Logger getChainOfLoggers() {
        Logger errorLogger = new ErrorLogger(Logger.ERROR);
        Logger debugLogger = new DebugLogger(Logger.DEBUG);
        Logger infoLogger = new InfoLogger(Logger.INFO);

        infoLogger.setNextLogger(debugLogger);
        debugLogger.setNextLogger(errorLogger);

        return infoLogger;
    }

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

优点：

• 灵活性高：可以根据需要增加或删除日志记录器。
• 职责分离：不同级别的日志由不同的记录器处理，符合单一职责原则。

缺点：

• 请求处理可能无结果：如果没有合适的日志记录器，日志信息可能会丢失。
• 性能开销：链的长度可能会影响日志的记录速度。

总结

责任链模式	优点	缺点
基本责任链模式	减少耦合，增强灵活性，职责分离	请求处理可能无结果，性能开销
处理日志记录	灵活性高，职责分离	请求处理可能无结果，性能开销

选择哪种实现方式应根据具体的需求和系统的复杂度来决定。基本责任链模式适用于一般的请求处理场景，而处理日志记录的职责链模式更适用于需要不同级别处理的日志记录系统。通过合理的设计，可以充分利用责任链模式的优势，减少耦合，提高系统的灵活性和可扩展性。