简介 本文通过结合OkHttp源码,分析发送请求的大致流程。 本文源码基于3.12.0版本 示例 首先我们创建一个最简单的请求，以此为例开始进行分析 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
简介
本文通过结合OkHttp源码,分析发送请求的大致流程。
- 本文源码基于3.12.0版本
示例
首先我们创建一个最简单的请求，以此为例开始进行分析
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
OkHttpClient client=
new OkHttpClient.Builder().build();
//创建Request
Request request=
new Request
.Builder()
.url(url)
.build();
//发送一个异步请求
client.newCall(request).enqueue(
new Callback() {
public void (Call call, IOException e) {
}
public void onResponse(Call call, Response response) throws IOException {
}
});
//发送一个同步请求
try {
Response response = client.newCall(request).execute();
}
catch (IOException e) {
e.printStackTrace();
}
流程
1.1 创建请求
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
public
final
class Request {
final HttpUrl url;
final String method;
final Headers headers;
final
RequestBody body;
final Map<Class<?>, Object> tags;
private
volatile
CacheControl cacheControl;
Request(Builder builder) {
this.url = builder.url;
this.method = builder.method;
this.headers = builder.headers.build();
this.body = builder.body;
this.tags = Util.immutableMap(builder.tags);
}
...
public
static
class Builder {
HttpUrl url;
String method;
Headers.Builder headers;
RequestBody body;
Map<Class<?>, Object> tags = Collections.emptyMap();
....
}
}
首先使用建造者模式构建一个Requst,来插入请求的数据。
1.2 封装请求
请求封装在了接口Call的实现类RealCall中：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
final
class RealCall implements Call {
...
private RealCall(OkHttpClient client, Request originalRequest, boolean forWebSocket) {
//构建的OkHttpClient
this.client = client;
//用户构建的Request
this.originalRequest = originalRequest;
//是不是WebSocket请求
this.forWebSocket = forWebSocket;
//构建RetryAndFollowUpInterceptor拦截器
this.retryAndFollowUpInterceptor =
new RetryAndFollowUpInterceptor(client, forWebSocket);
//Okio中提供的用于超时机制的方法
this.timeout =
new AsyncTimeout() {
protected void timedOut() {
cancel();
}
};
this.timeout.timeout(client.callTimeoutMillis(), MILLISECONDS);
}
...
}
1.3 执行请求
请求分为同步请求和异步请求:
同步请求:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22public Response execute() throws IOException { synchronized ( this) { if (executed) throw new IllegalStateException( "Already Executed"); executed = true; } captureCallStackTrace(); timeout.enter(); eventListener.callStart( this); try { client.dispatcher().executed( this); Response result = getResponseWithInterceptorChain(); if (result == null) throw new IOException( "Canceled"); return result; } catch (IOException e) { e = timeoutExit(e); eventListener.callFailed( this, e); throw e; } finally { client.dispatcher().finished( this); } }异步请求:
1 2 3 4 5 6 7 8 9 10public void enqueue(Callback responseCallback) { synchronized ( this) { if (executed) throw new IllegalStateException( "Already Executed"); executed = true; } captureCallStackTrace(); eventListener.callStart( this); client.dispatcher().enqueue( new AsyncCall(responseCallback)); }
从上面可以看到不论是同步请求还是异步请求都是在Dispatcher中进行处理，
区别在于：
- 同步请求：直接执行executed，并返回结果
- 异步请求：构造一个AsyncCall，并将其加入到readyAsyncCalls这个准备队列中
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
final
class AsyncCall extends NamedRunnable {
private
final Callback responseCallback;
AsyncCall(Callback responseCallback) {
super(
"OkHttp %s", redactedUrl());
this.responseCallback = responseCallback;
}
String host() {
return originalRequest.url().host();
}
Request request() {
return originalRequest;
}
RealCall get() {
return RealCall.
this;
}
/**
* Attempt to enqueue this async call on {
@code executorService}. This will attempt to clean up
* if the executor has been shut down by reporting the call as failed.
*/
void executeOn(ExecutorService executorService) {
assert (!Thread.holdsLock(client.dispatcher()));
boolean success =
false;
try {
executorService.execute(
this);
success =
true;
}
catch (RejectedExecutionException e) {
InterruptedIOException ioException =
new InterruptedIOException(
"executor rejected");
ioException.initCause(e);
eventListener.callFailed(RealCall.
this, ioException);
responseCallback.onFailure(RealCall.
this, ioException);
}
finally {
if (!success) {
client.dispatcher().finished(
this);
// This call is no longer running!
}
}
}
protected void execute() {
boolean signalledCallback =
false;
timeout.enter();
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) {
e = timeoutExit(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 {
client.dispatcher().finished(
this);
}
}
}
AsyncCall继承自NamedRunnable，而NamedRunnable可以看成一个会给其所运行的线程设定名字的Runnable，Dispatcher会通过ExecutorService来执行这些Runnable。
1.4 请求的调度
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
public
final
class Dispatcher {
private
int maxRequests =
64;
private
int maxRequestsPerHost =
5;
private
Runnable idleCallback;
/** Executes calls. Created lazily. */
private
ExecutorService executorService;
/** 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<>();
/** Running synchronous calls. Includes canceled calls that haven't finished yet. */
private
final Deque<RealCall> runningSyncCalls =
new ArrayDeque<>();
void enqueue(AsyncCall call) {
synchronized (
this) {
readyAsyncCalls.add(call);
}
promoteAndExecute();
}
synchronized void executed(RealCall call) {
runningSyncCalls.add(call);
}
private boolean promoteAndExecute() {
assert (!Thread.holdsLock(
this));
List<AsyncCall> executableCalls =
new ArrayList<>();
boolean isRunning;
synchronized (
this) {
for (Iterator<AsyncCall> i = readyAsyncCalls.iterator(); i.hasNext(); ) {
AsyncCall asyncCall = i.next();
if (runningAsyncCalls.size() >= maxRequests)
break;
// Max capacity.
if (runningCallsForHost(asyncCall) >= maxRequestsPerHost)
continue;
// Host max capacity.
i.remove();
executableCalls.add(asyncCall);
runningAsyncCalls.add(asyncCall);
}
isRunning = runningCallsCount() >
0;
}
for (
int i =
0, size = executableCalls.size(); i < size; i++) {
AsyncCall asyncCall = executableCalls.get(i);
asyncCall.executeOn(executorService());
}
return isRunning;
}
}
请求的调度主要在Dispatcher类中进行，其中维护了3个双端队列：
- readyAsyncCalls:准备队列用于添加准备执行的异步请求。
- runningAsyncCalls：正在执行的异步请求队列。
- runningSyncCalls：正在执行的同步请求队列。
对于同步请求，Dispatcher会直接将请求加入到同步请求队列执行；对于异步请求首先会将请求加入readyAsyncCalls中，接下来会遍历readyAsyncCalls判断如果当前执行的异步请求数量小于65并且同一host下的异步请求数小于5，则将readyAsyncCalls中的请求加入到runningAsyncCalls开始执行并从readyAsyncCalls中移除。
1.5 请求的执行
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
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,
this, eventListener, client.connectTimeoutMillis(),
client.readTimeoutMillis(), client.writeTimeoutMillis());
return chain.proceed(originalRequest);
}
可以说okhttp最核心的部分就是拦截器的这部分，这里采用责任链的设计模式，使各个功能充分解耦，各司其职，请求从用户自定义的拦截器开始层层传递到CallServerInterceptor，每层做出相应的处理，直到请求发出，与此同时，返回的响应从CallServerInterceptor开始逐层上传直到用户的自定义拦截器，每层都会对返回的响应做出相应处理，最终将处理好的响应结果返回给用户。
原文:大专栏 OkHttp 流程浅析 - NoHarry的博客