简介

在优化系统性能时，优化数据库性能是非常重要的一个环节，而添加缓存则是优化数据库时最有效的手段之一。正确、合理地使用缓存可以将一部分数据库请求拦截在缓存这一层。

MyBatis 中提供了一级缓存和二级缓存，而这两级缓存都是依赖于基础支持层中的缓存模块实现的。这里需要注意的是，MyBatis 中自带的这两级缓存与 MyBatis 以及整个应用是运行在同一个 JVM 中的，共享同一块堆内存。如果这两级缓存中的数据量较大， 则可能影响系统中其他功能的运行，所以当需要缓存大量数据时，优先考虑使用 Redis、Memcache 等缓存产品

缓存模块的类图

缓存接口

public interface Cache {//获取当前缓存对象的idString getId();//保存缓存对象  void putObject(Object key, Object value);//获取缓存对象Object getObject(Object key);//删除缓存对象Object removeObject(Object key);//清空缓存void clear();//获取缓存的大小，这里返回的是缓存中对象的个数，而不是缓存对象占用内存的大小int getSize();//获取可重入锁，默认方法，由具体子类实现default ReadWriteLock getReadWriteLock() {return null;}
}

缓存实现

PerpetualCache

永久内存实现，底层使用使用线程不安全的HashMap作为缓存对象，只是对Map接口api的简单包装

