okhttp网络框架源码解析

最新推荐文章于 2021-08-11 16:54:04 发布

哆啦A梦z

最新推荐文章于 2021-08-11 16:54:04 发布

阅读量183

点赞数

分类专栏：框架源码解析文章标签：源码解析

本文链接：https://blog.csdn.net/zx_android/article/details/113124030

版权

框架源码解析专栏收录该内容

5 篇文章 0 订阅

订阅专栏

一、okhttp使用方法总结

1、创建OkHttpClient和Request对象
2、将Request封装成Call对象（ Call call = client.newCall(request)）
3、调用call的enqueue（异步）或execute（同步）发送请求

        OkHttpClient.Builder builder = new OkHttpClient.Builder();

        OkHttpClient client = new OkHttpClient.Builder().readTimeout(5, TimeUnit.SECONDS).build();
        Request request = new Request.Builder().url("www.baidu.com").get().build();
        Call call = client.newCall(request);
        call.enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {

            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {

            }
        });

二、okhttp请求需要注意

同步请求，当前线程就会进入阻塞状态，直到收到响应
异步请求，会开启一个新的子线程，请求成功后返回主线程，回调onResponse和onFailure，
onResponse和onFailure都是在子线程中执行的，如需更新UI，需切换到主线程

具体请求流程同步和异步的区别：

在这里插入图片描述

三、异步、同步的执行流程和源码分析

1、OkHttpClient创建
OkHttpClient创建采用的是Builder模式创建。当需要初始化很多的参数的时候，可以使用该模式。
里面有2个参数需要注意：
dispatcher（分发器）：保存请求和移除请求。
connectionPool（连接池）：缓存请求，第二次请求就从缓存中取。

2、Request创建
OkHttpClient创建采用的是Builder模式创建，初始化url，header和请求参数

3、Call创建
通过OkHttpClient和Request构建出Call对象
call的创建调用newCall方法，其实是在其实现类RealCall中创建，RealCall构造方法中持有了OkHttpClient和Request对象。（其实RealCall只是个空壳，最终还是调用了Dispatcher中的方法。）

4、执行请求（前三步都没有真正的发起网络请求，只是做了一些请求的准备）
同步请求源码(call.execute )：

//判断当前call是否只执行了一次，如果不是就会抛出异常 
if (executed) throw new IllegalStateException("Already Executed");
      executed = true;
//通过dispatcher把请求加入到请求队列中
client.dispatcher().executed(this);

异步请求源码(call.enqueue)：

//判断当前call是否只执行了一次，如果不是就会抛出异常 
if (executed) throw new IllegalStateException("Already Executed");
      executed = true;
/* 通过传入的callback对象，封装成了一个AsyncCall对象（就是一个runnable）
最后发起异步请求，首先会判断当前正在请求的请求数量是否小于请求最大值（64个），当前请求的host是否小于最大的请求host（5个），
    如果满足这2个条件，该请求就会添加到 正在执行的异步请求队列（runningAsyncCalls）中，然后通过线程池执行这个call请求。
    如果不是，就会添加到等待队列（readyAsyncCalls）中。*/
client.dispatcher().enqueue(new AsyncCall(responseCallback));

四、异步的流程和源码分析（二）

Response对象是通过一个拦截链返回的
异步总结：
1、创建一个OkHttpClient对象
2、构建Request对象，通过OkHttpClient和Request构建出Call对象
3、执行call的enqueue方法添加请求到调度器中，由于是异步的，需要注入一个CallBack对象

在异步中要注意Dispather类，它有3个重要的东西：
readyAsyncCalls 等待执行异步任务的队列
runningAsyncCalls 正在执行异步任务的队列
线程池

不管同步异步OkHttp真正的网络请求还是Dispatcher和拦截器链来进行操作的。
它们也是OkHttp中最重要的2个核心。

下节先讲Dispatcher，然后讲拦截器链

五、OkHttp任务调度：Dispatcher源码解析

1、OkHttp任务调度
发送的同步、异步请求都会在dispatcher中管理

2、到底什么是dispatcher
dispatcher的作用是：维护请求的状态，维护一个线程池用于执行请求。

Dispatcher中有3个集合和1个线程池比较重要：

  /** 线程池执行请求*/
  private @Nullable ExecutorService executorService;

