前言：okhttp框架已经使用了好多年了，本文基于3.12.13版本源码分析，个人觉得里面的设计确实非常巧妙。目前官网最新已经升级到4.12版本：https://github.com/square/okhttp 有兴趣可以看下 能完美兼容3.x版本，主要变更为kt实现。
okhttp从设计上亮点
1.大量运用设计模式，调用方便可扩展性强
2.分发器实现比较巧妙，异步请求设计保证了高并发最大吞吐量
3.拦截器使用责任链模式，保证了各个功能模块职责单一，暴露API方便用户扩展
4.连接池实现也保证了整体框架链接的高性能和资源开销
最简单的使用
只需要下面四个步骤就可以发起网络请求，但是真正去阅读他源码实现 会发现里面的很多细节很给力。
//建造者模式创建client
private OkHttpClient mOkHttpClient =mOkHttpClient.newBuilder()
.connectTimeout()
.readTimeout()
.writeTimeout()
.build();
//建造者模式创建request
Request.Builder builder = new Request.Builder().url(requestUrl);
builder.addHeader()
Request request = builder.build();
//把request给到 client
Call call = mOkHttpClient.newCall(request);
//执行移步请求
call.enqueue(new Callback() {
@Override
public void onFailure(Call call, IOException e) {
}
@Override
public void onResponse(Call call, Response response) throws IOException {
}
});
client 和request都是用了建造者模式，方便用户自定义扩展。思路也比较清晰，构建请求然后给到okcliet对象，由对象调用newCall()返回一个Call对象，在调用Call对象的异步方法发起请求得到结果回调。Call对象是一个接口，里面定义同步、异步、是否取消、超时等方法，只有一个实现类：RealCall
执行请求真正的实现类RealCall
上面的newCall方法调用如下，表明非websocket请求
@Override public Call newCall(Request request) {
return RealCall.newRealCall(this, request, false /* for web socket */);
}
调用异步请求方法：
@Override public void enqueue(Callback responseCallback) {
// 加同步限制保证同一个请求不会执行多次
synchronized (this) {
if (executed) throw new IllegalStateException("Already Executed");
//可以看到这个标记没有设置false的地方，每次请求发出去就不管了这个标记主要保证没执行
executed = true;
}
captureCallStackTrace();
eventListener.callStart(this);
// 核心方法
client.dispatcher().enqueue(new AsyncCall(responseCallback));
}
核心方法： client.dispatcher().enqueue(new AsyncCall(responseCallback)); 调用到Dispatcher类。这里用到了门面模式，Call里面的逻辑全部指向了这个分发器，里面设计也非常精妙。new AsyncCall(responseCallback) AsyncCall其实就是一个Runnable
public final class Dispatcher {
private int maxRequests = 64; // 最大请求数不能超过64个
private int maxRequestsPerHost = 5; //同一个host连接数不超过5
private @Nullable Runnable idleCallback;
/** Executes calls. Created lazily. */
private @Nullable ExecutorService executorService;
/** Ready async calls in the order they'll be run. */
// 等待被执行的请求双端队列
private final Deque<AsyncCall> readyAsyncCalls = new ArrayDeque<>();
/** Running asynchronous calls. Includes canceled calls that haven't finished yet. */
// 正在执行的请求对列异步
private final Deque<AsyncCall> runningAsyncCalls = new ArrayDeque<>();
/** Running synchronous calls. Includes canceled calls that haven't finished yet. */
// 正在执行的请求对列同步
private final Deque<RealCall> runningSyncCalls = new ArrayDeque<>();
public Dispatcher(ExecutorService executorService) {
this.executorService = executorService;
}
public Dispatcher() {
}
}
从上面代码分析，成员变量就定义了请求最大数量限制64，同一个host连接数限制5，里面定义了三个双端队列结构，两个队列用作异步请求，一个用作同步请求。还定义线程池，线程池的参数就比较有意思，能保证高并发下最大吞吐量。一个个来解释下
1.执行enqueue()时会调用如下逻辑，先把call加到等待队列，在执行promoteAndExcute方法
void enqueue(AsyncCall call) {
synchronized (this) {
readyAsyncCalls.add(call);
}
promoteAndExecute();
}
promoteAndExecute方法实现如下，核心逻辑添加了注释
private boolean promoteAndExecute() {
List<AsyncCall> executableCalls = new ArrayList<>();
boolean isRunning;
synchronized (this) {
for (Iterator<AsyncCall> i = readyAsyncCalls.iterator(); i.hasNext(); ) {
AsyncCall asyncCall = i.next(); //获取当前请求call
//正在运行的请求数量如果超过64 就break
if (runningAsyncCalls.size() >= maxRequests) break; // Max capacity.
// 当前请求host连接数量如果超过5个则不执行后续逻辑
if (runningCallsForHost(asyncCall) >= maxRequestsPerHost) continue; // Host max capacity.
// 把当前call移除等待队列
i.remove();
executableCalls.add(asyncCall);
// 添加到正在运行队列
runningAsyncCalls.add(asyncCall);
}
isRunning = runningCallsCount() > 0;
}
for (int i = 0, size = executableCalls.size(); i < size; i++) {
AsyncCall asyncCall = executableCalls.get(i);
asyncCall.executeOn(executorService()); //运行当前请求
}
return isRunning;
}
当满足条件后，会调用executeOn方法执行，传递的参数很重要，参数是个线程池对象,为啥说这样定义就可以保证高并发 最大吞吐量。
//同步线程池定义
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;
}
核心线程数0，最大线程数最大integer,存活时间60秒，队列是SynchronousQueue。回到线程池基础。
1.当一个线程执行提交任务时，首先判断是否超过核心线程数，如果不超过，会执行任务，如果超过最大核心数，则添加到队列，
2.添加到队列中如果如果队列满了添加不进去了，则会判断是否超过最大线程数，如果没超过创建线程执行任务，如果超过执行拒绝策略
在看ok的设置，第一个提交发现核心线程为0，则把任务添加到队列，而SynchronousQueue代表不存储的队列，也就会添加失败，添加失败后判断正在运行的线程数量 是否超过最大线程数，最大为integer最大值，不超过则创建线程执行任务。每提交一次就会创建一个线程执行。
这个不会有问题吗？扩展一个线程池的知识点
阿里开发手册为什么禁止使用线程池创建方式
newFixedThreadPool、newSingleThreadExecutor 方法创建线程
传入的是一个无界的阻塞队列，理论上可以无限添加任务到队列中 很可能触发OOM。
阻塞队列有还有ArrayBlockingQueue,如果是这种队列，需要指定大小，假如传入一个固定数字1，表明只能往里面添加1个，如果任务执行比较耗时，添加了一个任务到队列，再来一个任务，发现没有超过最大线程数，则会创建一个线程执行，这就导致先提交的任务后执行。LinkedBlockingQueue还可以传入数字就和ArrayBlockingQueue一样了。
CachedThreadPool 和ok使用的一样
任务会不断被提交，当核心线程耗时很久，线程池会尝试创建新的线程来执行提交的任务，当内存不足时就会报无法创建线程的错误而且安卓厂商一般还有限制，之前在做内存优化时候验证华为手机有限制 mate20pro手机上超过500多个就可能出现OOM
okhttp实现则用到了最大吞吐量，配合两个队列限制最大请求数64和同个host最大连接数不超过5，来控制来保证不会一直创建线程
我们继续看任务执行方法：
void executeOn(ExecutorService executorService) {
// 把任务给到线程池执行
try {
executorService.execute(this);
success = true;
} catch (RejectedExecutionException e) {
.....
} finally {
// 不管任务是否执行成功，都执行分发起的finish方法
if (!success) {
client.dispatcher().finished(this); // This call is no longer running!
}
}
不管任务是否执行成功，都执行分发起的finish方法
private <T> void finished(Deque<T> calls, T call) {
...
boolean isRunning = promoteAndExecute();
...
}
可以看到都会执行promoteAndExecute() 这样继续保证从等待队列里面去取任务给到运行中队列执行的机制。有没有感觉有点类似handler机制里面取消息。而把任务给到线程池调度会执行到runnable的run方法，run方法会执行RealCall的excute方法，
@Override protected void execute() {
try {
// 交给拦截器 请求并返回数据 再回调
Response response = getResponseWithInterceptorChain();
signalledCallback = true;
responseCallback.onResponse(RealCall.this, response);
} catch (IOException e) {
eventListener.callFailed(RealCall.this, e);
responseCallback.onFailure(RealCall.this, e);
} catch (Throwable t) {
cancel();
if (!signalledCallback) {
IOException canceledException = new IOException("canceled due to " + t);
responseCallback.onFailure(RealCall.this, canceledException);
}
throw t;
} finally {
client.dispatcher().finished(this);
}
}
拦截器
上面的分析是整个分发器的实现。这里就到了拦截器的实现了，拦截器用到了责任链模式。里面源码如下：
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));//添加socket连接拦截器
if (!forWebSocket) {
interceptors.addAll(client.networkInterceptors()); // 如果不是websockect 添加网络拦截器
}
interceptors.add(new CallServerInterceptor(forWebSocket)); // 添加与服务器通信协议
// 传入拦截器列表，返回拦截器链条
Interceptor.Chain chain = new RealInterceptorChain(interceptors, null, null, null, 0,
originalRequest, this, eventListener, client.connectTimeoutMillis(),
client.readTimeoutMillis(), client.writeTimeoutMillis());
// 调用链条的proceed方法返回response
Response response = chain.proceed(originalRequest);
if (retryAndFollowUpInterceptor.isCanceled()) {
closeQuietly(response);
throw new IOException("Canceled");
}
return response;
}
核心代码都加了注释。里面实现是通过index+1,不断取出下一个拦截器，并调用intercept方法。从链表头部到尾部的拦截器执行，等尾部拦截器返回response再一层一层返回到头部的拦截器。
Interceptor interceptor = interceptors.get(index);
Response response = interceptor.intercept(next);
由上面源码可以知道。第一个添加的是用户自定义的拦截器列表到链条列表里。如果在里面做一些逻辑，可能会影响后续添加拦截器执行。如果是非websockect 还会添加一个网络拦截器，这两个区别就是网络拦截器不一定执行，而用户自定义的会执行。网络的最先拿到response。分别介绍下各个拦截器作用
重试重定向：
主要调用recover方法判断是否能重试、重定向
判断client是否设置过不允许重试，请求发送出没请求体 是否是重试类型，比如证书失败 这种就不会给重试了，网络波动这种会重试
判断重定向逻辑也是先校验用户是否允许，匹配301 302 303这种取 头部的“location”继续重定向。最大重定向次数20次，参考了浏览器的实现
桥接拦截器：
这个拦截器主要是往头部添加压缩方式、内容长度、编码 cookie 添加UA 等处理头部信息
缓存拦截器：
这个拦截器的实现比较复杂，主要总结起来就是根据请求头、响应头决定当前的请求是否需要请求数据还是直接返回缓存，里面用到DiskLrucache策略，用户可以自定义缓存策略
连接拦截器：
RealConnection封装了socket和一个socket连接池 主要就是获取与目标服务器的连接，在连接上数据通信
关键代码在ConnectionPool中 最多保存 5个 处于空闲状态的连接，且连接的默认保活时间为 5分钟。 加一个connection 执行while (true) 执行clean方法，如果多了或者有超过5分钟异常最早的连接
主要工作就是负责建立 TCP 连接，建立 TCP 连接需要经历三次握手四次挥手等操作，如果每个 HTTP 请求都要新建一个 TCP 消耗资源比较多 而 Http1.1 已经支持 keep-alive ,即多个 Http 请求复用一个 TCP 连接，OKHttp 也做了相应的优化 这里用到享元模式
请求服务拦截器：
主要完成请求报文的封装与解析
框架常见问题总结
答案都在上面源码分析里面解释了，后面再继续补充下问题
1.添加网络拦截器和添加拦截器谁先执行 有什么区别，为什么
2.okhttp的连接池问题、拦截器、分发器核心逻辑是什么
连接池出现的背景：
频繁的进行建立Sokcet连接和断开Socket是非常消耗网络资源和浪费时间的，所以HTTP中的keepalive连接对于降低延迟和提升速度有非常重要的作用。keepalive机制是什么呢？也就是可以在一次TCP连接中可以持续发送多份数据而不会断开连接。
ConectionPool中维护了一个双端队列Deque 发起请求就会从当前连接池中get socket，如果没有就会创建并加进去，加进去就会触发清理 并返回下次清理的时间， 连接池最大可以存在5个连接 保留5分钟。
