当前位置：首页 > article >正文

【责任链模式的多种实现方式及其应用】

article 2025/3/20 21:13:26

责任链模式的多种实现方式及其应用

责任链模式是一种行为设计模式，旨在将请求沿着一个处理者链传递，直到有处理者处理该请求。它通过将请求的发送者与接收者解耦，实现灵活的请求处理机制。本文将介绍责任链模式的四种常见实现方式，并提供每种方式的经典示例。
设计原则
责任链模式的核心在于将请求的发送与处理解耦。它遵循以下设计原则：
单一职责原则： 每个处理者只负责处理自己能处理的请求部分。
开闭原则： 可以通过添加新的处理者来扩展系统，而无需修改现有代码。
低耦合： 请求的发送者无需知道链中的哪个处理者会处理请求。
经典实现： 在经典的责任链模式中，处理者对象形成一个链式结构。每个处理者都有一个指向下一个处理者的引用，当一个处理者不能处理请求时，它会将请求传递给链中的下一个处理者。
变体实现
除了经典的链式结构，责任链模式还有其他实现方式，如集合式遍历结构和拦截器链等。
集合式遍历结构： 通过使用列表或集合存储处理者，并遍历集合来处理请求。这种方式允许更灵活的处理者管理。
拦截器链： 类似于Java中的Servlet过滤器链，允许在请求处理前后执行额外操作。
实际应用场景
事件处理系统： 例如GUI事件处理，事件沿着组件链传递，直到被某个组件处理。
日志记录系统： 不同的日志处理器可以处理不同级别的日志信息。
请求过滤系统： 如网络请求的过滤和验证，可以通过责任链模式实现动态的过滤器配置。

1. 链式节点结构

概念：每个处理者有一个指向下一个处理者的引用。请求沿着节点链传递，直到某个处理者处理请求或链的末端。

示例代码：

abstract class NodeHandler {
    protected NodeHandler next;

    public void setNext(NodeHandler next) {
        this.next = next;
    }

    public void handleRequest(String request) {
        if (canHandle(request)) {
            processRequest(request);
        } else if (next != null) {
            next.handleRequest(request);
        }
    }

    protected abstract boolean canHandle(String request);
    protected abstract void processRequest(String request);
}

class NodeHandlerA extends NodeHandler {
    @Override
    protected boolean canHandle(String request) {
        return "A".equals(request);
    }

    @Override
    protected void processRequest(String request) {
        System.out.println("NodeHandlerA processed: " + request);
    }
}

应用场景：适用于处理流程明确且顺序固定的场景，如审批流程。

2. 集合式遍历结构

概念：使用列表或集合存储处理者，通过遍历集合来处理请求。

示例代码：

class CollectionHandler {
    private List<NodeHandler> handlers = new ArrayList<>();

    public void addHandler(NodeHandler handler) {
        handlers.add(handler);
    }

    public void handleRequest(String request) {
        for (NodeHandler handler : handlers) {
            if (handler.canHandle(request)) {
                handler.processRequest(request);
                break;
            }
        }
    }
}

应用场景：适用于需要灵活管理处理者顺序的场景，如插件系统。

3. 动态链

概念：允许在运行时动态添加或移除处理者，适用于需要灵活配置的场景。

示例代码：

class DynamicHandler extends NodeHandler {
    @Override
    protected boolean canHandle(String request) {
        return "Dynamic".equals(request);
    }

    @Override
    protected void processRequest(String request) {
        System.out.println("DynamicHandler processed: " + request);
    }
}

// 动态添加或移除处理者
DynamicHandler dynamicHandler = new DynamicHandler();
dynamicHandler.setNext(new NodeHandlerA());

应用场景：适用于需要根据业务需求动态调整处理流程的场景，如策略模式的变体。

4. 拦截器链

概念：类似于Java中的Servlet过滤器链，允许在请求前后进行处理（前置处理和后置处理）。

示例代码：

interface Interceptor {
    void preProcess(String request);
    void postProcess(String request);
}

class InterceptorChain {
    private List<Interceptor> interceptors = new ArrayList<>();

    public void addInterceptor(Interceptor interceptor) {
        interceptors.add(interceptor);
    }

    public void execute(String request) {
        for (Interceptor interceptor : interceptors) {
            interceptor.preProcess(request);
        }
        // 执行核心处理逻辑
        System.out.println("Core processing of: " + request);
        for (Interceptor interceptor : interceptors) {
            interceptor.postProcess(request);
        }
    }
}

class LoggingInterceptor implements Interceptor {
    public void preProcess(String request) {
        System.out.println("Pre-processing: " + request);
    }

    public void postProcess(String request) {
        System.out.println("Post-processing: " + request);
    }
}