超级实用的Android轻量级磁盘缓存工具DiskDataCacher用法以及原理

DiskDataCacher是一个轻量级的Android磁盘缓存工具,基于LRU算法实现,同时可以设置缓存有效期,使用起来十分方便。
源码托管:DiskDataCacher

工具用途

  • 用于缓存网络请求返回的数据,并且可以设置缓存数据的有效期,比如,缓存时间假设为1个小时,超时1小时后再次获取缓存会自动失效,让客户端重新请求新的数据,这样可以减少客户端流量,同时减少服务器并发量。
  • 用于代替SharePreference当做配置文件,缓存一些较大的配置数据,效率更高,可以减少内存消耗。
    SharePreference 不能用来缓存较大数据的理由:请不要滥用SharedPreference
  • 支持扩展,扩展后可以缓存JsonObjectBitmapDrawable和序列化的java对象等等。

对比ASimpleCacheDiskLruCache

 跟ASimpleCache比较,优点主要有:

  • 两者都是给予LRU(最近最少使用)算法,但ASimpleCache是使用HashMap实现lru,而DiskDataCacher是使用排序好的LinkedHashMap实现lru算法,查询过期数据的效率更高;
  • DiskDataCacher对线程同步的支持更好;
  • DiskDataCacher封装了线程池,支持异步存取。

 跟DiskLruCache比较,优点主要有:

  • DiskDataCacher支持设置缓存数据的有效期,再次获取超期数据会自动清除
  • DiskDataCacher实现方式更简单,使用更轻量,并不需要一个journal文件记录数据操作情况

用法简介

DiskStringCacheManager是专门用来缓存字符串的工具,是单例模式,一般在Application的onCreate中进行初始化:

1
2
3
4
5
6
@Override
public void onCreate() {
super.onCreate();
DiskStringCacheManager.init(new File(getCacheDir(), DiskStringCacheManager.DEFAULT_CACHE_FILE_NAME),
DiskStringCacheManager.MAX_CACHE_SIZE);
}

保存数据:

1
2
3
4
5
6

String cacheStringValue = "多线程比多任务更加有挑战。多线程是在同一个程序内部并行执行,\n";
long maxTime = 3 * 60 * 1000; //缓存有效期3分钟
DiskStringCacheManager.get().putAsync(cacheKey, cacheStringValue); //异步方式缓存, 缓存数据一直有效
DiskStringCacheManager.get().putAsync(cacheKey, cacheStringValue, maxTime); //异步方式缓存, 缓存数据一直有效期为3分钟
DiskStringCacheManager.get().put(cacheKey, cacheStringValue, maxTime); //同步方式缓存

获取数据:

1
2
3
4
5
6
7
8
9
10
11
//异步方式获取
DiskStringCacheManager.get().getAsync(cacheKey, new WeakReference<DiskStringCacheManager.Callback>(new DiskStringCacheManager.Callback() {
@Override
public void actionDone(final String result) {
if (!TextUtils.isEmpty(result)) {
textView.setText(result);
}
}
}));
//同步方式获取
String result = DiskStringCacheManager.get().get(cacheKey);

源码剖析

init方法实现思路:

初始化时,遍历缓存目录下的所有缓存文件,并读取出文件起始段的信息,此信息包含缓存文件大小,缓存有效期,缓存的键值,并将这些信息和缓存文件上次修改时间(LastModifiedTime)存到一个List中,然后将此list根据文件上次修改时间进行排序,排序好后,存到全局变量LinkedHashMap mCacheInfoMap中,这个map用于LRU算法获取缓存,具体的初始化实现如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
  ...
...
//先存到list中进行排序,然后再存到mCacheInfoMap中
List<CacheInfoWithModifiedTime> cacheInfoSortList = null;
try {
File[] fileList = mRootDirectory.listFiles();
cacheInfoSortList = new ArrayList<>(fileList.length); //设置初始化大小,避免扩容

for (File file : fileList) {
BufferedInputStream fis = null;
try {
fis = new BufferedInputStream(new FileInputStream(file));
CacheInfo info = CacheInfo.readCacheInfo(fis);
info.size = file.length();
//初始化时,遇到过期的数据,需要清除掉
if (info.isExpiredCache()) {
file.delete();
continue;
}
long fileLastModifiedTime = file.lastModified();
CacheInfoWithModifiedTime infoWithModifiedTime = new CacheInfoWithModifiedTime(info, fileLastModifiedTime);
cacheInfoSortList.add(infoWithModifiedTime);
} catch (Exception e) {
...
} finally {
...
}
}
} finally {
if (cacheInfoSortList != null && cacheInfoSortList.size() != 0) {
//对文件中取到的CacheInfo按照时间排序,用以实现最近最少原则
Collections.sort(cacheInfoSortList, new FileModifiedTimeComparator());
for (CacheInfoWithModifiedTime infoWithModifiedTime : cacheInfoSortList) {
putCacheInfo(infoWithModifiedTime.info.key, infoWithModifiedTime.info);
}
}
synchronized (mLock) {
mInitialized = true;
mLock.notifyAll();
}
}

get方法实现思路:

