Android网络编程（五）-由Okhttp看网络库

一、网络库选型

目前App开发网络库技术选型：

  • HttpClient： 在android 5.0就被从源码中移除了
  • HttpUrlConnection： 偏底层，不适合直接使用，封装起来也比较麻烦。
  • Volley：适合数据量小但是频繁的网络操作，对大文件下载表现糟糕。
  • Okhttp：目前主推的网络库，全面支持各种网络请求、文件上传下载；性能高效，底层线程池提高请求的复用性；优秀的代码设计。但是也需要进行二次封装。
  • Retrofit：对Okhttp的二次封装。

大部分公司要么自己封装一套Okhttp，要么直接用Retrofit，怎么样都需要先了解Okhttp。那么就选择用Okhttp来研究下网络库。
Okhttp项目地址：https://github.com/square/okhttp

二、OkHttp网络请求流程

从一个简单的异步GET请求开始：

File cacheDir = new File(MainActivity.this.getCacheDir(), "okhttpcache");//缓存目录
Cache mCache = new Cache(cacheDir, 8 * 1024 * 1024); //8M缓存空间
mOkHttpClient = new OkHttpClient.Builder()
        .connectTimeout(10, TimeUnit.SECONDS) //连接超时阈值
       .writeTimeout(10, TimeUnit.SECONDS) //写超时阈值
       .readTimeout(10, TimeUnit.SECONDS)  //读超时阈值
       .retryOnConnectionFailure(true) //当失败后重试
       .cache(mCache)
        .build();

String url = "https://www.baidu.com/img/bd_logo1.png";

CacheControl mCacheControl = new CacheControl.Builder()
        .noTransform()
        .maxAge(6, TimeUnit.SECONDS) //缓存有效期时长
       .build();

Request mRequest = new Request.Builder()
        .url(url)
        .method("GET",null)
        .cacheControl(mCacheControl)
        .build();

mOkHttpClient.newCall(mRequest).enqueue(new Callback() {
    @Override
   public void onFailure(@NotNull Call call, @NotNull IOException e) {
    }

    @Override
   public void onResponse(@NotNull Call call, @NotNull Response response) throws IOException {
        if (response.isSuccessful()) {
            byte[] bytes = response.body().bytes();
           final Bitmap bmp = BitmapFactory.decodeByteArray(bytes, 0, bytes.length);
           runOnUiThread(new Runnable() {
                @Override
               public void run() {
                    image.setImageBitmap(bmp);
               }
            });
       }
    }
});

上面代码效果是网络请求一张图片加载到ImageView，同时做了缓存。
下面来分析网络请求流程：

#OkHttpClient.java

public Builder() {
  dispatcher = new Dispatcher();//分发器
  ...
  connectionPool = new ConnectionPool();//连接池
  ...
}

先看构造方法，从命名看，一个分发器，一个连接池，mark下。继续看newCall方法

@Override public Call newCall(Request request) {
  return new RealCall(this, request);//实现类是RealCall
}

看下RealCall，execute是同步请求，enqueue是异步请求，那么重点看下enqueue：

#RealCall.java

void enqueue(Callback responseCallback, boolean forWebSocket) {
  synchronized (this) {
    if (executed) throw new IllegalStateException("Already Executed");
   executed = true;
  }
  client.dispatcher().enqueue(new AsyncCall(responseCallback, forWebSocket));
}

这里client.dispatcher()对应的正是OkHttpClient中的dispatcher，那么看看他的enqueue方法：

#Dispatcher.java

