OKHTTP相关文章虽然对，作为学习笔记使用，有问题希望能够尽情提出，共同交流
蒋八九

设计模式：

主要使用了建造者模式、责任链模式

简单使用

OkHttpClient okHttpClient = new OkHttpClient();                  //创建client对象
Request request = RequestBody.create(new MediaType(),jsonString);//post消息体
Request request = new Request.Builder().url(url).get().build();  //get请求
Request request = new Request.Builder().url(url).post(RequestBody.create(new MediaType(),jsonString)).build();                                //post请求
Call call = okHttpClient.newCall(request);                       //获取call，实体是realCall
Response response = call.execute();                              //同步阻塞
call.enqueue(new Callback()}                                     //异步提交

类的介绍

OkhttpClient：
主要封装dispatch调度器、自定义拦截器、代理、协议、连接池、读写超时时间等；
Dispatch：
client构造中创建的。其中有一个线程池（cacheSchesualThreadPool线程池）、一个运行中的同步队列runningAsyncCalls、一个运行中异步队列runningSyncCalls、一个等待异步队列readyAsyncCalls，最大运行中异步任务数：64个；同一个host访问上限数5个。

public final class Dispatcher {
  private int maxRequests = 64;                       同时提交的请求任务数量上限
  private int maxRequestsPerHost = 5;                 同时请求同一个服务器数量
  private @Nullable Runnable idleCallback;             
  private @Nullable ExecutorService executorService;  相当于cacheThreadPool线程池
  private final Deque<AsyncCall> readyAsyncCalls = new ArrayDeque<>(); 异步等待双向队列
  private final Deque<AsyncCall> runningAsyncCalls = new ArrayDeque<>();异步运行双向队列
  private final Deque<RealCall> runningSyncCalls = new ArrayDeque<>();  同步运行双向队列

Request：
主要封装请求方式、请求头、请求地址
Call call = okHttpClient.newCall(request)——>return RealCall.newRealCall(this, request, false)
其实就是将client和request封装到realcall对象中

static RealCall newRealCall(OkHttpClient client, Request originalRequest, boolean forWebSocket){
  //realcall中同时创建了RetryAndFollowUpInterceptor对象
RealCall call = new RealCall(client, originalRequest, forWebSocket); 
  call.eventListener = client.eventListenerFactory().create(call);   这个是http请求的监听器
  return call;
}

提交任务

提交同步任务

Response response = call.execute();
client.dispatcher().executed(this);
Response result = getResponseWithInterceptorChain();

提交异步任务

call.enqueue(new Callback()}
1、client.dispatcher().enqueue(new AsyncCall(responseCallback));
2、synchronized void enqueue(AsyncCall call) {
  if (runningAsyncCalls.size() < maxRequests && runningCallsForHost(call) < maxRequestsPerHost){
    runningAsyncCalls.add(call);  当前运行任务数小于64，服务器请求数小于5 入队
    executorService().execute(call); 交给cacheThreadPoll线程池进行子线程操作
  } else {
    readyAsyncCalls.add(call);   入异步等待队列
  }
}
3、最终在AyncCall类中的execute方法中执行拦截器方法
Response result = getResponseWithInterceptorChain();

Interceptor拦截器：

一共有6个拦截器1、retryAndFollowUpInterceptor；2、BridgeInterceptor；3、CacheInterceptor；4、ConnectInterceptor；5、networkInterceptors；6、CallServerInterceptor；

一、RetryAndFollowUpInterceptor重定向拦截器作用：

首先创建一个StreamAllocation对象，然后将执行response = realChain.proceed(request, streamAllocation, null, null);将责任链+1然后分发到抛向下一个BridgeInterceptor

二、BridgeInterceptor组装请求头拦截器：

如果有自定义的请求头head或者是mediaType会将其添加进去，如果没有的话，会自动补充完成，如(“Host”, “www.baidu.com”)(“Connection”, “Keep-Alive”)(“Location”, “重定向地址”)(“Accept-Encoding”, “gzip”)(“User-Agent”, userAgent)

三、CacheInterceptor缓存拦截器：

客户端缓存就是为了下次请求时节省请求时间，可以更快的展示数据

实现原理：

Last-Modified配合If-Modified-Since或者If-Unmodified-since使用：对比上次修改时间来验证是否使用缓存。步骤是：client第一次对资源发起请求时，server会设置Last-Modified的头信息，当浏览器再次对相同的资源发起请求时，浏览器会设置request的头部(chrome可以使用disable cache来禁止浏览器自动设置，这样每次都会去源服务器获取)，设置If-Modified-Since或者If-Unmodified-since的值为之前接收到的Last-Modified的值，这样，server每次取得头部信息If-Modified-Since或者If- Unmodified-since，与文件的修改时间进行对比，如果相同，就返回304Not Modified，client使用缓存，如果不相同，就返回更新后的资源。
Etag 数字签名配合If-Match或者If-None-Match使用：一般的数字签名可以对资源的内容进行hash计算，client第一次请求资源时，在 server中设置头部信息Etag，值为hash值，当浏览器再次对相同的资源发起请求时，浏览器会设置request的头部，设置If-Match或者If-None-Match的值为之前接收到的Etag的值，这样，server每次取得头部信息If-Match或者If-None-match，与重新计算的hash值进行对比，如果相同，就返回304Not Modified，client使用缓存，如果不相同，就返回更新后的资源。

使用方法：

//配置缓存的路径，和缓存空间的大小；这里用的是diskLruCache缓存机制
Cache cache = new Cache(new File("/Users/zeal/Desktop/temp"),10*10*1024);
Cache(File directory, long maxSize, FileSystem fileSystem) {
  this.cache = DiskLruCache.create(fileSystem, directory, VERSION, ENTRY_COUNT, maxSize);
}
从这可以看出底层用的是DiskLruCache缓存机制；
OkHttpClient okHttpClient = new OkHttpClient.Builder() .cache(cache).build();
CacheControl.Builder builder = new CacheControl.Builder();
builder.noCache();//不使用缓存，全部走网络
builder.noStore();//不使用缓存，也不存储缓存
builder.onlyIfCached();//只使用缓存
builder.noTransform();//禁止转码
builder.maxAge(10, TimeUnit.MILLISECONDS);//指示客户机可以接收生存期不大于指定时间的响应。
builder.maxStale(10, TimeUnit.SECONDS);//指示客户机可以接收超出超时期间的响应消息
builder.minFresh(10, TimeUnit.SECONDS);//指示客户机可以接收响应时间小于当前时间加上指定时间的响应。
CacheControl cache = builder.build();//cacheControl
Request request = new Request.Builder().url(url).cacheControl(builder).build();
自定义拦截器应用：
        OkHttpClient.Builder newBuilder = mOkHttpClient.newBuilder();
         newBuilder.addInterceptor(new Interceptor() {
            @Override
            public Response intercept(Chain chain) throws IOException {
                Request request = chain.request();
                boolean connected = NetworkUtil.isConnected(context);
                if (!connected) {
                    request = request.newBuilder().cacheControl(CacheControl.FORCE_CACHE).build();
                }
                Response response = chain.proceed(request);
                return response;
            }
        });

四、ConnectInterceptor连接拦截器：

连接拦截器主要工作就是找到一个可用的连接去连接服务器。主要要求对socket、http1、http2、https的理解
实现流程如下：
在拦截器中主要做了两件事：

HttpCodec httpCodec = streamAllocation.newStream(client, chain, doExtensiveHealthChecks);
RealConnection connection = streamAllocation.connection();

在newStream中主要做了三件事：

查找是否有健康的连接，仅在http2.0有用，如果没有将会实例化一个；
何为健康？
1.socket没有关闭
2.输入流没有关闭
3.输出流没有关闭
4.http2时连接没有关闭
实例化httpcodec，如果是http2.0实例化Http2Codec否则实例化Http1Codec
移除不健康的连接

RealConnection resultConnection = findHealthyConnection(connectTimeout, readTimeout,
    writeTimeout, pingIntervalMillis, connectionRetryEnabled, doExtensiveHealthChecks);
HttpCodec resultCodec = resultConnection.newCodec(client, chain, this);

noNewStreams();
在findHealthyConnection的流程：
1.上一个连接是否完好，是，直接使用
2.缓存中有没有可以用的，有，使用
3.自己创建
4.握手、连接

releasedConnection = this.connection;    //先复用上一次连接
  if (this.connection != null) {
    result = this.connection;
}
  if (result == null) {                 如果本地没有，那么就连接池connectionPool中获取一个
    Internal.instance.get(connectionPool, address, this, null);
    if (connection != null) {
      result = connection;
    } else {selectedRoute = route;} } }
