快速理解 OkHttp

使用 OkHttp 的基本流程

1. 创建 OkHttpClient 对象
2. 创建 Request 对象
3. 创建 Call 对象
4. 同步请求调用 call.execute()；异步请求调用 call.enqueue()

同步执行

//创建OkHttpClient对象
OkHttpClient client = new OkHttpClient();

String run(String url) throws IOException {
   //创建Request请求对象
  Request request = new Request.Builder()
      .url(url)
      .build();

   //创建Call对象，并执行同步获取网络数据
  Response response = client.newCall(request).execute();
  return response.body().string();
}

异步执行

void runAsync(String url, Callback callback) {
    OkHttpClient client = new OkHttpClient.Builder().addInterceptor(new Interceptor() {
        @Override
        public Response intercept(Chain chain) throws IOException {
            Request request = chain.request();
            Request.Builder builder = request.newBuilder().addHeader("name", "test");
            return chain.proceed(builder.build());
        }
    }).build();
    //创建Request请求对象
    Request request = new Request.Builder()
        .url(url)
        .build();

    client.newCall(request).enqueue(callback);
}

---

创建 OkHttpClient 对象

创建 OkHttpClient 一般有两种方法，一种是直接 new OkHttpClient(),另外一种是通过 OkHttpClient.Builder()。

OkhttpClient client = new OkHttpClient
    .Builder()
    .connectTimeout(5, TimeUnit.SECONDS)
    .writeTimeout(10,TimeUnit.SECONDS)
    .readTimeout(10, TimeUnit.SECONDS)
    .build();

第二种创建方式主要是通过建造者模式，来配置一些参数，比如连接超时时间，读写超时时间，超时重试次数等。这样有一个好处，可以对外屏蔽掉构建 client 的细节。

OkhttpClient 对象主要处理一些基础的配置，比如连接超时，读写超时，添加拦截器。

---

创建 Request 对象

public final class Request {
    final HttpUrl url;
    final String method;
    final Headers headers;
    final RequestBody body;
    final Object tag;

    private volatile CacheControl cacheControl; // Lazily initialized.
}

Request 对象主要封装的是一些网络请求的信息，比如请求 url，请求方法，请求头，请求 body 等，也比较简单，这里不再展开阐述。

---

创建 Call 对象

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

可以看到 call 对象实际是 RealCall 的实例化对象。

---

同步请求

RealCall#execute()

@Override 
public Response execute() throws IOException {
    synchronized (this) {
        if (executed) throw new IllegalStateException("Already Executed");
        executed = true;
    }
    captureCallStackTrace();
    try {
        // 执行 client.dispatcher() 的 executed 方法
        client.dispatcher().executed(this);
        Response result = getResponseWithInterceptorChain();
        if (result == null) throw new IOException("Canceled");
        return result;
    } finally {
        // 最后再执行 dispatcher 的 finish 方法
        client.dispatcher().finished(this);
    }
}

在 execute 方法中：

1. 首先会调用 client.dispatcher().executed(this) 加入到 runningAsyncCalls 队列当中
2. 接着执行 getResponseWithInterceptorChain() 获取请求结果
3. 最终再执行 client.dispatcher().finished(this) 将 realCall 从 runningAsyncCalls 队列中移除

---

拦截器 Interceptor

getResponseWithInterceptorChain()

Response getResponseWithInterceptorChain() throws IOException {
    // Build a full stack of interceptors.
    List<Interceptor> 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 (!forWebSocket) {
        interceptors.addAll(client.networkInterceptors());
    }
    interceptors.add(new CallServerInterceptor(forWebSocket));
    Interceptor.Chain chain = new RealInterceptorChain(
        interceptors, null, null, null, 0, originalRequest);
    return chain.proceed(originalRequest);
}

可以看到，首先，他会将客户端的 interceptors 添加到 List 当中，接着，再添加 okhttp 里面的 interceptor，然后构建了一个 RealInterceptorChain 对象，并将我们的 List<Interceptor> 作为成员变量，最后调用 RealInterceptorChain 的 proceed 方法。

其中，client.interceptors() 为我们自己添加的请求拦截器，通常是做一些添加统一的token之类操作。

RetryAndFollowUpInterceptor 拦截器

• RetryAndFollowUpInterceptor 此拦截器顾名思义就是主要负责失败重连工作，但是并不是所有的网络请求都会进行失败重连的,在此拦截器内部会进行网络请求的异常检测和响应码的判断，如果都在限制范围内，那么就可以进行失败重连。

CacheInterceptor 拦截器

• 如果当前未使用网络，并且缓存不可以使用，通过构建者模式创建一个 Response 响应，抛出504错误。

• 如果有缓存但是不能使用网络，直接返回缓存结果。这是在进行网络请求之前所做的事情，当网络请求完成，得到下一个拦截器返回的 response 之后，判断 response 的响应码是否是 HTTP_NOT_MODIFIED = 304（未改变），是则从缓存中读取数据。

