OkHttp 原理解析

一、前言：

HTTP是现代应用常用的一种交换数据和媒体的网络方式，高效地使用HTTP能让资源加载更快，节省带宽。OkHttp是一个高效的HTTP客户端，它有以下默认特性：

• 支持HTTP/2，允许所有同一个主机地址的请求共享同一个socket连接
• 连接池减少请求延时
• 透明的GZIP压缩减少响应数据的大小
• 缓存响应内容，避免一些完全重复的请求

当网络出现问题的时候OkHttp依然坚守自己的职责，它会自动恢复一般的连接问题，如果你的服务有多个IP地址，当第一个IP请求失败时，OkHttp会交替尝试你配置的其他IP，OkHttp使用现代TLS技术(SNI, ALPN)初始化新的连接，当握手失败时会回退到TLS 1.0。

注意: OkHttp 支持 Android 2.3 及以上版本Android平台， 对于 Java, JDK 1.7及以上.

二、OkHttp 原理解析

1. OkHttp 的整体框架设计

建议将okhttp的 源码下载下来，用AndroidStudio 打开，整篇文章是根据源码的分析来学习okhttp的设计技巧和思想，如果本篇文章有内容分析不到位的地方，欢迎大家和我一起讨论。

下图为okhttp请求网络的完整流程图(大致看一遍)

2. okhttp的使用方法

OkHttpClient client = new OkHttpClient();

我们第一步先看一下okhttp的构造函数OkHttpClient()和一些配置相关，大致了解一下。

public OkHttpClient() {
        this(new Builder());
 }

原来OkHttpClient 内部已经实现了**OkHttpClient(Builder builder)，**如果我们不需要配置client，okhttp已将帮我们默认实现了配置。

public Builder() {
            dispatcher = new Dispatcher();
            protocols = DEFAULT_PROTOCOLS;
            connectionSpecs = DEFAULT_CONNECTION_SPECS;
            eventListenerFactory = EventListener.factory(EventListener.NONE);
            proxySelector = ProxySelector.getDefault();
            cookieJar = CookieJar.NO_COOKIES;
            socketFactory = SocketFactory.getDefault();
            hostnameVerifier = OkHostnameVerifier.INSTANCE;
            certificatePinner = CertificatePinner.DEFAULT;
            proxyAuthenticator = Authenticator.NONE;
            authenticator = Authenticator.NONE;
            connectionPool = new ConnectionPool();
            dns = Dns.SYSTEM;
            followSslRedirects = true;
            followRedirects = true;
            retryOnConnectionFailure = true;
            connectTimeout = 10_000;
            readTimeout = 10_000;
            writeTimeout = 10_000;
            pingInterval = 0;
        }

如果需要一些配置如添加拦截器等，则需要这样调用即可：

 mOkHttpClient = new OkHttpClient.Builder()
                            .addInterceptor(loggingInterceptor)
                            .retryOnConnectionFailure(true)
                            .connectTimeout(TIME_OUT, TimeUnit.SECONDS)
                            .readTimeout(TIME_OUT, TimeUnit.SECONDS)
                            .build();

我们看一下OkHttpClient 都有那些属性，稍微了解一下即可。后面在分析

final Dispatcher dispatcher;//调度器
    final @Nullable
    Proxy proxy;//代理
    final List protocols;//协议
    final List connectionSpecs;//传输层版本和连接协议
    final List interceptors;//拦截器
    final List networkInterceptors;//网络拦截器
    final EventListener.Factory eventListenerFactory;
    final ProxySelector proxySelector;//代理选择器
    final CookieJar cookieJar;//cookie
    final @Nullable
    Cache cache;//cache 缓存
    final @Nullable
    InternalCache internalCache;//内部缓存
    final SocketFactory socketFactory;//socket 工厂
    final @Nullable
    SSLSocketFactory sslSocketFactory;//安全套层socket工厂 用于https
    final @Nullable
    CertificateChainCleaner certificateChainCleaner;//验证确认响应书，适用HTTPS 请求连接的主机名
    final HostnameVerifier hostnameVerifier;//主机名字确认
    final CertificatePinner certificatePinner;//证书链
    final Authenticator proxyAuthenticator;//代理身份验证
    final Authenticator authenticator;//本地省份验证
    final ConnectionPool connectionPool;//链接池 复用连接
    final Dns dns; //域名
    final boolean followSslRedirects;//安全套接层重定向
    final boolean followRedirects;//本地重定向
    final boolean retryOnConnectionFailure;//重试连接失败
    final int connectTimeout;//连接超时
    final int readTimeout;//读取超时
    final int writeTimeout;//写入超时

