前言：
OKHttp是square出品的开源通信框架，也是我们安卓开发目前用的最多的一套网络框架。本文我想从OKHttp的基本使用开始讲起，这里将涉及到这么几个类：OKHttpClient，Request，Response，RealCall以及Dispatcher。
配置OKHttpClient
首先我们需要配置一个OKHttpClient，这里简单的创建个。
val builder = OkHttpClient.Builder();
val client = builder.build();
首先我们创建了一个builder，初始化了一些属性值。
OkHttpClient.Builder
public Builder() {
dispatcher = new Dispatcher();
protocols = DEFAULT_PROTOCOLS;
connectionSpecs = DEFAULT_CONNECTION_SPECS;
eventListenerFactory = EventListener.factory(EventListener.NONE);
proxySelector = ProxySelector.getDefault();
cookieJar = CookieJar.NO_COOKIES;
socketFactory = SocketFactory.getDefault();
hostnameVerifier = OkHostnameVerifier.INSTANCE;
certificatePinner = CertificatePinner.DEFAULT;
proxyAuthenticator = Authenticator.NONE;
authenticator = Authenticator.NONE;
connectionPool = new ConnectionPool();
dns = Dns.SYSTEM;
followSslRedirects = true;
followRedirects = true;
retryOnConnectionFailure = true;
connectTimeout = 10_000;
readTimeout = 10_000;
writeTimeout = 10_000;
pingInterval = 0;
}
接着我们调用了builder的build方法，build代码追进去我们看到它创建并返回了一个OkHttpClient对象。
OkHttpClient(Builder builder) {
this.dispatcher = builder.dispatcher;
this.proxy = builder.proxy;
this.protocols = builder.protocols;
this.connectionSpecs = builder.connectionSpecs;
this.interceptors = Util.immutableList(builder.interceptors);
this.networkInterceptors = Util.immutableList(builder.networkInterceptors);
this.eventListenerFactory = builder.eventListenerFactory;
this.proxySelector = builder.proxySelector;
this.cookieJar = builder.cookieJar;
this.cache = builder.cache;
this.internalCache = builder.internalCache;
this.socketFactory = builder.socketFactory;
boolean isTLS = false;
for (ConnectionSpec spec : connectionSpecs) {
isTLS = isTLS || spec.isTls();
}
if (builder.sslSocketFactory != null || !isTLS) {
this.sslSocketFactory = builder.sslSocketFactory;
this.certificateChainCleaner = builder.certificateChainCleaner;
} else {
X509TrustManager trustManager = systemDefaultTrustManager();
this.sslSocketFactory = systemDefaultSslSocketFactory(trustManager);
this.certificateChainCleaner = CertificateChainCleaner.get(trustManager);
}
this.hostnameVerifier = builder.hostnameVerifier;
this.certificatePinner = builder.certificatePinner.withCertificateChainCleaner(
certificateChainCleaner);
this.proxyAuthenticator = builder.proxyAuthenticator;
this.authenticator = builder.authenticator;
this.connectionPool = builder.connectionPool;
this.dns = builder.dns;
this.followSslRedirects = builder.followSslRedirects;
this.followRedirects = builder.followRedirects;
this.retryOnConnectionFailure = builder.retryOnConnectionFailure;
this.connectTimeout = builder.connectTimeout;
this.readTimeout = builder.readTimeout;
this.writeTimeout = builder.writeTimeout;
this.pingInterval = builder.pingInterval;
}
从代码中我们不难看出里面有很多属性值给我们去设置，可扩展性很强，这也是我们为什么用OKHttp的原因之一。到了这里OkHttpClient创建部分就完结了。
发送请求
请求分两种，同步请求和异步请求，同步请求需要在子线程执行。
第一种同步的方式：
val builder = Request.Builder()
val request = builder.url("https://www.baidu.com").build()
val newCall = client.newCall(request)
service.execute {
val response = newCall.execute()
}
Request.Builder
public static class Builder {
HttpUrl url;
String method;
Headers.Builder headers;
RequestBody body;
Object tag;
public Builder() {
this.method = "GET";
this.headers = new Headers.Builder();
}
...省略
}
从源码中我们可以看出，默认构造的是get请求，以及属性有url、method、headers、body、tag。
接着我们调用了Request#Builder的build方法，build代码追进去我们看到它创建并返回了一个Request对象。
Request(Builder builder) {
this.url = builder.url;
this.method = builder.method;
this.headers = builder.headers.build();
this.body = builder.body;
this.tag = builder.tag != null ? builder.tag : this;
}
和之前的一样，也是初始化了一些属性值。
newCall
@Override public Call newCall(Request request) {
return new RealCall(this, request, false /* for web socket */);
}
这就返回了我们另外一个主角RealCall，
RealCall
RealCall(OkHttpClient client, Request originalRequest, boolean forWebSocket) {
final EventListener.Factory eventListenerFactory = client.eventListenerFactory();
this.client = client;
this.originalRequest = originalRequest;
this.forWebSocket = forWebSocket;
this.retryAndFollowUpInterceptor = new RetryAndFollowUpInterceptor(client, forWebSocket);
// TODO(jwilson): this is unsafe publication and not threadsafe.
this.eventListener = eventListenerFactory.create(this);
}
这里主要包含原始的request，以及事件监听。这里想先小小总结下：
OkhttpClient可以理解为整个Okhttp框架的工具类。通过okhttp来进行网络请求，每个请求都会封装成一个Call任务。OkhttpClient的主要目的包括将请求封装为Call，为所有的请求提供通用的配置和监听，并负责具体任务的执行调度。
Okhttpclient在newCall的时候，还会给Call提供一个EventListener。EventListener是对每个具体网络请求的监听，一个完整的HTTP请求过程，可以拆分成很多小步骤，比如建立连接，发送请求头，发送请求实体，读取响应头等等。这些关键的事件，都可以在EventListener被监听到，Okhttp会在关键的步骤调用相应的监听函数。
开始请求流程RealCall. execute()
@Override public Response execute() throws IOException {
synchronized (this) {
if (executed) throw new IllegalStateException("Already Executed");
executed = true;
}
captureCallStackTrace();
try {
//开始请求接口，先将请求加入到runningSyncCalls中
client.dispatcher().executed(this);
Response result = getResponseWithInterceptorChain();
if (result == null) throw new IOException("Canceled");
return result;
} finally {
client.dispatcher().finished(this);
}
}
由于当前是同步请求，所以Dispatcher的execute只是把任务存到集合中：
/** Used by {@code Call#execute} to signal it is in-flight. */
synchronized void executed(RealCall call) {
runningSyncCalls.add(call);
}
然后继续调用RealCall的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);
}
这个时候就涉及到了okhttp的核心概念：拦截器。在okhttp中，将一个完整的Http请求拆分成了好几个步骤，然后每个步骤都通过拦截器来完成。一个HTTP请求的完整路径，会经过一系列拦截器的渗透和过滤。拦截器可以分为四种，有先后顺序，依次为：应用拦截器，okhttp核心拦截器，网络拦截器以及最后的call server拦截器。所谓的call server也就是真正的向服务器发送请求，按照HTTP协议的规范，顺序的向服务器发送请求头和请求实体，然后在顺序的读取响应头和响应实体。这些拦截器会形成一个拦截器链，对应的类型为Interceptor.Chain。
第二种异步的方式：
Request.Builder builder = new Request.Builder();
Request request = builder.url("https://www.baidu.com").build();
Call newCall = client.newCall(request);
newCall.enqueue(new Callback() {
@Override
public void onFailure(Call call, IOException e) {
}
@Override
public void onResponse(Call call, Response response) throws IOException {
}
});
前面的准备都是一样的，就不重复分析了，直接看enqueue方法：
开始请求流程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));
}
这里调用了调度器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);
}
}
这里就很明显了，首先对请求数量以及host做了判断不超过maxRequests（默认值64）和maxRequestsPerHost（默认值5）才会直接将请求加入到runningAsyncCalls中并且开始请求，否则加入到等待队列中。接着分析executorService().execute(call)。
public synchronized ExecutorService executorService() {
if (executorService == null) {
executorService = new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>(), Util.threadFactory("OkHttp Dispatcher", false));
}
return executorService;
}
这里构建了一个线程池，这里就不细拆线程池了感兴趣的可以查资料再去了解，获取到线程池后，就可以交给其call任务，让其去执行。最终会调用到AsyncCall的的execute方法。
可能有人会问为什么会执行AsyncCall的execute方法？？？
AsyncCall继承自NameRunnable，NameRunnable继承自Runnable。NameRunnable中的实现如下，所以会执行NameRunnable的execute方法，execute的实现在AsyncCall中。
AsyncCall
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;
}
@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);
}
}
}
NamedRunnable
public abstract class NamedRunnable implements Runnable {
protected final String name;
public NamedRunnable(String format, Object... args) {
this.name = Util.format(format, args);
}
@Override public final void run() {
String oldName = Thread.currentThread().getName();
Thread.currentThread().setName(name);
try {
execute();
} finally {
Thread.currentThread().setName(oldName);
}
}
protected abstract void execute();
}
接着看下AsyncCall的execute，它也是调用getResponseWithInterceptorChain，链式调用（责任链五层拦截器模式）获取Response最终通过responseCallback回调，完成异步请求。
拦截器部分没有展开讲解，后面有时间会另外开一篇讲解，此处就说明下OkHttp的初始化以及请求、回调的源码剖析。
OKHttp中默认包含五层责任链，分别为：
RetryAndFollowUpInterceptor：重试跟进拦截器。
BridgeInterceptor：桥接拦截器。
CacheInterceptor：缓存拦截器。
ConnectInterceptor：连接池拦截器。
CallServerInterceptor：请求拦截器。
一个请求的完整发送流程，会从上向下依次执行，如果某一个拦截器判断执行完成，则一层一层向上返回最终结果。
谢谢各位的阅读，觉得可以的小伙伴点个赞哦。
网友评论