okhttp使用分为同步请求和异步请求：
异步请求：
String url = "";
Request request = new Request.Builder().get().url(url).build();
OkHttpClient okHttpClient = new OkHttpClient();
public void request(){
okHttpClient.newCall(request).enqueue(new Callback() {
@Override
public void onFailure(Call call, IOException e) {
}
@Override
public void onResponse(Call call, Response response) throws IOException {
}
});
}
request是一个请求对像，包含了请求url，methord，heard等信息
okhttpclient 主要用于发送http请求以及读取回应
newcall方法主要是用于返回一个realcall对象，并且把请求对象request交给了realcall
@Override public Call newCall(Request request) {
return new RealCall(this, request, false /* for web socket */);
}
接下来看一下realcall的enqueue方法：
@Override public void enqueue(Callback responseCallback) {
synchronized (this) {
if (executed) throw new IllegalStateException("Already Executed");
executed = true;
}
captureCallStackTrace();
client.dispatcher().enqueue(new AsyncCall(responseCallback));
}
首先通过同步，确保call不会被重复执行（如果想要完全相同的call可以通过clone方法），然后利用dispatcher调度器来执行enqueue方法，下面看一下dispatcher.enqueue方法：
synchronized void enqueue(AsyncCall call) {
if (runningAsyncCalls.size() < maxRequests && runningCallsForHost(call) < maxRequestsPerHost) {
runningAsyncCalls.add(call);
executorService().execute(call);
} else {
readyAsyncCalls.add(call);
}
}
dispatcher就是一个异步请求是的策略，它里面包含了能同时进行的最大请求数（默认是64），同时请求相同host的最大数（默认是5），以及维护一个异步任务执行队列和一个异步任务等待队列，然后回来看dispatcher.enqueue方法，首先会判断当前执行队列是不是超出最大请求数，以及同时访问相同host的数量是不是超过，如果超过就将call放入等待队列，否则放入执行队列，并且交给线程池去执行
执行的为AsyncCall，我们看一下AsyncCall的实现：
final class AsyncCall extends NamedRunnable {
AsyncCall继承自NamedRunnable，NamedRunnable其实是继承自Runnable，在他的run方法中会调用execute();方法，说到底其实就是会执行AsyncCall的execute();方法，接下来看一下AsyncCall的execute();方法：
@Override protected void execute() {
boolean signalledCallback = false;
try {
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 {
responseCallback.onFailure(RealCall.this, e);
}
} finally {
client.dispatcher().finished(this);
}
}
可以看到真正执行请求的是getResponseWithInterceptorChain(),获取到response后回调给用户，值得注意的是最后finally，会通过调度器移除队列，并且判断如果执行队列没有达到最大值则把等待队列变为执行队列，这样就包证了等待队列的执行
下面我们看一下真正请求的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);
}
我们可以看到方法中首先创建一个拦截器的列表，添加各个拦截器，每个拦截器个自完成自己的任务，并且将不属于自己的任务交给下一个，这就是一种责任链模式，最后的执行是由chain.proceed(originalRequest);来实现的，责任链中每个拦截器都会执行chain.proceed()方法之前的代码，等责任链最后一个拦截器执行完毕后会返回最终的响应数据，而chain.proceed() 方法会得到最终的响应数据，这时就会执行每个拦截器的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 {
if (index >= interceptors.size()) throw new AssertionError();
calls++;
// If we already have a stream, confirm that the incoming request will use it.
if (this.httpCodec != null && !this.connection.supportsUrl(request.url())) {
throw new IllegalStateException("network interceptor " + interceptors.get(index - 1)
+ " must retain the same host and port");
}
// If we already have a stream, confirm that this is the only call to chain.proceed().
if (this.httpCodec != null && calls > 1) {
throw new IllegalStateException("network interceptor " + interceptors.get(index - 1)
+ " must call proceed() exactly once");
}
// Call the next interceptor in the chain.
RealInterceptorChain next = new RealInterceptorChain(
interceptors, streamAllocation, httpCodec, connection, index + 1, request);
Interceptor interceptor = interceptors.get(index);
Response response = interceptor.intercept(next);
// Confirm that the next interceptor made its required call to chain.proceed().
if (httpCodec != null && index + 1 < interceptors.size() && next.calls != 1) {
throw new IllegalStateException("network interceptor " + interceptor
+ " must call proceed() exactly once");
}
// Confirm that the intercepted response isn't null.
if (response == null) {
throw new NullPointerException("interceptor " + interceptor + " returned null");
}
return response;
}
简述okhttp的执行流程：
- OkhttpClient 实现了Call.Fctory,负责为Request 创建 Call；
- RealCall 为Call的具体实现，其enqueue() 异步请求接口通过Dispatcher()调度器利用ExcutorService实现，而最终进行网络请求时和同步的execute()接口一致，都是通过 getResponseWithInterceptorChain() 函数实现
- getResponseWithInterceptorChain() 中利用 Interceptor 链条，责任链模式 分层实现缓存、透明压缩、网络 IO 等功能；最终将响应数据返回给用户。
