RxCache
RxCache 是一款支援 Java 和 Android 的 Local Cache 。目前，支援堆記憶體、堆外記憶體(off-heap memory)、磁碟快取。
github地址：github.com/fengzhizi71…
堆外記憶體(off-heap memory)
物件可以儲存在 堆記憶體、堆外記憶體、磁碟快取甚至是分散式快取。
在 Java 中，與堆外記憶體相對的是堆記憶體。堆記憶體遵守 JVM 的記憶體管理機制，而堆外記憶體不受到此限制，它由作業系統進行管理。
堆外記憶體和堆記憶體有明顯的區別，或者說有相反的應用場景。
堆外記憶體更適合：
- 儲存生命週期長的物件
- 可以在程式間可以共享，減少 JVM 間的物件複製，使得 JVM 的分割部署更容易實現。
- 本地快取，減少磁碟快取或者分散式快取的響應時間。
RxCache 中使用的堆外記憶體
首先，建立一個 DirectBufferConverter ，用於將物件和 ByteBuffer 相互轉換，以及物件和byte陣列相互轉換。其中，ByteBuffer.allocteDirect(capability) 用於分配堆外記憶體。Cleaner 是自己定義的一個類，用於釋放 DirectByteBuffer。具體程式碼可以檢視：github.com/fengzhizi71…
public abstract class DirectBufferConverter<V> {
public void dispose(ByteBuffer direct) {
Cleaner.clean(direct);
}
public ByteBuffer to(V from) {
if(from == null) return null;
byte[] bytes = toBytes(from);
ByteBuffer.wrap(bytes);
ByteBuffer bf = ByteBuffer.allocateDirect(bytes.length);
bf.put(bytes);
bf.flip();
return bf;
}
abstract public byte[] toBytes(V value);
abstract public V toObject(byte[] value);
public V from(ByteBuffer to) {
if(to == null) return null;
byte[] bs = new byte[to.capacity()];
to.get(bs);
to.flip();
return toObject(bs);
}
}
複製程式碼接下來，定義一個 ConcurrentDirectHashMap<K, V> 實現Map介面。它是一個範性，支援將 V 轉換成 ByteBuffer 型別，儲存到 ConcurrentDirectHashMap 的 map 中。
public abstract class ConcurrentDirectHashMap<K, V> implements Map<K, V> {
final private Map<K, ByteBuffer> map;
private final DirectBufferConverter<V> converter = new DirectBufferConverter<V>() {
@Override
public byte[] toBytes(V value) {
return convertObjectToBytes(value);
}
@Override
public V toObject(byte[] value) {
return convertBytesToObject(value);
}
};
ConcurrentDirectHashMap() {
map = new ConcurrentHashMap<>();
}
ConcurrentDirectHashMap(Map<K, V> m) {
map = new ConcurrentHashMap<>();
for (Entry<K, V> entry : m.entrySet()) {
K key = entry.getKey();
ByteBuffer val = converter.to(entry.getValue());
map.put(key, val);
}
}
protected abstract byte[] convertObjectToBytes(V value);
protected abstract V convertBytesToObject(byte[] value);
@Override
public int size() {
return map.size();
}
@Override
public boolean isEmpty() {
return map.isEmpty();
}
@Override
public boolean containsKey(Object key) {
return map.containsKey(key);
}
@Override
public V get(Object key) {
final ByteBuffer byteBuffer = map.get(key);
return converter.from(byteBuffer);
}
@Override
public V put(K key, V value) {
final ByteBuffer byteBuffer = map.put(key, converter.to(value));
converter.dispose(byteBuffer);
return converter.from(byteBuffer);
}
@Override
public V remove(Object key) {
final ByteBuffer byteBuffer = map.remove(key);
final V value = converter.from(byteBuffer);
converter.dispose(byteBuffer);
return value;
}
@Override
public void putAll(Map<? extends K, ? extends V> m) {
for (Entry<? extends K, ? extends V> entry : m.entrySet()) {
ByteBuffer byteBuffer = converter.to(entry.getValue());
map.put(entry.getKey(), byteBuffer);
}
}
@Override
public void clear() {
final Set<K> keys = map.keySet();
for (K key : keys) {
map.remove(key);
}
}
@Override
public Set<K> keySet() {
return map.keySet();
}
@Override
public Collection<V> values() {
Collection<V> values = new ArrayList<>();
for (ByteBuffer byteBuffer : map.values())
{
V value = converter.from(byteBuffer);
values.add(value);
}
return values;
}
@Override
public Set<Entry<K, V>> entrySet() {
Set<Entry<K, V>> entries = new HashSet<>();
for (Entry<K, ByteBuffer> entry : map.entrySet()) {
K key = entry.getKey();
V value = converter.from(entry.getValue());
entries.add(new Entry<K, V>() {
@Override
public K getKey() {
return key;
}
@Override
public V getValue() {
return value;
}
@Override
public V setValue(V v) {
return null;
}
});
}
return entries;
}
@Override
public boolean containsValue(Object value) {
for (ByteBuffer v : map.values()) {
if (v.equals(value)) {
return true;
}
}
return false;
}
}
複製程式碼建立 ConcurrentStringObjectDirectHashMap，它的 K 是 String 型別，V 是任意的 Object 物件。其中，序列化和反序列化採用《Java 位元組的常用封裝》提到的 bytekit。
public class ConcurrentStringObjectDirectHashMap extends ConcurrentDirectHashMap<String,Object> {
@Override
protected byte[] convertObjectToBytes(Object value) {
return Bytes.serialize(value);
}
@Override
protected Object convertBytesToObject(byte[] value) {
return Bytes.deserialize(value);
}
}
複製程式碼基於 FIFO 以及堆外記憶體來實現 Memory 級別的快取。
public class DirectBufferMemoryImpl extends AbstractMemoryImpl {
private ConcurrentStringObjectDirectHashMap cache;
private List<String> keys;
public DirectBufferMemoryImpl(long maxSize) {
super(maxSize);
cache = new ConcurrentStringObjectDirectHashMap();
this.keys = new LinkedList<>();
}
@Override
public <T> Record<T> getIfPresent(String key) {
T result = null;
if(expireTimeMap.get(key)!=null) {
if (expireTimeMap.get(key)<0) { // 快取的資料從不過期
result = (T) cache.get(key);
} else {
if (timestampMap.get(key) + expireTimeMap.get(key) > System.currentTimeMillis()) { // 快取的資料還沒有過期
result = (T) cache.get(key);
} else { // 快取的資料已經過期
evict(key);
}
}
}
return result != null ? new Record<>(Source.MEMORY,key, result, timestampMap.get(key),expireTimeMap.get(key)) : null;
}
@Override
public <T> void put(String key, T value) {
put(key,value, Constant.NEVER_EXPIRE);
}
@Override
public <T> void put(String key, T value, long expireTime) {
if (keySet().size()<maxSize) { // 快取還有空間
saveValue(key,value,expireTime);
} else { // 快取空間不足，需要刪除一個
if (containsKey(key)) {
keys.remove(key);
saveValue(key,value,expireTime);
} else {
String oldKey = keys.get(0); // 最早快取的key
evict(oldKey); // 刪除最早快取的資料 FIFO演算法
saveValue(key,value,expireTime);
}
}
}
private <T> void saveValue(String key, T value, long expireTime) {
cache.put(key,value);
timestampMap.put(key,System.currentTimeMillis());
expireTimeMap.put(key,expireTime);
keys.add(key);
}
@Override
public Set<String> keySet() {
return cache.keySet();
}
@Override
public boolean containsKey(String key) {
return cache.containsKey(key);
}
@Override
public void evict(String key) {
cache.remove(key);
timestampMap.remove(key);
expireTimeMap.remove(key);
keys.remove(key);
}
@Override
public void evictAll() {
cache.clear();
timestampMap.clear();
expireTimeMap.clear();
keys.clear();
}
}
複製程式碼到了這裡，已經完成了堆外記憶體在 RxCache 中的封裝。其實，已經有很多快取框架都支援堆外記憶體，例如 Ehcache、MapDB 等。RxCache 目前已經有了 MapDB 的模組。
總結
RxCache 是一款 Local Cache，它已經應用到我們專案中，也在我個人的爬蟲框架 NetDiscovery 中使用。未來，它會作為一個成熟的元件，不斷運用到公司和個人的其他專案中。
RxCache 系列的相關文章：
- ReentrantReadWriteLock讀寫鎖及其在 RxCache 中的使用
- Retrofit 風格的 RxCache及其多種快取替換演算法
- RxCache 整合 Android 的持久層框架 greenDAO、Room
- 給 Java 和 Android 構建一個簡單的響應式Local Cache
Java與Android技術棧：每週更新推送原創技術文章，歡迎掃描下方的公眾號二維碼並關注，期待與您的共同成長和進步。
