okhttp拦截器之CacheInterceptor

最新推荐文章于 2021-08-05 19:09:36 发布
最新推荐文章于 2021-08-05 19:09:36 发布
阅读量347 收藏 1
点赞数 1
分类专栏： 学习笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/pxq10422/article/details/104784676
版权

1、背景

最近看了点http缓存相关点东西，之前看了下okhttp源码，但是看得一知半解，现在结合http缓存再看一次。

2、http缓存相关

2.1、http缓存的实现方式

http是通过header来控制缓存的，缓存方式分两种：

1、强制缓存

缓存是否过期不需要经过服务器确认，直接使用缓存。

实现方式： 响应包含Expires或者Cache-Control来指定响应过期时间，该有效时间内缓存可继续使用。Expires是http 1.0的字段，当两者同时存在时，优先使用Cache-Control。

2、协商缓存

缓存是否过期需要经过服务器确认

实现方式： 响应返回包含Last-Modified或者Etag的响应头。客户端请求时带上请求头If-Modified-Since或者If-None-Match，服务器进行对比后判断缓存是否可用，若缓存可用，则返回304状态码（此时响应不包含body），否者返回新的资源。Etag优先于Last-Modified。

  • Last-Modified：资源最后修改的时间
  • Etag：资源标志码

强制缓存优先于协商缓存。

2.2、http缓存相关指令
2.2.1、请求类
  • no-store：请求跟响应都不缓存
  • no-cache：忽略缓存，强制向源服务器请求
  • max-age(s)：响应的最大age值
  • max-stale(s)：可接受过期响应，但过期时间必须小于指定值，若不指定时间，则无限大
  • min-fresh(s)：可接受缓存刷新时间大于缓存age和min-fresh之和的缓存
  • only-if-cached：只从缓存里取
2.2.2、响应类
  • no-store：请求跟响应都不缓存
  • no-cache：缓存是否可用需要向服务器验证
  • public：任何用户都可缓存，如缓存服务器、cdn等
  • private：只有指定用户可以缓存，比如浏览器
  • must-revalidate：可缓存，但是需要跟源服务器确认，存在时忽略max-stale
  • max-age：响应的最大age值
  • s-maxage：缓存服务器响应的最大age值

3、CacheInterceptor分析

首先要使用缓存，必须要在初始化OkhttpClient时就设置好,默认是无缓存的：

/** Sets the response cache to be used to read and write cached responses. */
    public Builder cache(@Nullable Cache cache) {
      this.cache = cache;
      this.internalCache = null;
      return this;
    }

之后从缓存中取出缓存响应：

