缓存控制

浏览器 HTTP 协议缓存机制详解

确实很详细
缓存Cache详解

先前对http缓存的主要疑惑在于:

几个相关消息头的优先级顺序是怎样的?
请求中的字段对响应中的字段有什么影响或者有什么关系?

1473210330067_4.png

1473210326874_2.png

优先级顺序:
Cache-Control > Expires > ETag > Last-Modified

安卓app作为一个客户端,没必要精细地执行http协议.要自由地完全地由客户端控制缓存,那么就只控制Cache-Control.

cache-control的相关值有如下这些:

值可以是public、private、no-cache、no- store、no-transform、must-revalidate、proxy-revalidate、max-age
各个消息中的指令含义如下：
Public指示响应可被任何缓存区缓存。
Private指示对于单个用户的整个或部分响应消息，不能被共享缓存处理。这允许服务器仅仅描述当用户的部分响应消息，此响应消息对于其他用户的请求无效。
no-cache指示请求或响应消息不能缓存，该选项并不是说可以设置”不缓存“，容易望文生义~
no-store用于防止重要的信息被无意的发布。在请求消息中发送将使得请求和响应消息都不使用缓存，完全不存下來。
max-age指示客户机可以接收生存期不大于指定时间（以秒为单位）的响应。
min-fresh指示客户机可以接收响应时间小于当前时间加上指定时间的响应。
max-stale指示客户机可以接收超出超时期间的响应消息。如果指定max-stale消息的值，那么客户机可以接收超出超时期指定值之内的响应消息。
must-revalidate — 响应在特定条件下会被重用，以满足接下来的请求，但是它必须到服务器端去验证它是不是仍然是最新的。
proxy-revalidate — 类似于 must-revalidate,但不适用于代理缓存.

app中可能出现的缓存控制需求场景

请求头

如果不想从缓存中读取,就在请求头中设置no-cache,如此就可以强制访问网络而不读取缓存.

读取缓存有效期内的缓存: 请求头里设置max-age.
设置了这个之后,就去缓存里找,找到了缓存文件,而且文件里的有效期又在这个之内,那么就读取缓存.如果过期,就去访问网络.

强制读取缓存(比如在没有网络的情况下),而不管有没有过期: 设置max-age为一个非常大的值,比如几百年以后

响应

本来,响应头里的字段是服务器写的,但一般post请求甚至get请求,服务器都会直接返回no-cache,为了实现完全的客户端缓存的自我控制,拿到响应对象后,将里面响应头里Cache-Control字段值改成我们需要的值就行了.

如果不想缓存这个响应数据,设置为no-cache.

需要注意的

网络框架至少需要支持Cache-Control字段的逻辑

response对象中需要有一个字段标识其是由缓存中生成的还是网络拉取的,便于修改Cache-Control字段值时只修改网络返回的.

volley里的缓存控制(只看Cache-Control)

了解基本流程:
Android volley 解析（四）之缓存篇

缓存文件里的内容是怎样的:
Android中关于Volley的使用（八）缓存机制的深入认识

疑问:
发送请求时,去取缓存,怎么判断是否过期的?是根据Cache-Control字段吗?

看CacheDispatcher里的这段代码:
Cache.Entry entry = mCache.get(request.getCacheKey());
if (entry == null) {
request.addMarker("cache-miss");
// Cache miss; send off to the network dispatcher.
mNetworkQueue.put(request);
continue;
}

            // If it is completely expired, just send it to the network.
            if (entry.isExpired()) {
                request.addMarker("cache-hit-expired");
                request.setCacheEntry(entry);
                mNetworkQueue.put(request);
                continue;
            }

            // We have a cache hit; parse its data for delivery back to the request.
            request.addMarker("cache-hit");
            Response<?> response = request.parseNetworkResponse(
                    new NetworkResponse(entry.data, entry.responseHeaders));
            request.addMarker("cache-hit-parsed");

先是根据CacheKey去缓存中拿缓存,然后判断缓存有没有过期,判断缓存过期的方法:
Cache.Entry里:

 public boolean isExpired() {
        return this.ttl < System.currentTimeMillis();
    }

Cache.Entry.ttl是什么东西?注释也没有...那么,看它是怎么赋值的.
当然是响应回来后,解析响应头拿到的:

HttpHeaderParser的 Cache.Entry parseCacheHeaders(NetworkResponse response)方法里:
 Cache.Entry entry = new Cache.Entry();
    entry.data = response.data;
    entry.etag = serverEtag;
    entry.softTtl = softExpire;//软过期时间?什么鬼?
    entry.ttl = finalExpire;//表示的是最终过期时间
    entry.serverDate = serverDate;
    entry.lastModified = lastModified;
    entry.responseHeaders = headers;

    return entry;
    
