概念

  说到责任链模式，我就想起了okHttp中设置拦截器的时候了，今年、中外、开花，关注。
  其实责任链就是将多个处理连接成一条链，然后处理一个对象，正常点的解释：使多个对象都有机会处理同一个请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。

角色

抽象责任：定义了具体的操作方式。
具体责任：实现了抽象责任中的方法。
处理类：实现抽象责任接口，存储具体责任并完成调用。

Code、Code

  这里简单的模仿了一下okHttp的拦截器链。

首先是Request和Response

public class Request {
    private String requestStr;

    public String getRequestStr() {
        return requestStr;
    }

    public void setRequestStr(String requestStr) {
        this.requestStr = requestStr;
    }

}

public class Response {
    private String responseStr;

    public String getResponseStr() {
        return responseStr;
    }

    public void setResponseStr(String responseStr) {
        this.responseStr = responseStr;
    }

}

抽象责任：

public interface Filter {
    Response doFilter(Request request, Response response, FileterChain chain);
}

具体责任链（拦截器A、B）

public class AFilter implements Filter{

    @Override
    public Response doFilter(Request request, Response response, FileterChain chain) {
        Response newResponse = new Response();
        newResponse.setResponseStr(response.getResponseStr().replace("<>", ""));
        return newResponse;
    }

}

public class BFilter implements Filter {

    @Override
    public Response doFilter(Request request, Response response, FileterChain chain) {
        Response newResponse = new Response();
        newResponse.setResponseStr(response.getResponseStr().replace("33", "55"));
        return newResponse;
    }

}

责任链

   这里用List存放了具体的责任（拦截器），然后实现了传递。

public class FileterChain implements Filter {

    private List<Filter> filters = new ArrayList();

    private Response resultResponse;

    public FileterChain addFilter(Filter filter) {
        filters.add(filter);
        return this;
    }

    @Override
    public Response doFilter(Request request, Response response, FileterChain chain) {
        resultResponse = response;
        for (int i = 0; i < filters.size(); i++) {
            resultResponse = filters.get(i).doFilter(request, resultResponse, chain);
        }
        System.out.println(resultResponse.getResponseStr());
        return resultResponse;
    }

}

客户端测试类

public class Client {
    public static void main(String[] args) {
        String responseStr = "444<>33";
        Response response = new Response();
        response.setResponseStr(responseStr);
        
        FileterChain fc = new FileterChain()
                .addFilter(new AFilter())
                .addFilter(new BFilter());
        fc.doFilter(new Request(), response, fc);
    }
}

result

after that

  在okHttp中，intercepter接口如下：

public interface Interceptor {
  Response intercept(Chain chain) throws IOException;

  interface Chain {
    Request request();

    Response proceed(Request request) throws IOException;

    @Nullable Connection connection();
  }
}

这里面可以利用Chain获取request和response，而我的例子是把request和response分开的，其实可以抽象出一个BaseRequest和BaseResponse。而且我的举例中并没有用到Request。但是责任链模式还是这个流程

The End

优点：实现了请求和处理的分离。
缺点：每次都从链头开始调用。

我觉得学会了这些设计模式对看源码是非常有帮助的，至少能知道他们的大概实现思想。