Mybatis Cache缓存机制

wendu

　　剖析两个经典的缓存策略：最近最少被使用(LRU)和软引用缓存
　　LRU，Mybatis巧妙的使用了LinkedHashMap.removeEldestEntry，此方法是一个受保护的方法，继承并重写这个方法，在方法中eldestKey持有被回收的对象，在做相关操作的使用轮训eldestKey，发现对象存在的时候，回收缓存容器中的对象。

public class LruCache implements Cache {
private final Cache delegate;
private Map<Object, Object> keyMap;
private Object eldestKey;
public LruCache(Cache delegate) {
this.delegate = delegate;
setSize(1024);
}
public String getId() {
return delegate.getId();
}
public int getSize() {
return delegate.getSize();
}
public void setSize(final int size) {
keyMap = new LinkedHashMap<Object, Object>(size, .75F, true) {
private static final long serialVersionUID = 4267176411845948333L;
protected boolean removeEldestEntry(Map.Entry<Object, Object> eldest) {
boolean tooBig = size() > size;
if (tooBig) {
eldestKey = eldest.getKey();
}
return tooBig;
}
};
}
public void putObject(Object key, Object value) {
delegate.putObject(key, value);
cycleKeyList(key);
}
public Object getObject(Object key) {
keyMap.get(key); //touch
return delegate.getObject(key);
}
public Object removeObject(Object key) {
return delegate.removeObject(key);
}
public void clear() {
delegate.clear();
keyMap.clear();
}
public ReadWriteLock getReadWriteLock() {
return delegate.getReadWriteLock();
}
private void cycleKeyList(Object key) {
keyMap.put(key, key);
if (eldestKey != null) {
delegate.removeObject(eldestKey);
eldestKey = null;
}
}
}
　　软引用缓存，个人认为比较高效的缓存，也是结合了Java垃圾回收的特点，也就是说如果对象不被引用，一旦开始垃圾回收，则该缓存对象会被回收。Mybatis使用了ReferenceQueue，会根据垃圾回收结果，在操作缓存是，回收缓存容器对象。

public class SoftCache implements Cache {
private final LinkedList hardLinksToAvoidGarbageCollection;
private final ReferenceQueue queueOfGarbageCollectedEntries;
private final Cache delegate;
private int numberOfHardLinks;
public SoftCache(Cache delegate) {
this.delegate = delegate;
this.numberOfHardLinks = 256;
this.hardLinksToAvoidGarbageCollection = new LinkedList();
this.queueOfGarbageCollectedEntries = new ReferenceQueue();
}
public String getId() {
return delegate.getId();
}
public int getSize() {
removeGarbageCollectedItems();
return delegate.getSize();
}
public void setSize(int size) {
this.numberOfHardLinks = size;
}
public void putObject(Object key, Object value) {
removeGarbageCollectedItems();
delegate.putObject(key, new SoftEntry(key, value, queueOfGarbageCollectedEntries));
}
public Object getObject(Object key) {
Object result = null;
SoftReference softReference = (SoftReference) delegate.getObject(key);
if (softReference != null) {
result = softReference.get();
if (result == null) {
delegate.removeObject(key);
} else {
hardLinksToAvoidGarbageCollection.addFirst(result);
if (hardLinksToAvoidGarbageCollection.size() > numberOfHardLinks) {
hardLinksToAvoidGarbageCollection.removeLast();
}
}
}
return result;
}
public Object removeObject(Object key) {
removeGarbageCollectedItems();
return delegate.removeObject(key);
}
public void clear() {
hardLinksToAvoidGarbageCollection.clear();
removeGarbageCollectedItems();
delegate.clear();
}
public ReadWriteLock getReadWriteLock() {
return delegate.getReadWriteLock();
}
private void removeGarbageCollectedItems() {
SoftEntry sv;
while ((sv = (SoftEntry) queueOfGarbageCollectedEntries.poll()) != null) {
delegate.removeObject(sv.key);
}
}
private static class SoftEntry extends SoftReference {
private final Object key;
private SoftEntry(Object key, Object value, ReferenceQueue garbageCollectionQueue) {
super(value, garbageCollectionQueue);
this.key = key;
}
}
}