安卓面试清单----OKHttp源码解析（一）

版权声明：本文为博主原创文章，转载请注明出处。 https://blog.csdn.net/u012534831/article/details/75258087

本文基于OKHttp3.2 。

一个典型 OKhttp 同步请求的发起是这样的：

 Response response = client.newCall(request).execute();

在 OkHttpClient 类中, newCall 方法是这样的:

public Call newCall(Request request) {
      return new RealCall(this, request);
   }

RealCall 是 Call 的实现类，那我们去 RealCall 中找，

/**来自 RealCall 类*/


public Response execute() throws IOException {
        synchronized (this) {
            if (this.executed) {
                throw new IllegalStateException("Already Executed");
            }
            this.executed = true;
        }
        Response arg1;
        try {
            this.client.dispatcher().executed(this);
            Response result = this.getResponseWithInterceptorChain(false);
            if (result == null) {
                throw new IOException("Canceled");
            }
            arg1 = result;
        } finally {
            this.client.dispatcher().finished(this);
        }

        return arg1;
    }

很轻松就找到了 execute() 方法，上面代码第10行用到了一个从 OkHttpClient 获得的 Dispatcher 然后把它加入到分发器里面的队列 runningSyncCalls 中，在完成的时候会remove掉。这个队列是一个ArrayDeque。

private final Deque<RealCall> runningSyncCalls = new ArrayDeque();

/**来自 Dispatcher 类*/


synchronized void executed(RealCall call) {
      this.runningSyncCalls.add(call);
   }

   synchronized void finished(Call call) {
      if(!this.runningSyncCalls.remove(call)) {
         throw new AssertionError("Call wasn\'t in-flight!");
      }
   }

其次会执行：

Response result = this.getResponseWithInterceptorChain(false);

先到这儿，记住 getResponseWithInterceptorChain（） 方法，我们再来看异步请求：

也在 RealCall 中：

/**来自 RealCall 类*/


void enqueue(Callback responseCallback, boolean forWebSocket) {
        synchronized (this) {
            if (this.executed) {
                throw new IllegalStateException("Already Executed");
            }

            this.executed = true;
        }

        this.client.dispatcher().enqueue(
                new RealCall.AsyncCall(responseCallback, forWebSocket));
    }

是不是和同步很像，但是有两点不同：

1、同步调用的 executed 方法，而异步调用的是分发器的 enqueue 方法。

2、同步传入 execute 方法的参数是 Call，异步传入 enqueue 方法的是AsyncCall，这个是什么呢，这个是 Call 里面的一个内部类，而且是一个继承了Runnable的内部类。

先看第一个不同点：分发器的 enqueue 方法是干什么的？

/**来自 Dispatcher 类*/

synchronized void enqueue(AsyncCall call) {
 //判断当前运行的线程是否超过最大线程数，以及同一个请求是否要超过相同请求同时存在的最大数目
      if(this.runningAsyncCalls.size() < this.maxRequests && this.runningCallsForHost(call) < this.maxRequestsPerHost) {
         this.runningAsyncCalls.add(call);
         //将请求放到线程池里运行
         this.executorService().execute(call);
      } else {
        //不满足运行条件放到后备队列里
         this.readyAsyncCalls.add(call);
      }

   }

/**来自 Dispatcher 类*/

public synchronized ExecutorService executorService() {
      if(this.executorService == null) {
         this.executorService = new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue(), Util.threadFactory("OkHttp Dispatcher", false));
      }

      return this.executorService;
   }

很明显，这儿用线程池直接提交了这个实现了 Runable 的 AsyncCall 。
这是一个可缓存的线程池。

从上面代码我们看到异步请求是有条件限制的，默认最多64个请求，而对同一个主机的最大请求默认最多同时存在5个。这两个值都是可以更改的，Dispatcher 提供了相关方法。

