设计模式：责任链模式

概述

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

使用场景

1. 有多个对象可以处理请求，但具体处理者在运行时刻才确定。
2. 需要动态指定处理多个对象中的一个。
3. 需要在不明确指定接收者的情况下，向多个对象中的一个提交请求。

结构

责任链模式包含以下几个部分：

1. 处理者（Handler）：定义了处理请求的接口，包含一个指向下一个处理者的引用。
2. 具体处理者（ConcreteHandler）：实现处理者接口，处理它所负责的请求。可以访问它的后继者，如果可以处理该请求则处理，否则将请求转发给它的后继者。
3. 客户端（Client）：向链上的具体处理者提交请求。

代码实现

下面是一个 Java 实现责任链模式的例子，展示了如何通过责任链模式处理不同级别的请求。

示例代码：

// 处理者接口
abstract class Handler {
    protected Handler nextHandler;

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

    public abstract void handleRequest(int level);
}

// 具体处理者1
class ConcreteHandler1 extends Handler {
    @Override
    public void handleRequest(int level) {
        if (level == 1) {
            System.out.println("ConcreteHandler1 handled request with level " + level);
        } else if (nextHandler != null) {
            nextHandler.handleRequest(level);
        }
    }
}

// 具体处理者2
class ConcreteHandler2 extends Handler {
    @Override
    public void handleRequest(int level) {
        if (level == 2) {
            System.out.println("ConcreteHandler2 handled request with level " + level);
        } else if (nextHandler != null) {
            nextHandler.handleRequest(level);
        }
    }
}

// 具体处理者3
class ConcreteHandler3 extends Handler {
    @Override
    public void handleRequest(int level) {
        if (level == 3) {
            System.out.println("ConcreteHandler3 handled request with level " + level);
        } else if (nextHandler != null) {
            nextHandler.handleRequest(level);
        }
    }
}

// 客户端代码
public class ChainOfResponsibilityDemo {
    public static void main(String[] args) {
        // 创建具体处理者
        Handler handler1 = new ConcreteHandler1();
        Handler handler2 = new ConcreteHandler2();
        Handler handler3 = new ConcreteHandler3();

        // 设置责任链
        handler1.setNextHandler(handler2);
        handler2.setNextHandler(handler3);

        // 提交请求
        handler1.handleRequest(1);
        handler1.handleRequest(2);
        handler1.handleRequest(3);
        handler1.handleRequest(4); // 没有处理者能处理这个请求
    }
}

---

运用案例

1. Java 过滤器链（Servlet 过滤器）

Java Servlet 规范中的过滤器链就是责任链模式的典型应用。Servlet 过滤器在处理请求时，会沿着过滤器链依次调用每个过滤器。

示例代码：

// 定义一个过滤器接口
interface Filter {
    void doFilter(Request request, Response response, FilterChain chain);
}

// 具体过滤器1
class AuthenticationFilter implements Filter {
    @Override
    public void doFilter(Request request, Response response, FilterChain chain) {
        System.out.println("Authentication Filter");
        chain.doFilter(request, response);
    }
}

// 具体过滤器2
class LoggingFilter implements Filter {
    @Override
    public void doFilter(Request request, Response response, FilterChain chain) {
        System.out.println("Logging Filter");
        chain.doFilter(request, response);
    }
}

// 过滤器链
class FilterChain {
    private List<Filter> filters = new ArrayList<>();
    private int index = 0;

    public void addFilter(Filter filter) {
        filters.add(filter);
    }

    public void doFilter(Request request, Response response) {
        if (index < filters.size()) {
            filters.get(index++).doFilter(request, response, this);
        }
    }
}

// 请求和响应对象
class Request {}
class Response {}

// 客户端代码
public class FilterChainDemo {
    public static void main(String[] args) {
        Request request = new Request();
        Response response = new Response();
        FilterChain filterChain = new FilterChain();

        filterChain.addFilter(new AuthenticationFilter());
        filterChain.addFilter(new LoggingFilter());

        filterChain.doFilter(request, response);
    }
}

2. Apache Commons Chain

Apache Commons Chain 是一个通用的责任链实现框架，用于创建和执行责任链。

示例代码：

import org.apache.commons.chain.Command;
import org.apache.commons.chain.Context;
import org.apache.commons.chain.impl.ChainBase;
import org.apache.commons.chain.impl.ContextBase;

// 具体命令1
class Command1 implements Command {
    @Override
    public boolean execute(Context context) throws Exception {
        System.out.println("Executing Command1");
        return false; // 返回 false 继续执行链中的下一个命令
    }
}

// 具体命令2
class Command2 implements Command {
    @Override
    public boolean execute(Context context) throws Exception {
        System.out.println("Executing Command2");
        return false;
    }
}

// 客户端代码
public class CommonsChainDemo {
    public static void main(String[] args) throws Exception {
        ChainBase chain = new ChainBase();
        chain.addCommand(new Command1());
        chain.addCommand(new Command2());

        Context context = new ContextBase();
        chain.execute(context);
    }
}