3. 请求网络

String run(String url) throws IOException {
  Request request = new Request.Builder()
      .url(url)
      .build();

  Response response = client.newCall(request).execute();
  return response.body().string();
}

从源码中可以看出 okhttp 实现了Call.Factory接口

interface Factory {
    Call newCall(Request request);
  }

我们看一下okhttpClient 如何实现的Call接口，代码如下：

@Override
    public Call newCall(Request request) {
        return RealCall.newRealCall(this, request, false /* for web socket */);
    }

可以看出 真正的请求交给了 RealCall 类，并且RealCall 实现了Call方法，RealCall是真正的核心代码。
RealCall 主要方法：

• 同步请求 ：client.newCall(request).execute();
• 异步请求： client.newCall(request).enqueue();

下面我们着重分析一下异步请求，因为在项目中所有的网络请求基本都是异步的，同步很少用到，最后我们在分析一下同步请求即可。

4. 异步请求

跟着源码 走一遍 RealCall.enqueue() 的实现

#RealCall.java

 @Override public void enqueue(Callback responseCallback) {
    //TODO 不能重复执行
    synchronized (this) {
      if (executed) throw new IllegalStateException("Already Executed");
      executed = true;
    }
    captureCallStackTrace();
    eventListener.callStart(this);
    //TODO 交给 dispatcher调度器 进行调度
    client.dispatcher().enqueue(new AsyncCall(responseCallback));
  }

可以看到上述代码做了几件事：

1. synchronized (this) 确保每个call只能被执行一次不能重复执行，如果想要完全相同的call，可以调用如下方法：进行克隆

@SuppressWarnings("CloneDoesntCallSuperClone") // We are a final type & this saves clearing state.
  @Override public RealCall clone() {
    return RealCall.newRealCall(client, originalRequest, forWebSocket);
  }

2. 利用dispatcher调度器，来进行实际的执行client.dispatcher().enqueue(new AsyncCall(responseCallback));，在上面的OkHttpClient.Builder可以看出 已经初始化了Dispatcher。

下面我们着重看一下调度器的实现。

5. Dispatcher 调度器

Dispatcher#enqueue 的方法实现如下：

//TODO 执行异步请求
synchronized void enqueue(AsyncCall call) {
       //TODO 同时请求不能超过并发数(64,可配置调度器调整)
       //TODO okhttp会使用共享主机即 地址相同的会共享socket
       //TODO 同一个host最多允许5条线程通知执行请求
       if (runningAsyncCalls.size() < maxRequests &&
               runningCallsForHost(call) < maxRequestsPerHost) {
           //TODO 加入运行队列 并交给线程池执行
           runningAsyncCalls.add(call);
           //TODO AsyncCall 是一个runnable，放到线程池中去执行，查看其execute实现
           executorService().execute(call);
       } else {
           //TODO 加入等候队列
           readyAsyncCalls.add(call);
       }
   }

从上述代码可以看到Dispatcher将call 加入到队列中，然后通过线程池来执行call。

可能大家看了还是懵懵的，我们先了解一下Dispatcher几个属性和方法

 //TODO 同时能进行的最大请求数
    private int maxRequests = 64;
    //TODO 同时请求的相同HOST的最大个数 SCHEME :// HOST [ ":" PORT ] [ PATH [ "?" QUERY ]]
    //TODO 如 https://restapi.amap.com  restapi.amap.com - host
    private int maxRequestsPerHost = 5;
    /**
     * Ready async calls in the order they'll be run.
     * TODO 双端队列，支持首尾两端 双向开口可进可出，方便移除
     * 异步等待队列
     *
     */
    private final Deque readyAsyncCalls = new ArrayDeque<>();

    /**
     * Running asynchronous calls. Includes canceled calls that haven't finished yet.
     * TODO 正在进行的异步队列
     */
    private final Deque runningAsyncCalls = new ArrayDeque<>();

很明显，okhttp 可以进行多个并发网络请求，并且可以设置最大的请求数

executorService() 这个方法很简单，只是创建了一个线程池

public synchronized ExecutorService executorService() {
        if (executorService == null) {
            //TODO 线程池的相关概念 需要理解
            //TODO 核心线程 最大线程 非核心线程闲置60秒回收 任务队列
            executorService = new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60, TimeUnit.SECONDS,
                    new SynchronousQueue(), Util.threadFactory("OkHttp Dispatcher",
                    false));
        }
        return executorService;
    }

