Android OKHttp源码解析

学习了OKHttp的使用，现在来学学源码。

1、OkHttp是一个高效优秀的HTTP库
网上有很多相关的介绍文档 。

2、OKHttp的简单使用实例，实际一般都是和Retrofit结合使用，下面是OKHTTP的使用实例，分别就一二三四步进行分析：

(一) final OkHttpClient client = new OkHttpClient();       okHttpClient = new OkHttpClient.Builder()            .addInterceptor()            .addNetworkInterceptor()            .build();(二)   Request request = new Request.Builder()            .url("https://www.baidu.com/")            .get()            .build();(三) Response response = client.newCall(request).execute();  //同步请求(四)   okHttpClient.newCall(request).enqueue(new Callback() {        @Override        public void onFailure(Call call, IOException e) {            Log.d(TAG,"e="+e);        }        @Override        public void onResponse(Call call, Response response) throws IOException {           Log.d(TAG,"response="+ response.body().toString());        }    });

OKHttp的调用流程图：

下面来看看具体的过程：

一、OKHttpClient对象的创建

1 ：创建默认设置的client，或者如上的创建：
public final OkHttpClient client = new OkHttpClient();

2： OKHttpClient通过Builder模式创建

 okHttpClient = new OkHttpClient.Builder()                .addInterceptor(new HttpLogginInterceptor())                 .cache(new Cache(cacheDir,cacheSize))                 .build();

 OKHttpClient在一个应用程序中最好使用一个单例，因为每个OKHttpClient实例持有自己的线程池和连接池，重用线程池和连接池可以节省内存，如果每个请求都实例化一个client那么必然造成它本身线程池和连接池的资源浪费。当系统检测到她们已经闲置时，线程和连接资源会被自动释放，当然有需要时也可以主动释放。  * 通过Builder方式构建的OKHttpClient实例可以共享连接池、线程池和配置  * 通过client.dispatcher().executorService().shutdown():停止调度器的service，那么之后的请求都会被拒绝  * 通过client.connectionPool().evictAll():清除连接池，但是守护进程可能并不会马上释放  * 如果client有缓存的话，可以通过client.cache().close()来 关闭，但是不能重复调用，否则可能会crash  * OKHttp使用了守护线程来维护HTTP/2的连接，闲置时则会自动的停止  */ 步骤1：new OKHttpClient：分析OKHttpClient的主体 步骤2：Builder() :分析Builder的构建 步骤1： OKHTTPClient的关键代码：  

 public class OkHttpClient implements Cloneable, Call.Factory, WebSocket.Factory {      //Protocol是一个定义了几种协议版本http1.0,http1.1，spdy3,http2的枚举，这里返回的是装载了两个枚举常量Protocol.HTTP_2和Protocol_的不可变list      static final List<Protocol> DEFAULT_PROTOCOLS = Util.immutableList(      Protocol.HTTP_2, Protocol.HTTP_1_1);      //ConnectionSpec:证书      static final List<ConnectionSpec> DEFAULT_CONNECTION_SPECS = Util.immutableList(      ConnectionSpec.MODERN_TLS, ConnectionSpec.CLEARTEXT);      /**        * 静态Internal实例对象：        * OKHttp3 内部一些更新的API，继承自OKHTTP的包也能够使用，这个Internal仅在OKHTTPClient中使用        * 主要通过builder来设置到client中去         */      static {       Internal.instance = new Internal() {      }      }  }  //Dispatcher:执行异步请求的代理，下面有这个类的具体分析  final Dispatcher dispatcher;   //网络代理，有Direct、HTTP、SOCKS三种  final Proxy proxy;  //连接规范，配置Socket连接层，对于HTTPS，还能配置安全传输层协议TLS版本与密码套件（CipherSuite）  final List<ConnectionSpec> connectionSpecs;  //Interceptor:拦截器，观察、修改已经发出的请求或得到响应。常用来添加、移除或者转换请求或者  //response的header  final List<Interceptor> interceptors;  final List<Interceptor> networkInterceptors;   //EventListener：请求过程监听器  final EventListener.Factory eventListenerFactory;    /**    * CookieJar:管理cookie，根据URL保存或者取出cookie。    * 可以自定义，有两个方法:    * void saveFromResponse(HttpUrl url, List<Cookie> cookies);    * List<Cookie> loadForRequest(HttpUrl url);    */  final CookieJar cookieJar;  //Cache :缓存HTTP和HTTPS结果到文件系统，用常见的DiskLruCache来对response进行缓存。  final Cache cache;  //SocketFactory : 通过工厂方法创建Socket   final SocketFactory socketFactory;  final SSLSocketFactory sslSocketFactory;  final CertificateChainCleaner certificateChainCleaner;  //主机名验证器，与HTTPS中的SSL相关，当握手时如果URL的主机名不是可识别的主机，就会要求进行主机名验证  /**    *public interface HostnameVerifier {     //通过session验证指定的主机名是否被允许    boolean verify(String hostname, SSLSession session);    }   */  final HostnameVerifier hostnameVerifier;  //证书锁，约束哪些证书可以被信任，防止某些证书机构的攻击行为，如果所有证书都不被信任将抛出  //SSLPeerUnverifiedException异常。  final CertificatePinner certificatePinner;  //授权  final Authenticator proxyAuthenticator;  final Authenticator authenticator;  final ConnectionPool connectionPool;  //DNS域名转换  final Dns dns; }

步骤2；Builder()的创建相关代码：

    public Builder() {      dispatcher = new Dispatcher(); //实例线程调度器      protocols = DEFAULT_PROTOCOLS;         connectionSpecs = DEFAULT_CONNECTION_SPECS;      eventListenerFactory = EventListener.factory(EventListener.NONE);      proxySelector = ProxySelector.getDefault();   //获取系统的DefaultProxySelector      cookieJar = CookieJar.NO_COOKIES;      socketFactory = SocketFactory.getDefault();      connectionPool = new ConnectionPool();  //实例化一个连接池      //设置默认的连接时间，读写时间      connectTimeout = 10_000;      readTimeout = 10_000;      writeTimeout = 10_000;    }

通过.build()生成OKHTTPClient实例,.将Builder设置的参数设置给OKHTTPClient。

Dispatcher：

/**  * Dispatcher:是异步请求时的代理，所有请求都是在这里进行调用以及处理  * 每个Dispatcher使用一个ExecutorService来调用call请求。  * 如果 提供了自定义的executor，需要支持获取最大的请求数，因为Dispatcher需要根据最大值来维护请求队列  */public final class Dispatcher {  //默认的最大请求并发数64      private int maxRequests = 64;    //每个主机最大的请求数  private int maxRequestsPerHost = 5;  //当正在运行的请求数目为0时的回调  private Runnable idleCallback;  //线程池  private ExecutorService executorService;  //已ready的异步请求队列  private final Deque<AsyncCall> readyAsyncCalls = new ArrayDeque<>();  //正在运行的异步请求队列，包括已经cancel但是还没有finish  private final Deque<AsyncCall> runningAsyncCalls = new ArrayDeque<>();  //正在运行的同步请求队列，包括cancel但没有finish的  private final Deque<RealCall> runningSyncCalls = new ArrayDeque<>();  //可传入自定义的线程池  public Dispatcher(ExecutorService executorService) {    this.executorService = executorService;  }  public Dispatcher() {  }  //创建一个线程池实例对象  public synchronized ExecutorService executorService() {    if (executorService == null) {      executorService = new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60, TimeUnit.SECONDS,          new SynchronousQueue<Runnable>(), Util.threadFactory("OkHttp Dispatcher", false));    }    return executorService;  }  //设置最大的可同时发生的请求数目，如果超过这个请求数，那么就等待正在运行的完成之后再调用  public synchronized void setMaxRequests(int maxRequests) {    if (maxRequests < 1) {      throw new IllegalArgumentException("max < 1: " + maxRequests);    }    this.maxRequests = maxRequests;    //将请求放入正在运行队列中    promoteCalls();  }  public synchronized void setMaxRequestsPerHost(int maxRequestsPerHost) {    if (maxRequestsPerHost < 1) {      throw new IllegalArgumentException("max < 1: " + maxRequestsPerHost);    }    this.maxRequestsPerHost = maxRequestsPerHost;    promoteCalls();  }  //异步请求添加：如果此时运行队列大小小于最大值并且共享主机数小于最大值，则添加到正在运行队列并且将请求放入线程池执行，否则只是添加到准备队列中  synchronized void enqueue(AsyncCall call) {    if (runningAsyncCalls.size() < maxRequests && runningCallsForHost(call) < maxRequestsPerHost) {      runningAsyncCalls.add(call);      executorService().execute(call);    } else {      readyAsyncCalls.add(call);    }  }  //取消所有的请求  public synchronized void cancelAll() {    for (AsyncCall call : readyAsyncCalls) {      call.get().cancel();    }    for (AsyncCall call : runningAsyncCalls) {      call.get().cancel();    }    for (RealCall call : runningSyncCalls) {      call.cancel();    }  }  //异步请求被调用的过程  private void promoteCalls() {    //1、首先判断此刻运行的Call数目是否>=最大的请求数，或者没有正在等待的请求，则不需要再加载新的请求    if (runningAsyncCalls.size() >= maxRequests) return;     if (readyAsyncCalls.isEmpty()) return    for (Iterator<AsyncCall> i = readyAsyncCalls.iterator(); i.hasNext(); ) {      AsyncCall call = i.next();      /**        * 2、遍历即将运行的的Call，将其的host和正在运行的队列的host比较，如果共享主机数小于最大值的话        * 则将该请求添加到正在运行队列，并且从准备队列中移除        * 将该请求放入线程池执行        * 否则就继续等待。         *         */      if (runningCallsForHost(call) < maxRequestsPerHost) {        i.remove();        runningAsyncCalls.add(call);        executorService().execute(call);      }      //添加的call超过了最大的值，则停止增加新的请求。      if (runningAsyncCalls.size() >= maxRequests) return;     }  }  //返回共享主机的请求数目  private int runningCallsForHost(AsyncCall call) {    int result = 0;    for (AsyncCall c : runningAsyncCalls) {      if (c.host().equals(call.host())) result++;    }    return result;  }  //添加同步请求到运行队列中  synchronized void executed(RealCall call) {    runningSyncCalls.add(call);  }  void finished(AsyncCall call) {    finished(runningAsyncCalls, call, true);  }  void finished(RealCall call) {    finished(runningSyncCalls, call, false);  }  //请求完成之后从运行队列中移除该请求  private <T> void finished(Deque<T> calls, T call, boolean promoteCalls) {    int runningCallsCount;    Runnable idleCallback;    synchronized (this) {      //将该请求call从相应的队列移除              if (!calls.remove(call)) throw new AssertionError("Call wasn't in-flight!");      //移除之后再从准备队列往运行队列中添加新的请求【异步请求】      if (promoteCalls) promoteCalls();      runningCallsCount = runningCallsCount();      idleCallback = this.idleCallback;    }    //如果运行数目为0并且回调不为空，则调用回调的方法通知接收者请求已完成    if (runningCallsCount == 0 && idleCallback != null) {      idleCallback.run();    }  } //获取ready状态中的异步请求队列  public synchronized List<Call> queuedCalls() {    List<Call> result = new ArrayList<>();    for (AsyncCall asyncCall : readyAsyncCalls) {      result.add(asyncCall.get());    }    return Collections.unmodifiableList(result);  }  //返回running状态中的异步请求队列  public synchronized List<Call> runningCalls() {    List<Call> result = new ArrayList<>();    result.addAll(runningSyncCalls);    for (AsyncCall asyncCall : runningAsyncCalls) {      result.add(asyncCall.get());    }    return Collections.unmodifiableList(result);  }  //返回ready状态的异步请求数目，同步请求是马上执行的，所以没有ready这一状态  public synchronized int queuedCallsCount() {    return readyAsyncCalls.size();  }   //返回running状态的请求数目  public synchronized int runningCallsCount() {    return runningAsyncCalls.size() + runningSyncCalls.size();  }}

二、创建一个网络请求对象Request

Request request = new Request.Builder()        .url("https://www.baidu.com/")        .get()        .build();   

来看看Request的关键代码,Request同样通过Builder模式进行创建。

//Request是请求的实体，封装了请求的URL地址、请求方法，请求头、请求参数、请求体、请求响应体等等，  public final class Request {    //HttpUrl封装了请求url\post等相关信息  final HttpUrl url;   //OKHttp支持主流的网络请求，get/post/delete/put等方法   final String method;  //定义请求头  final Headers headers;  //请求体  final RequestBody body;  private volatile CacheControl cacheControl;  /**   * 返回该响应的缓存控制指令，不为空，即使该响应没有包含Cache-Control * *头，、CacheControl是从响应header解析出来的缓存控制指令。   */  public CacheControl cacheControl() {    CacheControl result = cacheControl;    return result != null ? result : (cacheControl = CacheControl.parse(headers));  }  //判断是否是HTTPS  public boolean isHttps() {    return url.isHttps();  }  public static class Builder {    HttpUrl url;    String method;    Headers.Builder headers;    RequestBody body;  //put 或 post、patch时定义的请求体    Object tag;    public Builder() {      this.method = "GET"; //默认为GET方法      this.headers = new Headers.Builder();    }    //设置当前请求为下列的某种请求    public Builder get() {      return method("GET", null);    }    public Builder head() {      return method("HEAD", null);    }    public Builder post(RequestBody body) {      return method("POST", body);    }    public Builder delete(RequestBody body) {      return method("DELETE", body);    }    public Builder delete() {      return delete(Util.EMPTY_REQUEST);    }    public Builder put(RequestBody body) {      return method("PUT", body);    }    public Builder patch(RequestBody body) {      return method("PATCH", body);    }    //拓展方法，可定义任意的请求方法，以及请求体     public Builder method(String method, RequestBody body) {      if (method == null) throw new NullPointerException("method == null");      if (method.length() == 0) throw new IllegalArgumentException("method.length() == 0");      if (body != null && !HttpMethod.permitsRequestBody(method)) {        throw new IllegalArgumentException("method " + method + " must not have a request body.");      }      if (body == null && HttpMethod.requiresRequestBody(method)) {        throw new IllegalArgumentException("method " + method + " must have a request body.");      }      this.method = method;      this.body = body;      return this;    }  }}

三、通过OKHTTPClient来发起请求

先来看看同步请求： Response response =  okHttpClient.newCall(request).execute(); 步骤1：看看okHttpClient.newCall(request)做了什么//1:生成一个RealCall对象@Override public Call newCall(Request request) {  return new RealCall(this, request, false );}//2：RealCall对象的关键代码

//RealCall实现了Call，Call是一个定义请求的方法的接口，Request定义了请求的基本属性、设置，Call定义了请求的操作，同步、异步、取消等各项操作  final class RealCall implements Call {    final OkHttpClient client;   //失败重连拦截器，在下面有介绍  final RetryAndFollowUpInterceptor retryAndFollowUpInterceptor;  //事件监听器，监听请求的步骤，用工厂模式创建实例对象  final EventListener eventListener;  //请求对象  final Request originalRequest;  // Guarded by this.  private boolean executed;  //创建RealCall的实例对象  RealCall(OkHttpClient client, Request originalRequest, boolean forWebSocket) {    final EventListener.Factory eventListenerFactory = client.eventListenerFactory();    this.client = client;    this.originalRequest = originalRequest;    this.forWebSocket = forWebSocket;    this.retryAndFollowUpInterceptor = new RetryAndFollowUpInterceptor(client, forWebSocket);    this.eventListener = eventListenerFactory.create(this);  }   步骤2：调用realCall.execute()方法执行请求，下面详细看看这个方法做了什么操作  @Override public Response execute() throws IOException {    synchronized (this) {    //  执行标志，不能重复执行      if (executed) throw new IllegalStateException("Already Executed");      executed = true;    }    try {      //前面有看到，请求是由Dispatcher来调度的，所以RealCall的execute()进入到Dispatcher的executed()方法中      client.dispatcher().executed(this);      //如何获取请求的返回结果的，可以看到最终的网络请求其实就是在这里做的。      Response result = getResponseWithInterceptorChain();      if (result == null) throw new IOException("Canceled");      return result;    } finally {      client.dispatcher().finished(this);    }  }  看看getResponseWithInterceptorChain()具体的实现：   Response getResponseWithInterceptorChain() throws IOException {    //看到这里添加了一系列的拦截器给interceptors，一个个看看这些拦截器都是做什么的       List<Interceptor> interceptors = new ArrayList<>();    interceptors.addAll(client.interceptors());    //retryAndFollowUpInterceptor:失败重连重定向拦截器    interceptors.add(retryAndFollowUpInterceptor);    //BridgeInterceptor:从应用程序代码到网络代码的桥梁，将用户的request转化成网络请求，然后根据网络响应转化为用户的response。    interceptors.add(new BridgeInterceptor(client.cookieJar()));    //CacheInterceptor:从缓存中发起request，并将响应写入的缓存中    interceptors.add(new CacheInterceptor(client.internalCache()));    //ConnectInterceptor:打开连接到指定服务器的连接，并且传递给下一个拦截器    interceptors.add(new ConnectInterceptor(client));    if (!forWebSocket) {      interceptors.addAll(client.networkInterceptors());    }    //CallServerInterceptor:这是拦截器链中的最后一个拦截器，它用于对服务器发起网络请求    interceptors.add(new CallServerInterceptor(forWebSocket));    //最后将所有的拦截器传递给RealInterceptorChain对象，执行proceed()操作    Interceptor.Chain chain = new RealInterceptorChain(        interceptors, null, null, null, 0, originalRequest);    return chain.proceed(originalRequest);  }

可以看出这是一种责任链的模式，每一个拦截器负责一项功能，完成之后往下传递。

//看看chain.proceed()做的具体内容，为了更加简明起见，把异常处理去掉

 @Override public Response proceed(Request request) throws IOException {    return proceed(request, streamAllocation, httpCodec, connection);  }  public Response proceed(Request request, StreamAllocation streamAllocation, HttpCodec httpCodec,      RealConnection connection) throws IOException {    //index是传给RealInterceptorChain的拦截器链的索引    if (index >= interceptors.size()) throw new AssertionError();    calls++;    //调用RealInterceptorChain中的下一个拦截器    RealInterceptorChain next = new RealInterceptorChain(        interceptors, streamAllocation, httpCodec, connection, index + 1, request);    //获取当前索引的拦截器            Interceptor interceptor = interceptors.get(index);    //执行拦截器的intercept的方法,最终得到返回结果response，返回给RealCall。    Response response = interceptor.intercept(next);    return response;  }

以上是OKHttp请求调用的基本流程。OKHttp请求最重要的的是拦截器的作用，下面再继续看看拦截器的具体内容。