@Override public Response intercept(Chain chain) throws IOException {
    Response cacheCandidate = cache != null
        ? cache.get(chain.request())
        : null;

    long now = System.currentTimeMillis();
	//根据缓存和请求判断缓存是否可用
    CacheStrategy strategy = new CacheStrategy.Factory(now, chain.request(), cacheCandidate).get();
    Request networkRequest = strategy.networkRequest;
    Response cacheResponse = strategy.cacheResponse;

通过CacheStrategy.Factory来拿到缓存策略：

/** Returns a strategy to use assuming the request can use the network. */
    private CacheStrategy getCandidate() {
      // 没有缓存，直接返回
      if (cacheResponse == null) {
        return new CacheStrategy(request, null);
      }

      // https协议，但是缺乏tls握手
      if (request.isHttps() && cacheResponse.handshake() == null) {
        return new CacheStrategy(request, null);
      }
      
      //判断缓存和请求是否可用（根据缓存响应码且请求和缓存的Cache-Control不为no-store）
      if (!isCacheable(cacheResponse, request)) {
        return new CacheStrategy(request, null);
      }
	  //请求为no-cache或请求头包含If-Modified-Since或If-None-Match，则缓存不可用
      CacheControl requestCaching = request.cacheControl();
      if (requestCaching.noCache() || hasConditions(request)) {
        return new CacheStrategy(request, null);
      }
      
      //------处理强制缓存------
        
      //计算缓存到现在为止的存活时间
      long ageMillis = cacheResponseAge();
      //计算缓存有效期，根据max-age等
      long freshMillis = computeFreshnessLifetime();
	  //如果请求带有max-age，则取最小的
      if (requestCaching.maxAgeSeconds() != -1) {
        freshMillis = Math.min(freshMillis, SECONDS.toMillis(requestCaching.maxAgeSeconds()));
      }
      //请求带有min-fresh
       long minFreshMillis = 0;
      if (requestCaching.minFreshSeconds() != -1) {
        minFreshMillis = SECONDS.toMillis(requestCaching.minFreshSeconds());
      }
      
      //计算max-stale：缓存过期后仍然可用的时间
      long maxStaleMillis = 0;
      CacheControl responseCaching = cacheResponse.cacheControl();
      //请求带有max-stale且缓存不包含must-revalidate（会令max-stale无效）
      if (!responseCaching.mustRevalidate() && requestCaching.maxStaleSeconds() != -1) {
        maxStaleMillis = SECONDS.toMillis(requestCaching.maxStaleSeconds());
      }
        
      
      //响应带有no-cache时需要向服务器询问缓存是否可用
      //计算缓存是否可直接使用：缓存存活时间 + min-fresh < 缓存有效时间 + 缓存过期仍然有效的时间
      if (!responseCaching.noCache() && ageMillis + minFreshMillis < freshMillis + maxStaleMillis) {
        Response.Builder builder = cacheResponse.newBuilder();
        //如果缓存存活时间超过了有效时间，说明缓存过期了（max-stale生效）
        if (ageMillis + minFreshMillis >= freshMillis) {
          builder.addHeader("Warning", "110 HttpURLConnection \"Response is stale\"");
        }
        long oneDayMillis = 24 * 60 * 60 * 1000L;
        //缓存存活时间超过一天
        if (ageMillis > oneDayMillis && isFreshnessLifetimeHeuristic()) {
          builder.addHeader("Warning", "113 HttpURLConnection \"Heuristic expiration\"");
        }
        //缓存可直接使用
        return new CacheStrategy(null, builder.build());
      }
      
      //------处理协商缓存------
        
      //即处理ETag Last-Modified
      String conditionName;
      String conditionValue;
      //Etag/If-None-Match优先
      if (etag != null) {
        conditionName = "If-None-Match";
        conditionValue = etag;
      } else if (lastModified != null) {
        conditionName = "If-Modified-Since";
        conditionValue = lastModifiedString;
      } else if (servedDate != null) {
        conditionName = "If-Modified-Since";
        conditionValue = servedDateString;
      } else {
        return new CacheStrategy(request, null); // No condition! Make a regular request.
      }
      //添加上面的请求头进来
      Headers.Builder conditionalRequestHeaders = request.headers().newBuilder();
      Internal.instance.addLenient(conditionalRequestHeaders, conditionName, conditionValue);

      Request conditionalRequest = request.newBuilder()
          .headers(conditionalRequestHeaders.build())
          .build();
      //缓存需要经过服务器确认
      return new CacheStrategy(conditionalRequest, cacheResponse);
    }

拿到缓存策略CacheStrategy之后，如果参数networkRequest不为空，则说明需要进行网络请求。

/**
     * Returns a strategy to satisfy {@code request} using the a cached response {@code response}.
     */
    public CacheStrategy get() {
      CacheStrategy candidate = getCandidate();
	  //处理本地缓存无法直接使用或者没有缓存，而请求头又带有if-only-cache（只能用缓存）的情况
      if (candidate.networkRequest != null && request.cacheControl().onlyIfCached()) {
        // We're forbidden from using the network and the cache is insufficient.
        return new CacheStrategy(null, null);
      }

      return candidate;
    }

之后处理if-only-cache和缓存冲突的情况。这时已经处理完了缓存的所有情况。

CacheStrategy strategy = new CacheStrategy.Factory(now, chain.request(), cacheCandidate).get();
    //新的网络请求，可能带了请求头
    Request networkRequest = strategy.networkRequest;
    //响应缓存
    Response cacheResponse = strategy.cacheResponse;

    if (cache != null) {
      cache.trackResponse(strategy);
    }
    //如果缓存存在，但是不可用
    if (cacheCandidate != null && cacheResponse == null) {
      closeQuietly(cacheCandidate.body()); // The cache candidate wasn't applicable. Close it.
    }

    //only-if-cached的情况，即缓存不可用，但是必须从缓存读取，直接返回504错误码
    if (networkRequest == null && cacheResponse == null) {
      return new Response.Builder()
          .request(chain.request())
          .protocol(Protocol.HTTP_1_1)
          .code(504)
          .message("Unsatisfiable Request (only-if-cached)")
          .body(Util.EMPTY_RESPONSE)
          .sentRequestAtMillis(-1L)
          .receivedResponseAtMillis(System.currentTimeMillis())
          .build();
    }

    //networkRequest == null说明强制缓存生效，缓存可用
    if (networkRequest == null) {
      return cacheResponse.newBuilder()
          .cacheResponse(stripBody(cacheResponse))
          .build();
    }
    //否则说明是协商缓存或者无缓存，进行网络请求
    Response networkResponse = null;
    try {
      //责任链继续往后执行，向服务器请求并返回结果
      networkResponse = chain.proceed(networkRequest);
    } finally {
      ...
    }
  
    //cacheResponse != null说明是协商缓存
    if (cacheResponse != null) {
      //协商缓存返回304说明缓存依然有效,可以使用
      if (networkResponse.code() == HTTP_NOT_MODIFIED) {
        //更新本地缓存的headers
        Response response = cacheResponse.newBuilder()
            .headers(combine(cacheResponse.headers(), networkResponse.headers()))
            .sentRequestAtMillis(networkResponse.sentRequestAtMillis())
            .receivedResponseAtMillis(networkResponse.receivedResponseAtMillis())
            .cacheResponse(stripBody(cacheResponse))
            .networkResponse(stripBody(networkResponse))
            .build();
        networkResponse.body().close();
        ...
        //返回更新后的缓存
        return response;
      } else {
        closeQuietly(cacheResponse.body());
      }
    }
	//到这里说明无缓存或者协商缓存已经过期，服务器返回新的资源
    Response response = networkResponse.newBuilder()
        .cacheResponse(stripBody(cacheResponse))
        .networkResponse(stripBody(networkResponse))
        .build();
    //把新的响应缓存到本地
    if (cache != null) {
      if (HttpHeaders.hasBody(response) && CacheStrategy.isCacheable(response, networkRequest)) {
        // Offer this request to the cache.
        CacheRequest cacheRequest = cache.put(response);
        return cacheWritingResponse(cacheRequest, response);
      }

      if (HttpMethod.invalidatesCache(networkRequest.method())) {
        try {
          cache.remove(networkRequest);
        } catch (IOException ignored) {
          // The cache cannot be written.
        }
      }
    }
    //返回全新的响应
    return response;

缓存策略中networkRequest表示是否需要进行网络请求，cacheResponse表示缓存是否存在。分几种情况：

  1. networkRequest == null && cacheResponse == null 返回504错误（only-if-cached）
  2. networkRequest == null && cacheResponse != null 强制缓存，缓存生效
  3. networkRequest != null && cacheResponse != null 协商缓存，需要向服务器确认
  4. networkRequest != null && cacheResponse == null 无缓存，需要向服务器请求

4、总结

虽然看了不少网上资料但是都感觉解释得不太好，看得一知半解，代码也是边看边查资料再结合自己的理解分析下来的，还有许多不懂的地方。http相关的知识还是看书比较全面、靠谱。

impxq
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
OkHttp原理第六篇-CacheInterceptor
zjm807778317的博客
07-03 437
OkHttp的第六篇，本篇文章重点讲解Cache拦截器，并对Http协议中的缓存进行验证和分析。
OkHttp的源码分析（四）——缓存拦截器CacheInterceptor分析
ezview_uniview的博客
12-15 1109
继续上一篇文章，本文目的分析OkHttp的缓存流程，以及相关源码的学习，了解Http的缓存原理，以及OkHttp是如何缓存的
OKHTTP系列（六）--拦截器之CacheInterceptor缓存拦截器
freak_csh的博客
07-10 853
我们知道为了节省流量和提高响应速度，Okhttp是有自己的一套缓存机制的，CacheInterceptor就是用来负责读取缓存以及更新缓存的。 一、CacheInterceptor拦截器intercept(Chain chain)方法 /** Serves requests from the cache and writes responses to the cache. */ //从缓存中...
Okhttp之CacheInterceptor简单分析
菜鸟博客
06-15 5872
Oktttp 拦截器之CacheInterceptor简单分析
OKHTTP分享二缓存策略
a854702872的博客
01-02 2103
与缓存有关的Header Expires Expires: Thu, 12 Jan 2017 11:01:33 GMT 表示到期时间，一般用在response报文中，当超过此时间响应将被认为是无效的而需要网络连接，反之直接使用缓存 条件GET 客户端发送条件get请求，如果缓存是有效的，则返回304 Not Modifiled，否则才返回body。 ETag ETag是对资源文件的一种摘要，
okhttp拦截器
07-22
okhttp
Android OKHttp3拦截器的使用方法
01-20
本文介绍了Android OKHttp3拦截器的使用方法，分享给大家，具体如下： 添加Interceptor 在上一篇中我们已经知道了okhttp的基本使用，其中在介绍OkHttpClient初始化的时候，介绍了两种方式，第二种方式就可以对这个...
SeismicInterceptor:轻巧的OkHttp拦截器
03-26
地震拦截器 ，可通过摇动设备来显示OkHttp请求和响应数据中的日志。 将此添加到您的OkHttpClient设置中： OkHttpClient client = new OkHttpClient . Builder () .addInterceptor( SeismicInterceptor . create...
okhttp-awssigner:OkHttp拦截器，用于使用AWSv4签名对请求进行签名
05-01
OkHttp AWSv4 Signer拦截器它是什么？ Square的OkHttpClient的拦截器，用于对要求签名的AWS服务的请求进行签名。 该项目旨在遵循此处描述的AWSv4签名规范： ://docs.aws.amazon....
OKHttp系列十、CacheInterceptor缓存策略拦截器
haoyuegongzi的博客
12-12 208
1、主要作用： 让我们的客户端对同一个请求再次发起请求的时候可用节省时间。我们先看看在使用OK好的时候是如何实现缓存功能的： File cacheDir = new File("HttpResponseCache"); Cache cache = new Cache(cacheDir, 24 * 1024 * 1024); //缓存可用大小为24M OkHttpClient client = ne...
Android 中okhttp自定义Interceptor（缓存拦截器）
08-31
主要介绍了Android 中okhttp自定义Interceptor（缓存拦截器）的相关资料,需要的朋友可以参考下
OK HTTP(二)Okhttp的缓存拦截器CacheInterceptor
Applicaton的专栏
08-05 276
Okhttp的缓存拦截器CacheInterceptor okhttp 提供了 CacheInterceptor 来处理缓存 关于如何使用缓存请参考····· 下面我们分析下该拦截器的工作流程 流程分析 主要流程都在intercept 方法里 下面看代码 public final class CacheInterceptor implements Interceptor { final @Nullable // 注意观察 这里InternalCache InternalCac
OkHttp 源码分析(四)——CacheInterceptor
青风飘雨的博客
09-13 393
前面简单分析了retryAndFollowUpInterceptor和BridgeInterceptor这两个拦截器的处理流程，今天来分析Okhttp的第三个拦截器CacheInterceptor：缓存拦截器的代码逻辑。在上源码前，先来熟悉下关于http的缓存机制。 1、Http缓存机制 http大致可划分成两种缓存规则：1、强缓存；2、协商缓存。  强缓存 当客户端存在缓存数据时，再次发...
okhttp之CacheInterceptor
guo807015563的专栏
04-06 145
CacheInterceptor是okhttp中缓存拦截器，是负责http请求的缓存处理。当从上个拦截器中获取到http请求时，会从缓存里面取出对应的响应（之前缓存过的），如果没有，返回null。然后会根据request和获取到的缓存的response生成一个缓存策略CacheStrategy。 @Override public Response inte...
OkHttp3源码分析-缓存与CacheInterceptor
wfeii的博客
03-12 456
基本结构 CacheInterceptor依赖两个关键类，一个是CacheStrategy，一个是InternalCache。 CacheStrategy采用的是简单工厂模式（其实只是抽象工厂的特例），此类用于判定使用缓存，网络还是二者都使用。 InternalCache基本不会自己去设置，会使用Cache中的InternalCache的结构，而Cache实际上是通过DiskLruCache实现...
okhttp3缓存设置及拦截器的使用
weixin_42429629的博客
07-18 1922
缓存： 服务器支持缓存 如果服务器支持缓存，请求返回的Response会带有这样的Header:Cache-Control, max-age=xxx,这种情况下我们只需要手动给okhttp设置缓存就可以让okhttp自动帮你缓存了。这里的max-age的值代表了缓存在你本地存放的时间。 OkHttpClient okHttpClient = new OkHttpClient(); OkHt...
【Android】OkHttp系列(四)：缓存拦截器CacheInterceptor
大东的博客
02-13 540
该系列OkHttp源码分析基于OkHttp3.14.0版本 文章目录概述源码分析返回缓存缓存响应 概述 缓存响应以及返回之前的缓存的响应。整个拦截器可以分为两个部分，第一个部分为读取缓存，第二个部分为保存缓存。 需要注意的是，如果没有配置缓存管理的话，OkHttp是不会帮你缓存的，每次请求都会向服务器发起。但是OkHttp是自带了一个缓存管理的，一个名为Cache的类。不过在OkHttpClien...
关于Okhttp3（六）-CacheInterceptor
Red风信子的博客
10-08 175
现在的app没有几个是不联网的了，在流量费用很高、速度一般的今天给用户合理节省流量，以及提高响应速度就显得尤为重要了。所以一个优秀的app都会在发展到一定程度后就会开始引入缓存，什么是缓存呢？ 百度百科： 缓存就是数据交换的缓冲区（称作Cache），当某一硬件要读取数据时，会首先从缓存中查找需要的数据，如果找到了则直接执行，找不到的话则从内存中找。由于缓存的运行速度比内存快得多，故缓存的作用...
okhttp 拦截器
最新发布
11-16
OkHttp是一个用于处理HTTP请求的开源Java库。它提供了一个拦截器机制，可以在发送请求和接收响应之前对它们进行修改和处理。以下是关于OkHttp拦截器的一些介绍和示例： 1. OkHttp的拦截器是一个接口，它有一个方法intercept(Chain chain)，该方法接收一个Chain对象作为参数，该对象表示当前的拦截器链。 2. 拦截器链是按照添加顺序执行的，每个拦截器都可以选择将请求传递给下一个拦截器或者直接返回响应。 3. 拦截器可以在请求和响应中添加、修改或删除头信息，也可以重试请求或者记录请求和响应的日志等。 以下是一个简单的OkHttp拦截器示例，它会在请求头中添加一个自定义的User-Agent信息： ```java public class UserAgentInterceptor implements Interceptor { private static final String USER_AGENT_HEADER = "User-Agent"; private final String userAgent; public UserAgentInterceptor(String userAgent) { this.userAgent = userAgent; } @Override public Response intercept(Chain chain) throws IOException { Request request = chain.request(); Request newRequest = request.newBuilder() .header(USER_AGENT_HEADER, userAgent) .build(); return chain.proceed(newRequest); } } ``` 在上面的示例中，我们创建了一个名为UserAgentInterceptor的拦截器，它接收一个User-Agent字符串作为参数。在intercept方法中，我们首先获取当前的请求对象，然后使用Request.Builder添加一个自定义的User-Agent头信息，最后使用chain.proceed方法将请求传递给下一个拦截器或者返回响应。 以下是一个使用上面定义的拦截器的示例： ```java OkHttpClient client = new OkHttpClient.Builder() .addInterceptor(new UserAgentInterceptor("MyApp/1.0")) .build(); ``` 在上面的示例中，我们创建了一个OkHttpClient对象，并使用addInterceptor方法添加了一个UserAgentInterceptor拦截器。这样，在发送请求时，OkHttp会自动调用我们定义的拦截器，并在请求头中添加一个自定义的User-Agent信息。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值