既然我们将 call放到了线程池中那么它是如何执行的呢？注意这里的call是AsyncCall。

我们看一下AsyncCall的实现：

final class AsyncCall extends NamedRunnable

NamedRunnable 是什么鬼？点进去看一下

public abstract class NamedRunnable implements Runnable {
 protected final String name;

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

 @Override public final void run() {
   String oldName = Thread.currentThread().getName();
   Thread.currentThread().setName(name);
   try {
     execute();
   } finally {
     Thread.currentThread().setName(oldName);
   }
 }

 protected abstract void execute();
}

原来如此 AsyncCall其实就是一个 Runnable，线程池实际上就是执行了execute()。

我们在看一下AsyncCall的execute()

final class AsyncCall extends NamedRunnable {
   @Override protected void execute() {
     boolean signalledCallback = false;
     try {
       //TODO 责任链模式
       //TODO 拦截器链  执行请求
       Response response = getResponseWithInterceptorChain();
       //回调结果
       if (retryAndFollowUpInterceptor.isCanceled()) {
         signalledCallback = true;
         responseCallback.onFailure(RealCall.this, new IOException("Canceled"));
       } else {
         signalledCallback = true;
         responseCallback.onResponse(RealCall.this, response);
       }
     } catch (IOException e) {
       if (signalledCallback) {
         // Do not signal the callback twice!
         Platform.get().log(INFO, "Callback failure for " + toLoggableString(), e);
       } else {
         eventListener.callFailed(RealCall.this, e);
         responseCallback.onFailure(RealCall.this, e);
       }
     } finally {
       //TODO 移除队列
       client.dispatcher().finished(this);
     }
   }
 }

从上述代码可以看出真正执行请求的是getResponseWithInterceptorChain(); 然后通过回调将Response返回给用户。

值得注意的finally 执行了client.dispatcher().finished(this); 通过调度器移除队列，并且判断是否存在等待队列，如果存在，检查执行队列是否达到最大值，如果没有将等待队列变为执行队列。这样也就确保了等待队列被执行。

private  void finished(Deque calls, T call, boolean promoteCalls) {
       int runningCallsCount;
       Runnable idleCallback;
       synchronized (this) {
           //TODO calls 移除队列
           if (!calls.remove(call)) throw new AssertionError("Call wasn't in-flight!");
           //TODO 检查是否为异步请求，检查等候的队列 readyAsyncCalls，如果存在等候队列，则将等候队列加入执行队列
           if (promoteCalls) promoteCalls();
           //TODO 运行队列的数量
           runningCallsCount = runningCallsCount();
           idleCallback = this.idleCallback;
       }
       //闲置调用
       if (runningCallsCount == 0 && idleCallback != null) {
           idleCallback.run();
       }
   }
   
   private void promoteCalls() {
       //TODO 检查 运行队列 与 等待队列
       if (runningAsyncCalls.size() >= maxRequests) return; // Already running max capacity.
       if (readyAsyncCalls.isEmpty()) return; // No ready calls to promote.

       //TODO 将等待队列加入到运行队列中
       for (Iterator i = readyAsyncCalls.iterator(); i.hasNext(); ) {
           AsyncCall call = i.next();
           //TODO  相同host的请求没有达到最大，加入运行队列
           if (runningCallsForHost(call) < maxRequestsPerHost) {
               i.remove();
               runningAsyncCalls.add(call);
               executorService().execute(call);
           }

           if (runningAsyncCalls.size() >= maxRequests) return; // Reached max capacity.
       }
   }

真正的执行网络请求和返回响应结果：getResponseWithInterceptorChain()，下面我们着重分析一下这个方法：

每段代码我都加上了注释。

