OKHTTP解析之责任链模式

熟悉或者使用过OKHTTP框架的都了解过，OKHTTP允许我们自定义拦截器做自定义业务，同时内部也存在RetryAndFollowUpInterceptor、
BridgeInterceptor、 CacheInterceptor、ConnectInterceptor、 CallServerInterceptor以及NetworkInterceptors 等各种拦截器，也是OKHTTP进行网络请求的主要实现，对应OKHTTP内部重试，桥接，缓存，链接，请求以及网络等功能。
而这么多拦截器是如何管理和实现的，我们来分析下OKHTTP内部的拦截器机制。
首先我们先来了解一下责任链模式，这是我们理解拦截器实现原理的前提。

责任链模式

责任链定义：为了避免请求发送者与多个请求处理者耦合在一起，将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条链；当有请求发生时，可将请求沿着这条链传递，直到有对象处理它为止。
UML如下图所示：

责任链模式UML.png

Handler接口作为处理器处理请求，存在handleRequest的接口，并持有Handler对象。
ConcreteHandler1 和 ConcreteHandler2 为Hanlder两个具体实现。为了Handler串成一条链，ConcreteHandler1 或者ConcreteHandler2 需要持有下一个Handler对象。
当请求触发的时候，ConcreteHandler根据实际情况来决定是否继续交由下一个Handler处理还是直接终止。

下面我们来实现一下责任链机制：
举一个实际的场景：员工申请部门经费，需要经过直接上级、部门领导、老板进行审批，直接上级的权限是审批5W元以下的经费，部门领导有审批10W以下的权限，超过10W都必须要老板直接审批。

public class FoundsApplyDemo {

    public void main() {
        Boss boss = new Boss();
        DepartmentHead departmentHead = new DepartmentHead(boss);
        DirectLeader directLeader = new DirectLeader(departmentHead);
        directLeader.handleRequest(1000);
    }

    /**
     * 直接上级
     */
    public class DirectLeader implements FoundsApplyHandler {

        private FoundsApplyHandler mHandler;

        public DirectLeader(FoundsApplyHandler handler) {
            mHandler = handler;
        }

        @Override
        public boolean handleRequest(int money) {
            //处理5w以下的需求
            if (money < 50000) {
                return true;
            } else {
                return mHandler.handleRequest(money);
            }
        }
    }


    /**
     * 部门主管
     */
    public class DepartmentHead implements FoundsApplyHandler {

        private FoundsApplyHandler mHandler;

        public DepartmentHead(FoundsApplyHandler handler) {
            mHandler = handler;
        }

        @Override
        public boolean handleRequest(int money) {
            //处理10w以下的需求
            if (money < 100000) {
                return true;
            } else {
                return mHandler.handleRequest(money);
            }
        }
    }

    /**
     * 老板
     */
    public class Boss implements FoundsApplyHandler {

        @Override
        public boolean handleRequest(int money) {
            //处理10w以上的需求，都给你
            return true;
        }
    }

    public interface FoundsApplyHandler {

        /**
         * 处理请求
         *
         * @param money 数量
         * @return 是否通过，true表示通过
         */
        boolean handleRequest(int money);
    }
}

OKHTTP 责任链机制

首先看下我们平时如何添加拦截器

OkHttpClient.Builder builder = new OkHttpClient.Builder();
//添加拦截器，框架内部已经默认添加了部分拦截器，通过接口添加的拦截器在列表首部
builder.addInterceptor(new LogInterceptor());
//添加网络拦截器，网络拦截器可以操作重定向和失败重连的返回值，以及监控所有的网络数据
builder.addNetworkInterceptor(new NetworkInterceptor());

下图为内部自定义实现的拦截器和框架内部拦截器

拦截器实现.png

首先我们添加的拦截器会保存在OkHttpClient#interceptors中
当我们开始执行一个网络请求的时候：
```
 client.newCall(request).enqueue(callback）
```

