编程设计模式之责任链模式

为什么有责任链模式？

在软件开发中，经常会遇到需要处理一系列相似但不完全相同的请求或事件的情况。如果每个请求都由单独的逻辑处理，会导致代码重复和耦合度增加。责任链模式就是为了解决这一问题而诞生的。

责任链模式的设计思路

责任链模式的核心思想是将请求或事件的处理者组织成一条链，并在接收到请求时，沿着这条链逐个处理，直到有一个处理者能够处理该请求为止。

责任链模式包含三个主要角色：

Handler（处理者）：定义了处理请求的接口，并维护了一个对下一个处理者的引用。
ConcreteHandler（具体处理者）：实现了处理请求的具体逻辑，如果自己不能处理该请求，则将请求传递给下一个处理者。
Client（客户端）：创建责任链并将请求发送给责任链的头部。

Java示例代码

下面是一个简单的Java示例代码，演示了责任链模式的应用：

java 复制代码

// 处理请求的接口
interface Handler {
    void handleRequest(int request);
}

// 具体处理者A
class ConcreteHandlerA implements Handler {
    private Handler nextHandler;

    public ConcreteHandlerA(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    @Override
    public void handleRequest(int request) {
        if (request < 10) {
            System.out.println("ConcreteHandlerA 处理请求：" + request);
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        }
    }
}

// 具体处理者B
class ConcreteHandlerB implements Handler {
    private Handler nextHandler;

    public ConcreteHandlerB(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    @Override
    public void handleRequest(int request) {
        if (request < 20) {
            System.out.println("ConcreteHandlerB 处理请求：" + request);
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        }
    }
}

// 客户端代码
public class Main {
    public static void main(String[] args) {
        // 创建具体处理者
        Handler handlerA = new ConcreteHandlerA(null);
        Handler handlerB = new ConcreteHandlerB(handlerA);

        // 发送请求给责任链的头部
        handlerB.handleRequest(5);
        handlerB.handleRequest(15);
        handlerB.handleRequest(25);
    }
}

在这个示例中，请求会从责任链的头部（ConcreteHandlerB）开始传递，如果某个处理者能够处理该请求，则直接处理；否则，将请求传递给下一个处理者，直到有一个处理者能够处理为止。

SpringBoot工程中如何应用责任链模式

在SpringBoot工程中，我们可以使用责任链模式来处理一系列的拦截器或过滤器，例如HTTP请求的拦截器链。

首先，定义处理请求的接口：

java 复制代码

// HTTP请求处理接口
public interface RequestHandler {
    void handleRequest(HttpServletRequest request, HttpServletResponse response, RequestHandlerChain chain);
}

// 请求处理链
public interface RequestHandlerChain {
    void doHandle(HttpServletRequest request, HttpServletResponse response);
}

然后，实现具体的处理者：

java 复制代码

// HTTP请求日志记录处理者
@Component
public class HttpRequestLoggingHandler implements RequestHandler {
    @Override
    public void handleRequest(HttpServletRequest request, HttpServletResponse response, RequestHandlerChain chain) {
        System.out.println("记录HTTP请求日志");
        chain.doHandle(request, response);
    }
}

// 权限验证处理者
@Component
public class AuthenticationHandler implements RequestHandler {
    @Override
    public void handleRequest(HttpServletRequest request, HttpServletResponse response, RequestHandlerChain chain) {
        System.out.println("进行权限验证");
        chain.doHandle(request, response);
    }
}

最后，在配置类中将处理者组织成责任链：

java 复制代码

@Configuration
public class RequestHandlerConfig {
    @Autowired
    private List<RequestHandler> requestHandlers;

    @Bean
    public RequestHandlerChain requestHandlerChain() {
        RequestHandlerChain chain = new RequestHandlerChain() {
            private Iterator<RequestHandler> iterator = requestHandlers.iterator();

            @Override
            public void doHandle(HttpServletRequest request, HttpServletResponse response) {
                if (iterator.hasNext()) {
                    iterator.next().handleRequest(request, response, this);
                }
            }
        };
        return chain;
    }
}

通过这种方式，在SpringBoot工程中，我们可以方便地构建出一个HTTP请求处理的责任链，每个请求会依次经过责任链中的处理者，直到有一个处理者能够处理该请求为止。