..........
if (result != null) {
  return result;                               获取到了就return
}
if (selectedRoute == null && (routeSelection == null || !routeSelection.hasNext())) {
  routeSelection = routeSelector.next();      如果连接池中也没有，就从路由选择器中获取
}
synchronized (connectionPool) {
    List<Route> routes = routeSelection.getAll();
    遍历routes
      Internal.instance.get(connectionPool, address, this, route);
      if (connection != null) {
        result = connection;                    如果获取到了就返回
} 
  if (!foundPooledConnection) {                 到最后都没有找到的话就自己new一个
    result = new RealConnection(connectionPool, selectedRoute);   
    acquire(result, false);
  }}
result.connect(connectTimeout, readTimeout, writeTimeout, pingIntervalMillis,  
    connectionRetryEnabled, call, eventListener);  连接并握手
routeDatabase().connected(result.route());
synchronized (connectionPool) {
  Internal.instance.put(connectionPool, result);  最后将result添加到连接池中，方便下次复用
}
上面的result.connect()中
while (true) {
    if (route.requiresTunnel()) {                 如果是通道，则建立通道
      connectTunnel(connectTimeout, readTimeout, writeTimeout, call, eventListener);
    } else {                                      否正建立socket，就是最简单的那中建立
      connectSocket(connectTimeout, readTimeout, call, eventListener);
    }
建立http连接
    establishProtocol(connectionSpecSelector, pingIntervalMillis, call, eventListener);
    break;
}

