介绍一个支持自动向前或向后预取的缓存。特性:1使用简单2可自动预取新数据3可选择多种缓存算法4省流量性能佳5支持不同类型网络处理6可序列化到本地缓存,可从文件中恢复7扩展性强

本文主要介绍一个支持自动向前或向后获取新数据的缓存的使用及功能。Android图片内存缓存可见ImageCache。

主要特性：(1).使用简单 (2).可自动预取新数据 (3).可选择多种缓存算法(包括FIFO、LIFO、LRU、MRU、LFU、MFU等15种)或自定义缓存算法 (4).省流量性能佳(有且仅有一个线程获取数据) (5).支持不同类型网络处理 (6)缓存可序列化到本地缓存可从文件中恢复 (7).扩展性强 (8). 包含map的大多数接口

适用：Java和Android开发中获取数据较耗时的应用，如网络通讯、响应慢数据获取，在类似网易新闻、花瓣这类应用中可以起到很好的效果。对于图片缓存可直接使用ImageCache。

1、使用

引入TrineaAndroidCommon@Github(欢迎star和fork^_^)作为你项目的library(如何拉取代码及添加公共库)，或是自己抽取其中的PreloadDataCache@Github部分使用。

测试场景：获取每个数据需用时2秒，10次获取的场景效果对比，缓存前用时(ms)：20004，缓存后用时(ms)：4026。缓存命中率为80%。实例代码如下：

private static String[]            data       = { "data1", "data2", "data3", "data4", "data5", "data6", "data7",
		"data8", "data9", "data10", "data11", "data12", "data13", "data14", "data15", "data16", "data17", "data18",
		"data19", "data20"                   };
private static ArrayList<String>   keyList    = new ArrayList<String>();
private static Map<String, String> dataSource = new HashMap<String, String>();
private static int                 index      = 0;

/**
 * 初始化数据源
 */
static {
	for (int i = 0; i < data.length; i++) {
		String temp = Integer.toString(i);
		dataSource.put(temp, data[i]);
		keyList.add(temp);
	}
}

/**
 * 模拟从数据源中获取数据
 * 
 * @return
 */
public static String getSlowResponseData() {
	try {
		Thread.sleep(2000);
	} catch (InterruptedException e) {
		e.printStackTrace();
	}
	return dataSource.get(Integer.toString((index++) % keyList.size()));
}

public static void main(String[] args) {
	// init cache, setOnGetDataListener
	PreloadDataCache<String, String> cache = new PreloadDataCache<String, String>(5);
	cache.setOnGetDataListener((new OnGetDataListener<String, String>() {

		private static final long serialVersionUID = 1L;

		@Override
		public CacheObject<String> onGetData(String key) {
			CacheObject<String> o = new CacheObject<String>();
			o.setData(getSlowResponseData());
			return o;
		}
	}));
	cache.setCacheFullRemoveType(new RemoveTypeEnterTimeFirst<String>());

	// get data by cache
	int count = 10;
	long start = System.currentTimeMillis();
	for (int i = 0; i < count; i++) {
		System.out.print(cache.get(Integer.toString(i), keyList).getData() + " ");
	}
	System.out.println("\r\n缓存后用时(ms)：" + (System.currentTimeMillis() - start) + "。缓存命中率为" + cache.getHitRate()
					   + "(" + cache.getHitCount() + "/" + (cache.getHitCount() + cache.getMissCount()) + ")");

	// get data normal
	start = System.currentTimeMillis();
	for (int i = 0; i < count; i++) {
		System.out.print(getSlowResponseData() + " ");
	}
	System.out.println("\r\n缓存前用时(ms)：" + (System.currentTimeMillis() - start));
}

private static String[] data = { "data1", "data2", "data3", "data4", "data5", "data6", "data7",

"data8", "data9", "data10", "data11", "data12", "data13", "data14", "data15", "data16", "data17", "data18",

"data19", "data20" };

private static ArrayList<String> keyList = new ArrayList<String>();

private static Map<String, String> dataSource = new HashMap<String, String>();

private static int index = 0;