//TODO 核心代码 开始真正的执行网络请求
 Response getResponseWithInterceptorChain() throws IOException {
   // Build a full stack of interceptors.
   //TODO 责任链
   List interceptors = new ArrayList<>();
   //TODO 在配置okhttpClient 时设置的intercept 由用户自己设置
   interceptors.addAll(client.interceptors());
   //TODO 负责处理失败后的重试与重定向
   interceptors.add(retryAndFollowUpInterceptor);
   //TODO 负责把用户构造的请求转换为发送到服务器的请求 、把服务器返回的响应转换为用户友好的响应 处理 配置请求头等信息
   //TODO 从应用程序代码到网络代码的桥梁。首先，它根据用户请求构建网络请求。然后它继续呼叫网络。最后，它根据网络响应构建用户响应。
   interceptors.add(new BridgeInterceptor(client.cookieJar()));
   //TODO 处理 缓存配置 根据条件(存在响应缓存并被设置为不变的或者响应在有效期内)返回缓存响应
   //TODO 设置请求头(If-None-Match、If-Modified-Since等) 服务器可能返回304(未修改)
   //TODO 可配置用户自己设置的缓存拦截器
   interceptors.add(new CacheInterceptor(client.internalCache()));
   //TODO 连接服务器 负责和服务器建立连接 这里才是真正的请求网络
   interceptors.add(new ConnectInterceptor(client));
   if (!forWebSocket) {
     //TODO 配置okhttpClient 时设置的networkInterceptors
     //TODO 返回观察单个网络请求和响应的不可变拦截器列表。
     interceptors.addAll(client.networkInterceptors());
   }
   //TODO 执行流操作(写出请求体、获得响应数据) 负责向服务器发送请求数据、从服务器读取响应数据
   //TODO 进行http请求报文的封装与请求报文的解析
   interceptors.add(new CallServerInterceptor(forWebSocket));

   //TODO 创建责任链
   Interceptor.Chain chain = new RealInterceptorChain(interceptors, null, null, null, 0,
       originalRequest, this, eventListener, client.connectTimeoutMillis(),
       client.readTimeoutMillis(), client.writeTimeoutMillis());

   //TODO 执行责任链
   return chain.proceed(originalRequest);
 }

从上述代码中，可以看出都实现了Interceptor接口，这是okhttp最核心的部分，采用责任链的模式来使每个功能分开，每个Interceptor自行完成自己的任务，并且将不属于自己的任务交给下一个，简化了各自的责任和逻辑。

责任链模式是设计模式中的一种也相当简单参考链接，这里不在复述。

我们着重分析一下，okhttp的设计实现，如何通过责任链来进行传递返回数据的。

上述代码中可以看出interceptors，是传递到了RealInterceptorChain该类实现了Interceptor.Chain，并且执行了chain.proceed(originalRequest)。

其实核心代码就是chain.proceed() 通过该方法进行责任链的执行。

public Response proceed(Request request, StreamAllocation streamAllocation, HttpCodec httpCodec,
     RealConnection connection) throws IOException {
   if (index >= interceptors.size()) throw new AssertionError();
   calls++;
   //TODO 创建新的拦截链，链中的拦截器集合index+1
   RealInterceptorChain next = new RealInterceptorChain(interceptors, streamAllocation, httpCodec,
       connection, index + 1, request, call, eventListener, connectTimeout, readTimeout,
       writeTimeout);
   //TODO 执行当前的拦截器-如果在配置okhttpClient，时没有设置intercept默认是先执行：retryAndFollowUpInterceptor 拦截器
   Interceptor interceptor = interceptors.get(index);
   //TODO 执行拦截器
   Response response = interceptor.intercept(next);
   return response;
 }

从上述代码，我们可以知道，新建了一个RealInterceptorChain 责任链 并且 index+1，然后 执行interceptors.get(index); 返回Response。

其实就是按顺序执行了拦截器，这里我画了一个简图：

拦截器的执行顺序便是如上图这样执行的。

这样设计的一个好处就是，责任链中每个拦截器都会执行chain.proceed()方法之前的代码，等责任链最后一个拦截器执行完毕后会返回最终的响应数据，而chain.proceed() 方法会得到最终的响应数据，这时就会执行每个拦截器的chain.proceed()方法之后的代码，其实就是对响应数据的一些操作。

CacheInterceptor 缓存拦截器就是很好的证明，我们来通过CacheInterceptor 缓存拦截器来进行分析，大家就会明白了。

CacheInterceptor 的实现如下：

代码比较长，我们一步一步的来进行分析。

首先我们先分析上部分代码当没有网络的情况下是如何处理获取缓存的。

