责任链模式：解耦请求与处理，打造灵活系统架构

责任链模式：解耦请求与处理，打造灵活系统架构

引用

CSDN

1.

https://blog.csdn.net/weixin_41883161/article/details/136496873

责任链模式是一种行为设计模式，通过使多个对象都有机会处理请求，避免了请求发送者与接收者之间的直接耦合。它通过将请求沿着对象链传递，直到有对象处理它为止，实现了请求的动态处理。在实际开发中，责任链模式广泛应用于日志处理、异常处理和权限校验等场景，特别是在Spring框架中，通过HandlerAdapter、MessageListenerAdapter等机制，实现了对不同组件和接口的适配和解耦。责任链模式的主要优势在于降低耦合度、增强系统的灵活性和可扩展性，但需要注意链条过长可能带来的性能问题和调试难度。通过责任链模式，可以打造一个职责单一、结构清晰、易于维护的系统架构。

责任链模式（Chain of Responsibility）

定义

责任链模式是一种行为设计模式，使得多个对象都有机会处理请求，从而避免请求的发送者与接收者之间的耦合关系。通过将请求沿着对象链传递，直到有对象处理它为止，可以动态地指定处理某个请求的对象。

使用场景

1. 多个对象可以处理同一个请求，但具体由哪个对象处理由运行时决定。
2. 需要在不明确接收者的情况下，向多个对象中的一个提交请求。
3. 请求的处理者应当从多个可用的处理者中选择一个。

主要角色

1. 处理器链（HandlerChain）：管理和调用链条中的处理器。
2. 抽象处理器（Handler）：定义处理请求的接口，并保持对下一个处理器的引用。
3. 具体处理器（ConcreteHandler）：实现处理请求的具体逻辑。

类图

示例代码

数组实现

通过数组实现的责任链模式，每个处理器存储在一个列表中，依次调用处理器进行处理。

public interface IHandler {
    boolean handle();
}

public class HandlerA implements IHandler {
    @Override
    public boolean handle() {
        boolean handled = false;
        System.out.println("HandlerA handle()");
        return handled;
    }
}

public class HandlerB implements IHandler {
    @Override
    public boolean handle() {
        boolean handled = false;
        System.out.println("HandlerB handle()");
        return handled;
    }
}

public class HandlerChain {
    private final List<IHandler> handlers = new ArrayList<>();
    public void addHandler(IHandler handler) {
        this.handlers.add(handler);
    }
    public void handle() {
        for (IHandler handler : handlers) {
            boolean handled = handler.handle();
            if (handled) {
                break;
            }
        }
    }
}

链表实现

通过链表实现的责任链模式，每个处理器持有对下一个处理器的引用，依次调用处理器进行处理。

public abstract class Handler {
    protected Handler nextHandler = null;
    public void setNextHandler(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }
    public final void handle() {
        boolean handled = doHandle();
        if (nextHandler != null && !handled) {
            nextHandler.handle();
        }
    }
    protected abstract boolean doHandle();
}

public class HandlerA extends Handler {
    @Override
    protected boolean doHandle() {
        boolean handled = false;
        System.out.println("HandlerA doHandle()");
        return handled;
    }
}

public class HandlerB extends Handler {
    @Override
    protected boolean doHandle() {
        boolean handled = false;
        System.out.println("HandlerB doHandle()");
        return handled;
    }
}

public class HandlerChain {
    private Handler head = null;
    private Handler tail = null;
    public void addHandler(Handler handler) {
        handler.setNextHandler(null);
        if (head == null) {
            head = handler;
            tail = handler;
            return;
        }
        tail.setNextHandler(handler);
        tail = handler;
    }
    public void handle() {
        if (head != null) {
            head.handle();
        }
    }
}

public class Client {
    public static void main(String[] args) {
        HandlerChain chain = new HandlerChain();
        chain.addHandler(new HandlerA());
        chain.addHandler(new HandlerB());
        chain.handle();
    }
}

工作中遇到场景

责任链模式在企业级应用和框架中有广泛的应用，以下是一些具体的场景：

Spring 框架中的应用

1. HandlerAdapter：
   在Spring MVC中，HandlerAdapter接口及其实现类用于适配不同类型的处理器（Controller）。不同的Controller可能有不同的接口，而HandlerAdapter负责将它们适配到Spring MVC框架中，以便它们能够正确处理请求。例如，SimpleControllerHandlerAdapter适配传统的Controller，而HttpRequestHandlerAdapter适配Http请求处理器。

2. MessageListenerAdapter：
   在Spring的消息处理中，MessageListenerAdapter用于将普通的Java对象转换为消息监听器。通过适配器模式，可以将接收到的消息传递给目标对象的特定方法进行处理，从而简化消息监听器的开发。

3. JDBC适配器：
   Spring的JdbcTemplate和NamedParameterJdbcTemplate等类使用了适配器模式，将JDBC的底层操作适配到Spring的数据访问框架中，使得开发者可以更方便地使用JDBC进行数据库操作。这些模板类封装了JDBC的复杂操作，使得数据库操作更简洁。

4. Advisor适配器：
   在Spring AOP中，AdvisorAdapter接口定义了如何适配不同类型的通知（Advice）。Spring通过适配器模式将不同类型的通知适配到切面（Aspect）中，从而实现对不同通知的灵活支持。这样可以在不修改核心业务逻辑的情况下，添加日志、事务等功能。

5. HandlerInterceptor适配器：
   Spring MVC中的HandlerInterceptor接口定义了拦截器的方法。不同的拦截器可能只实现了其中的某些方法，而适配器模式用于适配这些拦截器，使得它们只需要实现自己关心的方法。拦截器可以在请求处理的不同阶段进行拦截处理，增强了系统的可扩展性。

其他应用场景

1. 责任链模式在日志处理中的应用：
   在日志处理系统中，不同级别的日志处理器可以形成一条责任链。例如，错误日志处理器、警告日志处理器和信息日志处理器可以依次处理日志消息，直到找到适合的处理器。

2. 异常处理：
   在复杂系统中，不同的异常处理器可以形成一条责任链，根据异常类型逐层传递和处理异常。例如，系统异常处理器、应用异常处理器和业务异常处理器可以形成一条责任链，按需处理不同级别的异常。

3. 权限校验：
   在权限校验系统中，不同的权限校验器可以形成一条责任链，逐层校验用户的权限。例如，模块权限校验器、功能权限校验器和操作权限校验器可以依次校验用户的权限。

责任链模式的优缺点

优点

1. 降低耦合度：请求发送者和接收者解耦，发送者无需关心具体处理者。
2. 动态组合：可以通过动态地添加或删除处理器，灵活地改变责任链的结构。
3. 责任分担：各个处理器只需处理自己负责的部分，职责单一明确，便于维护。

缺点

1. 性能问题：责任链较长时，可能会导致请求处理过程较长，影响性能。
2. 调试困难：由于请求在多个处理器间传递，可能会增加调试的难度。
3. 职责不明确：如果责任链过长或者处理器职责划分不清，可能导致责任不明确，影响代码可读性和维护性。

适用场景

1. 有多个对象可以处理同一个请求，具体处理者在运行时决定。
2. 需要在多个对象中找到一个合适的处理者来处理请求。
3. 希望将请求的发送者与接收者解耦，使得系统更灵活和可扩展。

通过以上内容的优化和扩展，我们可以更全面地理解责任链模式的定义、使用场景、主要角色、实现方式、实际应用和优缺点。这种模式在实际开发中有广泛的应用，可以有效提升系统的灵活性和可维护性。