public class PerpetualCache implements Cache {private final String id;//使用HashMap作为缓存private final Map<Object, Object> cache = new HashMap<>();public PerpetualCache(String id) {this.id = id;}@Overridepublic String getId() {return id;}@Overridepublic int getSize() {return cache.size();}@Overridepublic void putObject(Object key, Object value) {cache.put(key, value);}@Overridepublic Object getObject(Object key) {return cache.get(key);}@Overridepublic Object removeObject(Object key) {return cache.remove(key);}@Overridepublic void clear() {cache.clear();}@Overridepublic boolean equals(Object o) {if (getId() == null) {throw new CacheException("Cache instances require an ID.");}//同一个缓存实例if (this == o) {return true;}if (!(o instanceof Cache)) {return false;}//如果两个缓存实例的id相同，也视为相等Cache otherCache = (Cache) o;return getId().equals(otherCache.getId());}/*** id的hashcode**/@Overridepublic int hashCode() {if (getId() == null) {throw new CacheException("Cache instances require an ID.");}return getId().hashCode();}}

LoggingCache

支持打印日志的缓存，与PerpetualCache不同的是增加了请求计数和命中计数属性，并会在debug日志级别时将这两个属性的值打印，与缓存有关的操作委派给了delegate属性中的缓存对应

public class LoggingCache implements Cache {private final Log log;//包装的缓存对象private final Cache delegate;//请求计数protected int requests = 0;//缓存命中计数protected int hits = 0;public LoggingCache(Cache delegate) {this.delegate = delegate;this.log = LogFactory.getLog(getId());}@Overridepublic String getId() {return delegate.getId();}@Overridepublic int getSize() {return delegate.getSize();}@Overridepublic void putObject(Object key, Object object) {delegate.putObject(key, object);}@Overridepublic Object getObject(Object key) {//请求计数加一requests++;final Object value = delegate.getObject(key);//如果get到了值，则对命中计数加一if (value != null) {hits++;}if (log.isDebugEnabled()) {log.debug("Cache Hit Ratio [" + getId() + "]: " + getHitRatio());}return value;}@Overridepublic Object removeObject(Object key) {return delegate.removeObject(key);}@Overridepublic void clear() {delegate.clear();}@Overridepublic int hashCode() {return delegate.hashCode();}@Overridepublic boolean equals(Object obj) {return delegate.equals(obj);}//获取缓存的命中率//命中率 = 命中次数/请求次数private double getHitRatio() {return (double) hits / (double) requests;}}

BlockingCache

阻塞缓存实现

一般情况下，当在缓存中获取不到数据后，都会向缓存中put值。所以BlockingCache会阻塞后续所有请求该缓存的请求，直到当前线程添加完缓存对象，防止多个线程同时填加同一个缓存对象。

public class BlockingCache implements Cache {//超时时间private long timeout;//包装的缓存实例private final Cache delegate;//缓存key 与 ReentrantLock 锁对象的映射private final ConcurrentHashMap<Object, ReentrantLock> locks;public BlockingCache(Cache delegate) {this.delegate = delegate;this.locks = new ConcurrentHashMap<>();}@Overridepublic String getId() {return delegate.getId();}@Overridepublic int getSize() {return delegate.getSize();}@Overridepublic void putObject(Object key, Object value) {try {delegate.putObject(key, value);} finally {releaseLock(key);}}@Overridepublic Object getObject(Object key) {//获取key对应的锁acquireLock(key);Object value = delegate.getObject(key);if (value != null) {//释放锁releaseLock(key);}return value;}@Overridepublic Object removeObject(Object key) {// despite of its name, this method is called only to release locksreleaseLock(key);return null;}@Overridepublic void clear() {delegate.clear();}private ReentrantLock getLockForKey(Object key) {//从locks属性中获取缓存key对应的可重入锁对象return locks.computeIfAbsent(key, k -> new ReentrantLock());}private void acquireLock(Object key) {Lock lock = getLockForKey(key);if (timeout > 0) {try {//尝试获取锁资源，超时时间为timeoutboolean acquired = lock.tryLock(timeout, TimeUnit.MILLISECONDS);if (!acquired) {throw new CacheException("Couldn't get a lock in " + timeout + " for the key " +  key + " at the cache " + delegate.getId());}} catch (InterruptedException e) {throw new CacheException("Got interrupted while trying to acquire lock for key " + key, e);}} else {lock.lock();}}private void releaseLock(Object key) {ReentrantLock lock = locks.get(key);//如果持有锁的线程就是当前线程，则释放锁资源if (lock.isHeldByCurrentThread()) {lock.unlock();}}public long getTimeout() {return timeout;}public void setTimeout(long timeout) {this.timeout = timeout;}
}

SynchronizedCache

同步缓存，只是单纯的通过synchronized关键字的方式把所有方法变成同步的，简单粗暴

/*** @author Clinton Begin*/
public class SynchronizedCache implements Cache {private final Cache delegate;public SynchronizedCache(Cache delegate) {this.delegate = delegate;}@Overridepublic String getId() {return delegate.getId();}@Overridepublic synchronized int getSize() {return delegate.getSize();}@Overridepublic synchronized void putObject(Object key, Object object) {delegate.putObject(key, object);}@Overridepublic synchronized Object getObject(Object key) {return delegate.getObject(key);}@Overridepublic synchronized Object removeObject(Object key) {return delegate.removeObject(key);}@Overridepublic synchronized void clear() {delegate.clear();}@Overridepublic int hashCode() {return delegate.hashCode();}@Overridepublic boolean equals(Object obj) {return delegate.equals(obj);}}

SerializedCache

支持序列化值的 Cache 实现类

如果缓存的value没有实现Serializable接口，则抛出异常

如果缓存的value实现了Serializable接口，则将其序列化为二级制流

/*** @author Clinton Begin*/
public class SerializedCache implements Cache {private final Cache delegate;public SerializedCache(Cache delegate) {this.delegate = delegate;}@Overridepublic String getId() {return delegate.getId();}@Overridepublic int getSize() {return delegate.getSize();}@Overridepublic void putObject(Object key, Object object) {if (object == null || object instanceof Serializable) {delegate.putObject(key, serialize((Serializable) object));} else {throw new CacheException("SharedCache failed to make a copy of a non-serializable object: " + object);}}@Overridepublic Object getObject(Object key) {Object object = delegate.getObject(key);return object == null ? null : deserialize((byte[]) object);}@Overridepublic Object removeObject(Object key) {return delegate.removeObject(key);}@Overridepublic void clear() {delegate.clear();}@Overridepublic int hashCode() {return delegate.hashCode();}@Overridepublic boolean equals(Object obj) {return delegate.equals(obj);}/*** 将对象序列化为二进制流**/private byte[] serialize(Serializable value) {try (ByteArrayOutputStream bos = new ByteArrayOutputStream();ObjectOutputStream oos = new ObjectOutputStream(bos)) {oos.writeObject(value);oos.flush();return bos.toByteArray();} catch (Exception e) {throw new CacheException("Error serializing object.  Cause: " + e, e);}}/*** 将二进制流反序列化为对象**/private Serializable deserialize(byte[] value) {Serializable result;try (ByteArrayInputStream bis = new ByteArrayInputStream(value);ObjectInputStream ois = new CustomObjectInputStream(bis)) {result = (Serializable) ois.readObject();} catch (Exception e) {throw new CacheException("Error deserializing object.  Cause: " + e, e);}return result;}public static class CustomObjectInputStream extends ObjectInputStream {public CustomObjectInputStream(InputStream in) throws IOException {super(in);}//重写了ObjectInputStream#resolveClass方法//以mybatis定义的类加载器的优先级去获取对应的Class对象@Overrideprotected Class<?> resolveClass(ObjectStreamClass desc) throws ClassNotFoundException {return Resources.classForName(desc.getName());}}}

ScheduledCache

定期清理所有缓存，本质上是对过期键的一种删除策略

在学习ScheduledCache代码之前，应该知道常见的过期键删除策略如下

1、定时删除，创建一个定时器，定期的扫描缓存中key是否过期，当到达过期时间时，立即将其删除。对内存友好，对cpu不友好

2、懒删除，也就是说即使缓存已经到了过期时间，也不会立即删除，只是在下次获取该缓存的时候进行判断，如果已经过期则对其删除。对cpu友好，对内存不友好。

3、定期删除，定期删除是对定时删除策略的一种优化，通过定义一个定时器，每次扫描部分缓存的方式达到删除过期key的目的，一个合理的定期删除策略可以达到对cpu友好，对内存友好的双赢结果

ScheduledCache的删除策略是定期删除的一种，只不过比较暴力。。。

/*** @author Clinton Begin** 定期清理所有缓存*/
public class ScheduledCache implements Cache {private final Cache delegate;//清除时间间隔，默认为一小时protected long clearInterval;//上次清除缓存的时间戳protected long lastClear;public ScheduledCache(Cache delegate) {this.delegate = delegate;this.clearInterval = TimeUnit.HOURS.toMillis(1);this.lastClear = System.currentTimeMillis();}public void setClearInterval(long clearInterval) {this.clearInterval = clearInterval;}@Overridepublic String getId() {return delegate.getId();}@Overridepublic int getSize() {clearWhenStale();return delegate.getSize();}@Overridepublic void putObject(Object key, Object object) {clearWhenStale();delegate.putObject(key, object);}@Overridepublic Object getObject(Object key) {return clearWhenStale() ? null : delegate.getObject(key);}@Overridepublic Object removeObject(Object key) {clearWhenStale();return delegate.removeObject(key);}@Overridepublic void clear() {lastClear = System.currentTimeMillis();delegate.clear();}@Overridepublic int hashCode() {return delegate.hashCode();}@Overridepublic boolean equals(Object obj) {return delegate.equals(obj);}private boolean clearWhenStale() {//直接清空所有的数据if (System.currentTimeMillis() - lastClear > clearInterval) {clear();return true;}return false;}}

FifoCache

基于队列的缓存

常见的内存淘汰策略如下(基于redis的策略)：

1、volatile-lru：在设置了过期时间的数据中，淘汰最近最少使用的数据

2、volatile-ttl：在设置了过期时间的数据中，淘汰马上到期的数据

3、volatile-random：在设置了过期时间的数据中，随机淘汰数据

4、allkeys-lru：在所有数据中，淘汰最近最少使用的数据

5、allkeys-random：在所有数据中，随机淘汰数据

6、no-enviction：不淘汰数据，内存不够就报错

7、还有就是FifoCache这种的策略，基于队列，淘汰最老的数据

public class FifoCache implements Cache {private final Cache delegate;//双端队列，队列中保存着缓存中所有的key，按照时间顺序入队private final Deque<Object> keyList;//队列大小，默认队列大小为1024private int size;public FifoCache(Cache delegate) {this.delegate = delegate;this.keyList = new LinkedList<>();this.size = 1024;}@Overridepublic String getId() {return delegate.getId();}@Overridepublic int getSize() {return delegate.getSize();}public void setSize(int size) {this.size = size;}@Overridepublic void putObject(Object key, Object value) {cycleKeyList(key);delegate.putObject(key, value);}@Overridepublic Object getObject(Object key) {return delegate.getObject(key);}@Overridepublic Object removeObject(Object key) {return delegate.removeObject(key);}@Overridepublic void clear() {delegate.clear();keyList.clear();}private void cycleKeyList(Object key) {//将缓存的key入队keyList.addLast(key);if (keyList.size() > size) {//触发内存淘汰机制Object oldestKey = keyList.removeFirst();//将key出队delegate.removeObject(oldestKey);//删除对应的缓存}}
}

LruCache

基于LinkedHashMap实现的一个Lru缓存，原理可以参考https://www.cnblogs.com/mengheng/p/3683137.html的内容

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);}@Overridepublic String getId() {return delegate.getId();}@Overridepublic 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;@Overrideprotected boolean removeEldestEntry(Map.Entry<Object, Object> eldest) {boolean tooBig = size() > size;if (tooBig) {eldestKey = eldest.getKey();}return tooBig;}};}@Overridepublic void putObject(Object key, Object value) {delegate.putObject(key, value);cycleKeyList(key);}@Overridepublic Object getObject(Object key) {keyMap.get(key); // touchreturn delegate.getObject(key);}@Overridepublic Object removeObject(Object key) {return delegate.removeObject(key);}@Overridepublic void clear() {delegate.clear();keyMap.clear();}private void cycleKeyList(Object key) {keyMap.put(key, key);//每次操作值的时候会将修改过的Entry移到连表的最后if (eldestKey != null) {delegate.removeObject(eldestKey);eldestKey = null;}}
}

WeakCache

弱引用缓存

public class WeakCache implements Cache {//强引用的队列private final Deque<Object> hardLinksToAvoidGarbageCollection;//已经被GC回收的Entry，当GC通过可达性分析发现对象已经不可达，需要被回收时，会将对象加入到ReferenceQueue//队列的实例中，等待GC回收private final ReferenceQueue<Object> queueOfGarbageCollectedEntries;private final Cache delegate;//强引用的个数private int numberOfHardLinks;public WeakCache(Cache delegate) {this.delegate = delegate;this.numberOfHardLinks = 256;this.hardLinksToAvoidGarbageCollection = new LinkedList<>();this.queueOfGarbageCollectedEntries = new ReferenceQueue<>();}@Overridepublic String getId() {return delegate.getId();}@Overridepublic int getSize() {removeGarbageCollectedItems();return delegate.getSize();}public void setSize(int size) {this.numberOfHardLinks = size;}@Overridepublic void putObject(Object key, Object value) {removeGarbageCollectedItems();delegate.putObject(key, new WeakEntry(key, value, queueOfGarbageCollectedEntries));}@Overridepublic Object getObject(Object key) {Object result = null;@SuppressWarnings("unchecked") // assumed delegate cache is totally managed by this cacheWeakReference<Object> weakReference = (WeakReference<Object>) delegate.getObject(key);if (weakReference != null) {result = weakReference.get();if (result == null) {//表示缓存对象已经被删除delegate.removeObject(key);} else {//表示当前对象还在hardLinksToAvoidGarbageCollection.addFirst(result);if (hardLinksToAvoidGarbageCollection.size() > numberOfHardLinks) {hardLinksToAvoidGarbageCollection.removeLast();}}}return result;}@Overridepublic Object removeObject(Object key) {removeGarbageCollectedItems();return delegate.removeObject(key);}@Overridepublic void clear() {hardLinksToAvoidGarbageCollection.clear();removeGarbageCollectedItems();delegate.clear();}//将缓存中已经被GC判定为GC Root不可达的对象删除private void removeGarbageCollectedItems() {WeakEntry sv;//循环删除被GC清除的所有缓存对象while ((sv = (WeakEntry) queueOfGarbageCollectedEntries.poll()) != null) {delegate.removeObject(sv.key);}}//弱引用，用于包装缓存中的key和value，会在GC下一次收集的时候被GC从堆中删除private static class WeakEntry extends WeakReference<Object> {private final Object key;private WeakEntry(Object key, Object value, ReferenceQueue<Object> garbageCollectionQueue) {super(value, garbageCollectionQueue);this.key = key;}}}

SoftCache

软引用缓存

public class SoftCache implements Cache {//强引用的队列private final Deque<Object> hardLinksToAvoidGarbageCollection;//已经被GC回收的Entry，当GC通过可达性分析发现对象已经不可达，需要被回收时，会将对象加入到ReferenceQueue//队列的实例中，等待GC回收private final ReferenceQueue<Object> 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<>();}@Overridepublic String getId() {return delegate.getId();}@Overridepublic int getSize() {removeGarbageCollectedItems();return delegate.getSize();}public void setSize(int size) {this.numberOfHardLinks = size;}@Overridepublic void putObject(Object key, Object value) {removeGarbageCollectedItems();delegate.putObject(key, new SoftEntry(key, value, queueOfGarbageCollectedEntries));}@Overridepublic Object getObject(Object key) {Object result = null;@SuppressWarnings("unchecked") // assumed delegate cache is totally managed by this cacheSoftReference<Object> softReference = (SoftReference<Object>) delegate.getObject(key);if (softReference != null) {result = softReference.get();if (result == null) {delegate.removeObject(key);} else {// See #586 (and #335) modifications need more than a read lock//没看懂为什么在软引用时需要加锁，而在弱引用时却不需要，上面的issue搜了一下，一脸懵逼的进去，一脸		//懵逼出来synchronized (hardLinksToAvoidGarbageCollection) {hardLinksToAvoidGarbageCollection.addFirst(result);if (hardLinksToAvoidGarbageCollection.size() > numberOfHardLinks) {hardLinksToAvoidGarbageCollection.removeLast();}}}}return result;}@Overridepublic Object removeObject(Object key) {removeGarbageCollectedItems();return delegate.removeObject(key);}@Overridepublic void clear() {synchronized (hardLinksToAvoidGarbageCollection) {hardLinksToAvoidGarbageCollection.clear();}removeGarbageCollectedItems();delegate.clear();}//将缓存中已经被GC判定为GC Root不可达的对象删除private void removeGarbageCollectedItems() {SoftEntry sv;//循环删除被GC清除的所有缓存对象while ((sv = (SoftEntry) queueOfGarbageCollectedEntries.poll()) != null) {delegate.removeObject(sv.key);}}//软引用，用于包装缓存中的key和value，会在内存不足的时候被GC从堆中删除private static class SoftEntry extends SoftReference<Object> {private final Object key;SoftEntry(Object key, Object value, ReferenceQueue<Object> garbageCollectionQueue) {super(value, garbageCollectionQueue);this.key = key;}}
}

CacheKey

缓存键对象，由多个对象组成。所以 CacheKey 可以理解成将多个对象放在一起，计算其缓存键。

public class CacheKey implements Cloneable, Serializable {private static final long serialVersionUID = 1146682552656046210L;//null对应的keypublic static final CacheKey NULL_CACHE_KEY = new CacheKey() {@Overridepublic void update(Object object) {throw new CacheException("Not allowed to update a null cache key instance.");}@Overridepublic void updateAll(Object[] objects) {throw new CacheException("Not allowed to update a null cache key instance.");}};private static final int DEFAULT_MULTIPLIER = 37;private static final int DEFAULT_HASHCODE = 17;private final int multiplier;//生成后的hashCodeprivate int hashcode;//校验和private long checksum;//updateList集合的size()private int count;// 8/21/2017 - Sonarlint flags this as needing to be marked transient. While true if content is not serializable, this// is not always true and thus should not be marked transient.//private List<Object> updateList;public CacheKey() {this.hashcode = DEFAULT_HASHCODE;this.multiplier = DEFAULT_MULTIPLIER;this.count = 0;this.updateList = new ArrayList<>();}public CacheKey(Object[] objects) {this();updateAll(objects);}public int getUpdateCount() {return updateList.size();}public void update(Object object) {int baseHashCode = object == null ? 1 : ArrayUtil.hashCode(object);count++;//checksum 等于数组中所有对象的baseHashCode的和checksum += baseHashCode;baseHashCode *= count;hashcode = multiplier * hashcode + baseHashCode;updateList.add(object);}public void updateAll(Object[] objects) {for (Object o : objects) {update(o);}}@Overridepublic boolean equals(Object object) {//是内存中的同一个对象，肯定相等if (this == object) {return true;}//连CacheKey的实例都不是，一定不相等if (!(object instanceof CacheKey)) {return false;}final CacheKey cacheKey = (CacheKey) object;//如果两个CacheKey对象的hashCode值不相等，则一定不是同一个keyif (hashcode != cacheKey.hashcode) {return false;}//如果两个CacheKey对象的校验和值不相等，则一定不是同一个keyif (checksum != cacheKey.checksum) {return false;}//如果两个CacheKey对象的对象总数不相等，则一定不是同一个keyif (count != cacheKey.count) {return false;}//上面所有的都相等时，再比较updateList集合中的每一个对象是否相等for (int i = 0; i < updateList.size(); i++) {Object thisObject = updateList.get(i);Object thatObject = cacheKey.updateList.get(i);if (!ArrayUtil.equals(thisObject, thatObject)) {return false;}}return true;}@Overridepublic int hashCode() {return hashcode;}@Overridepublic String toString() {//tringJoiner是Java8新出的一个类，用于构造由分隔符分隔的字符序列，//并可选择性地从提供的前缀开始和以提供的后缀结尾。省的我们开发人员再次通过StringBuffer//或者StingBuilder拼接。StringJoiner returnValue = new StringJoiner(":");returnValue.add(String.valueOf(hashcode));returnValue.add(String.valueOf(checksum));updateList.stream().map(ArrayUtil::toString).forEach(returnValue::add);return returnValue.toString();}//实现业务角度的深拷贝@Overridepublic CacheKey clone() throws CloneNotSupportedException {CacheKey clonedCacheKey = (CacheKey) super.clone();clonedCacheKey.updateList = new ArrayList<>(updateList);return clonedCacheKey;}}