通过Volley我们能学到什么?(3) — 缓存原理

目录

构建缓存容器

生成缓存 

向容器中插入缓存

获取缓存

构建缓存容器

在最初创建Volley的RequestQueue对象时，构造DiskBasedCache类时如果不设置缓存大小的话，默认缓存是5M；

//默认缓存5M

RequestQueue queue = new RequestQueue(new DiskBasedCache(cacheDir), network);

或

//自定义缓存xM

RequestQueue queue = new RequestQueue(new DiskBasedCache(cacheDir，x*1024*1024), network);

生成缓存 

生成缓存大体逻辑是在通过网络成功获取数据后，在解析成Response对象的过程中将获取的内容拷贝到缓存对象中。

NetworkDispatcher.java

public void run() {

    ......

    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");
    }

    ......

}

这里只看第5行的parseNetworkResponse()。

parseNetworkResponse()方法里面最终默认调用的是 

Response.success(parsed, HttpHeaderParser.parseCacheHeaders(response));

而生成缓存的方法就在parseCacheHeaders(response)方法里面，所以我们主要看它。 

HttpHeaderParser.java

    public static Cache.Entry parseCacheHeaders(NetworkResponse response) {
        …….

        String serverEtag = null;
        String headerValue;

        headerValue = headers.get("Date");
        if (headerValue != null) {
            serverDate = parseDateAsEpoch(headerValue);
        }

        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;
                }
            }
        }

        headerValue = headers.get("Expires");
        if (headerValue != null) {
            serverExpires = parseDateAsEpoch(headerValue);
        }

        headerValue = headers.get("Last-Modified");
        if (headerValue != null) {
            lastModified = parseDateAsEpoch(headerValue);
        }

        serverEtag = headers.get("ETag");

        // Cache-Control takes precedence over an Expires header, even if both exist and Expires
        // is more restrictive.
        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;
        }

        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;
    }

1、获取"Date”字段，即服务器时间(7 - 10行)；

2、获取"Cache-Control”信息，即缓存过期时间(12 - 15行)；

3、如果不允许缓存，直接返回null(18 - 19行)；

4、“max-age=”为缓存过期时间(20 - 24行)；

5、“stale-while-revalidate=”为过了缓存时间后还可以继续使用缓存的时间，即真正的缓存时间是“max-age=” + “stale-while-revalidate=”的总时间，但如果有“must-revalidate”或者“proxy-revalidate”字段则过了缓存时间缓存就立即请求服务器(25 - 32行)；

6、“Expires”字段是一个时间点，其实和Cache-Control的意思是一致的，控制缓存的过期时间的，是为了兼容HTTP1.0和HTTP1.1的才会使用的字段，如果有Cache-Control的话优先使用Cache-Control(36 - 39行)；

7、“Last-Modified”字段是服务器最后修改时间，如果缓存过期了，带上“Last-Modified”这个字段的时间与服务器的最后修改时间比较，如果服务器最后修改时间比“Last-Modified”字段的时间新，则重新获取，如果交旧，则返回304，继续用之前的缓存(41 - 44行)；

8、“ETag”字段是服务器资源的唯一标识符，与“Last-Modified”配合使用，因为“Last-Modified”只能精确到秒。如果“ETag”与服务器一致，再判断“Last-Modified”，防止一秒内服务器多次修改而导致数据不准确的情况(46行)；

9、如果支持Cache-Control则使用Cache-Control中的缓存验证信息，否则使用“Expires”中的验证信息(50 - 59行)；

10、将服务器请求内容和验证信息都赋值给entry对象(61 - 68行)；

缓存对象创建完成。

向容器中插入缓存

插入缓存还是看 NetworkDispatcher.java中的run()里面。 

public void run() {

    ......

    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");
    }

    ......

}

第11行的put()方法为缓存的插入，向下看源码。

DiskBasedCache.java

  public synchronized void put(String key, Entry entry) {
        pruneIfNeeded(entry.data.length);
        File file = getFileForKey(key);
        try {
            BufferedOutputStream fos = new BufferedOutputStream(new FileOutputStream(file));
            CacheHeader e = new CacheHeader(key, entry);
            boolean success = e.writeHeader(fos);
            if (!success) {
                fos.close();
                VolleyLog.d("Failed to write header for %s", file.getAbsolutePath());
                throw new IOException();
            }
            fos.write(entry.data);
            fos.close();
            putEntry(key, e);
            return;
        } catch (IOException e) {
        }
        boolean deleted = file.delete();
        if (!deleted) {
            VolleyLog.d("Could not clean up file %s", file.getAbsolutePath());
        }
    }

1、判断要插入新的缓存文件后会不会超出缓存最大值(2行)；

                                    

                                    ①如果当前已缓存总大小 + 要插入缓存的大小小于缓存最大值直接返回，否则需要清理(247 - 249行)；

                                   ②获取所有缓存头的集合，逐一删除集合中key值对应的文件夹，也就是删除其对应的缓存文件，直到当前缓存空间可以容纳要插入的缓存为止(259 - 275行)；

2、创建缓存文件(3行)；

3、将头部信息和数据内容写入到缓存文件里面(5 - 14行)；

4、将头文件放入临时存储所有头部信息的容器中，更新并计算所有缓存头文件的大小和当前对应缓存头文件的内容(15行)；

5、如果出现IO异常删掉创建的文件；

这样缓存就插入到缓存文件里面了，其中涉及一些IO知识。

获取缓存

  public synchronized Entry get(String key) {
        CacheHeader entry = mEntries.get(key);
        // if the entry does not exist, return.
        if (entry == null) {
            return null;
        }

        File file = getFileForKey(key);
        CountingInputStream cis = null;
        try {
            cis = new CountingInputStream(new BufferedInputStream(new FileInputStream(file)));
            CacheHeader.readHeader(cis); // eat header
            byte[] data = streamToBytes(cis, (int) (file.length() - cis.bytesRead));
            return entry.toCacheEntry(data);
        } catch (IOException e) {
            VolleyLog.d("%s: %s", file.getAbsolutePath(), e.toString());
            remove(key);
            return null;
        } finally {
            if (cis != null) {
                try {
                    cis.close();
                } catch (IOException ioe) {
                    return null;
                }
            }
        }
    }

1、预先根据URL组成的Key在存储缓存头的容器中来搜索缓存头文件信息，这样就省去文件搜索，更快捷(2 - 6行)；

2、找到存储缓存的文件夹(8行)；

3、将缓存内容读出来并返回(9 - 14行)；

总结：

这个版本的Volley只是一级的缓存，未存储在磁盘中。