OkHttp源码的samples的简单使用的示例：
public static void main(String... args) throws Exception{
OkHttpClient client=new OkHttpClient();
// Create request for remote resource.
Request request=new Request.Builder()
.url(ENDPOINT)
.build();
// Execute the request and retrieve the response.
Response response=client.newCall(request).execute();
// Deserialize HTTP response to concrete type.
ResponseBody body=response.body();
Listcontributors=CONTRIBUTORS_JSON_ADAPTER.fromJson(body.source());
body.close();
......
}
静态常量
OkHttpClient开始就定义了两个静态常量，这两个常量是与协议相关分别是DEFAULT_CONNECTION_SPECS和DEFAULT_PROTOCOLS。
静态代码块
接下来看OkHttpClient的static代码块主要就是创建了一个Internal的内部类对象。
接口
OkHttpClient实现了三个接口，分别是Cloneable,Call.Factory,WebSocket.Factory
重点在Call.Factory接口上，Call该接口的实例就是我么去执行请求网络数据的对象，
Call中的主要方法
/** 返回该Call创建的Request请求对象 */
Request request();
/** 同步执行请求网络数据，返回服务端响应结果*/
Response execute()throwsIOException;
/** 异步执行请求网络数据的回调方法*/
void enqueue(Callback responseCallback);
/** 取消网络请求*/
void cancel();
/** 判断网络请求是否被执行了*/
boolean isExecuted();
/** 判断网络请求是否被取消了*/
boolean isCanceled();
/**clone该方法是Cloneable接口中的方法，意义在于创建一个相同的请求对象*/
Call clone();
/**Factory内部接口就是创建Call的工厂接口,该接口定义的方法newCall需要传入Request对象*/
interface Factory{
Call newCall(Request request);
}
成员变量
最重要的就是OkHttpClient，该类的成员变量中6个成员变量进行重点说明的
final Dispatcher dispatcher;
final List interceptors;
final List networkInterceptors;
final EventListener.Factory eventListenerFactory;
final @Nullable Cache cache;
final @Nullable InternalCache internalCache;
1、同步请求过程解析
Response response=client.newCall(request).execute(); 这句代码执行过程：
（1）client.newCall(request)
第一步：上面提到OkHttpClient的三个接口中有个Factory内部接口（创建Call的工厂接口）,而Call对象有个实现类RealCall，其实newCall方法是RealCall执行自己的newRealCall方法创建了一个RealCall实例，该方法三个参数如下：
*@param client OkHttpClient对象
*@param originalRequest 之前传入的那个原始请求对象
*@param forWebSocket 是否是WebSocket
RealCall call=newRealCall(client,originalRequest,forWebSocket);
第二步：上面提到OkHttpClient的6个成员变量中有个EventListener.Factory eventListenerFactory对象（也是个工厂接口，内部定义了一个create方法用于创建EventListener对象），上一步传入了OkHttpClient对象，该对象已经创建完了eventListenerFactory实例，所以拿到该实例传入call对象创建EventListener对象。
抽象类EventListener中有一大堆的网络连接的监听方法
call.eventListener=client.eventListenerFactory().create(call);
最后返回当前的Call对象
（2）call.execute()
@Override
publicResponse execute()throwsIOException{
synchronized(this) {
if(executed)throw newIllegalStateException("Already Executed");
executed=true;
}
captureCallStackTrace();
try{
client.dispatcher().executed(this);
Response result=getResponseWithInterceptorChain();
if(result==null)throw newIOException("Canceled");
returnresult;
}finally{
client.dispatcher().finished(this);
}
}
（2.1）call中的execute方法中的client.dispatcher().executed(this);
由于execute是同步执行网络请求所以要用关键字synchronized，
synchronized(this) {
if(executed)throw newIllegalStateException("Already Executed");
executed=true;
}
之后再执行captureCallStackTrace()方法，放入堆栈进行追踪捕捉。
client.dispatcher()是获得上面OkHttpClient的成员变量Dispatcher dispatcher，注意啦Dispatcher中的方法基本都是同步，用的Synchronized修饰的方法。为了分析清楚这里插一段Dispatcher的说明。
Dispatcher中维护着执行发送请求的线程池，所有的请求都是放在请求队列中的总共有三个队列readyAsyncCalls（准备的异步请求队列），runningAsyncCalls（正在在执行的异步请求还包括被中断的），runningSyncCalls（正在在执行的异步请求还包括被中断的）
private final Deque<AsyncCall> readyAsyncCalls=newArrayDeque<>();
private final Deque<AsyncCall> runningAsyncCalls=newArrayDeque<>();
private final Deque<RealCall> runningSyncCalls=newArrayDeque<>();
RealCall和AsyncCall的关系通过Dispatcher类的导入代码可以看出
import okhttp3.RealCall.AsyncCall; // AsyncCall其实就是RealCall的内部类
具体实现如下：
final class AsyncCall extends NamedRunnable{
private final Callback responseCallback;
// 构造时需要传入一个Callback接口，也就是返回给我们成功失败的回调方法
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,newIOException("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);
}
}
}
dispatcher中erexecuted方法的具体实现
// 加入同步执行队列
synchronized void executed(RealCall call) {
runningSyncCalls.add(call);
}
（2.2）Response result=getResponseWithInterceptorChain();
下面回过头去看RealCall的execute方法中client.dispatcher().executed(this);执行结束后的代码Response result=getResponseWithInterceptorChain();
为了分析清楚这里插一段Interceptor的说明
Response getResponseWithInterceptorChain()throwsIOException{
//创建一个存放拦截器的集合，最后传入 newRealInterceptorChain对象中
List<Intercepter> interceptors=newArrayList<>();
// client.interceptors() (自定义的拦截器, 在call api的前的拦截) - > //retryAndFollowUpInterceptor （实现请求重试）
interceptors.addAll(client.interceptors());
// 重定向拦截器
interceptors.add(retryAndFollowUpInterceptor);
// 桥接拦截器（处理header 、cookie 等）
interceptors.add(newBridgeInterceptor(client.cookieJar()));
// 缓存拦截器（处理 cache）
interceptors.add(newCacheInterceptor(client.internalCache()));
// 连接拦截器（负责建立连接）
interceptors.add(newConnectInterceptor(client));
if(!forWebSocket) {
// 自定义网络拦截器（此时已建立连接）
interceptors.addAll(client.networkInterceptors());
}
// 服务请求拦截器（发起请求、接收响应）
interceptors.add(newCallServerInterceptor(forWebSocket));
Interceptor.Chain chain = new RealInterceptorChain(interceptors,null,null,null,0,originalRequest,this,eventListener); return chain.proceed(originalRequest);
}
上面的RealInterceptorChain方法具体实现。在RealCall里的getResponseWithInterceptorChain方法里，创建了一个RealInterceptorChain对象，调用proceed(),在interceptor的intercept()方法里又调用proceed()，明显形成了一个递归，像链表一下一个一个递归传递并且做相应的拦截处理。
RealInterceptorChain next=newRealInterceptorChain(interceptors,streamAllocation,httpCodec,
connection,index+1,request,call,eventListener);
Interceptor interceptor=interceptors.get(index);
Response response=interceptor.intercept(next);
最后一个拦截器返回处理的Response,也就是服务器端返回的结果，并且在代码中加了许多的判断如：this.httpCodec!=null 意思就是还没有拦截链执行完。interceptor必须执行一次proceed()方法，否则会抛异常。
RealInterceptorChain ＋ Interceptor实现了装饰器模式，实现了请求/响应的串式或流式处理。只不过内层装饰器不是外层装饰器的成员变量，而是接口方法中创建的临时变量。
在ConnectInterceptor之后的拦截器必须满足：request的url要一致，interceptor必须执行一次proceed()。这样子做是为了保证递推的正常运作。而对与client.interceptors是在ConnectInterceptor之前的拦截器，可以不用必须执行一次proceed()。可以实现直接返回虚拟的response用于是测试等功能。
这几个Interceptor的职责：
RetryAndFollowUpInterceptor --->创建StreamAllocation对象，处理http的redirect，出错重试。对后续Interceptor的执行的影响：修改request及StreamAllocation。
BridgeInterceptor-------------->补全缺失的一些http header。对后续Interceptor的执行的影响：修改request。
CacheInterceptor-------------->处理http缓存。对后续Interceptor的执行的影响：若缓存中有所需请求的响应，则后续Interceptor不再执行。
ConnectInterceptor------------>借助于前面分配的StreamAllocation对象建立与服务器之间的连接，并选定交互所用的协议是HTTP 1.1还是HTTP 2。对后续Interceptor的执行的影响：创建了httpStream和connection。
CallServerInterceptor----------->处理IO，与服务器进行数据交换。对后续Interceptor的执行的影响：为Interceptor链中的最后一个Interceptor，没有后续Interceptor
（2.3）client.dispatcher().finished(this);
dispatcher中finish方法的具体实现（注意第三个参数的差别）
/** Used by {@codeCall #execute} to signal completion.同步方法 */
void finished(RealCall call) {
finished(runningSyncCalls,call,false);
}
/** Used by {@codeAsyncCall#run} to signal completion. 异步方法*/
void finished(AsyncCall call) {
finished(runningAsyncCalls,call,true);
}
上面的finished(runningAsyncCalls,call,true);方法实现如下:
private void finished(Dequecalls,T call,boolean promoteCalls) {
int runningCallsCount;
Runnable idleCallback;
synchronized(this) {
if (!calls.remove(call) ) throw newAssertionError("Call wasn't in-flight!");
if(promoteCalls) promoteCalls(); // 异步Call数量多时需要维护队列，而不是立即执.行，所以要加入到runningAsyncCalls中
runningCallsCount = runningCallsCount();
idleCallback = this.idleCallback;
}
if(runningCallsCount==0&&idleCallback!=null) {
idleCallback.run();
}
}
上面promoteCalls方法的具体实现如下：
private int maxRequests=64;
private int maxRequestsPerHost=5;
private void promoteCalls() {
if(runningAsyncCalls.size()>=maxRequests) return;// 已经达到最大容器.
if ( readyAsyncCalls.isEmpty() ) return; // 队列为空
for(Iterator i=readyAsyncCalls.iterator();i.hasNext();) { // 遍历取出
AsyncCall call=i.next();
// 当正在执行的任务总数及相同host下的任务数小于最大值时，直接执行当前请求，而任务数超过限定时，将其加入等待队列。
if ( runningCallsForHost(call) < maxRequestsPerHost ){
i.remove();
runningAsyncCalls.add(call);
executorService().execute(call);
}
}
if ( runningAsyncCalls.size()>=maxRequests ) return;// Reached max capacity.
}
}
还可以通setMaxRequests()设置同时允许执行的最大请求数，以及setMaxRequestsPerHost()设置相同host下最多运行的请求数。从源码中看出OkHttpClient用了许多的Budiler设计模式，几个重要的类Response、Request、OkHttpClient。
2、异步请求过程解析
RealCall的enqueue方法，其中遇到的大部分方法在同步请求中有分析就不赘述了。主要讲一下异步网络请求的流程
@Override
public voidenqueue(Callback responseCallback) {
synchronized(this) {
if(executed)throw newIllegalStateException("Already Executed");
executed=true;
}
captureCallStackTrace();
client.dispatcher().enqueue(newAsyncCall(responseCallback));
}
上面client.dispatcher().enqueue(newAsyncCall(responseCallback));中Dispatcher的enqueue方法
synchronized void enqueue(AsyncCall call) {
// 如果正在执行异步请求的队列没有超过最大请求数量，并且有没有超过每个主机允许的最大访问量
// 就将请求加入到正在执行异步请求的队列中，否则就加入到准备异步请求的队列中去
if(runningAsyncCalls.size() < maxRequests && runningCallsForHost(call) < maxRequestsPerHost
runningAsyncCalls.add(call);
executorService().execute(call);
}else{
readyAsyncCalls.add(call);
}
异步请求返回是通过接口回调的具体实现如下：
final classAsyncCallextendsNamedRunnable{
private finalCallback 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 voidexecute() {
booleansignalledCallback=false;
try{
Response response=getResponseWithInterceptorChain();
if (retryAndFollowUpInterceptor.isCanceled() ) {
signalledCallback=true;
responseCallback.onFailure(RealCall.this,newIOException("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);
}
}
}
