【设计模式】Java 设计模式之责任链模式（Chain of Responsibility）

责任链模式是一种行为设计模式，它允许请求在多个处理对象之间传递，直至被处理。此模式降低了请求发送者与处理者之间的耦合度，提高了系统的灵活性和可扩展性。它适用于多个处理器按特定顺序处理请求、动态改变处理流程、未知处理者数量等场景。然而，责任链模式也存在请求可能不被处理、系统性能下降以及调试复杂的缺点。在实际应用中，需避免无限循环，提供明确的错误处理机制，考虑性能优化，保持链的简洁性，并文档化链的结构

新手村长

2423人浏览 · 2024-03-21 10:30:07

新手村长 · 2024-03-21 10:30:07 发布

责任链模式（Chain of Responsibility）

一、概述

责任链模式是一种行为设计模式，它允许请求在对象链中传递。每个对象都有机会处理该请求，并且能将其传递给链中的下一个对象。这种模式为请求创建了一个处理对象的链，并沿着这条链传递该请求，直到有一个对象处理它为止。

二、模式结构

责任链模式主要包含以下几个角色：

抽象处理者（Handler）角色：定义了一个处理请求的接口，同时含有一个后继者的引用。
具体处理者（Concrete Handler）角色：实现抽象处理者的处理方法，判断能否处理本次请求，如果可以则处理，否则将该请求转发给它的后继者。
客户类（Client）角色：创建处理链，并向链头的具体处理者对象提交请求。

三、实现方式

通常，实现责任链模式时，我们会在每个处理者对象中维护一个指向下一个处理者的引用。当处理者无法处理请求时，它会将该请求传递给下一个处理者。

四、代码示例

下面是一个简单的责任链模式的代码示例：

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

    public void setNextHandler(Handler handler) {
        this.nextHandler = handler;
    }

    public abstract void handleRequest(String request);
}

// 具体处理者A
public class ConcreteHandlerA extends Handler {
    @Override
    public void handleRequest(String request) {
        if ("TypeA".equals(request)) {
            System.out.println("ConcreteHandlerA handles request: " + request);
        } else {
            if (nextHandler != null) {
                nextHandler.handleRequest(request);
            } else {
                System.out.println("No handler for request: " + request);
            }
        }
    }
}

// 具体处理者B
public class ConcreteHandlerB extends Handler {
    @Override
    public void handleRequest(String request) {
        if ("TypeB".equals(request)) {
            System.out.println("ConcreteHandlerB handles request: " + request);
        } else {
            if (nextHandler != null) {
                nextHandler.handleRequest(request);
            } else {
                System.out.println("No handler for request: " + request);
            }
        }
    }
}

// 客户类
public class Client {
    public static void main(String[] args) {
        Handler handlerA = new ConcreteHandlerA();
        Handler handlerB = new ConcreteHandlerB();

        handlerA.setNextHandler(handlerB);

        handlerA.handleRequest("TypeA"); // 输出: ConcreteHandlerA handles request: TypeA
        handlerA.handleRequest("TypeB"); // 输出: ConcreteHandlerB handles request: TypeB
        handlerA.handleRequest("TypeC"); // 输出: No handler for request: TypeC
    }
}

五、优缺点分析

优点：

降低了对象之间的耦合度。该模式使得一个对象无须知道到底哪一个对象会处理其请求以及链的结构。
增强了系统的可扩展性。可以根据需要增加新的请求处理类，满足开闭原则。
增强了给对象指派职责的灵活性。当工作流程发生变化，可以动态地改变链内的成员或者调动它们的次序，也可动态地新增或者删除责任。

缺点：

不能保证每个请求一定被处理。由于一个请求没有明确的接收者，所以不能保证它一定会被处理，该请求可能一直传到链的末端都得不到处理。
对比较长的职责链，请求的处理可能涉及多个处理对象，系统性能将受到一定影响。

六、常见应用场景

责任链模式常见于以下场景：

多个对象可以处理同一请求，但具体由哪个对象处理该请求在运行时确定。
当你想在不明确指定接收者的情况下，向多个对象中的一个提交一个请求。
当系统需要动态地决定请求的处理者时。

七、实际应用案例解读

假设在一个日志系统中，不同类型的日志需要不同的处理器来处理，如错误日志、警告日志、信息日志等。我们可以使用责任链模式来构建一个日志处理链，每个处理器负责处理特定类型的日志，如果无法处理则传递给下一个处理器。