public final class Dispatcher {
   private int maxRequests = 64;
   private int maxRequestsPerHost = 5;
   private ExecutorService executorService;
   private final Deque<AsyncCall> readyAsyncCalls = new ArrayDeque();
   private final Deque<AsyncCall> runningAsyncCalls = new ArrayDeque();
   private final Deque<RealCall> runningSyncCalls = new ArrayDeque();

   public Dispatcher(ExecutorService executorService) {
      this.executorService = executorService;
   }

/**来自 Dispatcher 类*/

 private int runningCallsForHost(AsyncCall call) {
      int result = 0;
      Iterator arg2 = this.runningAsyncCalls.iterator();

      while(arg2.hasNext()) {
         AsyncCall c = (AsyncCall)arg2.next();
          通过比较每个请求的主机地址，一样代表同一个请求
         if(c.host().equals(call.host())) {
            ++result;
         }
      }
      return result;
   }

/**来自 RealCall类*/

String host() {
            return RealCall.this.originalRequest.url().host();
            }

OK，第一个不同点已经分析完，再来看看第二个不同点 AsyncCall 是个什么东东？

AsyncCall 继承自 NamedRunnable ，NamedRunnable 实现了 Runnable 。NamedRunnable 只是给这个 Runnable 起了个名字而已。

public NamedRunnable(String format, Object... args) {
      this.name = String.format(format, args);
   }

再来看看AsyncCall 的run里面的代码：

/**来自 NamedRunnable 类*/
public final void run() {
      String oldName = Thread.currentThread().getName();
      Thread.currentThread().setName(this.name);
      try {
         this.execute();
      } finally {
         Thread.currentThread().setName(oldName);
      }
   }