@Override public Response intercept(Chain chain) throws IOException
  {
//TODO 获取request对应缓存的Response 如果用户没有配置缓存拦截器 cacheCandidate == null
    Response cacheCandidate = cache != null
        ? cache.get(chain.request())
        : null;

    //TODO 执行响应缓存策略
    long now = System.currentTimeMillis();
    CacheStrategy strategy = new CacheStrategy.Factory(now, chain.request(), cacheCandidate).get();
    //TODO 如果networkRequest == null 则说明不使用网络请求
    Request networkRequest = strategy.networkRequest;
    //TODO 获取缓存中（CacheStrategy）的Response
    Response cacheResponse = strategy.cacheResponse;

    if (cache != null) {
      cache.trackResponse(strategy);
    }
    //TODO 缓存无效 关闭资源
    if (cacheCandidate != null && cacheResponse == null) {
      closeQuietly(cacheCandidate.body()); // The cache candidate wasn't applicable. Close it.
    }

    // If we're forbidden from using the network and the cache is insufficient, fail.
    //TODO networkRequest == null 不实用网路请求 且没有缓存 cacheResponse == null  返回失败
    if (networkRequest == null && cacheResponse == null) {
      return new Response.Builder()
          .request(chain.request())
          .protocol(Protocol.HTTP_1_1)
          .code(504)
          .message("Unsatisfiable Request (only-if-cached)")
          .body(Util.EMPTY_RESPONSE)
          .sentRequestAtMillis(-1L)
          .receivedResponseAtMillis(System.currentTimeMillis())
          .build();
    }

    //TODO 不使用网络请求 且存在缓存 直接返回响应
    // If we don't need the network, we're done.
    if (networkRequest == null) {
      return cacheResponse.newBuilder()
          .cacheResponse(stripBody(cacheResponse))
          .build();
    }
    }

上述的代码，主要做了几件事：

1. 如果用户自己配置了缓存拦截器，cacheCandidate = cache.Response 获取用户自己存储的Response,否则 cacheCandidate = null;同时从CacheStrategy 获取cacheResponse 和 networkRequest
2. 如果cacheCandidate ！= null 而 cacheResponse == null 说明缓存无效清楚cacheCandidate缓存。
3. 如果networkRequest == null 说明没有网络，cacheResponse == null 没有缓存，返回失败的信息，责任链此时也就终止，不会在往下继续执行。
4. 如果networkRequest == null 说明没有网络，cacheResponse != null 有缓存，返回缓存的信息，责任链此时也就终止，不会在往下继续执行。

上部分代码，其实就是没有网络的时候的处理。

那么下部分代码肯定是，有网络的时候处理

 //TODO 执行下一个拦截器
    Response networkResponse = null;
    try {
      networkResponse = chain.proceed(networkRequest);
    } finally {
      // If we're crashing on I/O or otherwise, don't leak the cache body.
      if (networkResponse == null && cacheCandidate != null) {
        closeQuietly(cacheCandidate.body());
      }
    }

    //TODO 网络请求 回来 更新缓存
    // If we have a cache response too, then we're doing a conditional get.
    //TODO 如果存在缓存 更新
    if (cacheResponse != null) {
      //TODO 304响应码 自从上次请求后，请求需要响应的内容未发生改变
      if (networkResponse.code() == HTTP_NOT_MODIFIED) {
        Response response = cacheResponse.newBuilder()
            .headers(combine(cacheResponse.headers(), networkResponse.headers()))
            .sentRequestAtMillis(networkResponse.sentRequestAtMillis())
            .receivedResponseAtMillis(networkResponse.receivedResponseAtMillis())
            .cacheResponse(stripBody(cacheResponse))
            .networkResponse(stripBody(networkResponse))
            .build();
        networkResponse.body().close();

        // Update the cache after combining headers but before stripping the
        // Content-Encoding header (as performed by initContentStream()).
        cache.trackConditionalCacheHit();
        cache.update(cacheResponse, response);
        return response;
      } else {
        closeQuietly(cacheResponse.body());
      }
    }
    //TODO 缓存Response
    Response response = networkResponse.newBuilder()
        .cacheResponse(stripBody(cacheResponse))
        .networkResponse(stripBody(networkResponse))
        .build();

    if (cache != null) {
      if (HttpHeaders.hasBody(response) && CacheStrategy.isCacheable(response, networkRequest)) {
        // Offer this request to the cache.
        CacheRequest cacheRequest = cache.put(response);
        return cacheWritingResponse(cacheRequest, response);
      }

      if (HttpMethod.invalidatesCache(networkRequest.method())) {
        try {
          cache.remove(networkRequest);
        } catch (IOException ignored) {
          // The cache cannot be written.
        }
      }
    }

    return response;
  }

下部分代码主要做了这几件事：