我们会经过Dispatcher.enqueue()，然后执行promoteAndExecute()方法进入RealCall$AsyncCall.execute()方法，最终执行getResponseWithInterceptorChain()方法。

Response getResponseWithInterceptorChain() throws IOException {
    // Build a full stack of interceptors.
    List<Interceptor> interceptors = new ArrayList<>();
   //首先取出来客户端添加的放在列表前面
    interceptors.addAll(client.interceptors());
    //重试逻辑拦截器
    interceptors.add(new RetryAndFollowUpInterceptor(client));
    //桥接拦截器
    interceptors.add(new BridgeInterceptor(client.cookieJar()));
    //缓存拦截器
    interceptors.add(new CacheInterceptor(client.internalCache()));
    //连接拦截器
    interceptors.add(new ConnectInterceptor(client));
    if (!forWebSocket) {
      //网络连接器
      interceptors.addAll(client.networkInterceptors());
    }
    //真正的请求连接器
    interceptors.add(new CallServerInterceptor(forWebSocket));
    
    //重点，责任链真正实现
    Interceptor.Chain chain = new RealInterceptorChain(interceptors, transmitter, null, 0,
        originalRequest, this, client.connectTimeoutMillis(),
        client.readTimeoutMillis(), client.writeTimeoutMillis());

    boolean calledNoMoreExchanges = false;
    try {
      Response response = chain.proceed(originalRequest);
      if (transmitter.isCanceled()) {
        closeQuietly(response);
        throw new IOException("Canceled");
      }
      return response;
    } catch (IOException e) {
      calledNoMoreExchanges = true;
      throw transmitter.noMoreExchanges(e);
    } finally {
      if (!calledNoMoreExchanges) {
        transmitter.noMoreExchanges(null);
      }
    }
  }

首先，会将自定义的interceptor以及内部的拦截器按照顺序添加到list里面；
然后，构建RealInterceptorChain对象，并传入拦截器列表等参数；
最后，调用RealInterceptorChain.proceed方法开始执行责任链机制。

执行到RealInterceptorChain，代码如下：

public Response proceed(Request request, Transmitter transmitter, @Nullable Exchange exchange)
      throws IOException {
    //...省略部分代码
    // Call the next interceptor in the chain.
    RealInterceptorChain next = new RealInterceptorChain(interceptors, transmitter, exchange,
        index + 1, request, call, connectTimeout, readTimeout, writeTimeout);
    Interceptor interceptor = interceptors.get(index);
    Response response = interceptor.intercept(next);

    // Confirm that the next interceptor made its required call to chain.proceed().
    if (exchange != null && index + 1 < interceptors.size() && next.calls != 1) {
      throw new IllegalStateException("network interceptor " + interceptor
          + " must call proceed() exactly once");
    }
//...省略部分代码
    return response;
  }

这里首先去获取传入的interceptors（拦截器列表）取出下一个拦截器，并调用拦截器的intercept方法，并传入下一个RealInterceptorChain对象供当前拦截器调用。

然后每个拦截器根据会根据情况，拿到传入的RealInterceptorChain调用chain.proceed，调用下一个拦截器。
下面以BridgeInterceptor为例看下：

@Override public Response intercept(Chain chain) throws IOException {
    Request userRequest = chain.request();
    Request.Builder requestBuilder = userRequest.newBuilder();
    RequestBody body = userRequest.body();
   //省略处理header 逻辑...
  
    //调用，并执行下一个拦截器
    Response networkResponse = chain.proceed(requestBuilder.build());

    HttpHeaders.receiveHeaders(cookieJar, userRequest.url(), networkResponse.headers());

    Response.Builder responseBuilder = networkResponse.newBuilder()
        .request(userRequest);
    //省略部分结果处理
    return responseBuilder.build();
  }

调用 chain.proceed(requestBuilder.build())之后，调用链会不断的取下一个拦截器执行，直到取到最后一个拦截器，并执行返回Response。
这时候继续执行 chain.proceed(requestBuilder.build())下方的代码。整个调用流程如下图所示。

拦截器调用流程.png