/**异步等待队列*/
  private final Deque<AsyncCall> readyAsyncCalls = new ArrayDeque<>();

  /** 正在执行的异步请求队列.（包含已取消的请求） */
  private final Deque<AsyncCall> runningAsyncCalls = new ArrayDeque<>();

  /** 正在执行的同步请求队列 （包含已取消的请求）*/
  private final Deque<RealCall> runningSyncCalls = new ArrayDeque<>();

每当有新的请求到达dispatcher中时，
同步请求会直接调用runningSyncCalls.add(call) 加到同步队列中。
而异步请求会判断当前正在请求的请求数量是否小于请求最大值（64个），当前请求的host是否小于最大的请求host（5个）；
如果满足这2个条件，该请求就会添加到正在执行的异步请求队列（runningAsyncCalls）中，然后通过线程池执行这个call请求。
如果不是，就会添加到等待队列（readyAsyncCalls）中。

请求结束之后会调用dispatcher中的finished方法：
1、把请求从队列中删除
2、在同步代码块中调整异步请求队列（为了保证线程安全，所以在同步代码块中调整）
promoteCalls()：遍历readyAsyncCalls ，把请求从readyAsyncCalls 中删除，然后添加到runningAsyncCalls
3、重新计算正在执行的线程数量（正在执行的异步数量+正在执行的同步数量）

六、OkHttp拦截器解析

官网定义：
拦截器是OkHttp中提供的一种强大机制，可以实现网络监听、请求以及响应重写、请求失败重试等功能，是不管同步还是异步都是使用到拦截器。

当发送一个请求，okhttp内部会通过一个拦截器链来执行请求，分别是：
RetryAndFollowUpInterceptor：重试和重定向请求
BridgeInterceptor：将request请求转化为能够进行网络访问的请求（添加http的请求头）
CacheInterceptor：缓存拦截器
下面两个是核心的拦截器：
ConnectInterceptor：负责建立可用的连接
CallServerInterceptor：发送请求和读取响应

发起一个请求会执行到RealCall的此方法获取Response
Response result = getResponseWithInterceptorChain();

OkHttp拦截器总结1：
1、创建一系列拦截器，并将其放入一个拦截器list中
2、创建一个拦截器链RealInterceptorChain，并执行拦截器的proceed方法

proceed方法的核心是创建下一个拦截器链，构造方法中传入的是index+1,这样就会依次调用下一个拦截器的Response response = interceptor.intercept(next);方法，这样就完整的构成了一个拦截器链。

那么拦截器都是怎么衔接的呢？
内部的intercept方法中执行了拦截器链的proceed方法，
proceed方法内部会执行下一个拦截器的intercept方法。整个拦截器链就完整的交替执行，最终可以把所有的拦截器都做完，这就是拦截器的核心逻辑。

OkHttp拦截器总结2（核心逻辑，要弄懂拦截器链，为什么要调用下一个拦截器）：
1、在发起请求前对request进行处理
2、调用下一个拦截器，获取Response（因为只有调用下一个拦截器，才能构成链条）
3、对Response进行处理，返回给上一个拦截器

具体的拦截器解析：

只要当所有的拦截器执行完后，才会返回Response

1、RetryAndFollowUpInterceptor：失败重连只有20次。

1、创建StreamAllocation对象：为了获取服务端的connection连接和输入输出流。
2、调用RealInterceptorChain.proceed进行网络请求
3、根据响应结果判断是否要重新请求
4、调用下一个拦截器，对response进行处理，返回给上一个拦截器

比如：
CacheInterceptor返回的Response交给拦截器链前面的一个拦截器,即BridgeInterceptor来处理

2、BridgeInterceptor：设置内容长度和编码方式，主要是添加请求头Header，让它成为一个可以发送网络请求的request

1、负责将request请求转化为能够进行网络访问的请求
2、将这个符合网络请求的request进行网络请求
3、如果客户端支持gzip压缩，服务端会返回支持Gzip压缩的Response，转化为用户可用的Response

3、CacheInterceptor：

想要了解CacheInterceptor必须要先知道缓存策略。

OkHttp缓存策略（put和get方法）源码分析：
put和get数据都是从Entry对象里面获取的。

