okHttp概述
retrofit网络请求框架,其实retrofit内部并没有真正的实现网络请求,它内部将网络请求封装成了Call,并将网络请求转角给okhttp去执行。okhttp是square开源的一个网络库,将每一个网络请求都封装成一个call,然后利用call去执行网络请求。
下面是官方给的例子:
OkHttpClient client = new OkHttpClient();
String run(String url) throws IOException {
Request request = new Request.Builder()
.url(url)
.build();
Response response = client.newCall(request).execute();
return response.body().string();
}
okHttp源码阅读
okhttp的使用就像上面的例子一样这么简单,我们看看其内部的实现
调用流程
构造Client
首先用builder模式创建一个okhttpClient实例,里面有一个非常重要的成员dispatcher,顾名思义,主要是用来做okHttp的网络请求分发的。后续我们会再详细介绍。每一个client在创建时,都会直接new出一个dispatcher。
public Builder() {
dispatcher = new Dispatcher();
}
构造Request
okHttp的网络请求表示为Request,里面包含了一个请求所需要的参数。
//请求url
HttpUrl url;
//请求方式
String method;
//请求头
Headers.Builder headers;
//请求body
RequestBody body;
//请求tag
Object tag;
对于okHttp请求的直接触发单位并不是request,而是在request的基础上继续包装了一层,包装为Call。
构造Call
call是一个接口,供我们外部调用,主要有以下几个比较重要的方法
//获取当次请求的Request
Request request();
//同步执行入口
Response execute() throws IOException;
//异步执行入口
void enqueue(Callback responseCallback);
//取消入口
void cancel();
我们实际使用的是其实现类RealCall,我们直接通过client提供的工厂方法,传入request,并返回RealCall。
private RealCall(OkHttpClient client, Request originalRequest, boolean forWebSocket) {
this.client = client;
this.originalRequest = originalRequest;
this.forWebSocket = forWebSocket;
this.retryAndFollowUpInterceptor = new RetryAndFollowUpInterceptor(client, forWebSocket);
}
请求的执行
同步请求 execute
@Override public Response execute() throws IOException {
synchronized (this) {
if (executed) throw new IllegalStateException("Already Executed");
executed = true;
}
captureCallStackTrace();
try {
//添加到dispatcher的同步队列中
client.dispatcher().executed(this);
//通过拦截器链执行请求
Response result = getResponseWithInterceptorChain();
if (result == null) throw new IOException("Canceled");
return result;
} finally {
//从dispatcher正在运行队列中中移除
client.dispatcher().finished(this);
}
}
通过局部变量executed来标识一个call只能执行一次,需要用symchronized来保证多线程同步。
然后通过dispatcher的请求处理,其实仅仅是将这个call添加到维护的正在运行的队列中,然后立马通过拦截器链发起请求。
synchronized void executed(RealCall call) {
runningSyncCalls.add(call);
}
后面通过拦截器链执行网络请求。
异步请求
异步请求和同步请求非常类似。
@Override public 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));
}
enqueue仅仅调用了dispatcher的enqueue,需要将RealCall转化为AsyncCall,也就是异步请求Call,其实就是一个Runnable。
final class AsyncCall extends NamedRunnable {
private final Callback responseCallback;
AsyncCall(Callback responseCallback) {
super("OkHttp %s", redactedUrl());
this.responseCallback = responseCallback;
}
Dispatcher的分发机制
不管同步还是异步请求,okHttp最终都会将请求传递给dispatcher。
dispatcher内部维护三个队列,一个线程池。
private @Nullable ExecutorService executorService;
private final Deque<AsyncCall> readyAsyncCalls = new ArrayDeque<>();
private final Deque<AsyncCall> runningAsyncCalls = new ArrayDeque<>();
private final Deque<RealCall> runningSyncCalls = new ArrayDeque<>();
对于同步请求,会直接将请求添加到运行队列中,并马上执行请求,而异步请求可能需要先将请求添加到就绪异步队列中,等待dispatcher的调度唤起。
synchronized void enqueue(AsyncCall call) {
if (runningAsyncCalls.size() < maxRequests && runningCallsForHost(call) < maxRequestsPerHost) {
runningAsyncCalls.add(call);
executorService().execute(call);
} else {
readyAsyncCalls.add(call);
}
}
如果当前正在运行的网络请求�数小于设置最大值,那么表示这个请求可以立马发起,则需要将这个call添加到运行的异步队列中,并且调用线程池执行这个请求。否则需要奖这个请求添加到等待队列中。当线程池执行时,其实是调用了这个runnable的run方法,
@Override public final void run() {
String oldName = Thread.currentThread().getName();
Thread.currentThread().setName(name);
try {
execute();
} finally {
Thread.currentThread().setName(oldName);
}
}
其实内部就是执行excute方法
@Override protected void execute() {
boolean signalledCallback = false;
try {
Response response = getResponseWithInterceptorChain(null);
....
responseCallback.onFailure()
responseCallback.onResponse()
....
} finally {
client.dispatcher().finished(this);
}
}
在run方法执行了execute方法之后,同样是先调用了拦截器链发起网络请求,然后在网络请求回来之后,回调callback,所以,可见这个callBack是在子线程里面做的回调。最后同样是调用finished关闭这个请求。
private <T> void finished(Deque<T> calls, T call, boolean promoteCalls) {
int runningCallsCount;
Runnable idleCallback;
synchronized (this) {
//从异步执行队列中移除
if (!calls.remove(call)) throw new AssertionError("Call wasn't in-flight!");
//唤起下一个call的调用
if (promoteCalls) promoteCalls();
//重新计算当前网络请求数
runningCallsCount = runningCallsCount();
idleCallback = this.idleCallback;
}
if (runningCallsCount == 0 && idleCallback != null) {
idleCallback.run();
}
}
如果是异步执行的call的finish操作,那么它还多了一个非常重要的步骤,通过promoteCalls来唤起下一个call请求发起。
private void promoteCalls() {
if (runningAsyncCalls.size() >= maxRequests) return; // Already running max capacity.
if (readyAsyncCalls.isEmpty()) return; // No ready calls to promote.
for (Iterator<AsyncCall> i = readyAsyncCalls.iterator(); i.hasNext(); ) {
AsyncCall call = i.next();
if (runningCallsForHost(call) < maxRequestsPerHost) {
i.remove();
runningAsyncCalls.add(call);
executorService().execute(call);
}
if (runningAsyncCalls.size() >= maxRequests) return; // Reached max capacity.
}
}
首先会判断当前正在请求数是否大于设置的最大请求,然后判断等待队列是否为空,在非空的情况下,从就绪队列中移除首个call,并开始执行。
拦截器链->获取response
上面的同步或者异步请求,最终都会调用到getResponseWithinterceptorChain这个方法上。
Response getResponseWithInterceptorChain(DiskCacheListener diskCacheListener) 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(), diskCacheListener));
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);
}
首先会构造拦截器链,其实就是一个list,将一些需要的拦截器按序添加到list中,然后构造Chain,最终调用proceed开始执行。
链式调用
okHttp这个拦截器的遍历的实现其实是非常巧妙的。Chain有一个index表示当前执行的哪一个拦截器。
//第一次执行
Interceptor.Chain chain = new RealInterceptorChain(.., 0, ...);
return chain.proceed(originalRequest);
proceed方法
// Call the next interceptor in the chain.
RealInterceptorChain next = new RealInterceptorChain(index + 1);
Interceptor interceptor = interceptors.get(index);
Response response = interceptor.intercept(next);
在proceed中首先会构造出下一个Chain,只需要把index+1即可,然后拿出当前的拦截器,并且执行其intercept方法。
@Override public Response intercept(Chain chain) throws IOException {
....
Response networkResponse = chain.proceed(requestBuilder.build());
....
}
在intercept中,再次调用了下一个链的proceed方法。依次执行,形成了一个链式调用。
拦截器
RetryAndFollow
网络请求失败时的重连和重定向的拦截器
Bridge
桥接拦截器,主要是用来增加请求头,cookied, userAgent。
Cache
主要是负责okHttp的缓存。okHttp有一个缓存策略。
CacheStrategy strategy = new CacheStrategy.Factory(now, chain.request(), cacheCandidate).get();
Request networkRequest = strategy.networkRequest;
Response cacheResponse = strategy.cacheResponse;
networkRequest表示当前请求,cacheResponse表示是否有该请求对应的缓存response。
// If we're forbidden from using the network and the cache is insufficient, fail.
if (networkRequest == null && cacheResponse == null) {
return new Response.Builder()
.request(chain.request())
.protocol(Protocol.HTTP_1_1)
.code(504)
.message("Unsatisfiable Request (only-if-cached)")
.body(Util.EMPTY_RESPONSE)
.sentRequestAtMillis(-1L)
.receivedResponseAtMillis(System.currentTimeMillis())
.build();
}
// If we don't need the network, we're done.
if (networkRequest == null) {
return cacheResponse.newBuilder()
.cacheResponse(stripBody(cacheResponse))
.build();
}
如果当前发起的请求为null,而且没有缓存的response,那么直接返回错误。
如果发起的请求不为null,而且存在缓存,那么直接用缓存,提前返回。否则正常发起网络请求。
Connect
ConnectIntercept主要用建立网络链接。
public Response intercept(Chain chain) throws IOException {
RealInterceptorChain realChain = (RealInterceptorChain) chain;
Request request = realChain.request();
StreamAllocation streamAllocation = realChain.streamAllocation();
// We need the network to satisfy this request. Possibly for validating a conditional GET.
boolean doExtensiveHealthChecks = !request.method().equals("GET");
HttpCodec httpCodec = streamAllocation.newStream(client, chain, doExtensiveHealthChecks);
RealConnection connection = streamAllocation.connection();
return realChain.proceed(request, streamAllocation, httpCodec, connection);
}
-
首先会从获取出链中拿出stramALlocation。StreamAlloction是okHttp用来辅助管理的一个类,主要是管理流、连接、和call之间的关系。是流和连接之间的component,它会为call请求去寻找连接并建立一个流。这个流是在第一个retryAndFollowIntercept中创建的,最后传递到connectIntercept。
-
然后通过newStream方法找到一个合适的socket链接。并返回对应的socket操作封装类HttpCodeC,newStream会从连接池中去寻找合适的连接,如果没有可复用的连接,将会创建出新连接。
RealConnection resultConnection = findHealthyConnection(connectTimeout, readTimeout,
writeTimeout, connectionRetryEnabled, doExtensiveHealthChecks);
HttpCodec resultCodec = resultConnection.newCodec(client, chain, this);
CallServer
CallServerIntercept是真正发起网络请求的类,通过上一个拦截器处理完后的HttpCodec进行网络的读写。内部封装了okio进行数据读写
...
//写入请求头
httpCodec.writeRequestHeaders(request);
//通过okIo写入请求请求体
request.body().writeTo(bufferedRequestBody);
然后通过okio进行response读取
if (responseBuilder == null) {
realChain.eventListener().responseHeadersStart(realChain.call());
responseBuilder = httpCodec.readResponseHeaders(false);
}
Response response = responseBuilder
.request(request)
.handshake(streamAllocation.connection().handshake())
.sentRequestAtMillis(sentRequestMillis)
.receivedResponseAtMillis(System.currentTimeMillis())
.build();
okHttp连接池的处理
put
当没有找到可以复用的连接时,需要创建新的连接,并将连接放入连接池中,
void put(RealConnection connection) {
assert (Thread.holdsLock(this));
if (!cleanupRunning) {
cleanupRunning = true;
executor.execute(cleanupRunnable);
}
connections.add(connection);
}
每次添加新的连接,需要看是否需要清理连接池。这个处理操作是通过线程池来处理的。通过下面几个步骤来判断一个连接是否需要被回收
- 计数,看一个connect是否被多个streamAllocation所引用。Connecttion内部存储了一个StreamAllocation的弱引用列表list,当一个网络请求结束时,将会关闭stremAllocation,并且回收
for (Iterator<RealConnection> i = connections.iterator(); i.hasNext(); ) {
RealConnection connection = i.next();
// If the connection is in use, keep searching.
if (pruneAndGetAllocationCount(connection, now) > 0) {
inUseConnectionCount++;
continue;
}
idleConnectionCount++;
}
- 如果空闲数大于最大空闲数,那么回收
if (longestIdleDurationNs >= this.keepAliveDurationNs
|| idleConnectionCount > this.maxIdleConnections) {
connections.remove(longestIdleConnection);
}
get连接
Internal.instance.get(connectionPool, address, this, null);
通过address来从连接池中获取需要复用的连接。
@Nullable RealConnection get(Address address, StreamAllocation streamAllocation, Route route) {
assert (Thread.holdsLock(this));
for (RealConnection connection : connections) {
if (connection.isEligible(address, route)) {
streamAllocation.acquire(connection);
return connection;
}
}
return null;
}
首先会判断连接池中是否包含了这个请求地址和路由对应的连接,如果有,那么在这个connection中添加streamAllocation的引用并直接返回,
socket
socket连接的建立,是在StreamAllocation中建立的。当我们没找到可以复用的连接,那么将会创建一个新的连接。
result = new RealConnection(connectionPool, selectedRoute);
//为connect添加streamAllocation的引用
acquire(result);
在创建完connection之后,需要建立socket连接
/** Does all the work necessary to build a full HTTP or HTTPS connection on a raw socket. */
private void connectSocket(int connectTimeout, int readTimeout, Call call,
EventListener eventListener) throws IOException {
Proxy proxy = route.proxy();
Address address = route.address();
rawSocket = proxy.type() == Proxy.Type.DIRECT || proxy.type() == Proxy.Type.HTTP
? address.socketFactory().createSocket()
: new Socket(proxy);
eventListener.connectStart(call, route.socketAddress(), proxy);
rawSocket.setSoTimeout(readTimeout);
try {
Platform.get().connectSocket(rawSocket, route.socketAddress(), connectTimeout);
} catch (ConnectException e) {
ConnectException ce = new ConnectException("Failed to connect to " + route.socketAddress());
ce.initCause(e);
throw ce;
}
// The following try/catch block is a pseudo hacky way to get around a crash on Android 7.0
// More details:
// https://github.com/square/okhttp/issues/3245
// https://android-review.googlesource.com/#/c/271775/
try {
source = Okio.buffer(Okio.source(rawSocket));
sink = Okio.buffer(Okio.sink(rawSocket));
} catch (NullPointerException npe) {
if (NPE_THROW_WITH_NULL.equals(npe.getMessage())) {
throw new IOException(npe);
}
}
}
上面的就是socket连接的建立过程,大体可以分为以下几步:
- 创建socket套接字:
rawSocket = proxy.type() == Proxy.Type.DIRECT || proxy.type() == Proxy.Type.HTTP
? address.socketFactory().createSocket()
: new Socket(proxy);
- 连接远端Socket
Platform.get().connectSocket(rawSocket, route.socketAddress(), connectTimeout);
- 读写流,okIo封装
//read
source = Okio.buffer(Okio.source(rawSocket));
//write
sink = Okio.buffer(Okio.sink(rawSocket));
这个是客户端的socket创建,服务端的socket创建需要多一个监听
总结
其实okHttp的利用了java的职责链模式,每一个拦截器都有属于自己功能。下面看看一张自己绘制的okhttp访问的流程。
[图片上传失败…(image-2de00c-1541683717380)]