例如，ErrorHandler 处理错误日志，WarningHandler 处理警告日志，InfoHandler 处理信息日志。当收到一条日志时，先传递给 ErrorHandler，如果它不能处理（比如这条日志不是错误类型），则传递给 WarningHandler，如果还是不能处理，最后传递给 InfoHandler。

代码示例：

// 日志处理器接口
public interface LogHandler {
    boolean handle(Log log);
}

// 错误日志处理器
public class ErrorHandler implements LogHandler {
    @Override
    public boolean handle(Log log) {
        if (log.getLevel().equals(LogLevel.ERROR)) {
            System.out.println("Error log handled: " + log.getMessage());
            return true; // 已处理
        }
        return false; // 未处理，传递给下一个处理器
    }
}

// 警告日志处理器
public class WarningHandler implements LogHandler {
    private LogHandler nextHandler;

    public WarningHandler(LogHandler nextHandler) {
        this.nextHandler = nextHandler;
    }

    @Override
    public boolean handle(Log log) {
        if (log.getLevel().equals(LogLevel.WARNING)) {
            System.out.println("Warning log handled: " + log.getMessage());
            return true;
        }
        if (nextHandler != null) {
            return nextHandler.handle(log);
        }
        return false;
    }
}

// 信息日志处理器
public class InfoHandler implements LogHandler {
    @Override
    public boolean handle(Log log) {
        if (log.getLevel().equals(LogLevel.INFO)) {
            System.out.println("Info log handled: " + log.getMessage());
            return true;
        }
        return false;
    }
}

// 日志类
public class Log {
    private LogLevel level;
    private String message;

    // 省略构造器和其他方法
}

// 日志级别枚举
public enum LogLevel {
    ERROR, WARNING, INFO
}

// 客户类
public class LoggingSystem {
    public static void main(String[] args) {
        LogHandler errorHandler = new ErrorHandler();
        LogHandler warningHandler = new WarningHandler(new InfoHandler());

        // 组装责任链
        warningHandler.handle(new Log(LogLevel.ERROR, "This is an error log")); // Error log handled
        warningHandler.handle(new Log(LogLevel.WARNING, "This is a warning log")); // Warning log handled
        warningHandler.handle(new Log(LogLevel.INFO, "This is an info log")); // Info log handled
        warningHandler.handle(new Log(LogLevel.DEBUG, "This is a debug log")); // 无处理器处理，因为没有对应的Debug处理器
    }
}

在这个例子中，ErrorHandler、WarningHandler 和 InfoHandler 各自负责处理特定类型的日志。WarningHandler 持有对 InfoHandler 的引用，以便在无法处理警告日志时传递给 InfoHandler。如果 InfoHandler 也不能处理，那么该日志就不会被进一步处理。

八、总结

责任链模式提供了一种将多个请求处理器组织成链的方式，使得请求能够沿着链传递直到被处理。它降低了请求发送者和多个请求处理者之间的耦合度，提高了系统的灵活性和可扩展性。然而，使用责任链模式时需要注意，过长的责任链可能会影响系统性能，且需要确保每个请求都能被正确处理，避免请求丢失。在实际应用中，应根据具体场景和需求来选择合适的实现方式。
九、责任链模式的适用场景

责任链模式在许多场景中都非常有用，特别是在以下情况中：

多个处理器按特定顺序处理请求：当系统中有多个组件需要按特定顺序处理某个请求时，责任链模式可以确保请求按照正确的顺序传递到每个组件。
动态改变处理流程：如果处理请求的流程经常需要动态改变，责任链模式非常适用。通过添加、删除或重新排序处理器，可以轻松改变处理流程。
未知的处理者数量：当处理请求所需的处理器数量未知或可能变化时，责任链模式允许灵活地添加或删除处理器，而无需修改其他代码。
日志记录、异常处理或权限检查：这些通常涉及多个级别的处理，每个级别可能有自己的处理逻辑。责任链模式可以确保这些请求按正确的顺序和逻辑进行处理。
GUI事件处理：在图形用户界面（GUI）中，用户交互事件（如点击、键盘输入等）通常需要经过多个处理阶段，如事件分发、处理、反馈等。责任链模式可以帮助组织这些处理阶段。
中间件或管道处理：在分布式系统或中间件中，请求可能需要经过多个服务或组件的处理。责任链模式可以确保请求按照正确的顺序和逻辑在这些服务或组件之间传递。