proceed()

public Response proceed(Request request, StreamAllocation streamAllocation, HttpCodec httpCodec,
                        Connection connection) throws IOException {

    // 省略无关代码


    //  生成 list 当中下一个 interceptot 的 chain 对象
    RealInterceptorChain next = new RealInterceptorChain(
        interceptors, streamAllocation, httpCodec, connection, index + 1, request);
    // 当前的 interceptor
    Interceptor interceptor = interceptors.get(index);
    // 当前的 intercept 处理下一个 intercept 包装的 chain 对象
    Response response = interceptor.intercept(next);

    // ----

    return response;
}

proceed 方法也很简单，proceed方法每次从拦截器列表中取出拦截器，并调用 interceptor.intercept(next)。

熟悉 Okhttp 的应该都知道，我们在 addInterceptor 创建 Interceptor 实例，最终都会调用 chain.proceed(Request request),从而形成一种链式调用。这种便是责任链设计模式。

OkHttpClient client = new OkHttpClient.Builder().addInterceptor(new Interceptor() {
    @Override
    public Response intercept(Chain chain) throws IOException {
        Request request = chain.request();
        Request.Builder builder = request.newBuilder().addHeader("name","test");
        return chain.proceed(builder.build());
    }
}).build();

而 OkHttp 是怎样结束循环调用的，这是因为最后一个拦截器 CallServerInterceptor 并没有调用 chain.proceed(request)，所以能够结束循环调用。

---

异步请求

dispatcher 分发器

public final class Dispatcher {
    private int maxRequests = 64;
    private int maxRequestsPerHost = 5;
    private Runnable idleCallback;

    /** Executes calls. Created lazily. */
    private ExecutorService executorService;

    // 异步的请求等待队列
    private final Deque<AsyncCall> readyAsyncCalls = new ArrayDeque<>();

    // 异步的正在请求的队列
    private final Deque<AsyncCall> runningAsyncCalls = new ArrayDeque<>();

    // 同步的正在请求的队列
    private final Deque<RealCall> runningSyncCalls = new ArrayDeque<>();
}

分发器 Dispatcher，里面有三个请求队列，一个是正在请求的队列，一个是等待队列，另外一个是同步的正在请求的队列，当我们执行 enqueue 方法的时候，他会判断正在请求队列数量是否超过允许的最大并发数量（默认是 64）（线程池的原理），如果超过了，会添加到等待队列里面。

maxRequests：可以同时运行的最大请求数，也就是说一个 okhttp 的 client 可以同时发 64 个请求。

maxRequestsPerHost：对每个域名我们最多同时只能有5个请求。

这个参数的实际意义是针对每个域名，okhttp 最多可以发起5条 TCP 连接。

execute 方法是同步执行的，每次执行会添加到同步请求队列当中，执行完毕之后会移除。

RealCall#enqueue(Callback responseCallback)

@Override 
public void enqueue(Callback responseCallback) {
    synchronized (this) {
        if (executed) throw new IllegalStateException("Already Executed");
        executed = true;
    }
    captureCallStackTrace();
    client.dispatcher().enqueue(new AsyncCall(responseCallback));
}

其中，AsyncCall 是 Runnable 的子类，实现了 run 方法。

dispatcher().enqueue(AsyncCall call)

synchronized void enqueue(AsyncCall call) {
    if (runningAsyncCalls.size() < maxRequests && runningCallsForHost(call) < maxRequestsPerHost) {
        runningAsyncCalls.add(call);
        executorService().execute(call);
    } else {
        readyAsyncCalls.add(call);
    }
}

当执行 executorService().execute(call) 的时候，会调用 run 方法， run 方法又会调用到 execute 方法进行网络请求，请求完成之后，会调用 client.dispatcher().finished(this) 从队列里面移除。

---

到此， Okhttp 的主要流程已经讲完。

---

小结

1. 有一个分发器 Dispatcher，里面有三个请求队列，一个是正在请求的队列，一个是等待队列，另外一个是同步的正在请求的队列，当我们执行 enqueue 方法的时候，他会判断正在请求队列数量是否超过允许的最大并发数量（默认是 64）（线程池的原理），如果超过了，会添加到等待队列里面。
   excute 方法是同步执行的，每次执行会添加到同步请求队列当中，执行完毕之后会移除。

2. 设计的核心思想责任链模式，当我们需要拦截的时候，可以实现 Interceptor 接口，会按照添加的顺序执行 Chain.proceed 方法。

3. 职责分明，OkhttpClient 对象主要处理一些基础的配置，比如连接超时，读写超时，添加拦截器。Request 主要配置请求方法，请求头等。

---

参考资料：

• 一步步带你读懂 Okhttp 源码
• okhttp拦截器Interceptor详解