1. 执行下一个拦截器，也就是请求网络
2. 责任链执行完毕后，会返回最终响应数据，如果缓存存在更新缓存，如果缓存不存在加入到缓存中去。

这样就体现出了，责任链这样实现的好处了，当责任链执行完毕，如果拦截器想要拿到最终的数据做其他的逻辑处理等，这样就不用在做其他的调用方法逻辑了，直接在当前的拦截器就可以拿到最终的数据。

这也是okhttp设计的最优雅最核心的功能。

当然我们可以通过一个小例子来进行验证，实践才最重要。

首先我们模拟一个 拦截器的接口

/**
 * @author prim
 * @version 1.0.0
 * @desc 模拟okhttp拦截器
 * @time 2018/8/3 - 下午4:29
 */
public interface Interceptor {
    String interceptor(Chain chain);

    interface Chain {
        String request();

        String proceed(String request);
    }
}

然后在实现几个拦截器

public class BridgeInterceptor implements Interceptor {
    @Override
    public String interceptor(Chain chain) {
        System.out.println("执行 BridgeInterceptor 拦截器之前代码");
        String proceed = chain.proceed(chain.request());
        System.out.println("执行 BridgeInterceptor 拦截器之后代码 得到最终数据："+proceed);
        return proceed;
    }
}

public class RetryAndFollowInterceptor implements Interceptor {
    @Override
    public String interceptor(Chain chain) {
        System.out.println("执行 RetryAndFollowInterceptor 拦截器之前代码");
        String proceed = chain.proceed(chain.request());
        System.out.println("执行 RetryAndFollowInterceptor 拦截器之后代码 得到最终数据：" + proceed);
        return proceed;
    }
}

public class CacheInterceptor implements Interceptor {
    @Override
    public String interceptor(Chain chain) {
        System.out.println("执行 CacheInterceptor 最后一个拦截器 返回最终数据");
        return "success";
    }
}

然后实现Chain 接口

public class RealInterceptorChain implements Interceptor.Chain {

    private List interceptors;

    private int index;

    private String request;

    public RealInterceptorChain(List interceptors, int index, String request) {
        this.interceptors = interceptors;
        this.index = index;
        this.request = request;
    }

    @Override
    public String request() {
        return request;
    }

    @Override
    public String proceed(String request) {
        if (index >= interceptors.size()) return null;

        //获取下一个责任链
        RealInterceptorChain next = new RealInterceptorChain(interceptors, index+1, request);
        // 执行当前的拦截器
        Interceptor interceptor = interceptors.get(index);

        return interceptor.interceptor(next);
    }
}

然后进行测试，看看我们是否分析的正确

List interceptors = new ArrayList<>();
        interceptors.add(new BridgeInterceptor());
        interceptors.add(new RetryAndFollowInterceptor());
        interceptors.add(new CacheInterceptor());

        RealInterceptorChain request = new RealInterceptorChain(interceptors, 0, "request");

        request.proceed("request");

打印的log日志如下：

执行 BridgeInterceptor 拦截器之前代码
执行 RetryAndFollowInterceptor 拦截器之前代码
执行 CacheInterceptor 最后一个拦截器 返回最终数据
执行 RetryAndFollowInterceptor 拦截器之后代码 得到最终数据：success
执行 BridgeInterceptor 拦截器之后代码 得到最终数据：success

OK 完美，验证没有问题，我想至此大家都应该懂了 okhttp的核心设计思想了。

okhttp的其他拦截器的具体实现大家可以自己研究一下即可，okhttp的这种设计思想我们完全可以应用到项目中去，解决一些问题。

5. 同步请求

这里在稍微讲一下，okhttp的同步请求，代码很简单
同样是在RealCall 类中实现的

//TODO 同步执行请求 直接返回一个请求的结果
  @Override public Response execute() throws IOException {
    synchronized (this) {
      if (executed) throw new IllegalStateException("Already Executed");
      executed = true;
    }
    captureCallStackTrace();
    //TODO 调用监听的开始方法
    eventListener.callStart(this);
    try {
      //TODO 交给调度器去执行
      client.dispatcher().executed(this);
      //TODO 获取请求的返回数据
      Response result = getResponseWithInterceptorChain();
      if (result == null) throw new IOException("Canceled");
      return result;
    } catch (IOException e) {
      eventListener.callFailed(this, e);
      throw e;
    } finally {
      //TODO 执行调度器的完成方法 移除队列
      client.dispatcher().finished(this);
    }
  }

