Android Volley 源码解析(二),探究缓存机制

前言

在上一篇文章中,带大家阅读了 Volley 网络请求的执行流程,算是对 Volley 有了一个比较清晰的认识,从这篇文章开始,我们开始针对 Volley 的某个功能进行深入地分析,慢慢将 Volley 的各项功能进行全面把握。

我们先从缓存这一块的内容开始入手,不过今天的缓存分析是是建立在上一篇源码分析的基础上的,还没有看过上一篇文章的朋友,建议先去阅读 Android Volley 源码解析(一),网络请求的执行流程

一、Volley 缓存的总体设计

在开始细节分析之前,我们先来看下 Volley 缓存的设计,了解这个流程有助于我们对于缓存细节的把握。Volley 提供了一个 Cache 作为缓存的接口,封装了缓存的实体 Entry,以及一些常规的增删查操作。

public interface Cache {

    Entry get(String key);

    void put(String key, Entry entry);

    void initialize();

    /**
     * 使缓存中的 Entry 失效
     */
    void invalidate(String key, boolean fullExpire);

    void remove(String key);

    void clear();

    /**
     * 用户缓存的实体
     */
    class Entry {

        public byte[] data;

        public String etag;

        public long serverDate;

        public long lastModified;

        public long ttl;

        public long softTtl;

        public Map<String, String> responseHeaders = Collections.emptyMap();

        public List<Header> allResponseHeaders;

        /** 判断 Entry 是否过期. */
        public boolean isExpired() {
            return this.ttl < System.currentTimeMillis();
        }

        /** 判断 Entry 是否需要刷新. */
        public boolean refreshNeeded() {
            return this.softTtl < System.currentTimeMillis();
        }
    }

}

Entry 里面主要是放网络响应的原始数据 data、跟缓存相关的属性以及对应的响应头,作为缓存的一个实体。Cache 的具体实现类是 DiskBaseCache,它实现了 Cache 接口,并实现了响应的方法,那我们就来看看 DiskBaseCache 的设计吧,我们先看下 DiskBaseCache 中的一个静态内部类 CacheHeader.

    static class CacheHeader {

        long size;

        final String key;

        final String etag;

        final long serverDate;

        final long lastModified;

        final long ttl;

        final long softTtl;

        final List<Header> allResponseHeaders;

        private CacheHeader(String key, String etag, long serverDate, long lastModified, long ttl,
                           long softTtl, List<Header> allResponseHeaders) {
            this.key = key;
            this.etag = ("".equals(etag)) ? null : etag;
            this.serverDate = serverDate;
            this.lastModified = lastModified;
            this.ttl = ttl;
            this.softTtl = softTtl;
            this.allResponseHeaders = allResponseHeaders;
        }

        CacheHeader(String key, Entry entry) {
            this(key, entry.etag, entry.serverDate, entry.lastModified, entry.ttl, entry.softTtl,
                    getAllResponseHeaders(entry));
            size = entry.data.length;
        }
    }

DiskBaseCache 的设计很巧妙,它在内部放入了一个静态内部类 CacheHeader,我们可以发现这个类跟 Cache 的 Entry 非常像,是不是会觉得好像有点多余,Volley 之所以要这样设计,主要是为了缓存的合理性。我们知道每一个应用都是有一定内存限制的,程序占用了过高的内存就容易出现 OOM(Out of Memory),如果每一个请求都原封不动的把所有的信息都缓存到内存中,这样是非常占内存的。

我们可以发现 CacheHeader 和 Entry 最大的区别,其实就是是否有 byte[] data 这个属性,data 代表网络响应的元数据,是返回的内容中最占地方的东西,所以 DiskBaseCache 重新抽象了一个不包含 data 的 CacheHeader,并将其缓存到内存中,而 data 部分便存储在磁盘缓存中,这样就能最大程度的利用有限的内存空间。代码如下:

    BufferedOutputStream fos = new BufferedOutputStream(createOutputStream(file));
    CacheHeader e = new CacheHeader(key, entry);
    boolean success = e.writeHeader(fos);
    // 将 entry.data 写入磁盘中
    fos.write(entry.data);
    fos.close();
    // 将 Cache 缓存到内存中
    putEntry(key, e);

二、DiskBaseCache 的具体实现

看完了 Volley 的缓存设计,我们接着看 DiskBaseCache 的具体实现。

2.1 初始化缓存

  // 内存缓存的目录
  private final File mRootDirectory;

  public DiskBasedCache(File rootDirectory, int maxCacheSizeInBytes) {
      mRootDirectory = rootDirectory;
      mMaxCacheSizeInBytes = maxCacheSizeInBytes;
  }

  @Override
  public synchronized void initialize() {
      // 如果 mRootDirectroy 不存在,则进行创建
      if (!mRootDirectory.exists()) {
          if (!mRootDirectory.mkdirs()) {
              VolleyLog.e("Unable to create cache dir %s", mRootDirectory.getAbsolutePath());
          }
          return;
      }
      File[] files = mRootDirectory.listFiles();
      if (files == null) {
          return;
      }
      // 遍历 mRootDirectory 中的所有文件
      for (File file : files) {
          try {
              long entrySize = file.length();
              CountingInputStream cis = new CountingInputStream(
                      new BufferedInputStream(createInputStream(file)), entrySize);
              // 将对应的文件缓存到内存中
              CacheHeader entry = CacheHeader.readHeader(cis);
              entry.size = entrySize;
              putEntry(entry.key, entry);
          } catch (IOException e) {
              file.delete();
          }
      }
  }

