责任链模式两种典型实现

liuyang

2021-01-20

设计模式

责任链模式（Chain of Responsibility）是一种处理请求的模式，它让多个处理器都有机会处理该请求，直到其中某个处理成功为止。

责任链模式解决的问题：避免请求的发送者和接收者之间的耦合关系。

Rxjava的拦截器是典型的责任链例子，同时我们自己实现类似的拦截器功能时，也会用到责任链模式，通过研究Rxjava的源码，总结两种实现方案：

方案一：List，for循环+返回值（最简单的实现）
方案二：List，链式+手动调用（Rxjava的实现）

方案一：for循环+返回值

示例代码

public interface Interceptor {
    // 返回TRUE，拦截此请求
    // 返回null 或 FALSE = 交下一个处理
    Boolean intercept(Request request);
}

public class InterceptorA implements Interceptor {
    public Boolean intercept(Request request){
        // 此拦截器对request做个性化处理
        ...

        // 拦截此请求
        return true
        // 交下一个拦截器处理
        return false
    }
}

public class InterceptorChain {

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

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

    public boolean process(Request request){
        for(Interceptor interceptor : interceptors) {
            Boolean result = interceptor.intercept(request);
            if(result == true) {
                return ;
            }
        }
    }

    public static void main(String[] args) {
        InterceptorChain chain = InterceptorChain();
        chain.addInterceptor(new InterceptorA());
        chain.addInterceptor(new InterceptorB());

        // 处理请求
        boolean result = chain.process(new Request("Hello Wrold"));
    }
}

类图

时序图

方案二：链式+手动调用

示例代码

public interface Interceptor {
    Response intercept(Chain chain, Request request);
}

public interface Chain {
    Response process(Request request);
}

public class InterceptorA implements Interceptor {
    Response intercept(Chain chain, Request request){
        // 此拦截器对request做个性化处理
        ...

        // 拦截此请求
        return null;
        // 交下一个拦截器处理，chain 可以理解为下一个链路结点，即下一个拦截器
        return chain.process(request);
    }
}

public class InterceptorChain implements Chain {

    private final List<Interceptor> interceptors = new ArrayList<Interceptor>();
    private final int index;

    public InterceptorChain(List<Interceptor> interceptors, int index){
        this.interceptors = interceptors;
        this.index = index;
    }

    @Override
    public Response process(Request request);
        if(index >= interceptors.size()) {
            // 所有拦截器都已处理完成
            return processFinal(request);
        }

        // 构建下一个执行链路节点
        InterceptorChain next = new InterceptorChain(interceptors, index + 1);
        Interceptor interceptor = interceptors.get(index);
        return interceptor.intercept(next, request);
    }

    public static void main(String[] args) {
        
        List<Interceptor> interceptors = new ArrayList<Interceptor>();
        interceptors.add(new InterceptorA());
        interceptors.add(new InterceptorB());

        Response response = new InterceptorChain(interceptors, 0).process(new Request("Hello Wrold"));
    }
}