OkHttp得拦截机制
现在得android网络请求框架中使用得最多得还是okhttp，okhttp得拦截机制很巧妙，所以就看下是如何设计得。
一般得使用例子如下。
OkHttpClient okHttpClient = new OkHttpClient.Builder()
.build();
Request request = new Request.Builder()
.url(url)
.build();
okHttpClient.newCall(request).enqueue(new Callback() {
@Override
public void onFailure(Call call, IOException e) {
}
@Override
public void onResponse(Call call, Response response) throws IOException {
}
});构建一个OkHttpClient客户端和一个请求Request，然后调用newCall发送请去。先看下一张okhttp整个网络架构图。
（https://raw.githubusercontent.com/sucese/android-open-framework- analysis/master/art/okhttp/request_and_response_structure.png）
网络配置层：利用Builder模式配置各种参数，例如：超时时间、拦截器等，这些参数都会由Okhttp分发给各个需要的子系统。
重定向层：负责重定向。
Header拼接层：负责把用户构造的请求转换为发送给服务器的请求，把服务器返回的响应转换为对用户友好的响应。
HTTP缓存层：负责读取缓存以及更新缓存。
连接层：连接层是一个比较复杂的层级，它实现了网络协议、内部的拦截器、安全性认证，连接与连接池等功能，但这一层还没有发起真正的连接，它只是做了连接器一些参数的处理。
数据响应层：负责从服务器读取响应的数据。
Okhttp的整个请求与响应的流程就是Dispatcher不断从Request Queue里取出请求（Call），根据是否已经存存缓存，从内存缓存或者服务器获取请求的数据，请求分为同步和异步两种，同步请求通过 调用Call.exectute()方法直接返回当前请求的Response，异步请求调用Call.enqueue()方法将请求（AsyncCall）添加到请求队列中去，并通过回调（Callback）获取服务器返回的结果。
整个请求和响应得过程中，设计了一层一层得拦截器，每个拦截器对应相应得功能，简化了设计逻辑，提升了框架得扩展性。接着看下，Dispatcher是如何请求得。
先看下整个拦截流程。
（https://raw.githubusercontent.com/sucese/android-open-framework-analysis/master/art/okhttp/request_and_response_sequence.png）
发起请求在newCall中。
/**
* Prepares the {@code request} to be executed at some point in the future.
*/
@Override public Call newCall(Request request) {
return RealCall.newRealCall(this, request, false /* for web socket */);
}真正请求得是RealCall得newRealCall，RealCall是继承Call这个接口得。
public interface Call extends Cloneable {
//当前请求
Request request();
//同步请求方法
Response execute() throws IOException;
//异步请求方法
void enqueue(Callback responseCallback);
//取消请求
void cancel();
//是否执行
boolean isExecuted();
//是否取消
boolean isCanceled();
Call clone();
interface Factory {
Call newCall(Request 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);
}RealCall实现了Call接口，分装请求，赋值外部传入的OkHttpClient、Request与forWebSocket，并 创建了重试与重定向拦截器RetryAndFollowUpInterceptor。
请求分为同步请求和异步请求。
异步请求。
final class RealCall implements Call {
@Override public void enqueue(Callback responseCallback) {
synchronized (this) {
if (executed) throw new IllegalStateException("Already Executed");
executed = true;
}
captureCallStackTrace();
client.dispatcher().enqueue(new AsyncCall(responseCallback));
}
}同步请求
final class RealCall implements Call {
@Override public Response execute() throws IOException {
synchronized (this) {
if (executed) throw new IllegalStateException("Already Executed");
executed = true;
}
captureCallStackTrace();
try {
client.dispatcher().executed(this);
Response result = getResponseWithInterceptorChain();
if (result == null) throw new IOException("Canceled");
return result;
} finally {
client.dispatcher().finished(this);
}
}
}从上面可知，无论是同步还是异步请求，都是交给Dispatcher处理。AsyncCall本质上是一个Runnable。
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 {
eventListener.callFailed(RealCall.this, e);
responseCallback.onFailure(RealCall.this, e);
}
} finally {
client.dispatcher().finished(this);
}
}
}从代码可以看到无论是同步还是异步，最终都是通过getResponseWithInterceptorChain()获取Response。
请求和响应流程完了，接着看下拦截调度是如何实现得。
Response getResponseWithInterceptorChain() throws IOException {
// Build a full stack of interceptors.
List 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);
}
}
可以看到我们得拦截器是在这里添加得，Interceptor将网络请求、缓存、透明压缩等功能统一了起来，它的实现采用责任链模式，各司其职， 每个功能都是一个Interceptor，上一级处理完成以后传递给下一级，它们最后连接成了一个Interceptor.Chain。位置决定功能，位置靠前，先执行，所以我们自定义得拦截器是最先执行得。从发起到服务器返回数据得流程是相反得。
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内置的拦截器如下所示：
- RetryAndFollowUpInterceptor：负责失败重试以及重定向。
- BridgeInterceptor：负责把用户构造的请求转换为发送给服务器的请求，把服务器返回的响应转换为对用户友好的响应。
- CacheInterceptor：负责读取缓存以及更新缓存。
- ConnectInterceptor：负责与服务器建立连接。
- CallServerInterceptor：负责从服务器读取响应的数据。
Request是按照interpretor的顺序正向处理，而Response是逆向处理的。这参考了OSI七层模型的原理。上面我们也提到过。CallServerInterceptor相当于最底层的物理层， 请求从上到逐层包装下发，响应从下到上再逐层包装返回。
interceptor的执行顺序：RetryAndFollowUpInterceptor -> BridgeInterceptor -> CacheInterceptor -> ConnectInterceptor -> CallServerInterceptor。
response的拦截的执行顺序是：CallServerInterceptor ->ConnectInterceptor ->CacheInterceptor -> BridgeInterceptor ->
RetryAndFollowUpInterceptor 。
总结：
okhtto的拦截模式像OSI七层模型的原理，按照顺序拦截，理解起来非常的清晰，链路设计通俗易懂。