通过外部传入的 rootDirectory 和 maxCacheSizeInBytes 构造 DiskBaseCache 的实例,mRootDirectory 代表我们内存缓存的目录,maxCacheSizeInBytes 代表磁盘缓存的大小,默认是 5M。如果 mRootDirectory 为 null,则进行创建,然后将 mRootDirectory 中的所有文件进行内存缓存。

2.2 put() 方法的实现

    @Override
    public synchronized void put(String key, Entry entry) {
        pruneIfNeeded(entry.data.length);
        File file = getFileForKey(key);
        try {
            BufferedOutputStream fos = new BufferedOutputStream(createOutputStream(file));
            CacheHeader e = new CacheHeader(key, entry);
            boolean success = e.writeHeader(fos);
            fos.write(entry.data);
            fos.close();
            putEntry(key, e);
            return;
        } catch (IOException e) {
        }
    }

    private void pruneIfNeeded(int neededSpace) {
        // 如果内存还够用,就直接 return.
        if ((mTotalSize + neededSpace) < mMaxCacheSizeInBytes) {
            return;
        }

        long before = mTotalSize;
        int prunedFiles = 0;

        Iterator<Map.Entry<String, CacheHeader>> iterator = mEntries.entrySet().iterator();
        // 遍历所有的文件,开始进行删除文件
        while (iterator.hasNext()) {
            Map.Entry<String, CacheHeader> entry = iterator.next();
            CacheHeader e = entry.getValue();
            boolean deleted = getFileForKey(e.key).delete();
            if (deleted) {
                mTotalSize -= e.size;
            } 
            iterator.remove();
            prunedFiles++;
            
            // 如果删除文件后,存储空间已经够用了,就停止循环
            if ((mTotalSize + neededSpace) < mMaxCacheSizeInBytes * HYSTERESIS_FACTOR) {
                break;
            }
        }
    }

可以看到 Volley 的代码实现是相当完善的,在添加缓存之前,先调用 pruneIfNeed() 方法进行内存空间的判断和处理,如果不进行限制的话,内存占用将无限制的增大,最后到达 SD 卡容量时,会发生无法写入的异常(因为存储空间满了)。

这里有一点要补充一下,Volley 在缓存方面,主要是使用了 LRU(Least Recently Used)算法,LRU 算法是最近最少使用算法,它的核心思想是当缓存满时,优先淘汰那些近期最少使用的缓存对象。主要的算法原理是把最近使用的对象用强引用的方式(即我们平常使用的对象引用方式)存储在 LinkedHashMap 中,当缓存满时,把最近最少使用的对象从内存中移除。有关 LRU 算法,可以看下这篇文章:彻底解析 Android 缓存机制 —— LruCache

在进行内存空间的判断之后,便将 entry.data 保存在磁盘中,将 CacheHeader 缓存在内存中,这样 DiskBaseCache 的 put() 方法就完成了。

2.3 get() 方法的实现

既然是缓存功能,必然有用于进行缓存的 key,我们来看下 Volley 的缓存 key 是怎么生成的。

    private String getFilenameForKey(String key) {
        int firstHalfLength = key.length() / 2;
        String localFilename = String.valueOf(key.substring(0, firstHalfLength).hashCode());
        localFilename += String.valueOf(key.substring(firstHalfLength).hashCode());
        return localFilename;
    }

Volley 的缓存 key 的生成方法还是很骚的,将网络请求的 Url 分成两半,然后将这两部分的 hashCode 拼接成缓存 key。Volley 之所以要这样做,主要是为了尽量避免 hashCode 重复造成的文件名重复,求两次 hashCode 都与另外一个 Url 相同的概率比只求一次要小很多,不过概率小不代表不存在,但是 Java 在计算 hashCode 的速度是非常快的,这应该是 Volley 在权衡了安全性和效率之后做出的决定,这个思想是很值得我们学习的。

    @Override
    public synchronized Entry get(String key) {
        CacheHeader entry = mEntries.get(key);
        if (entry == null) {
            return null;
        }
        File file = getFileForKey(key);
        try {
            CountingInputStream cis = new CountingInputStream(
                    new BufferedInputStream(createInputStream(file)), file.length());
            try {
                CacheHeader entryOnDisk = CacheHeader.readHeader(cis);
                if (!TextUtils.equals(key, entryOnDisk.key)) {
                    // 一个文件可能映射着两个不同的 key,保存在不同的 Entry 中
                    removeEntry(key);
                    return null;
                }
                byte[] data = streamToBytes(cis, cis.bytesRemaining());
                return entry.toCacheEntry(data);
            } finally {
                cis.close();
            }
        } catch (IOException e) {
            remove(key);
            return null;
        }
    }