//ArrayDeque是数组实现的双端队列性能比LinkedList要好。
/** 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 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;
}

从线程池的配置看，就是一个CacheThreadPool。那么它支持高并发低耗时任务。

synchronized void enqueue(AsyncCall call) {
   //当正在运行的异步请求队列中的数量小于64并且正在运行的请求主机数小于5
  if (runningAsyncCalls.size() < maxRequests && runningCallsForHost(call) < maxRequestsPerHost) {
    runningAsyncCalls.add(call);
   executorService().execute(call);
  } else {
    readyAsyncCalls.add(call);
  }
}

当前AsyncCall满足条件后，异步执行队列添加，并交由线程池执行，否则添加到异步准备队列。执行就参考CacheThreadPool：当执行execute方法时，向SynchronousQueue提交任务，此时SynchronousQueue需要移除一个任务去被执行，如果此时有空闲线程则交给空闲线程处理，没有则新建线程处理。空闲线程超过60s没被使用则回收。

线程池中传进来的参数就是AsyncCall它是RealCall的内部类，内部也实现了execute方法：

#RealCall.java

@Override protected void execute() {
boolean signalledCallback = false;
  try {
    Response response = getResponseWithInterceptorChain(forWebSocket);
   if (canceled) {
      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 {
      responseCallback.onFailure(RealCall.this, e);
   }
  } finally {
    client.dispatcher().finished(this);
  }
}

这部分主要是获取response以及callback回调。重点关注getResponseWithInterceptorChain：

private Response getResponseWithInterceptorChain(boolean forWebSocket) throws IOException {
  Interceptor.Chain chain = new ApplicationInterceptorChain(0, originalRequest, forWebSocket);
  return chain.proceed(originalRequest);
}

创建了ApplicationInterceptorChain，它是一个拦截器链。拦截器的作用就是：可以在应用拿到response之前，先获得response，对其中某些数据进行监控，在有必要的情况下，对response的某些内容（比如response的header，body，response内的request的header，body）进行更改。

ApplicationInterceptorChain 

public Response proceed(Request request) throws IOException {
    if (this.index < Call.this.client.interceptors().size()) {
        Chain chain = Call.this.new ApplicationInterceptorChain(this.index + 1, request, this.forWebSocket);
       Interceptor interceptor = (Interceptor)Call.this.client.interceptors().get(this.index);
       Response interceptedResponse = interceptor.intercept(chain);
       if (interceptedResponse == null) {
            throw new NullPointerException("application interceptor " + interceptor + " returned null");
       } else {
            return interceptedResponse;
       }
    } else {
        return Call.this.getResponse(request, this.forWebSocket);
   }
}

最终都会返回response，那么直接来看看getResponse方法:

#Call.java

Response getResponse(Request request, boolean forWebSocket) throws IOException {
...
   // Create the initial HTTP engine. Retries and redirects need new engine for each attempt.
   engine = new HttpEngine(client, request, false, false, forWebSocket, null, null, null);
   int followUpCount = 0;
   while (true) {
     if (canceled) {
       engine.releaseStreamAllocation();
       throw new IOException("Canceled");
     }
     boolean releaseConnection = true;
     try {
       engine.sendRequest();
       engine.readResponse();
       releaseConnection = false;
     } catch (RequestException e) {
       // The attempt to interpret the request failed. Give up.
       throw e.getCause();
     } catch (RouteException e) {
       // The attempt to connect via a route failed. The request will not have been sent.
        HttpEngine retryEngine = engine.recover(e.getLastConnectException(), null);
       if (retryEngine != null) {
          releaseConnection = false;
          engine = retryEngine;
          continue;
     }
 ...    
   }
 }

这里网络请求和响应的核心逻辑封装在HttpEngine中。两个关键方法：sendRequest() 和 readResponse()，发送请求与接收响应。另外这里要注意：当发生IOException或者RouteException时会执行HttpEngine的recover方法，该方法实现失败重连。

Call 的execute同步逻辑就不分析了。

整体流程如下图所示：

三、Okhttp缓存策略

上节讲到HttpEngine，来看下sendRequest方法，作用是发送请求，逻辑中包含了缓存策略，所以先来简单了解下Http缓存相关知识点。

3.1Http缓存机制

http有强制和对比两种缓存方式：

  • 强制缓存：在有效时间内直接获取本地缓存。对应有俩请求头参数
    Cache-Control
    在请求中使用Cache-Control 时，它可选的值有：

    在响应中使用Cache-Control 时，它可选的值有：


Expires: 过期时间
超过过期时间需要重新请求服务器

  • 对比缓存：先获取本地缓存数据标识，然后请求服务器确认缓存数据是否失效，如果没失效返回304，则直接使用标识对应的本地缓存，如果失效，服务器会返回新的数据再缓存起来。

ETag：缓存数据标识
If-None-Match：向服务器发请求时加的flag。 例如：If-None-Match:1ec5-502264e2ae4c0
Last-Modified: 由服务器返回，表示响应的数据最近修改的时间。
If-Modified-Since：由客户端请求，表示询问服务器这个时间是不是上次修改的时间。如果服务端该资源的修改时间小于等于If-Modified-Since指定的时间，说明资源没有改动，返回响应状态码304，可以使用缓存。如果服务端该资源的修改时间大于If-Modified-Since指定的时间，说明资源又有改动了，则返回响应状态码200和最新数据给客户端，客户端使用响应返回的最新数据。

3.2 Http缓存规则：

好，那么来看Okttp是怎么做缓存策略的，还是拿开头的GET请求小例子，我截取了缓存部分的内容：

File cacheDir = new File(MainActivity.this.getCacheDir(), "okhttpcache");//缓存目录
Cache mCache = new Cache(cacheDir, 8 * 1024 * 1024); //8M缓存空间
mOkHttpClient = new OkHttpClient.Builder()
       .cache(mCache)

CacheControl mCacheControl = new CacheControl.Builder()
        .noTransform()
        .maxAge(6, TimeUnit.SECONDS) //缓存有效期时长
       .build();

Request mRequest = new Request.Builder()
       .cacheControl(mCacheControl)

生成的缓存文件：

/data/data/com.stan.okhttpdemo/cache/okhttpcache # ls -al
total 56
drwx------ 2 u0_a138 u0_a138 4096 2019-11-23 10:50 .
drwxrwx--x 3 u0_a138 u0_a138 4096 2019-11-23 10:50 ..
-rw------- 1 u0_a138 u0_a138 6677 2019-11-23 10:50 5f8dcf06d74b796a51269303a0d2e07b.0
-rw------- 1 u0_a138 u0_a138 7877 2019-11-23 10:50 5f8dcf06d74b796a51269303a0d2e07b.1
-rw------- 1 u0_a138 u0_a138  124 2019-11-23 10:50 journal

cat 5f8dcf06d74b796a51269303a0d2e07b.0

GET
0
HTTP/1.1 200 OK
14
Accept-Ranges: bytes
Cache-Control: max-age=315360000
Connection: Keep-Alive
Content-Length: 7877
Content-Type: image/png
Date: Sat, 23 Nov 2019 02:50:48 GMT
Etag: "1ec5-502264e2ae4c0"
Expires: Tue, 20 Nov 2029 02:50:48 GMT
Last-Modified: Wed, 03 Sep 2014 10:00:27 GMT

好，了解这些之后，咱们再来看HttpEngine的两个方法。

public final class HttpEngine {
...
public void sendRequest(){//读缓存or网络请求
   先查找是否有可用的Cache，然后通过Cache找到请求对应的缓存，然后将请求和缓存交给缓存策略去判断使用请求还是缓存，
得出结果后，再判断使用缓存还是请求，如果使用缓存，用缓存构造响应直接返回，如果使用请求，那么开始网络请求流程。
}
...
public void readResponse(){//读取网络响 、存储缓存
   读取响应，然后存储缓存：
   如上面文件介绍
   通过maybeCache缓存头部信息到：/data/data/com.stan.okhttpdemo/cache/okhttpcache/ 5f8dcf06d74b796a51269303a0d2e07b.0
  通过cacheWritingResponse 缓存响应体信息到：/data/data/com.stan.okhttpdemo/cache/okhttpcache/ 5f8dcf06d74b796a51269303a0d2e07b.1
  缓存只支持GET请求方式。
  最后写文件保存通过DiskLruCache，按照LRU这种最近最少使用删除的原则，当总的大小超过限定大小后，删除最近最少使用的缓存文件。
   缓存空间指定Cache mCache = new Cache(cacheDir, 8 * 1024 * 1024); //8M缓存空间
}

缓存具体源码分析可以参考：https://www.jianshu.com/p/00d281c226f6

四、Okhttp复用连接池

通常我们进行HTTP连接网络的时候我们会进行TCP的三次握手，然后传输数据，然后再四次挥手释放连接。但是大量连接每次连接关闭都要三次握手四次分手很显然性能低下。因此http有一种叫做keepalive connections的机制，它可以在传输数据后仍然保持连接，当客户端需要再次获取数据时，直接使用刚刚空闲下来的连接而不需要再次握手。在HTTP1.1中缺省就是支持keepalive的。

image.jpeg
  • 非keepalive connections:

  • keepalive connections:

在前面OkhttpClient的Builder中我还提到过一个类：ConnectionPool。

public final class ConnectionPool {
   //类似CachedThreadPool的线程池，用于执行清理空闲连接
   private static final Executor executor = new ThreadPoolExecutor(0 /* corePoolSize */,
     Integer.MAX_VALUE /* maximumPoolSize */, 60L /* keepAliveTime */, TimeUnit.SECONDS,
     new SynchronousQueue<Runnable>(), Util.threadFactory("OkHttp ConnectionPool", true));
   //最大的空闲socket连接数
   private final int maxIdleConnections;
   //socket的keepAlive时间
   private final long keepAliveDurationNs;
   //Deque维护了一个队列，RealConnection是socket物理连接
   private final Deque<RealConnection> connections = new ArrayDeque<>();
   final RouteDatabase routeDatabase = new RouteDatabase();
   boolean cleanupRunning;

  public ConnectionPool() {
...
  //默认空闲的socket最大连接数为5个，socket的keepAlive时间为5分钟
    this(5, 5, TimeUnit.MINUTES);
  }
}
...
}

