1.OkHttp的简单使用
一般情况下，对于网络框架有两种常见的使用场景，同步请求和异步请求。
同步请求：
OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder().url("http://www.baidu.com").build();
Call call = client.newCall(request);
Response response = call.execute();
异步请求：
OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder().url("http://www.baidu.com").build();
client.newCall(request).enqueue(new Callback() {
@Override
public void onFailure(Call call, IOException e) {
}
@Override
public void onResponse(Call call, Response response) throws IOException {
}
});
上面代码比较简单，并不是本文的重点。旨在抛砖引玉...
2.OkHttp内部相关类的介绍
- OkHttpClient：Okhttp的主类，一般情况下设计成单列使用。
- Request：OkHttp的请求类，可以分装了请求消息头，消息实体相关的信息
- Response：OkHttp的响应类，分装了相应码，相应实体相关的信息
- Call：对于OkHttp来说，一个call对应一次网络请求操作
- RealCall：Call接口的真正实现
- AsyncCall：当执行的时移步请求时，会转化成AsyncCall，它实现Runnable接口，是对RealCall的再次封装
- Dispatcher：用来分发请求任务的类
- RetryAndFollowUpInterceptor：负责重连和重定向的拦截器
- BridgeInterceptor：桥拦截器，处理请求头
- CacheInterceptor：缓存拦截器
- ConnectInterceptor：连接拦截器
- CallServerInterceptor：服务相应拦截器
3.OkHttp内部执行流程介绍
同步请求流程：
当一次同步请求被执行时，会先调用RealCall的excute方法
@Override public Response execute() throws IOException {
synchronized (this) {
if (executed) throw new IllegalStateException("Already Executed");
executed = true;
}
captureCallStackTrace();
try {
client.dispatcher().executed(this);
Response result = getResponseWithInterceptorChain();
if (result == null) throw new IOException("Canceled");
return result;
} finally {
client.dispatcher().finished(this);
}
}
这个方法的作用是先对同步请求进行分发，调用的Diapatcher的excuted方法，这个方法只是将请求缓存到dispatcher的runningSyncCalls的队列集合中，然后调用RealCall自己的getResponseWithInterceptorChain方法，这是整体OkHttp最为核心的方法，这个一个拦截器链，它将一层层过滤请求，最终返回响应，然后在调用dispatcher的finished方法，就是从runningSyncCalls队列集合中将请求剔除。这就是一次完整的okhttp的同步请求。
异步请求流程：
当一次异步请求被执行时，会先调用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));
}
这个方法的作用时判断这个请求是否已经被执行了，如果没有被执行，会将这个RealCall转化成AsyncCall对象，然后把他交给dispatcher类进行分发，dispather对象中有两个队列集合跟异步请求有关系。
/** Ready async calls in the order they'll be run. */
private final Deque<AsyncCall> readyAsyncCalls = new ArrayDeque<>();
/** Running asynchronous calls. Includes canceled calls that haven't finished yet. */
private final Deque<AsyncCall> runningAsyncCalls = new ArrayDeque<>();
这两个队列集合从名字上就可以看出一个是准备去执行的异步请求，一个时正在执行中的异步请求。dsipather的enqueue方法会对异步请求做进一步处理
synchronized void enqueue(AsyncCall call) {
if (runningAsyncCalls.size() < maxRequests && runningCallsForHost(call) < maxRequestsPerHost) {
runningAsyncCalls.add(call);
executorService().execute(call);
} else {
readyAsyncCalls.add(call);
}
}
这个方法的逻辑很清晰，如果超过最大任务数量64个，或者同一个域名任务数5个，它将进入准备队列，反之将进入执行队列，交由线程池执行。因为AsyncCall继承了NamedRunnable类，而NamedRunnable类实现了Runnable接口，所以最终的执行方法在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);
}
}
这个方法的逻辑的核心还是getResponseWithInterceptorChai这个方法，根据这个方法的返回回调Callback接口实现，然后在Dispatcher中的集合中剔除。
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);
}
这个就是getResponseWithInterceptorChain的方法实现，这个就是一个责任链设计的拦截器链，每个拦截器层层处理。
以上就是okhttp内部的大致使用流程。