主要做了几件事：

1. synchronized (this) 避免重复执行，上面的文章部分有讲。
2. client.dispatcher().executed(this); 实际上调度器只是将call 加入到了同步执行队列中。代码如下：

//TODO 调度器执行同步请求
  synchronized void executed(RealCall call) {
      runningSyncCalls.add(call);
  }

3. getResponseWithInterceptorChain()最核心的代码，上面已经分析过了，请求网络得到响应数据，返回给用户。
4. client.dispatcher().finished(this); 执行调度器的完成方法 移除队列

可以看出，在同步请求的方法中，涉及到dispatcher 只是告知了执行状态，开始执行了（调用 executed），执行完毕了（调用 finished）其他的并没有涉及到。dispatcher 更多的是服务异步请求。

三、总结

1. 异步请求线程池-OkHttp Dispatcher

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

• 该线程池与Android下的 Executors.newCachedThreadPool() 比较类似；
• 无任务上限，自动回收闲置60s的线程，适用于大量耗时较短的任务；
• 虽然线程池无任务上限，但是Dispatcher对入口enqueue()进行了把关，最大的异步任务数默认是64，同一个主机默认是5，当然这两个默认值是可以修改的，Dispatcher提供的修改接口；

okHttpClient.dispatcher().setMaxRequests(128);
okHttpClient.dispatcher().setMaxRequestsPerHost(10);

2. 连接池清理线程池-OkHttp ConnectionPool

/**
* Background threads are used to cleanup expired connections. There will be at most a single
* thread running per connection pool. The thread pool executor permits the pool itself to be
* garbage collected.
*/
private static final Executor executor = new ThreadPoolExecutor(0 /* corePoolSize */,
   Integer.MAX_VALUE /* maximumPoolSize */, 60L /* keepAliveTime */, TimeUnit.SECONDS,
   new SynchronousQueue(), Util.threadFactory("OkHttp ConnectionPool", true));

• 该线程池用来清理长时间闲置的和泄漏的连接；
• 该线程池本身无任务上限，线程闲置60s自动回收；
• 虽然任务无上限，但其通过 cleanupRunning 标记来控制只有一个线程在运行，当连接池中没有连接后才会被重新设置为 false;

3. 缓存整理线程池-OkHttp DiskLruCache

// Use a single background thread to evict entries.
Executor executor = new ThreadPoolExecutor(0, 1, 60L, TimeUnit.SECONDS,
   new LinkedBlockingQueue(), Util.threadFactory("OkHttp DiskLruCache", true));

• 该线程池用于整理本地请求缓存数据；
• 缓存的整理包含: 达到阀值大小的文件，删除最近最少使用的记录，在有关操作达到一定数量以后对记录进行重建；
• 最大运行线程数1，无需考虑线程安全问题，自动回收闲置60s的线程；

4. HTTP2异步事务线程池-OkHttp Http2Connection

• HTTP2采用了多路复用，因此需要维护连接有效性，本线程池就是用于维护相关的各类HTTP2事务;
• 线程池本身无任务上限，自动回收闲置60s的线程;
• 每一个HTTP2连接都有这么一个线程池存在;

四、采用的设计模式：

1. 对象创建型模式(Builder模式)

使用Builder模式处理需要很多参数的构造函数，提高代码可读性。（Builder模式的优点）
比如：OkHttpClient、Request、Response、MultipartBody、HttpUrl

public OkHttpClient() {  
  this(new Builder());
}
public Builder() {
 dispatcher = new Dispatcher();
 protocols = DEFAULT_PROTOCOLS;
 connectionSpecs = DEFAULT_CONNECTION_SPECS;
 proxySelector = ProxySelector.getDefault();
 cookieJar = CookieJar.NO_COOKIES;
 socketFactory = SocketFactory.getDefault();
 hostnameVerifier = OkHostnameVerifier.INSTANCE;
 certificatePinner = CertificatePinner.DEFAULT;
 proxyAuthenticator = Authenticator.NONE;
 authenticator = Authenticator.NONE;
 connectionPool = new ConnectionPool();
 dns = Dns.SYSTEM;
 followSslRedirects = true;
 followRedirects = true;
 retryOnConnectionFailure = true;
 connectTimeout = 10_000;
 readTimeout = 10_000;
 writeTimeout = 10_000;
}

对象创建型模式(Builder模式)