五、CallServerInterceptor访问服务器拦截器：

Http发送网络请求前两个步骤是：

建立TCP链接：
客户端向web服务器发送请求命令：形如GET /login/login.jsp?username=android&password=123 HTTP/1.1的信息
这一步在connectInterceptor中完成；当建立socket连接时，同时生成BufferSource读和BufferSink 写输入和输出

httpCodec.writeRequestHeaders(request); 首先向web服务端发送请求命令；通过sink写
if (HttpMethod.permitsRequestBody(request.method()) && request.body() != null) {
 if ("100-continue".equalsIgnoreCase(request.header("Expect"))) {  对Expect请求头做了处理
  }
  if (responseBuilder == null) {                         如果是Expect请求头，把body写出去
    BufferedSink bufferedRequestBody = Okio.buffer(requestBodyOut);
    request.body().writeTo(bufferedRequestBody);}}
客户端向服务端发送的部分就结束了，剩下的就是送服务端读取了
responseBuilder = httpCodec.readResponseHeaders(false);  通过readResponseHeaders读取响应头
Response response = responseBuilder                      构建responseBuilder对象
    .request(request)
    .handshake(streamAllocation.connection().handshake())
    .sentRequestAtMillis(sentRequestMillis)
    .receivedResponseAtMillis(System.currentTimeMillis())
    .build();
  response = response.newBuilder()                        
      .body(httpCodec.openResponseBody(response))        
      .build();
最后通过openResponseBody方法将Socket的输入流InputStream对象交给OkIo的Source对象BufferedSource中，最后封装到RealResponseBody中返回
return new RealResponseBody(contentType, -1L, Okio.buffer(source));
最后在ResponseBody中提供了string()方法读取字符串
response.body().string()
public final String string() throws IOException {
  BufferedSource source = source();                           获取source输入流
  Charset charset = Util.bomAwareCharset(source, charset());  获取字符编码utf-8
  return source.readString(charset);                          将输入流转utf-8字符串输出
}

OKHTTP使用以及源码分析