本文深入解析OkHttp的使用方法及内部机制，涵盖依赖添加、基本使用、源码分析、时序图、拦截器分析等内容，重点讲解OkHttpClient、Request、Call对象的创建与使用，以及同步异步请求流程。
Android-OkHttp
基本使用
现在4.0以后基于Kotlin…
我们今天来看看3.14.2版，基于java…
kotlin目前博主不熟 - -！
添加依赖
implementation(“com.squareup.okhttp3:okhttp:3.14.2”)
代码使用
我们先来看看基本使用
建造者模式：一般在构建对象的过程需要配置很多很多的参数时，可以使用建造者模式来构建实体对象。
OkHttpClient client = new OkHttpClient();
//建造者模式：一般在
Request request = new Request.Builder()
.url(url)
.get() //默认为GET请求，可以不写
.build();
final Call call = client.newCall(request);
try {
//call.execute();//同步
call.enqueue(new Callback() { //异步
@Override
public void onFailure(Call call, IOException e) {
}
@Override
public void onResponse(Call call, Response response) throws IOException {
}
});
} catch (IOException e) {
e.printStackTrace();
}
源码分析
第一步：构建 OkHttpClient
第一步：我们先来看这个建造者模式在构建 OkHttpClient（new OkHttpClient）的时候做的事情
无参构造方法：内部自己new了一个Builder对象，并传入到了无修饰符的构造方法中；
有参构造方法：内部将个传入进来的Builder对象进行取值，并赋值到类中的成员变量中；
无修饰符的情况姑且称为default，访问范围是package，就是同一个包中的类可访问
....
public class OkHttpClient implements Cloneable, Call.Factory, WebSocket.Factory {
....
public OkHttpClient() {
//在我们没有传入Builder对象的时候自己去new了一个，并传入到了下面这一个构造方法中
this(new Builder());
}
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 = Util.platformTrustManager();
this.sslSocketFactory = newSslSocketFactory(trustManager);
this.certificateChainCleaner = CertificateChainCleaner.get(trustManager);
}
if (sslSocketFactory != null) {
Platform.get().configureSslSocketFactory(sslSocketFactory);
}
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.callTimeout = builder.callTimeout;
this.connectTimeout = builder.connectTimeout;
this.readTimeout = builder.readTimeout;
this.writeTimeout = builder.writeTimeout;
this.pingInterval = builder.pingInterval;
if (interceptors.contains(null)) {
throw new IllegalStateException("Null interceptor: " + interceptors);
}
if (networkInterceptors.contains(null)) {
throw new IllegalStateException("Null network interceptor: " + networkInterceptors);
}
}
我们再来看看OkHttpClient里面的Builder静态内部类
来看看Builder的两个构造方法
上面OkHttpClient构造方法中new了一个无参的Builer构造方法，这个无参构造方法里面进行了默认值的设置，上面有参构造方法中就讲这些默认参数设置到了自己的成员变量中
public static final class Builder {
//调度器
Dispatcher dispatcher;
//代理类：默认有三种代理模式DIRECT(直连)，HTTP(http代理)，SOCKS(SOCKS代理)
@Nullable Proxy proxy;
//协议集合，协议类，用来表示使用的协议版本，比如：http/1.0、http1.1、spdy/3.1、h2等
List<Protocol> protocols;
//连接规范，用于配置Socket连接层。对于Https，还能配置安全传输层协议（TLS）版本和密码套件
List<ConnectionSpec> connectionSpecs;
//拦截器，可以监听、重写和重试请求等
final List<Interceptor> interceptors = new ArrayList<>();
final List<Interceptor> networkInterceptors = new ArrayList<>();
EventListener.Factory eventListenerFactory;
//代理选择类，默认不适用代理，即使用直连方式，当前我们可以使用自定义指定URL使用某种代理，类似代理软件的PAC功能
ProxySelector proxySelector;
//Cookie 的保存获取
CookieJar cookieJar;
//缓存类，内部使用了DiskLruCache磁盘缓存来进行管理缓存
@Nullable Cache cache;
//内置缓存
@Nullable InternalCache internalCache;
//Socket的抽象创建工厂，通过createSocket来创建Socket
SocketFactory socketFactory;
//安全套接层工厂，HTTPS相关，用于创建SSLSocket，一般配置HTTPS证书
//对于不受信任的证书一般会提示 javax.net.ssl.SSLHandshakeException异常
@Nullable SSLSocketFactory sslSocketFactory;
@Nullable CertificateChainCleaner certificateChainCleaner;
HostnameVerifier hostnameVerifier;
CertificatePinner certificatePinner;
Authenticator proxyAuthenticator;
Authenticator authenticator;
//连接池：我们通常将一个客户端和服务端和连接抽象为一个connection,
//而每一个connection都会被存放在ConnectionPool中，由它进行统一管理
//例如有一个相同的http请求产生时，connection就可以得到复用
ConnectionPool connectionPool;
//域名解析系统
Dns dns;
//是否遵循SSL重定向
boolean followSslRedirects;
//是否重定向
boolean followRedirects;
//失败是否重新连接
boolean retryOnConnectionFailure;
//回调超时时长
int callTimeout;
//连接超时时长
int connectTimeout;
//读取超时时长
int readTimeout;
//写入超时时长
int writeTimeout;
//与WebSocket有关，为了保持长连接，我们必须间隔一段时间发送一个ping指令进行保活
int pingInterval;
//无参的时候，做了一下默认值初始化
public Builder() {
dispatcher = new Dispatcher();
protocols = DEFAULT_PROTOCOLS;
connectionSpecs = DEFAULT_CONNECTION_SPECS;
eventListenerFactory = EventListener.factory(EventListener.NONE);
proxySelector = ProxySelector.getDefault();
if (proxySelector == null) {
proxySelector = new NullProxySelector();
}
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;
callTimeout = 0;
connectTimeout = 10_000;
readTimeout = 10_000;
writeTimeout = 10_000;
pingInterval = 0;
}
//有参OkHttpClient的时候，将这些值进行了赋值
Builder(OkHttpClient okHttpClient) {
this.dispatcher = okHttpClient.dispatcher;
this.proxy = okHttpClient.proxy;
this.protocols = okHttpClient.protocols;
this.connectionSpecs = okHttpClient.connectionSpecs;
this.interceptors.addAll(okHttpClient.interceptors);
this.networkInterceptors.addAll(okHttpClient.networkInterceptors);
this.eventListenerFactory = okHttpClient.eventListenerFactory;
this.proxySelector = okHttpClient.proxySelector;
this.cookieJar = okHttpClient.cookieJar;
this.internalCache = okHttpClient.internalCache;
this.cache = okHttpClient.cache;
this.socketFactory = okHttpClient.socketFactory;
this.sslSocketFactory = okHttpClient.sslSocketFactory;
this.certificateChainCleaner = okHttpClient.certificateChainCleaner;
this.hostnameVerifier = okHttpClient.hostnameVerifier;
this.certificatePinner = okHttpClient.certificatePinner;
this.proxyAuthenticator = okHttpClient.proxyAuthenticator;
this.authenticator = okHttpClient.authenticator;
this.connectionPool = okHttpClient.connectionPool;
this.dns = okHttpClient.dns;
this.followSslRedirects = okHttpClient.followSslRedirects;
this.followRedirects = okHttpClient.followRedirects;
this.retryOnConnectionFailure = okHttpClient.retryOnConnectionFailure;
this.callTimeout = okHttpClient.callTimeout;
this.connectTimeout = okHttpClient.connectTimeout;
this.readTimeout = okHttpClient.readTimeout;
this.writeTimeout = okHttpClient.writeTimeout;
this.pingInterval = okHttpClient.pingInterval;
}
......
public OkHttpClient build() {
return new OkHttpClient(this);
}
}
第二步：创建Request对象
第二步：创建Request对象，也是建造者模式构建出来的
new Request.Builder()的时候也是在初始化一些成员变量；
无参构造初始化了一个默认方法，一个请求头的Builder对象
有参构造的时候讲传入的参数进行赋值到成员变量中
public static class Builder {
@Nullable HttpUrl url;
String method;
Headers.Builder headers;
@Nullable RequestBody body;
Map<Class<?>, Object> tags = Collections.emptyMap();
public Builder() {
this.method = "GET";
this.headers = new Headers.Builder();
}
Builder(Request request) {
this.url = request.url;
this.method = request.method;
this.body = request.body;
this.tags = request.tags.isEmpty()
? Collections.emptyMap()
: new LinkedHashMap<>(request.tags);
this.headers = request.headers.newBuilder();
}
public Builder url(HttpUrl url) {
if (url == null) throw new NullPointerException("url == null");
this.url = url;
return this;
}
public Builder url(String url) {
if (url == null) throw new NullPointerException("url == null");
// Silently replace web socket URLs with HTTP URLs.
if (url.regionMatches(true, 0, "ws:", 0, 3)) {
url = "http:" + url.substring(3);
} else if (url.regionMatches(true, 0, "wss:", 0, 4)) {
url = "https:" + url.substring(4);
}
return url(HttpUrl.get(url));
}
public Builder url(URL url) {
if (url == null) throw new NullPointerException("url == null");
return url(HttpUrl.get(url.toString()));
}
public Builder header(String name, String value) {
headers.set(name, value);
return this;
}
public Builder addHeader(String name, String value) {
headers.add(name, value);
return this;
}
public Builder removeHeader(String name) {
headers.removeAll(name);
return this;
}
public Builder headers(Headers headers) {
this.headers = headers.newBuilder();
return this;
}
public Builder cacheControl(CacheControl cacheControl) {
String value = cacheControl.toString();
if (value.isEmpty()) return removeHeader("Cache-Control");
return header("Cache-Control", value);
}
public Builder get() {
return method("GET", null);
}
public Builder head() {
return method("HEAD", null);
}
public Builder post(RequestBody body) {
return method("POST", body);
}
public Builder delete(@Nullable RequestBody body) {
return method("DELETE", body);
}
public Builder delete() {
return delete(Util.EMPTY_REQUEST);
}
public Builder put(RequestBody body) {
return method("PUT", body);
}
public Builder patch(RequestBody body) {
return method("PATCH", body);
}
public Builder method(String method, @Nullable RequestBody body) {
if (method == null) throw new NullPointerException("method == null");
if (method.length() == 0) throw new IllegalArgumentException("method.length() == 0");
if (body != null && !HttpMethod.permitsRequestBody(method)) {
throw new IllegalArgumentException("method " + method + " must not have a request body.");
}
if (body == null && HttpMethod.requiresRequestBody(method)) {
throw new IllegalArgumentException("method " + method + " must have a request body.");
}
this.method = method;
this.body = body;
return this;
}
/** Attaches {@code tag} to the request using {@code Object.class} as a key. */
public Builder tag(@Nullable Object tag) {
return tag(Object.class, tag);
}
public <T> Builder tag(Class<? super T> type, @Nullable T tag) {
if (type == null) throw new NullPointerException("type == null");
if (tag == null) {
tags.remove(type);
} else {
if (tags.isEmpty()) tags = new LinkedHashMap<>();
tags.put(type, type.cast(tag));
}
return this;
}
public Request build() {
if (url == null) throw new IllegalStateException("url == null");
return new Request(this);
}
}
第三步：创建Call对象
第三步：创建Call对象
final Call call = client.newCall(request)
newCall这个方法是OkHttpClient的方法
@Override public Call newCall(Request request) {
return RealCall.newRealCall(this, request, false /* for web socket */);
}
然后跟进RealCall.newRealCall去看看。
Call对象是个接口。
RealCall是Call对象的实现类，上面newRealCall返回的是这个Call的实现类。
newRealCall方法传入了OkHttpClient、Request对象、是否说使用WebSocket。
然后创建了RealCall对象，并返回了RealCall对象。
final class RealCall implements Call {
......
static RealCall newRealCall(OkHttpClient client, Request originalRequest, boolean forWebSocket) {
// Safely publish the Call instance to the EventListener.
RealCall call = new RealCall(client, originalRequest, forWebSocket);
call.transmitter = new Transmitter(client, call);
return call;
}
}
......
第四步：发起请求（同步）
第四步：发起请求（同步）
execute()：同步 一般用的比较少的…
getResponseWithInterceptorChain()方法的执行，我们留到后面来看，因为同步和异步最终都会调用这个方法…
只不过异步是创建了一个线程池，在线程池中执行了该方法的调用
接下来我们来看看这个同步的方法
因为Call是个接口，所以我们来看看他的实现类RealCall里面这个同步的方法实现；
@Override public Response execute() throws IOException {
//同步锁
synchronized (this) {
if (executed) throw new IllegalStateException("Already Executed");
executed = true;
}
transmitter.timeoutEnter();
transmitter.callStart();
try {
//最终调用了OkHttpClient对象调度器（分发）的executed方法
client.dispatcher().executed(this);
//晚点我们再来看看这个方法的执行
return getResponseWithInterceptorChain();
} finally {
client.dispatcher().finished(this);
}
}
进入到调度器（分发）的executed方法看看；
将RealCall 对象传入进来，并添加到了队列集合当中；
到这一步这个executed方法就执行完了
//队列集合
private final Deque<RealCall> runningSyncCalls = new ArrayDeque<>();
synchronized void executed(RealCall call) {
//将我们这个RealCall对象添加到队列集合当中
runningSyncCalls.add(call);
}
第四步：发起请求（异步）
第四步：发起请求（异步）
enqueue()：异步
接下来我们看看异步请求这个方法的调用
因为Call是个接口，所以我们来看看他的实现类RealCall里面这个异步的方法实现；
client.dispatcher().enqueue(new AsyncCall(responseCallback));
同样这里还是调用的调度器（分发）里面的方法；
但是这里调用的是异步的方法，并传入了OkHttp里面自定义的Runnable的接口实现类，并传入了我们自己实现的接口，等待回调；
@Override public void enqueue(Callback responseCallback) {
synchronized (this) {
if (executed) throw new IllegalStateException("Already Executed");
executed = true;
}
transmitter.callStart();
//创建了一个子线程，将传入进来的回调传入到子线程，调用调度器（分发）的enqueue方法，把这个穿件出来的子线程传入进去了
client.dispatcher().enqueue(new AsyncCall(responseCallback));
}
我们来看看AsyncCall这个在RealCall中的内部类NamedRunnable的子类
NamedRunnable 是实现了Runnable接口的，也就是创建了个子线程。
final class AsyncCall extends NamedRunnable {
private final Callback responseCallback;
private volatile AtomicInteger callsPerHost = new AtomicInteger(0);
AsyncCall(Callback responseCallback) {
super("OkHttp %s", redactedUrl());
this.responseCallback = responseCallback;
}
......
}
client.dispatcher().enqueue(new AsyncCall(responseCallback));
再来看看这个调度器里面的enqueue方法
//子线程队列
private final Deque<AsyncCall> readyAsyncCalls = new ArrayDeque<>();
void enqueue(AsyncCall call) {
synchronized (this) {
//将外面创建的子线程，添加到了子线程集合队列当中
readyAsyncCalls.add(call);
// Mutate the AsyncCall so that it shares the AtomicInteger of an existing running call to
// the same host.
if (!call.get().forWebSocket) {
AsyncCall existingCall = findExistingCallWithHost(call.host());
if (existingCall != null) call.reuseCallsPerHostFrom(existingCall);
}
}
//调用了自己的方法
promoteAndExecute();
}
promoteAndExecute()来看看这个方法内部
将上面添加的子线程集合进行了过滤，放入到了局部子线程集合中
再次遍历过滤后的子线程集合，创建线程池传入到，子线程的executeOn方法中。
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.
//超过了设置的主机最大容量 host
if (asyncCall.callsPerHost().get() >= maxRequestsPerHost) continue; // Host max capacity.
i.remove();
asyncCall.callsPerHost().incrementAndGet();
//过滤掉了一些请求后，添加到了局部变量的子线程集合中去
executableCalls.add(asyncCall);
runningAsyncCalls.add(asyncCall);
}
isRunning = runningCallsCount() > 0;
}
//遍历过滤后的请求集合队列
for (int i = 0, size = executableCalls.size(); i < size; i++) {
AsyncCall asyncCall = executableCalls.get(i);
//将创建出来的线程池传入到子线程的executeOn方法中
asyncCall.executeOn(executorService());
}
return isRunning;
}
//创建了线程池
public synchronized ExecutorService executorService() {
if (executorService == null) {
//创建线程池
executorService = new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60, TimeUnit.SECONDS,
new SynchronousQueue<>(), Util.threadFactory("OkHttp Dispatcher", false));
}
return executorService;
}
来看看AsyncCall .executeOn方法的执行；
记得上面调用时传入了一个创建的额线程池吗？
executeOn方法传入了线程池；
在这个方法内部调用了线程器的execute方法，进行执行了改子线程，也就会调用子线程的run方法
final class AsyncCall extends NamedRunnable {
void executeOn(ExecutorService executorService) {
assert (!Thread.holdsLock(client.dispatcher()));
boolean success = false;
try {
//执行线程池，传入的是this，当前这个子线程，也就是会调用到当前这个子线程的run方法。
executorService.execute(this);
success = true;
} catch (RejectedExecutionException e) {
InterruptedIOException ioException = new InterruptedIOException("executor rejected");
ioException.initCause(e);
transmitter.noMoreExchanges(ioException);
responseCallback.onFailure(RealCall.this, ioException);
} finally {
if (!success) {
client.dispatcher().finished(this); // This call is no longer running!
}
}
}
}
父类（NamedRunnable ）里面的run方法执行，
父类里面的run方法中，先获取了下当前的线程名，设置了新的线程名，然后执行了execute()抽象方法，最后又将旧的线程名设置回去了。
最终调用的是execute()抽象方法，我们还得回溯到子类当中去；
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抽象方法的实现…
final class AsyncCall extends NamedRunnable {
......
@Override protected void execute() {
boolean signalledCallback = false;
transmitter.timeoutEnter();
try {
//获取了Response 对象
Response response = getResponseWithInterceptorChain();
signalledCallback = true;
//还记得这个responseCallback吗？ 这里也就是我们传入进来的CallBack实现...也就是在这里我们将Response回调出去了
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);
}
}
......
}
接下来我们看看getResponseWithInterceptorChain()这个方法；
还记得上面同步也调用了这个方法吗？
只不过上面的同步方法调用时没有在线程池中执行，执行完的结果直接return出去了，而这个异步是创建了线程池，在线程池中执行了这个方法…并将结果通过CallBack回调出去了…
getResponseWithInterceptorChain()
这个方法才是做出真正的响应，返回了Response对象；
1、创建了拦截器集合；
2、添加了各种拦截器（包括最先添加的用户自己定义的拦截器）；
3、最终调用了 chain.proceed(originalRequest);得到一个Response 对象将其返回出去了；
等会儿在来看看proceed这个方法的调用
Response getResponseWithInterceptorChain() throws IOException {
// 创建了拦截器集合，添加了各种拦截器
List<Interceptor> interceptors = new ArrayList<>();
//用户添加的全局拦截器 也就是我们自己自定义的拦截器
interceptors.addAll(client.interceptors());
//错误、重定向拦截器
interceptors.add(new RetryAndFollowUpInterceptor(client));
//桥接拦截器，桥接应用层与网络层，添加必要的头
interceptors.add(new BridgeInterceptor(client.cookieJar()));
//缓存处理的拦截器
interceptors.add(new CacheInterceptor(client.internalCache()));
//连接拦截器
interceptors.add(new ConnectInterceptor(client));
if (!forWebSocket) {
//通过okHttpClient.Builder#addNetworkInterceptor()传进来的拦截器只对非网页的请求生效
interceptors.addAll(client.networkInterceptors());
}
//真正访问服务器的拦截器
interceptors.add(new CallServerInterceptor(forWebSocket));
Interceptor.Chain chain = new RealInterceptorChain(interceptors, transmitter, null, 0,
originalRequest, this, client.connectTimeoutMillis(),
client.readTimeoutMillis(), client.writeTimeoutMillis());
boolean calledNoMoreExchanges = false;
try {
//获取到了 Response 对象；
Response response = chain.proceed(originalRequest);
if (transmitter.isCanceled()) {
closeQuietly(response);
throw new IOException("Canceled");
}
//将其返回出去了
return response;
} catch (IOException e) {
calledNoMoreExchanges = true;
throw transmitter.noMoreExchanges(e);
} finally {
if (!calledNoMoreExchanges) {
transmitter.noMoreExchanges(null);
}
}
}
时序图
下面来看看上面同步和异步的时序图
拦截器（分析）
接下来我们来看看OkHttp里面的拦截器
Interceptor 是一个接口
既然是个接口，肯定在框架里面会有接口的实现
是否还记得getResponseWithInterceptorChain() 这个方法？
方法中创建了一个拦截器集合，往里面添加了很多拦截器…
package okhttp3;
......
public interface Interceptor {
Response intercept(Chain chain) throws IOException;
interface Chain {
Request request();
Response proceed(Request request) throws IOException;
/**
* Returns the connection the request will be executed on. This is only available in the chains
* of network interceptors; for application interceptors this is always null.
*/
@Nullable Connection connection();
Call call();
int connectTimeoutMillis();
Chain withConnectTimeout(int timeout, TimeUnit unit);
int readTimeoutMillis();
Chain withReadTimeout(int timeout, TimeUnit unit);
int writeTimeoutMillis();
Chain withWriteTimeout(int timeout, TimeUnit unit);
}
}
OkHttp当中分为哪两类别？
1、应用拦截器addInterceptor()：关注对象是request请求对象；
2、网络拦截器addNetworkInterceptor()：关注的是发起请求，请求过程中，以及请求的数据之后；可以去做重定向，以及请求失败了去做重试；
在getResponseWithInterceptorChain()中添加完了拦截器集合之后
创建了一个RealInterceptorChain()拦截器，并将拦截器集合都传入进去了
RealInterceptorChain实现了implements Interceptor.Chain接口，
最终调用 Response response = chain.proceed(originalRequest);得到Response对象
Interceptor.Chain chain = new RealInterceptorChain(interceptors, transmitter, null, 0,
originalRequest, this, client.connectTimeoutMillis(),
client.readTimeoutMillis(), client.writeTimeoutMillis());
Response response = chain.proceed(originalRequest);
上面通过RealInterceptorChain调用了proceed方法，我们跟进去看看proceed方法中的代码，里面各种判断，不符合的都会抛出异常；我们来看主要的代码；
这里面又new了一个自己，并将index+1，还记得是传入了拦截器集合吗？这里一个一个的将上面添加的拦截器取了出来，拦截器调用了intercept方法获取Response对象；
注：
结合拦截器的实现类中的intercept方法去看，这里是取出当前的拦截器的同时，准备new了个RealInterceptorChain对象，并将上一个拦截器获取到的数据传递到了下一个RealInterceptorChain对象中，方便在拦截器实现类中调用新的对象的proceed方法，拿到集合中的下一个拦截器。可以说是这里只是在做个标记，我这么理解
责任链模式
@Override public Response proceed(Request request) throws IOException {
return proceed(request, transmitter, exchange);
}
public Response proceed(Request request, Transmitter transmitter, @Nullable Exchange exchange)
throws IOException {
......
calls++;
......
// 自己创建了自己，然后将下表index+1;
//我们结合拦截器的实现类中的intercept方法去看，大概就明白了
//准备new了个RealInterceptorChain对象，并将上一个拦截器获取到的东西传递到了下一个RealInterceptorChain对象中，方便在拦截器实现类中调用新的对象的proceed方法，拿到集合中的下一个拦截器。可以说是这里只是在做个标记，我这么理解
RealInterceptorChain next = new RealInterceptorChain(interceptors, transmitter, exchange,
index + 1, request, call, connectTimeout, readTimeout, writeTimeout);
//获取了集合中当前下标的拦截器
Interceptor interceptor = interceptors.get(index);
//拦截器调用了intercept方法，将刚刚new出来的自己传入进去了，获取到Response对象
Response response = interceptor.intercept(next);
......
return response;
}
既然interceptor拦截器是个接口，所以我们得去看看他的实现类
看看这个intercept方法的实现
看到中间这句 response = realChain.proceed(request, transmitter, null);
realChain记得是传入进来的new了新的RealInterceptorChain 方法，又调用了RealInterceptorChain 类中的proceed这个方法
public final class RetryAndFollowUpInterceptor implements Interceptor {
......
//刚刚是拦截器调用了intercept这个方法 外部RealInterceptorChain 的proceed方法中调用的，传入了一个新的RealInterceptorChain对象，记住是新的，创建时将index下标+了1
@Override public Response intercept(Chain chain) throws IOException {
Request request = chain.request();
RealInterceptorChain realChain = (RealInterceptorChain) chain;
Transmitter transmitter = realChain.transmitter();
int followUpCount = 0;
Response priorResponse = null;
while (true) {
transmitter.prepareToConnect(request);
if (transmitter.isCanceled()) {
throw new IOException("Canceled");
}
Response response;
boolean success = false;
try {
//又调用到了RealInterceptorChain 类中的proceed方法，记得吗？
//不过是新new的RealInterceptorChain 对象的proceed方法
response = realChain.proceed(request, transmitter, null);
success = true;
} catch (RouteException e) {
// The attempt to connect via a route failed. The request will not have been sent.
if (!recover(e.getLastConnectException(), transmitter, false, request)) {
throw e.getFirstConnectException();
}
continue;
} catch (IOException e) {
// An attempt to communicate with a server failed. The request may have been sent.
boolean requestSendStarted = !(e instanceof ConnectionShutdownException);
if (!recover(e, transmitter, requestSendStarted, request)) throw e;
continue;
} finally {
// The network call threw an exception. Release any resources.
if (!success) {
transmitter.exchangeDoneDueToException();
}
}
// Attach the prior response if it exists. Such responses never have a body.
if (priorResponse != null) {
response = response.newBuilder()
.priorResponse(priorResponse.newBuilder()
.body(null)
.build())
.build();
}
Exchange exchange = Internal.instance.exchange(response);
Route route = exchange != null ? exchange.connection().route() : null;
Request followUp = followUpRequest(response, route);
if (followUp == null) {
if (exchange != null && exchange.isDuplex()) {
transmitter.timeoutEarlyExit();
}
return response;
}
RequestBody followUpBody = followUp.body();
if (followUpBody != null && followUpBody.isOneShot()) {
return response;
}
closeQuietly(response.body());
if (transmitter.hasExchange()) {
exchange.detachWithViolence();
}
if (++followUpCount > MAX_FOLLOW_UPS) {
throw new ProtocolException("Too many follow-up requests: " + followUpCount);
}
request = followUp;
priorResponse = response;
}
}
......
}
ConnectInterceptor 拦截器
我们大致来看一个拦截器ConnectInterceptor 拦截器
public final class ConnectInterceptor implements Interceptor {
public final OkHttpClient client;
public ConnectInterceptor(OkHttpClient client) {
this.client = client;
}
@Override public Response intercept(Chain chain) throws IOException {
RealInterceptorChain realChain = (RealInterceptorChain) chain;
Request request = realChain.request();
//先得到一个数据桥梁
Transmitter transmitter = realChain.transmitter();
// We need the network to satisfy this request. Possibly for validating a conditional GET.
boolean doExtensiveHealthChecks = !request.method().equals("GET");
//到这里就等于创建好了连接
Exchange exchange = transmitter.newExchange(chain, doExtensiveHealthChecks);
//这里就可以说是往集合中的下一个拦截器中传递进去
return realChain.proceed(request, transmitter, exchange);
}
}
newExchange方法调用
先进行了同步锁，做了一些异常判断；
Exchange newExchange(Interceptor.Chain chain, boolean doExtensiveHealthChecks) {
synchronized (connectionPool) {
if (noMoreExchanges) {
throw new IllegalStateException("released");
}
if (exchange != null) {
throw new IllegalStateException("cannot make a new request because the previous response "
+ "is still open: please call response.close()");
}
}
//获取到时HTTP1还是HTT2的链接方式
//对请求和响应去设置了各种信息，跟进去能看到设置了各种超时时间，在find这方法里面一步步跟进去
//会看到个RealConnection resultConnection = findHealthyConnection(connectTimeout, readTimeout, writeTimeout, pingIntervalMillis, connectionRetryEnabled, doExtensiveHealthChecks);
//一步步跟进去会进入到RealConnection类中的connect链接的方法
ExchangeCodec codec = exchangeFinder.find(client, chain, doExtensiveHealthChecks);
Exchange result = new Exchange(this, call, eventListener, exchangeFinder, codec);
synchronized (connectionPool) {
this.exchange = result;
this.exchangeRequestDone = false;
this.exchangeResponseDone = false;
return result;
}
}
通过上面调用这个转换器的find方法我们跟进来看看这个里面
获取一个有效的链接，尝试从复用池中去拿
final class ExchangeFinder {
//看名字是个连接池
private final RealConnectionPool connectionPool;
public ExchangeCodec find(
OkHttpClient client, Interceptor.Chain chain, boolean doExtensiveHealthChecks) {
//获取到超时一些超时设置
int connectTimeout = chain.connectTimeoutMillis();
int readTimeout = chain.readTimeoutMillis();
int writeTimeout = chain.writeTimeoutMillis();
int pingIntervalMillis = client.pingIntervalMillis();
boolean connectionRetryEnabled = client.retryOnConnectionFailure();
try {
//获取连接 核心代码 调用了自己内部的findHealthyConnection方法
RealConnection resultConnection = findHealthyConnection(connectTimeout, readTimeout,
writeTimeout, pingIntervalMillis, connectionRetryEnabled, doExtensiveHealthChecks);
return resultConnection.newCodec(client, chain);
} catch (RouteException e) {
trackFailure();
throw e;
} catch (IOException e) {
trackFailure();
throw new RouteException(e);
}
}
private RealConnection findHealthyConnection(int connectTimeout, int readTimeout,
int writeTimeout, int pingIntervalMillis, boolean connectionRetryEnabled,
boolean doExtensiveHealthChecks) throws IOException {
while (true) {
//
RealConnection candidate = findConnection(connectTimeout, readTimeout, writeTimeout,
pingIntervalMillis, connectionRetryEnabled);
// If this is a brand new connection, we can skip the extensive health checks.
synchronized (connectionPool) {
if (candidate.successCount == 0) {
return candidate;
}
}
// Do a (potentially slow) check to confirm that the pooled connection is still good. If it
// isn't, take it out of the pool and start again.
if (!candidate.isHealthy(doExtensiveHealthChecks)) {
candidate.noNewExchanges();
continue;
}
return candidate;
}
}
//获取到了一个有效的连接
private RealConnection findConnection(int connectTimeout, int readTimeout, int writeTimeout,
int pingIntervalMillis, boolean connectionRetryEnabled) throws IOException {
boolean foundPooledConnection = false;
RealConnection result = null;
Route selectedRoute = null;
RealConnection releasedConnection;
Socket toClose;
//connectionPool 连接池
synchronized (connectionPool) {
if (transmitter.isCanceled()) throw new IOException("Canceled");
hasStreamFailure = false; // This is a fresh attempt.
// Attempt to use an already-allocated connection. We need to be careful here because our
// already-allocated connection may have been restricted from creating new exchanges.
releasedConnection = transmitter.connection;
toClose = transmitter.connection != null && transmitter.connection.noNewExchanges
? transmitter.releaseConnectionNoEvents()
: null;
if (transmitter.connection != null) {
// We had an already-allocated connection and it's good.
result = transmitter.connection;
releasedConnection = null;
}
if (result == null) {
// 尝试先从复用池里面去拿
if (connectionPool.transmitterAcquirePooledConnection(address, transmitter, null, false)) {
foundPooledConnection = true;
result = transmitter.connection;
} else if (nextRouteToTry != null) {
selectedRoute = nextRouteToTry;
nextRouteToTry = null;
} else if (retryCurrentRoute()) {
selectedRoute = transmitter.connection.route();
}
}
}
closeQuietly(toClose);
if (releasedConnection != null) {
eventListener.connectionReleased(call, releasedConnection);
}
if (foundPooledConnection) {
eventListener.connectionAcquired(call, result);
}
if (result != null) {
//这里是如果已经拿到了这个有效连接的话，我们就直接返回出去了
return result;
}
// If we need a route selection, make one. This is a blocking operation.
boolean newRouteSelection = false;
if (selectedRoute == null && (routeSelection == null || !routeSelection.hasNext())) {
newRouteSelection = true;
routeSelection = routeSelector.next();
}
List<Route> routes = null;
synchronized (connectionPool) {
if (transmitter.isCanceled()) throw new IOException("Canceled");
if (newRouteSelection) {
// Now that we have a set of IP addresses, make another attempt at getting a connection from
// the pool. This could match due to connection coalescing.
routes = routeSelection.getAll();
if (connectionPool.transmitterAcquirePooledConnection(
address, transmitter, routes, false)) {
foundPooledConnection = true;
result = transmitter.connection;
}
}
if (!foundPooledConnection) {
if (selectedRoute == null) {
selectedRoute = routeSelection.next();
}
// Create a connection and assign it to this allocation immediately. This makes it possible
// for an asynchronous cancel() to interrupt the handshake we're about to do.
result = new RealConnection(connectionPool, selectedRoute);
connectingConnection = result;
}
}
// If we found a pooled connection on the 2nd time around, we're done.
if (foundPooledConnection) {
eventListener.connectionAcquired(call, result);
return result;
}
// 如果最终都没找到可以使用的链接的话，就自己去新增一次链接
result.connect(connectTimeout, readTimeout, writeTimeout, pingIntervalMillis,
connectionRetryEnabled, call, eventListener);
connectionPool.routeDatabase.connected(result.route());
Socket socket = null;
synchronized (connectionPool) {
connectingConnection = null;
// Last attempt at connection coalescing, which only occurs if we attempted multiple
// concurrent connections to the same host.
if (connectionPool.transmitterAcquirePooledConnection(address, transmitter, routes, true)) {
// We lost the race! Close the connection we created and return the pooled connection.
result.noNewExchanges = true;
socket = result.socket();
result = transmitter.connection;
} else {
connectionPool.put(result);
transmitter.acquireConnectionNoEvents(result);
}
}
closeQuietly(socket);
eventListener.connectionAcquired(call, result);
return result;
}
}
看到这行 connectSocket(connectTimeout, readTimeout, call, eventListener);
调用了自己类中的connectSocket方法
Platform.get().connectSocket(rawSocket, route.socketAddress(), connectTimeout);最终调用的是Socket连接
public final class RealConnection extends Http2Connection.Listener implements Connection {
......
public void connect(int connectTimeout, int readTimeout, int writeTimeout,
......
connectSocket(connectTimeout, readTimeout, call, eventListener);
......
}
......
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 {
//连接Socket
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);
}
}
}
}
我们看看最后调用到Platform类中的connectSocket方法
public class Platform {
public void connectSocket(Socket socket, InetSocketAddress address, int connectTimeout)
throws IOException {
//Socket连接 address ip]端口都在里面
socket.connect(address, connectTimeout);
}
}
时序图
来看看这个连接拦截器的时序图
发现类好多，但是都是单一职责，方便进行扩展
复用池
我们来大致看下这个复用池
看看这里面创建了一个线程池
public final class RealConnectionPool {
//创建了一个线程池
private static final Executor executor = new ThreadPoolExecutor(0 /* corePoolSize */,
Integer.MAX_VALUE /* maximumPoolSize */, 60L /* keepAliveTime */, TimeUnit.SECONDS,
new SynchronousQueue<>(), Util.threadFactory("OkHttp ConnectionPool", true));
}
复用池（线程池）
复用与一次响应过程不一样，一次响应式每次响应后都会去释放该链接；
复用池是在多长时间内，会进行复用，不用每次去重新打开链接，会去复用该链接；
阻塞时的连接，有链接过来时会被唤醒；
复用是需要ip和端口一样的情况下才会进行复用；
连接类型需要使用长连接Connection（请求头）
CallServerInterceptor拦截器
再来看看最后这个拦截器：interceptors.add(new CallServerInterceptor(forWebSocket));
最后执行到这个拦截器的时候，我们来看看它里面的intercept方法实现，最终他没有在调用proceed这个方法了吧
也就是到这个拦截器执行完的时候，最后通过所有拦截器的信息去获取最终的Response对象了，所以在添加连接器集合的时候这个是在最后添加的拦截器
来看看这个拦截器拦截的方法里面做了啥…
writeRequestHeaders写入了请求头
public final class CallServerInterceptor implements Interceptor {
@Override public Response intercept(Chain chain) throws IOException {
RealInterceptorChain realChain = (RealInterceptorChain) chain;
Exchange exchange = realChain.exchange();
Request request = realChain.request();
long sentRequestMillis = System.currentTimeMillis();
//写入请求头数据
exchange.writeRequestHeaders(request);
boolean responseHeadersStarted = false;
Response.Builder responseBuilder = null;
if (HttpMethod.permitsRequestBody(request.method()) && request.body() != null) {
// If there's a "Expect: 100-continue" header on the request, wait for a "HTTP/1.1 100
// Continue" response before transmitting the request body. If we don't get that, return
// what we did get (such as a 4xx response) without ever transmitting the request body.
if ("100-continue".equalsIgnoreCase(request.header("Expect"))) {
exchange.flushRequest();
responseHeadersStarted = true;
exchange.responseHeadersStart();
responseBuilder = exchange.readResponseHeaders(true);
}
if (responseBuilder == null) {
if (request.body().isDuplex()) {
// Prepare a duplex body so that the application can send a request body later.
exchange.flushRequest();
BufferedSink bufferedRequestBody = Okio.buffer(
exchange.createRequestBody(request, true));
request.body().writeTo(bufferedRequestBody);
} else {
// Write the request body if the "Expect: 100-continue" expectation was met.
BufferedSink bufferedRequestBody = Okio.buffer(
exchange.createRequestBody(request, false));
request.body().writeTo(bufferedRequestBody);
bufferedRequestBody.close();
}
} else {
exchange.noRequestBody();
if (!exchange.connection().isMultiplexed()) {
// If the "Expect: 100-continue" expectation wasn't met, prevent the HTTP/1 connection
// from being reused. Otherwise we're still obligated to transmit the request body to
// leave the connection in a consistent state.
exchange.noNewExchangesOnConnection();
}
}
} else {
exchange.noRequestBody();
}
if (request.body() == null || !request.body().isDuplex()) {
exchange.finishRequest();
}
if (!responseHeadersStarted) {
exchange.responseHeadersStart();
}
if (responseBuilder == null) {
responseBuilder = exchange.readResponseHeaders(false);
}
Response response = responseBuilder
.request(request)
.handshake(exchange.connection().handshake())
.sentRequestAtMillis(sentRequestMillis)
.receivedResponseAtMillis(System.currentTimeMillis())
.build();
int code = response.code();
if (code == 100) {
// server sent a 100-continue even though we did not request one.
// try again to read the actual response
response = exchange.readResponseHeaders(false)
.request(request)
.handshake(exchange.connection().handshake())
.sentRequestAtMillis(sentRequestMillis)
.receivedResponseAtMillis(System.currentTimeMillis())
.build();
code = response.code();
}
exchange.responseHeadersEnd(response);
if (forWebSocket && code == 101) {
// Connection is upgrading, but we need to ensure interceptors see a non-null response body.
response = response.newBuilder()
.body(Util.EMPTY_RESPONSE)
.build();
} else {
response = response.newBuilder()
.body(exchange.openResponseBody(response))
.build();
}
if ("close".equalsIgnoreCase(response.request().header("Connection"))
|| "close".equalsIgnoreCase(response.header("Connection"))) {
exchange.noNewExchangesOnConnection();
}
if ((code == 204 || code == 205) && response.body().contentLength() > 0) {
throw new ProtocolException(
"HTTP " + code + " had non-zero Content-Length: " + response.body().contentLength());
}
return response;
}
}
public final class Exchange {
//写入请求头数据 上面这个拦截器调用的方法
public void writeRequestHeaders(Request request) throws IOException {
try {
//监听回调 开始写入请求头
eventListener.requestHeadersStart(call);
//这个codec是最终的请求方式吧，对吧
// HTTP1 HTT2 写入请求头
codec.writeRequestHeaders(request);
//回调监听，请求头数据写入完成了
eventListener.requestHeadersEnd(call, request);
} catch (IOException e) {
eventListener.requestFailed(call, e);
trackFailure(e);
throw e;
}
}
}
看到没有，这个请求方式调用写入的方法，区分了http1、http2
这个是Http1里面最终拼接请求头的方法
/**
*
*Http1 的方式
*/
public final class Http1ExchangeCodec implements ExchangeCodec {
......
private final BufferedSink sink;
......
//写入请求头请求数据
public void writeRequest(Headers headers, String requestLine) throws IOException {
if (state != STATE_IDLE) throw new IllegalStateException("state: " + state);
sink.writeUtf8(requestLine).writeUtf8("\r\n");
for (int i = 0, size = headers.size(); i < size; i++) {
sink.writeUtf8(headers.name(i))
.writeUtf8(": ")
.writeUtf8(headers.value(i))
.writeUtf8("\r\n");
}
sink.writeUtf8("\r\n");
state = STATE_OPEN_REQUEST_BODY;
}
//发射数据 记得Socket的发射数据吗flush
@Override public synchronized void flush() throws IOException {
if (closed) return; // Don't throw; this stream might have been closed on the caller's behalf.
//最终肯定是调用了OutputStream.flush()
sink.flush();
}
}
这里是HTTP2拼接请求头的方法
@Override public void writeRequestHeaders(Request request) throws IOException {
if (stream != null) return;
boolean hasRequestBody = request.body() != null;
List<Header> requestHeaders = http2HeadersList(request);
stream = connection.newStream(requestHeaders, hasRequestBody);
// We may have been asked to cancel while creating the new stream and sending the request
// headers, but there was still no stream to close.
if (canceled) {
stream.closeLater(ErrorCode.CANCEL);
throw new IOException("Canceled");
}
stream.readTimeout().timeout(chain.readTimeoutMillis(), TimeUnit.MILLISECONDS);
stream.writeTimeout().timeout(chain.writeTimeoutMillis(), TimeUnit.MILLISECONDS);
}
RealConnection这个对象是有效连接，前面一系列操作就是为了得到这个有效链接，尝试从复用池去获取，如果没有，就会去创建新的Socket链接
HttpURLConnection是用的Socket；
OkHttp里面也是使用Socket来发送请求，但是他跳过了Android封装的HttpURLConnection；
扫一扫
763
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