下面例子比较可以很好理解Builder模式的好处。
本地缓存对象构造对比:

//如果这样构造对象可读性很差，虽然实现了功能
RxCache rxCache = new RxCache（new File(getCacheDir().getPath() + File.separator + "data-wuxiao"),
new DiskConverter(),2*1024*1024,40*1024*1024）

使用Builder模式

RxCache rxCache = new RxCache.Builder()
                .diskDir(new File(getCacheDir().getPath() + File.separator + "data-wuxiao"))
                .diskConverter(new DiskConverter())
                .memory(2*1024*1024)
                .disk(40*1024*1024)
                .build();

2. OkHttp - Interceptor责任链模式

Interceptor是 OkHttp 核心类，它把网络请求、缓存、透明压缩等功能都统一了起来，每一个功能都是一个 Interceptor，它们再连接成一个 Interceptor.Chain，如链条一般，分工明确，完美完成一次网络请求。

private Response getResponseWithInterceptorChain() throws IOException {
  // Build a full stack of interceptors.
  List interceptors = new ArrayList<>();
  interceptors.addAll(client.interceptors());
  interceptors.add(retryAndFollowUpInterceptor);
  interceptors.add(new BridgeInterceptor(client.cookieJar()));
  interceptors.add(new CacheInterceptor(client.internalCache()));
  interceptors.add(new ConnectInterceptor(client));
  if (!retryAndFollowUpInterceptor.isForWebSocket()) {
    interceptors.addAll(client.networkInterceptors());
  }
  interceptors.add(new CallServerInterceptor(
      retryAndFollowUpInterceptor.isForWebSocket()));

  Interceptor.Chain chain = new RealInterceptorChain(
      interceptors, null, null, null, 0, originalRequest);
  return chain.proceed(originalRequest);
}

责任链其实在Android应用也存在（如:事件传递就是责任链机制）。

3. 工厂模式（Factory Method）

如果简单工厂也算设计模式的话，在okhttp中倒是有很多。不过工厂方法却用的不多。下面是其中2个：

public interface Call extends Cloneable {
  ...
  interface Factory {  
    Call newCall(Request request);  
  }
}

public interface WebSocket {
  ...
  interface Factory {  
    WebSocket newWebSocket(Request request, WebSocketListener listener);  
  }  
}

4. 观察者模式（Observer）

观察者有两个，一个是EventListener，另一个是WebSocketListener。两者都可以看作是生命周期监听器，前者监听请求/响应，后者监听web socket。

public abstract class EventListener {
  ...
  public void requestHeadersStart(Call call) {}
  public void requestHeadersEnd(Call call, Request request) {}
  public void requestBodyStart(Call call) {}
  public void requestBodyEnd(Call call, long byteCount) {}
  public void responseHeadersStart(Call call) {}
  public void responseHeadersEnd(Call call, Response response) {}
  public void responseBodyStart(Call call) {}
  public void responseBodyEnd(Call call, long byteCount) {}
  ...
}

上面列出的方法被称作Request Events：

graph LR
requestHeaders --> requestBody
requestBody --> responseHeaders
responseHeaders --> responseBody

5. 策略模式（Strategy）

无论是源码，还是注释中很多地方都有strategy、policy这样的单词，但真正是策略模式的笔者只发现了CookieJar，定义了管理cookie的方法：

public interface CookieJar {  
  CookieJar NO_COOKIES = ...

  void saveFromResponse(HttpUrl url, List cookies);
  List loadForRequest(HttpUrl url);
}

其它诸如CacheStrategy、ConnectionSpecSelector，笔者认为都不是策略模式。

五、总结

本文主要讲解okhttp的核心设计思想，对整体有了清晰的认识之后，在深入细节，更容易理解。

简述okhttp的执行流程：

1. OkhttpClient 实现了Call.Fctory,负责为Request 创建 Call；
2. RealCall 为Call的具体实现，其enqueue() 异步请求接口通过Dispatcher()调度器利用ExcutorService实现，而最终进行网络请求时和同步的execute()接口一致，都是通过
3. getResponseWithInterceptorChain() 函数实现
   getResponseWithInterceptorChain() 中利用 Interceptor 链条，责任链模式 分层实现缓存、透明压缩、网络 IO 等功能；最终将响应数据返回给用户。

---

• https://www.jianshu.com/p/cb444f49a777
• https://www.jianshu.com/p/9deec36f2759
• https://blog.csdn.net/qq_23012315/article/details/82492165