我们在上面说道,Volley 将响应的 data 放在磁盘中,将 CacheHeader 缓存在内存中,而 get() 方法其实就是这个过程的逆过程,先通过 key 从 mEntries 从取出 CacheHeader,如果为 null,就直接返回 null,否则通过 key 来获取磁盘中的 data,并通过 entry.toCacheEntry(data) 将 CacheHeader 和 data 拼接成完整的 Entry 然后进行返回。

三、DiskBaseCache 在 Volley 中的使用

看完了 DiskBaseCache 的具体实现,我们最后看下 DiskBaseCache 在 Volley 中是怎么使用的,这样就能把 Volley 的缓存机制全部串联起来了。

3.1 DiskBaseCache 的构建

    private static RequestQueue newRequestQueue(Context context, Network network) {
        File cacheDir = new File(context.getCacheDir(), DEFAULT_CACHE_DIR);
        RequestQueue queue = new RequestQueue(new DiskBasedCache(cacheDir), network);
        queue.start();
        return queue;
    }

应该还记得 Volley 的基本使用方法吧,当时我们第一步就是使用 Volley.newRequestQueue() 来创建一个 RequestQueue,这也是一切的起点。可以看到我们先通过 context.getCacheDir() 获取缓存路径,然后创建我们缓存所需的目录 cacheDir,这其实就是在 DiskBaseCache 中的 mRootDirectory,然后将其传入 DiskBaseCache 只有一个参数的构造器中,创建了 DiskBaseCache 的实例,默认的内存缓存空间是 5M.

    private static final int DEFAULT_DISK_USAGE_BYTES = 5 * 1024 * 1024;

    public DiskBasedCache(File rootDirectory) {
        this(rootDirectory, DEFAULT_DISK_USAGE_BYTES);
    }

3.2 initialize() 方法的调用

public class CacheDispatcher extends Thread {

    @Override
    public void run() {
        Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
        mCache.initialize();

        while (true) {
            try {
                processRequest();
            } catch (InterruptedException e) {
            }
        }
    }
}

initialize() 是在 CacheDispatcher 中的 run 方法进行调用的,CacheDispatcher 是处理缓存队列中请求的线程。实例化 DiskBaseCache 之后,便在 while(true) 这个无线的循环当中,不断地等请求的到来,然后执行请求。

3.3 put() 方法的调用

public class NetworkDispatcher extends Thread {

    private void processRequest() throws InterruptedException {
        Request<?> request = mQueue.take();

        try {
            NetworkResponse networkResponse = mNetwork.performRequest(request);
            Response<?> response = request.parseNetworkResponse(networkResponse);

            if (request.shouldCache() && response.cacheEntry != null) {
                mCache.put(request.getCacheKey(), response.cacheEntry);
                request.addMarker("network-cache-written");
            }
    }
}

可以看到 put() 方法是在 NetworkDispatcher 中进行调用的,NetworkDispatcher 是一个执行网络请求的线程,从请求队列中取出 Request,然后执行请求,如果 Request 是需要被缓存的(默认情况下是必须被缓存的)而且 response 的 cacheEntry 不为 null,就调用 DiskBaseCache 的 put() 方法将 Entry 进行缓存。

3.4 get() 方法的调用

public class CacheDispatcher extends Thread {

    @Override
    public void run() {
        mCache.initialize();
        while (true) {
            try {
                processRequest();
            } catch (InterruptedException e) {
            }
        }
    }

    private void processRequest() throws InterruptedException {
        final Request<?> request = mCacheQueue.take();
        // 调用 get() 方法获取 Entry
        Cache.Entry entry = mCache.get(request.getCacheKey());

        if (entry.isExpired()) {
            request.setCacheEntry(entry);
            mNetworkQueue.put(request);
            return;
        }

        Response<?> response = request.parseNetworkResponse(
                new NetworkResponse(entry.data, entry.responseHeaders));

        if (!entry.refreshNeeded()) {
            mDelivery.postResponse(request, response);
        } 
}

我们在上面说到 DiskBaseCache 的 initialize() 方法是在 CacheDispatcher 中的 run() 方法中调用,其实 get() 方法也是一样的,在 while(true) 里面无限循环,当有请求到来时,便先根据请求的 Url 拿出对应的缓存在内存中的 Entry,然后对 Entry 进行一些判断和处理,最后将其构建成 Response 回调出去。

小结

在调用 Volley.newRequestQueue() 方法获取 RequestQueue 的时候,构建 DiskBaseCache 实例,在 CacheDispatcher 的 run() 方法中调用 DiskBaseCache 的 initialize() 方法初始化 DiskBaseCache,在 NetworkDispatcher 的 run() 方法中,在执行请求的时候,调用 DiskBaseCache 的 put() 方法将其缓存到内存中,然后在 CaheDispatcher 的 run() 方法中执行请求的时候调用 DiskBaseCache 的 get() 方法构建相应的 Response,最后将其分发出去。

    原文作者:developerHaoz
    原文地址: https://www.jianshu.com/p/48e4085ece0f
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