put方法：
DiskLruCahce缓存算法是核心，只缓存GET请求，写到磁盘上
先Md5加密处理，然后转为二进制

为什么只缓存get请求，不缓存post请求？

因为OkHttp缓存的是整个http请求的信息，所以这就和http协议有关系了。在RESTful API里面，我们把Get请求理解为从服务端查询数据，Post请求理解为更新服务端数据，而http协议里面缓存通常只适用于Get请求，为什么只适应Get请求？我们都知道Get请求url结合提交参数是唯一标示，而Post请求的参数是在http的body体里面，是可变的，无法成为唯一的标示。

post请求缓存我们可以手动缓存到文件中，利用disklrucache缓存

get方法：
解密Md5得到key，根据key值从缓存中获取

下面是重头戏：CacheInterceptor 缓存拦截器

okhttp中的缓存策略有强制缓存和对比缓存：

强制缓存，即缓存在有效期内就直接返回缓存，不进行网络请求。
对比缓存，即缓存超过有效期，进行网络请求。若数据未修改，服务端返回不带body的304响应，表示客户端缓存仍有效可用；否则返回完整最新数据，客户端取网络请求的最新数据。

okhttp利用CacheStrategy对象中的networkRequest和cacheResponse来判断执行什么策略：

  /** The request to send on the network, or null if this call doesn't use the network. */
  public final @Nullable Request networkRequest;

  /** The cached response to return or validate; or null if this call doesn't use a cache. */
  public final @Nullable Response cacheResponse;

通过注释可以知道networkRequest是否为空决定是否请求网络，cacheResponse是否为空决定是否使用缓存

有4种组合情况（这里先了解对应结论，后面再分析生成规则）：

networkRequest、cacheResponse均为空，构建返回一个状态码为504的response；
networkRequest为空、cacheResponse不为空，执行强制缓存
networkRequest、cacheResponse均不为空，执行对比缓存
networkRequest不为空、cacheResponse为空，网络请求获取到最新response后，视情况缓存response

总结

okhttp中缓存机制实现大致流程是先判断执行强制缓存策略，不执行则请求服务端获取数据，然后判断执行对比缓存策略，接着更新缓存或新增缓存，最后返回response到上层拦截器。

4、ConnectInterceptor和连接池：打开于服务器的连接，正式开启网络请求

StreamAllocation在RetryAndFollowUpInterceptor里面初始化，在ConnectInterceptor才真正的使用，

//1、ConnectInterceptor获取Inteceptor传过来的StreamAllocation
    StreamAllocation streamAllocation = realChain.streamAllocation();
    HttpCodec httpCodec = streamAllocation.newStream(client, doExtensiveHealthChecks);
    RealConnection connection = streamAllocation.connection();
//将创建的用于网络IO的RealConnection对象以及于服务器交互最关键的HttpCodec传递给后面的拦截器
    return realChain.proceed(request, streamAllocation, httpCodec, connection);

下面看下newStream方法
1、生成RealConnection 来进行网络连接
2、通过RealConnection 来生成HttpCodec 对象

newStream调用findHealthyConnection，findHealthyConnection调用findConnection

findConnection才是核心，我们看它具体做了什么
它会尝试获取RealConnection ，可以复用就复用，不能复用就从连接池（connectionPool）中获取新的RealConnection ，最后把新的RealConnection 放入连接池中。

在RealConnection的connect()的方法里面判断是隧道连接还是普通连接，如果是隧道连接就走connectTunnel()，如果是普通连接则走connectSocket()，

总结：
1、得到一个RealConnection（它代表实际的网络请求）对象
2、选择不同的连接方式（隧道连接或socket连接）
3、当ConnectInterceptor都完成后，最后会调用CallServerInterceptor完成整个OKhttp请求操作。

5、连接池(ConnectionPool)：复用连接的作用

服务端和客户端把网络连接抽象成了一个connection类，而RealConnection是它的真正实现。
get方法和put方法：从连接池connections中遍历获取connection和add到connections中

连接池总结：
1、每一次请求都会产生一个StreamAllocation对象
2、StreamAllocation对象的弱引用添加到RealConnection的allocations集合
3、从连接池中获取连接

