主线流程源码分析
常规使用
OkHttpClient okHttpClient = new OkHttpClient.Builder().build();
// 请求报文的信息
Request request = new Request.Builder().url("https://www.baidu.com").get().build();
// 连接request和response的桥梁
Call call = okHttpClient.newCall(request);
// 同一个call对象只能执行一次enqueue方法
// 异步请求
call.enqueue(new Callback() {
@Override
public void onFailure(Call call, IOException e) {
MLog.e(TAG, "onFailure: " + e.toString());
}
@Override
public void onResponse(Call call, Response response) throws IOException {
/*step 5:获取响应体*/
MLog.e(TAG, "onResponse: " + response.body());
}
});
// 同步请求
Response response = call.execute();
源码解析
同步请求
RealCall类调用execute方法
@Override public Response execute() throws IOException {
synchronized (this) {
...
try {
// 保存同步请求，加入到同步请求执行队列中
client.dispatcher().executed(this);
// 通过拦截器链获取到Response
Response result = getResponseWithInterceptorChain();
if (result == null) throw new IOException("Canceled");
return result;
} catch (IOException e) {
eventListener.callFailed(this, e);
throw e;
} finally {
// 移除同步请求
client.dispatcher().finished(this);
}
}
dispatcher作用：加入和移除同步请求。
异步请求
1.RealCall调用enqueue方法
client.dispatcher().enqueue(new AsyncCall(responseCallback));
/** 同步请求队列 */
private final Deque<RealCall> runningSyncCalls = new ArrayDeque<>();
/**异步就绪，执行队列*/
private final Deque<AsyncCall> readyAsyncCalls = new ArrayDeque<>();
// 里面还会包含已经被取消，但是未执行完的请求
private final Deque<AsyncCall> runningAsyncCalls = new ArrayDeque<>();
dispatcher的方法
synchronized void enqueue(AsyncCall call) {
// runningAsyncCalls运行队列
// 同时运行异步任务小于64，同时访问同一个服务器不超过5个
if (runningAsyncCalls.size() < maxRequests && runningCallsForHost(call) < maxRequestsPerHost) {
runningAsyncCalls.add(call);
// 线程池执行AsyncCall耗时任务
executorService().execute(call);
} else {
// readyAsyncCalls等待队列
readyAsyncCalls.add(call);
}
}
这两个队列是双端队列
AsyncCall 耗时任务
2.AsyncCall类
由上面可以看到RealCall的enqueue方法，会执行new AsyncCall的对象，该对象继承runnable，实现run方法，重写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) {
// signalledCallback为true，代表用户造成的异常，在回调的方法中业务处理出现错误
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 {
// 1.把请求从正在请求的异步队列中移除
// 2.所用到的队列是非线程安全的，为了考虑线程安全加了同步锁
// 3.调整任务队列
client.dispatcher().finished(this);
}
}
粗略梳理主线流程
异步：
创建okHttpClient，Request对象 --> 通过newCall()将Request转成RealCall对象 --> 调用RealCall的enqueue()(不能重复被执行) --> 传入的Callback封装成AsyncCall对象，AsyncCall是Runnable -> 在子线程中通过拦截器链获取到最终的Response
同步：
将Request方法封装成Call对象，真正实现类是RealCall - 直接调用拦截器链去获得最终的结果
用到的设计模式
建造者设计模式
OkHttpClient对象创建。
责任链设计模式
通过拦截器链获取到最终的Response进行处理。