先根据key从mCacheInfoMap中取缓存信息(mCacheInfoMap是一个LinkedHashMap,调用其get方法后,这个键值对就会添加到链表尾部成为最新的元素,以此实现LRU),然后根据key获取缓存文件名,从缓存文件中读取缓存内容,并将内容返回,以此实现get方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
@Override
public Entry get(String key) {
synchronized (mLock) {
awaitInitializeLocked();
//LinkedHashMap get之后,会将此键值对移到链表尾部,以实现LRU
CacheInfo info = mCacheInfoMap.get(key);
File cachedFile = getFileForKey(key);
//缓存文件不存在
if (!cachedFile.exists()) {
removeCacheInfo(key);
return null;
}
//缓存的数据已经过期
if (info != null && info.isExpiredCache()) {
removeCacheInfo(key);
cachedFile.delete();
return null;
}
CountingInputStream cis = null;
try {
cis = new CountingInputStream(new BufferedInputStream(new FileInputStream(cachedFile)));
CacheInfo fileInfo = CacheInfo.readCacheInfo(cis);
fileInfo.size = cachedFile.length();
//设置时间为了初始化时排序
cachedFile.setLastModified(System.currentTimeMillis());
if (info == null || !info.equals(fileInfo)) { //一般不会出现这种情况
info = fileInfo;
mCacheInfoMap.put(key, info);
}
byte[] data = StreamUtils.streamToBytes(cis, (int) (cachedFile.length() - cis.bytesRead));
return info.toCacheEntry(data);
} catch (Exception e) {
e.printStackTrace();
remove(key);
} finally {
...
}
return null;
}
}

put方法实现思路:

存储数据之前,需要先判断存储数据到本地磁盘后,是否会超出允许的最大存阈值,即mMaxCacheSizeInBytes,超出的话,就先遍历mCacheInfoMap一遍,删除所有的过期数据,再次判断是否超出最大阈值mMaxCacheSizeInBytes,超出的话,删除mCacheInfoMap中最老的数据,直到不再超出阈值,具体代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
private void trimToMaxSize(int neededSpace) {
if (mTotalSize + neededSpace < mMaxCacheSizeInBytes) {
return;
}
//先删除所有的过期数据
Iterator<Map.Entry<String, CacheInfo>> iterator = mCacheInfoMap.entrySet().iterator();
while (iterator.hasNext()) {
Map.Entry<String, CacheInfo> entry = iterator.next();
String key = entry.getKey();
CacheInfo info = entry.getValue();
if (info.isExpiredCache()) {
File file = getFileForKey(key);
boolean deleted = file.delete();
if (deleted) {
mTotalSize -= info.size;
} else {
}
iterator.remove();
}
}
if (mTotalSize + neededSpace <= mMaxCacheSizeInBytes) {
return;
}
//再根据Lru算法删除最老的数据,直到不超过阈值
Iterator<Map.Entry<String, CacheInfo>> iterator2 = mCacheInfoMap.entrySet().iterator();
while (iterator2.hasNext()) {
Map.Entry<String, CacheInfo> entry = iterator2.next();
String key = entry.getKey();
CacheInfo info = entry.getValue();
File file = getFileForKey(key);
boolean deleted = file.delete();
if (deleted) {
mTotalSize -= info.size;
} else {
}
iterator2.remove();
if (mTotalSize + neededSpace < mMaxCacheSizeInBytes * DEFAULT_LOAD_FACTOR) {
break;
}
}
}

判断完成之后,就将需要存储的数据信息(CacheInfo)和数据详细内容(entry.data)依次存储到文件中:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
@Override
public void put(String key, Entry entry) {
synchronized (mLock) {
awaitInitializeLocked();
trimToMaxSize(entry.data.length);
File file = getFileForKey(key);
BufferedOutputStream fos = null;
try {
fos = new BufferedOutputStream(new FileOutputStream(file));
CacheInfo info = new CacheInfo(key, entry); //创建CacheInfo
boolean success = info.writeCacheInfo(fos); //将CacheInfo信息写入到文件前面
if (!success) {
return;
}
fos.write(entry.data); //将data数据写入到文件后面
file.setLastModified(System.currentTimeMillis());//设置时间为了初始化时缓存排序
putCacheInfo(key, info); //保存CachInfo到map中
} catch (Exception e) {
boolean deleted = file.delete();
e.printStackTrace();
} finally {
...
}
}
}

以上就是DiskDataCacher主要的实现思路

总结

  1. 通过以上源码分析,容易知道,在get put方法一定要在初始化方法(initialize())完成之后进行,因此,代码中使用了mLock.wait()和mLock.notifyAll()方法对此进行控制,initialize()方法最好在Application的onCreate中调用。
  2. 因为是磁盘缓存,当存储较大数据时,磁盘读写会比较耗时,因此需要在工作线程中执行,代码中已经封装好了一个工具DiskStringCacheManager,实现了对字符串的缓存以及线程池的封装。
  3. 需要缓存Bitmap或者JsonObject的话,只需要实现一个类似于DiskStringCacheManager的类,将String与byte[]的转换更改为Bitmap与byte[]的转换即可。当然,此处也有进一步的优化空间,可以将DiskStringCacheManager中String换成泛型,这样可以更容易扩展对其他类型数据的缓存。