// finalExpire  是怎么拿到的?
 if (hasCacheControl) {
        softExpire = now + maxAge * 1000;
        finalExpire = mustRevalidate
                ? softExpire
                : softExpire + staleWhileRevalidate * 1000;
    } else if (serverDate > 0 && serverExpires >= serverDate) {
        // Default semantic for Expire header in HTTP specification is softExpire.
        softExpire = now + (serverExpires - serverDate);
        finalExpire = softExpire;
    }
    
//hasCacheControl 是表示响应头里有没有Cache-Control字段
headerValue = headers.get("Cache-Control");
    if (headerValue != null) {
        hasCacheControl = true;
        
//同理,mustRevalidate是表示响应头里是否有mustRevalidate字段.不管怎么,既然我决定拦截重写响应头,那我就不要它.为false.最终走到
softExpire = now + maxAge * 1000;
finalExpire = softExpire + staleWhileRevalidate * 1000;

//maxAge当然就是max-Age解析出来的,但staleWhileRevalidate又是什么?
//先把本地缓存的文件给用户，同时会去后端server进行数据对比,后端server能正常响应的话，squid会对比数据是否更新，更新的话，就把更新的数据给到下一次用户请求.我们不需要这么复杂,重写时果断不写.


干脆放出整段源码:

 headerValue = headers.get("Cache-Control");
    if (headerValue != null) {
        hasCacheControl = true;
        String[] tokens = headerValue.split(",");
        for (int i = 0; i < tokens.length; i++) {
            String token = tokens[i].trim();
            if (token.equals("no-cache") || token.equals("no-store")) {
                return null;
            } else if (token.startsWith("max-age=")) {
                try {
                    maxAge = Long.parseLong(token.substring(8));
                } catch (Exception e) {
                }
            } else if (token.startsWith("stale-while-revalidate=")) {
                try {
                    staleWhileRevalidate = Long.parseLong(token.substring(23));
                } catch (Exception e) {
                }
            } else if (token.equals("must-revalidate") || token.equals("proxy-revalidate")) {
                mustRevalidate = true;
            }
        }
    }

//最终,finalExpire = softExpire,我们要覆写的响应头达到的效果是,只有一个cache-control ,内部只有一个max-age=xxx,没有其他值了.

复写响应头:

缓存控制相关的字段都有的响应头长这样:

HTTP/1.1 200 OK
Date: Fri, 30 Oct 1998 13:19:41 GMT
Server: Apache/1.3.3 (Unix)
Cache-Control: max-age=3600, must-revalidate
Expires: Fri, 30 Oct 1998 14:19:41 GMT
Last-Modified: Mon, 29 Jun 1998 02:28:12 GMT
ETag: "3e86-410-3596fbbc"
Content-Length: 1040
Content-Type: text/html

我们要变成的效果是:

HTTP/1.1 200 OK
Date: Fri, 30 Oct 1998 13:19:41 GMT
Server: Apache/1.3.3 (Unix)

Cache-Control: max-age=3600

Content-Length: 1040
Content-Type: text/html

有两种方法可以达到效果,

一是在resonse解析前复写里面的header,二是解析成Cache.entry后修改entry里的值.注意,如果header里cache-control的值为no-cache或no-store,那么解析Cache.entry时直接返回空,所以,还是第一种保险一点.

看NetworkResponse里源码,

 /** Response headers. */
public final Map<String, String> headers;

 public NetworkResponse(int statusCode, byte[] data, Map<String, String> headers,
        boolean notModified, long networkTimeMs) {
    this.statusCode = statusCode;
    this.data = data;
    this.headers = headers;
    this.notModified = notModified;
    this.networkTimeMs = networkTimeMs;
}

这个对象在request里有返回,Request抽象类定义了方法让子类实现:

abstract protected Response<T> parseNetworkResponse(NetworkResponse response);

比如StringRequest的实现:

@Override
protected Response<String> parseNetworkResponse(NetworkResponse response) {
    String parsed;
    try {
        parsed = new String(response.data, HttpHeaderParser.parseCharset(response.headers));
    } catch (UnsupportedEncodingException e) {
        parsed = new String(response.data);
    }
    return Response.success(parsed, HttpHeaderParser.parseCacheHeaders(response));
}

这里的HttpHeaderParser.parseCacheHeaders(response)就是解析生成Cache.Entry的地方,那么,自定义一个request,更改了NetworkResponse里面的headers后,再传入这个方法中,就可以达到完全控制缓存的目的了.

 @Override
protected Response<String> parseNetworkResponse(NetworkResponse response) {
    String parsed;
    try {
        parsed = new String(response.data, HttpHeaderParser.parseCharset(response.headers));
    } catch (UnsupportedEncodingException e) {
        parsed = new String(response.data);
    }
    reSetCacheControl(response);
    return Response.success(parsed, HttpHeaderParser.parseCacheHeaders(response));
}

long time;

private void reSetCacheControl(NetworkResponse response) {
    //怎么判断是从缓存中取的还是从网络上取的?请求时设置的缓存时间怎么传?
    if(isFromNet){
        Map<String, String> headers = response.headers;
        headers.put("Cache-Control","max-age="+time);
    }
    
}

注意解析之后的缓存,还需要判断shouldecache的值:(NetworkDispatcher里)

  Response<?> response = request.parseNetworkResponse(networkResponse);
            request.addMarker("network-parse-complete");

            // Write to cache if applicable.
            // TODO: Only update cache metadata instead of entire record for 304s.
            if (request.shouldCache() && response.cacheEntry != null) {
                mCache.put(request.getCacheKey(), response.cacheEntry);
                request.addMarker("network-cache-written");
            }

            // Post the response back.
            request.markDelivered();

针对上面的两个问题:

怎么判断是从缓存中取的还是从网络上取的

在CacheDisPatcher里,当拿到的Cache没有过期时:

   // We have a cache hit; parse its data for delivery back to the request.
            request.addMarker("cache-hit");
            Response<?> response = request.parseNetworkResponse(
                    new NetworkResponse(entry.data, entry.responseHeaders));
            request.addMarker("cache-hit-parsed");

            if (!entry.refreshNeeded()) {
                // Completely unexpired cache hit. Just deliver the response.
                mDelivery.postResponse(request, response);
            } else {
                // Soft-expired cache hit. We can deliver the cached response,
                // but we need to also send the request to the network for
                // refreshing.
                request.addMarker("cache-hit-refresh-needed");
                request.setCacheEntry(entry);

                // Mark the response as intermediate.
                response.intermediate = true;

                // Post the intermediate response back to the user and have
                // the delivery then forward the request along to the network.
                final Request<?> finalRequest = request;
                mDelivery.postResponse(request, response, new Runnable() {
                    @Override
                    public void run() {
                        try {
                            mNetworkQueue.put(finalRequest);
                        } catch (InterruptedException e) {
                            // Not much we can do about this.
                        }
                    }
                });
            }
    // request.addMarker("cache-hit-parsed"); ? addMarker也许有用? 看了源码 略有失望
    /**
     * Adds an event to this request's event log; for debugging.
     */
    public void addMarker(String tag) {
        if (MarkerLog.ENABLED) {
            mEventLog.add(tag, Thread.currentThread().getId());
        }
    }
    //这个方法是用于debug的,但是可以复写啊,
    //在自定义的request里设置一个int值,遇到"cache-hit","cache-hit-parsed"就加1,最终到2,就可以判定是从缓存中读取的. 
    
    
    long cacheTime;//毫秒

    public boolean isFromCache = false;
    public int cacheHitCount = 0;

    @Override
    public void addMarker(String tag) {
        super.addMarker(tag);
        if ("cache-hit".equals(tag)){
            cacheHitCount++;
        }else if ("cache-hit-parsed".equals(tag)){
            cacheHitCount++;
        }

        if (cacheHitCount == 2){
            isFromCache = true;
        }
    }
    
     private void reSetCacheControl(NetworkResponse response) {
    this.setShouldCache(true);//重置cache开关
    if (!isFromCache){
        Map<String, String> headers = response.headers;
        headers.put("Cache-Control","max-age="+cacheTime);
    }
}

缓存时间的话,就设置成这个自定义的request的成员变量就好,代码见上面

于是,几种场景的解决方案如下:

强制进行网络访问,但回来的请求又想缓存个几个小时或几天,或者永久缓存.
request.setShouldCache(false)
myStringRequest.setResponseCacheTime(xxx)//自定义的方法

设置普通的请求缓存时间,过期就拉网络:
这个就是普通的用法了,设置请求头.

 public void setRequestHeadCacheTime(int timeInSecond){
    try {
        getHeaders().put("Cache-Control","max-age="+timeInSecond);
    } catch (AuthFailureError authFailureError) {
        authFailureError.printStackTrace();
    }

}