连接池复用的核心就是用Deque<RealConnection>来存储连接，通过put、get、connectionBecameIdle和evictAll几个操作来对Deque进行操作，另外通过判断连接中的计数对象StreamAllocation来进行自动回收连接。

复用连接池具体源码分析可以参考：https://www.jianshu.com/p/ea1587646750

参考：
http://liuwangshu.cn/application/network/8-okhttp3-sourcecode2.html
http://liuwangshu.cn/application/network/7-okhttp3-sourcecode.html
https://blog.csdn.net/qq_29152241/article/details/82011539
https://www.jianshu.com/p/00d281c226f6
https://blog.csdn.net/u012375924/article/details/82806617
https://www.jianshu.com/p/ea1587646750

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 206,126评论 6赞 481
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 88,254评论 2赞 382
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 152,445评论 0赞 341
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 55,185评论 1赞 278
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 64,178评论 5赞 371
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 48,970评论 1赞 284
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 38,276评论 3赞 399
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 36,927评论 0赞 259
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 43,400评论 1赞 300
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,883评论 2赞 323
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 37,997评论 1赞 333
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,646评论 4赞 322
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 39,213评论 3赞 307
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 30,204评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,423评论 1赞 260
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 45,423评论 2赞 352
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,722评论 2赞 345

推荐阅读更多精彩内容