     protected abstract void execute();

显然AsyncCall的execute才是核心。

/**来自 RealCall 的内部类 AsyncCall 类，继承自 NamedRunnable */

protected void execute() {
            boolean signalledCallback = false;

            try {
                Response e = RealCall.this.getResponseWithInterceptorChain(this.forWebSocket);
                if (RealCall.this.canceled) {
                    signalledCallback = true;
    //若请求被取消，则回调 onFailure  
                this.responseCallback.onFailure(RealCall.this,
                            new IOException("Canceled"));
                } else {
                    signalledCallback = true;
    //若成功返回Response，则回调 onResponse
        this.responseCallback.onResponse(RealCall.this, e);
                }
            } catch (IOException arg5) {
                if (signalledCallback) {
                    Internal.logger.log(Level.INFO, "Callback failure for "
                            + RealCall.this.toLoggableString(), arg5);
                } else {
                    this.responseCallback.onFailure(RealCall.this, arg5);
                }
            } finally {
                RealCall.this.client.dispatcher().finished(this);
            }
        }

在代码第八行我们又看到了getResponseWithInterceptorChain()方法。 可以看到，异步和同步一样，最后都执行到了这个方法并返回 Response 。
那我们就来看一下这个方法的实现：

/**来自 RealCall类 */

private Response getResponseWithInterceptorChain(boolean forWebSocket)throws IOException {
        RealCall.ApplicationInterceptorChain chain = new RealCall.ApplicationInterceptorChain(
                0, this.originalRequest, forWebSocket);
        return chain.proceed(this.originalRequest);
    }

创建了一个ApplicationInterceptorChain ，并且第一个参数传入0，这个0是有特殊用法的，涉及到OKHttp里面的一个功能叫做拦截器，从getResponseWithInterceptorChain这个名字里其实也能看出一二。先看看proceed做了什么：

OKHttp增加的拦截器机制，先来看看官方文档对Interceptors 的解释 :

Interceptors are a powerful mechanism that can monitor, rewrite, and
retry calls.

解释下就是拦截器可以用来转换，重试，重写请求的机制。

/**来自 RealCall 的内部类 ApplicationInterceptorChain，实现了 Chain 接口 */

public Response proceed(Request request) throws IOException {
              /**先判断是否有拦截器，如果有则首先执行拦截器重写的 intercept 方法，执行完自己写的代码之后，并手动调用 proceed()方法再次判断是否还有拦截器。

               若已经没有拦截器存在的话就执行 getResponse()方法*/
            if (this.index < RealCall.this.client.interceptors().size()) {
                RealCall.ApplicationInterceptorChain chain = RealCall.this.new ApplicationInterceptorChain(
                        this.index + 1, request, this.forWebSocket);
                Interceptor interceptor = (Interceptor) RealCall.this.client
                        .interceptors().get(this.index);
                Response interceptedResponse = interceptor.intercept(chain);
                if (interceptedResponse == null) {
                    throw new NullPointerException("application interceptor "
                            + interceptor + " returned null");
                } else {
                    return interceptedResponse;
                }
            } else {
                return RealCall.this.getResponse(request, this.forWebSocket);
            }
        }

创建 ApplicationInterceptorChain 的时候第一个参数为0，则this.index==0；

若没有拦截器的话走 else，执行：

return RealCall.this.getResponse(request, this.forWebSocket);

若有1个拦截器的话：

则0<1，回调拦截器中的 intercept 方法。

当我们在拦截器中手动调用 process 后再次回到方法中检查是否有拦截器，此时不满足条件，走 else，最终还是回到了 getResponse 方法。

ApplicationInterceptorChain(int index, Request request,
                boolean forWebSocket) {
            this.index = index;
            this.request = request;
            this.forWebSocket = forWebSocket;
        }

看下我当时用的一个用于获取打印http请求信息的拦截器（包括请求头，body，url等等，直接打印）：

/**
 * Created by QHT on 2017-04-05.
 */
public class OK_LoggingInterceptor implements Interceptor{
        @SuppressLint("DefaultLocale")
        @Override
        public Response intercept(Interceptor.Chain chain) throws IOException {
            //这个chain里面包含了request和response，所以你要什么都可以从这里拿
            Request request = chain.request();

            long t1 = System.nanoTime();//请求发起的时间
            LogUtil.e(String.format("发送请求 %s on %s%n%s",
                    request.url(), chain.connection(), request.headers()));
            //自定义拦截器必须执行 proceed 方法,以便继续判断是否还存在拦截器
            Response response = chain.proceed(request);

            long t2 = System.nanoTime();//收到响应的时间

            //这里不能直接使用response.body().string()的方式输出日志
            //因为response.body().string()之后，response中的流会被关闭，程序会报错，我们需要创建出一个新的response给应用层处理
            ResponseBody responseBody = response.peekBody(1024 * 1024);

            LogUtil.e(String.format("接收响应: [%s] %n返回json:【%s】 %.1fms%n%s",
                    response.request().url(),
                    responseBody.string(),
                    (t2 - t1) / 1e6d,
                    response.headers()));

            return response;
        }
}

这个拦截器发送完请求后打印的效果是这样的：

---

H快递: com.qht.blog2.Net.OK_LoggingInterceptor.intercept(OK_LoggingInterceptor.java:25)
H快递: 发送请求 http://www.kuaidi100.com/query?type=yunda&postid=7700008953907 on null
H快递: com.qht.blog2.Net.OK_LoggingInterceptor.intercept(OK_LoggingInterceptor.java:37)
H快递: 接收响应: [http://www.kuaidi100.com/query?type=yunda&postid=7700008953907]
返回json:【】 370.2ms
Server: nginx
Date: Tue, 13 Jun 2017 15:21:58 GMT
Content-Type: text/html;charset=UTF-8
Transfer-Encoding: chunked
Connection: keep-alive
P3P: CP=”IDC DSP COR ADM DEVi TAIi PSA PSD IVAi IVDi CONi HIS OUR IND CNT”
Cache-Control: no-cache
Vary: Accept-Encoding

---

在处理完拦截器操作后，就进入到重要的getResponse方法，真正的去进行发送请求，处理请求，接收返回结果。

/**来自RealCall类 */

Response getResponse(Request request, boolean forWebSocket)
            throws IOException {
        RequestBody body = request.body();
        if (body != null) { 
            Builder followUpCount = request.newBuilder();
            MediaType releaseConnection = body.contentType();
            if (releaseConnection != null) {
                followUpCount.header("Content-Type",
                        releaseConnection.toString());
            }

            long response = body.contentLength();
            if (response != -1L) {
                followUpCount.header("Content-Length", Long.toString(response));
                followUpCount.removeHeader("Transfer-Encoding");
            } else {
                followUpCount.header("Transfer-Encoding", "chunked");
                followUpCount.removeHeader("Content-Length");
            }

            request = followUpCount.build();
        }
 //新建HttpEngine，用于进行发送请求和读取答复的细节处理
        this.engine = new HttpEngine(this.client, request, false, false,
                forWebSocket, (StreamAllocation) null, (RetryableSink) null,
                (Response) null);
        int arg19 = 0;

        while (!this.canceled) {
            boolean arg20 = true;
            boolean arg14 = false;

            StreamAllocation streamAllocation;
            label173: {
                label172: {
                    try {
                        HttpEngine followUp;
                        try {
                            arg14 = true;
                            this.engine.sendRequest();
                            this.engine.readResponse();
                            arg20 = false;
                            arg14 = false;
                            break label173;
                        } catch (RequestException arg15) {
                            throw arg15.getCause();
                        } catch (RouteException arg16) {
                            followUp = this.engine.recover(
                                    arg16.getLastConnectException(),
                                    (Sink) null);
                            if (followUp == null) {
                                throw arg16.getLastConnectException();
                            }
                        } catch (IOException arg17) {
                            followUp = this.engine.recover(arg17, (Sink) null);
                            if (followUp != null) {
                                arg20 = false;
                                this.engine = followUp;
                                arg14 = false;
                                break label172;
                            }

                            throw arg17;
                        }

                        arg20 = false;
                        this.engine = followUp;
                        arg14 = false;
                    } finally {
                        if (arg14) {
                            if (arg20) {
                                StreamAllocation streamAllocation1 = this.engine
                                        .close();
                                streamAllocation1.release();
                            }

                        }
                    }

                    if (arg20) {
                        streamAllocation = this.engine.close();
                        streamAllocation.release();
                    }
                    continue;
                }

                if (arg20) {
                    streamAllocation = this.engine.close();
                    streamAllocation.release();
                }
                continue;
            }

            if (arg20) {
                StreamAllocation arg21 = this.engine.close();
                arg21.release();
            }

            Response arg22 = this.engine.getResponse();
             //得到该请求对应的后续请求，比如重定向之类的
            Request arg23 = this.engine.followUpRequest();
            if (arg23 == null) {
                if (!forWebSocket) {
                    this.engine.releaseStreamAllocation();
                }

                return arg22;
            }

            streamAllocation = this.engine.close();
            ++arg19;
            if (arg19 > 20) {
                streamAllocation.release();
                throw new ProtocolException("Too many follow-up requests: "
                        + arg19);
            }

            if (!this.engine.sameConnection(arg23.url())) {
                streamAllocation.release();
                streamAllocation = null;
            }

            this.engine = new HttpEngine(this.client, arg23, false, false,
                    forWebSocket, streamAllocation, (RetryableSink) null, arg22);
        }

        this.engine.releaseStreamAllocation();
        throw new IOException("Canceled");
    }

没错，就是这么长。
可以看到如果是post请求，先做一定的头部处理，然后新建一个HttpEngine去处理具体的操作，通过sendRequest发送具体请求操作，readResponse对服务器的答复做一定处理，最后得到从服务器返回的Response，讲到这里，我们整个的流程大概疏通了，代码贴了很多，简单的可以用下面一张图概括 ：

getResponse() 方法的内容还有很多，下篇再分析。