/**

* 初始化数据源

static {

for (int i = 0; i < data.length; i++) {

String temp = Integer.toString(i);

dataSource.put(temp, data[i]);

keyList.add(temp);

}

/**

* 模拟从数据源中获取数据

* @return

public static String getSlowResponseData() {

try {

Thread.sleep(2000);

} catch (InterruptedException e) {

e.printStackTrace();

}

return dataSource.get(Integer.toString((index++) % keyList.size()));

}

public static void main(String[] args) {

// init cache, setOnGetDataListener

PreloadDataCache<String, String> cache = new PreloadDataCache<String, String>(5);

cache.setOnGetDataListener((new OnGetDataListener<String, String>() {

private static final long serialVersionUID = 1L;

@Override

public CacheObject<String> onGetData(String key) {

CacheObject<String> o = new CacheObject<String>();

o.setData(getSlowResponseData());

return o;

}

}));

cache.setCacheFullRemoveType(new RemoveTypeEnterTimeFirst<String>());

// get data by cache

int count = 10;

long start = System.currentTimeMillis();

for (int i = 0; i < count; i++) {

System.out.print(cache.get(Integer.toString(i), keyList).getData() + " ");

}

System.out.println("\r\n缓存后用时(ms)：" + (System.currentTimeMillis() - start) + "。缓存命中率为" + cache.getHitRate()

+ "(" + cache.getHitCount() + "/" + (cache.getHitCount() + cache.getMissCount()) + ")");

// get data normal

start = System.currentTimeMillis();

for (int i = 0; i < count; i++) {

System.out.print(getSlowResponseData() + " ");

}

System.out.println("\r\n缓存前用时(ms)：" + (System.currentTimeMillis() - start));

}

从上面的代码中缓存定义部分可以看出，只需要定义PreloadDataCache，并设置获取数据的接口setOnGetDataListener，以后使用get获取数据即可。

2、功能介绍
(1) 初始化缓存
可以使用以下四种方式之一初始化缓存
PreloadDataCache()
PreloadDataCache(int)
PreloadDataCache(int, int)
loadCache(String) 从文件中恢复缓存
支持缓存大小和获取数据线程池大小的设置，默认缓存大小为SimpleCache#DEFAULT_MAX_SIZE，默认线程池大小根据系统Cpu个数设置。

(2)、设置数据获取方式
public void setOnGetDataListener(OnGetDataListener<K, V> onGetDataListener)
设置数据获取的方式。缓存通过该接口获取数据及预取数据。

(3) 获取及预取数据
public CacheObject<V> get(K key, List<K> keyList) get某个key(同步)，并且会根据key在keyList中的顺序自动向前或向后获取新数据进行缓存
public CacheObject<V> get(K key) get某个key(同步)，但不会自动获取新数据进行缓存
public void setForwardCacheNumber(int forwardCacheNumber) 向前预取数据个数设置，默认为PreloadDataCache#DEFAULT_FORWARD_CACHE_NUMBER

public void setBackwardCacheNumber(int backwardCacheNumber)向后预取数据个数设置默认，默认为PreloadDataCache#DEFAULT_BACKWARD_CACHE_NUMBER

(4)、设置缓存算法
public void setCacheFullRemoveType(CacheFullRemoveType<V> cacheFullRemoveType)
设置缓存算法，缓存算法即为缓存满时为了插入新数据，删除旧数据的规则。

目前包括FIFO、LIFO、LRU、MRU、LFU、MFU、优先级低先删除、优先级高先删除、数据小先删除、数据大先删除、图片小先删除、图片大先删除、文件小的先删除、文件大的先删除、永不删除。还可以通过实现CacheFullRemoveType来自定义缓存算法。。默认为RemoveTypeEnterTimeFirst，即先进先出。下面为详细介绍

RemoveTypeEnterTimeFirst FIFO先进先出，先进入先删除
RemoveTypeEnterTimeLast LIFO后进先出，后进入先删除
RemoveTypeLastUsedTimeFirst LRU(Least Recently User)，最先使用先删除
RemoveTypeLastUsedTimeLast MRU(Most Recently Used)，最近使用先删除
RemoveTypeUsedCountSmall LFU(Least Frequently Used)，使用频率低先删除
RemoveTypeUsedCountBig MRU(Most Frequently Used)，使用频率高先删除
RemoveTypePriorityLow 优先级低先删除
RemoveTypePriorityHigh 优先级低先删除
RemoveTypeDrawableSmall 图片小的先删除
RemoveTypeDrawableLarge 图片大的先删除

RemoveTypeFileSmall 文件小的先删除

RemoveTypeFileLarge 文件大的先删除
RemoveTypeDataBig 数据大先删除，根据缓存数据的compareTo函数决定
RemoveTypeDataSmall 数据小先删除，根据缓存数据的compareTo函数决定
RemoveTypeNotRemove 不删除，缓存满时不再允许插入新数据

自定义缓存算法只需要实现CacheFullRemoveType的compare方法即可。比较结果小于0表示会被先删除

public class RemoveTypePriorityHigh<T> implements CacheFullRemoveType<T> {

    private static final long serialVersionUID = 1L;

    @Override
    public int compare(CacheObject<T> obj1, CacheObject<T> obj2) {
        return (obj2.getPriority() > obj1.getPriority()) ? 1 : ((obj2.getPriority() == obj1.getPriority()) ? 0 : -1);
    }
}

public class RemoveTypePriorityHigh<T> implements CacheFullRemoveType<T> {

private static final long serialVersionUID = 1L;

@Override

public int compare(CacheObject<T> obj1, CacheObject<T> obj2) {

return (obj2.getPriority() > obj1.getPriority()) ? 1 : ((obj2.getPriority() == obj1.getPriority()) ? 0 : -1);

}

(5)、优化数据读取
a. 设置数据读取http超时
public void setHttpReadTimeOut(int httpReadTimeOut)
若httpReadTimeOut小于0表示不设置超时，默认不设置，单位为毫秒

b. 设置无网络不读取
public void setContext(Context context)
设置context，网络连接失败不会新建线程请求数据。

c. 支持不同网络类型的处理
public void setAllowedNetworkTypes(int allowedNetworkTypes)
设置允许的网络类型，可选择PreloadDataCache#NETWORK_MOBILE、PreloadDataCache#NETWORK_WIFI或两者都允许。默认两者都允许。
注意：这个接口生效必须先setContext(Context context)

(6)、缓存元素有效时间
public void setValidTime(long validTime)
设置缓存元素有效时间，小于0表示不会失效，此时仅根据CacheFullRemoveType在缓存满时替换元素
通过protected boolean isExpired(K key)判断某key是否过期

(7)、缓存命中率
getHitRate()、getHitCount()、getMissCount()分别表示缓存命中率、命中次数、未命中次数

(8) 序列化
序列化需要缓存数据类型支持Serializable，关于序列化可参考Java Serializable的理解和总结

使用loadCache(String)从文件中恢复缓存
saveCache(String, SimpleCache)保存缓存到文件

(9)、其他与map类似接口
public boolean containsKey(K key) 缓存中是否包含该key
public CacheObject<V> remove(K key) 从缓存中删除某个key
public void clear() 清空缓存
public Set<K> keySet() 缓存中key集合
public Set<Map.Entry<K, CacheObject<V>>> entrySet() 缓存中key,value键值对集合
public Collection<CacheObject<V>> values() 缓存中元素集合
public CacheObject<V> put(K key, V value) 手动插入某个元素
public CacheObject<V> put(K key, CacheObject<V> value) 手动插入某个元素
public CacheObject<V> get(K key) 得到某个key
public int getSize() 得到缓存中有效元素个数
public int getMaxSize() 得到缓存中元素最大个数

(10)得到设置
上面的set几乎都可以通过对应的get得到相应value
使用getOnGetDataListener()得到获取数据的方法
getForwardCacheNumber()得到自动向前缓存的个数
getBackCacheNumber()得到自动向后缓存的个数
getMaxSize()得到缓存最大容量
getValidTime()得到有效时间，以毫秒计
getCacheFullRemoveType()得到cache满时删除元素类型

10 thoughts on “PreloadDataCache支持预取的数据缓存，使用简单，支持多种缓存算法，支持不同网络类型，扩展性强”

WymSkPhN

2024 年 1 月 22 日 at 上午 2:27

1

回复
anonymous

2014 年 5 月 29 日 at 上午 9:45

我说一下我需要实现的功能吧，看你们能不能给个建议，我这边从网络获取数据，存入本地，由于网络是使用的第三方的云服务，所以网络实现改不了，不能使用你们提供的HttpCache，我看到你们里面有个preloaddatacache，所以就想试试。但是一直失败，不知道有没有好的建议，谢谢。我的QQ：493797369。很急！！！！！！！！！！！！！！

回复
anonymous

2014 年 5 月 29 日 at 上午 9:43

(8) 序列化序列化需要缓存数据类型支持Serializable，关于序列化可参考Java Serializable的理解和总结使用loadCache(String)从文件中恢复缓存saveCache(String, SimpleCache)保存缓存到文件存文件时总是提示FileNotFoundException occurred.我传了路径，怎么提时候这个错误呢，saveCache的时候根本没存进去，我看了路径下面没任何文件。save代码：SimpleCache.saveCache(LoveCrystalCookie.ANONY_CAMERA_DATA_PATH, simp);

回复
- Trinea
  
  2014 年 5 月 29 日 at 下午 1:21
  
  保存文件需要有写sd卡权限，如果有权限还是有问题，源码都有，直接Debug看看
  
  回复
柯震陆

2014 年 3 月 13 日 at 下午 10:20

请问，如果我想获取网络请求的数据，是直接用就好，还是要先获取数据，在用这个预取？

回复
- Trinea
  
  2014 年 3 月 13 日 at 下午 11:28
  
  直接用更好。另外网络预取你的需求很强烈？建议你用我博客上介绍的网络缓存httpcache
  
  回复
李铁山

2014 年 3 月 3 日 at 下午 5:27

如果有的话就给些代码实例，那样的话好做参考啊，明天早上就要做成功。

回复
ai钢镚儿

2013 年 10 月 10 日 at 下午 2:30

膜拜中

回复
dzwillpower

2013 年 7 月 11 日 at 下午 2:42

怎么样可以联系到你有一些问题想请教谢谢

回复
- Trinea
  
  2013 年 7 月 11 日 at 下午 3:32
  
  什么问题？
  
  回复