如何回收connection ？
1、利用了GC的回收算法
2、StreamAllocation的数量渐渐的变为0的时候会被线程池监测到，然后进行回收，这样就可以保持多个健康的keep-alive连接

6、CallServerInterceptor（发送请求和读取响应两大工作）
最后一个拦截器它会获取到：


重要的一共有5步(不用刻意记方法名，知道这个步骤顺序就好了)：

//1、写入请求的头部信息
httpCodec.writeRequestHeaders(request);
//2、写入请求的Body信息
request.body().writeTo(bufferedRequestBody);
//3、完成了网络请求的写入工作
httpCodec.finishRequest();

写完了，就要读了
//4、读取响应头部信息
httpCodec.readResponseHeaders(false);
//5、读取响应Body信息
response = response.newBuilder()
          .body(httpCodec.openResponseBody(response))
          .build();

HttpCodec：编码Request和解码Response

最后总结Okhttp：OkHttp中一次网络请求的大致过程：

1、获取Call对象
2、diapatcher对请求的分发
3、getResponseWithInterceptors方法（这个方法就是拦截器链：5个拦截器）

LruCache和DisLruCache的区别

LruCache内部是通过LinkedHashMap来完成。
LinkedHashMap也是一个HashMap,但是内部维持了一个双向链表,可以保持顺序

核心思想是当缓存满时，会优先淘汰那些近期最少使用的缓存对象。
采用LRU算法的缓存有两种：LrhCache和DisLruCache，分别用于实现内存缓存和硬盘缓存，其核心思想都是LRU缓存算法。

主要算法原理是把最近使用的对象存储在 LinkedHashMap 中。
当缓存满时，把最近最少使用的对象从内存中移除，并提供了get和put方法来完成缓存的获取和添加操作。

缓存图片步骤：
①设置LruCache缓存的大小，一般为当前进程可用容量的1/8。
②重写sizeOf方法，计算出要缓存的每张图片的大小。

三、LruCache的实现原理
LruCache的核心思想很好理解，就是要维护一个缓存对象列表，其中对象列表的排列方式是按照访问顺序实现的，即一直没访问的对象，将放在队尾，即将被淘汰。而最近访问的对象将放在队头，最后被淘汰。

那么这个队列到底是由谁来维护的，前面已经介绍了是由LinkedHashMap来维护。

而LinkedHashMap是由数组+双向链表的数据结构来实现的。其中双向链表的结构可以实现访问顺序和插入顺序，使得LinkedHashMap中的<key,value>对按照一定顺序排列起来。

LruCache巧妙实现，就是利用了LinkedHashMap的这种数据结构。

总结：
LruCache中维护了一个集合LinkedHashMap，该LinkedHashMap是以访问顺序排序的。当调用put()方法时，就会在结合中添加元素，并调用trimToSize()判断缓存是否已满，如果满了就用LinkedHashMap的迭代器删除队尾元素，即近期最少访问的元素。当调用get()方法访问缓存对象时，就会调用LinkedHashMap的get()方法获得对应集合元素，同时会更新该元素到队头。

作者：Ruheng
链接：https://www.jianshu.com/p/b49a111147ee

DiskLruCache是square公司一个开源框架，是磁盘缓存

https://github.com/JakeWharton/DiskLruCache
优酷是今日头条就是用的这个缓存数据到本地。

使用：
1、DiskLruCache.open初始化对象
2、DiskLruCache.get方法获取缓存数据
3、DiskLruCache.Editor将数据保存到本地

放在data/data/包名/cache文件夹中，在app卸载后，这个数据也会被清除掉。

第三方库在使用的时候，一般都会封装一下，这样的话，后期第三方库改变了，不会影响到我们的逻辑。

DiskLruCache和LruCache内部都是使用了LinkedHashMap去实现缓存算法的，
只不过前者针对的是将缓存存在本地，而后者是直接将缓存存在内存；

哆啦A梦z

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
okhttp网络框架源码解析

一、okhttp使用方法总结1、创建OkHttpClient和Request对象2、将Request封装成Call对象（ Call call = client.newCall(request)）3、调用call的enqueue（异步）或execute（同步）发送请求 OkHttpClient.Builder builder = new OkHttpClient.Builder(); OkHttpClient client = new OkHttpClient.Bu.
复制链接

扫一扫