MyBatis缓存模块源码分析
优秀的ORM框架都应该提供缓存机制，MyBatis也不例外，在org.apache.ibatis.cache包下面定义了MyBatis缓存的核心模块，需要注意的是这个包中只是MyBatis缓存的核心实现，并不涉及一级缓存和二级缓存的实现，本文同样没有涉及到一二级缓存的具体实现方式的讲解。
在阅读缓存模块源码之前，读者们应该首先弄懂装饰器模式的含义，因为缓存模块的实现是装饰器模式的一种最佳实践，只有弄懂了装饰器模式才能更好的理解缓存模块的原理。
一. 初探缓存模块源码结构
缓存模块源码结构如下：
- decorators包：该包存放的是装饰器，通过这些装饰器可以为缓存添加一下核心功能，例如：防止缓存击穿，添加缓存清空策略，日志功能、序列化功能、定时清空功能。
BlockingCache：防止缓存击穿的装饰器。FifoCache：缓存淘汰策略装饰器（先进先出）。LoggingCache：缓存的日志装饰器，用于输出缓存命中率。LruCache：缓存淘汰策略装饰器（最近最少使用）ScheduledCache：缓存清空计划装饰器，该装饰器目的是实现每小时清空一次缓存。SerializedCache：缓存值序列化装饰器。将对象存存入缓存之前将对象序列化为字节数组存入缓存，在get时反序列化为对象。SoftCache：软引用缓存装饰器。SynchronizedCache：同步装饰器，用于保证缓存的更新操作是线程安全的。TransactionalCache：二级缓存事务缓冲区。WeakCache：弱引用缓存装饰器。
- impl包：该包下只有一个PerpetualCache类，它就是缓存模块的核心类。
一. 缓存模块的核心接口（Cache）
/**
* MyBatis缓存模块采用装饰器模式
*/
public interface Cache {
/**
* @return 获取这个缓存的ID
*/
String getId();
void putObject(Object key, Object value);
Object getObject(Object key);
Object removeObject(Object key);
void clear();
int getSize();
//获取读写锁。从3.2.6开始，这个方法不再被核心调用
default ReadWriteLock getReadWriteLock() {
return null;
}
}
可以看到putObject方法的key不是使用的String而是Object，这是因为MyBatis涉及动态SQL的原因，缓存项的key不能仅仅通过一个String来表示，所以通过CacheKey来封装缓存的Key。在CacheKey中封装类多个影响缓存项 的因素。
构成CacheKey的对象：
- mappedStatement的id
- 指定查询结果集的范围（分页信息）
- 查询所使用的SQL语句
- 用户传递给SQL语句的实际参数值
/**
* 缓存key
* MyBatis 对于其 Key 的生成采取规则为：[mappedStementId + offset + limit + SQL + queryParams + environment]生成一个哈希码
*/
public class CacheKey implements Cloneable, Serializable {
private static final long serialVersionUID = 1146682552656046210L;
public static final CacheKey NULL_CACHE_KEY = new CacheKey() {
@Override
public void update(Object object) {
throw new CacheException("Not allowed to update a null cache key instance.");
}
@Override
public 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;//参与hash计算的乘数
private int hashcode; //当前CacheKey的HashCode
private long checksum; //校验和
private int count; //updateList的元素个数
// 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++; //updateList中的size +1
checksum += baseHashCode;//计算校验和
baseHashCode *= count;
hashcode = multiplier * hashcode + baseHashCode; //更新Hash值
updateList.add(object);
}
public void updateAll(Object[] objects) {
for (Object o : objects) {
update(o);
}
}
@Override
public boolean equals(Object object) {
if (this == object) {
return true;
}
if (!(object instanceof CacheKey)) {
return false;
}
final CacheKey cacheKey = (CacheKey) object;
/**
* 这三个值都相同equals才有可能相同，目的是快速剔除大部分不相同的对象
*/
if (hashcode != cacheKey.hashcode) {
return false;
}
if (checksum != cacheKey.checksum) {
return false;
}
if (count != cacheKey.count) {
return false;
}
//经过上面三个元素的筛选，说明这两个对象极大可能相等，这里进行最后的判断
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;
}
@Override
public int hashCode() {
return hashcode;
}
}
二. 缓存的核心实现（PerpetualCache）
Mybatis 缓存实现是基于HashMap实现的，所以PerpetualCache实现了实际上是线程不安全的。如果想要实现线程安全的缓存，就需要使用SynchronizedCache装饰器装饰PerpetualCache。
/**
* MyBatis缓存的核心实现类。类似于IO中的FileInputStream（JDK中的IO同样采用装饰器模式）
* @author Clinton Begin
*/
public class PerpetualCache implements Cache {
//每一个缓存都有一个唯一ID
private final String id;
//缓存底层使用HashMap保存数据，所以单独的PerpetualCache实例是不支持多线程的，而decorators包中提供的装饰器可以将其包装为Blocking
private final Map<Object, Object> cache = new HashMap<>();
...
@Override
public void putObject(Object key, Object value) {
cache.put(key, value);
}
@Override
public Object getObject(Object key) {
return cache.get(key);
}
...
}
三. 装饰器
由于缓存模块的装饰器比较多，下面抽出几个有代表性的装饰器讲解，其他的装饰器原理可以参考博主的中文注释项目：
3.1 BlockingCache
BlockingCache装饰器是为了防止缓存击穿，保证只有一个线程根据指定的key到数据库中查找对应的数据，使用ConcurrentHashMap（安全，不重复）去存放锁的key（按照key加锁的细粒度锁）。
/**
* 装饰器，让缓存拥有阻塞的功能，目的是为了防止缓存击穿。（当在缓存中找不到元素时，它设置对缓存键的锁定，这样，其他线程将一直等待，直到该缓存键放入了缓存值）
*
* 需要注意的是，这个装饰器并不能保证缓存操作的线程安全
*
* Simple and inefficient version of EhCache's BlockingCache decorator.
* It sets a lock over a cache key when the element is not found in cache.
* This way, other threads will wait until this element is filled instead of hitting the database.
*
* @author Eduardo Macarron
*
*/
public class BlockingCache implements Cache {
//超时时间
private long timeout;
//被装饰的对象
private final Cache delegate;
/**
* 这里采用分段锁，每一个Key对应一个锁，当在缓存中找不到元素时，它设置对缓存键的锁定。
* 这样，其他线程将一直等待，直到该缓存键放入了缓存值，这也是防止缓存击穿的典型方案。
*
* 需要注意的是，这里每一个Key都对应一个锁，就并不能保证对底层Map的更新操作（主要是put操作），
* 只由一个线程执行，那这样多线程状态下对底层HashMap的更新操作也是线程不安全的！
*
* 也就是说，BlockingCache只是为了解决缓存击穿的问题，而不是解决缓存操作的线程安全问题，
* 线程安全问题交由SynchronizedCache装饰器来完成
*
*/
private final ConcurrentHashMap<Object, ReentrantLock> locks;
public BlockingCache(Cache delegate) {
this.delegate = delegate;
this.locks = new ConcurrentHashMap<>();
}
@Override
public String getId() {
return delegate.getId();
}
@Override
public int getSize() {
return delegate.getSize();
}
@Override
public void putObject(Object key, Object value) {
try {
delegate.putObject(key, value);
} finally {
//释放锁
releaseLock(key);
}
}
@Override
public Object getObject(Object key) {
//尝试获取锁，获取到锁之前一直阻塞，如果超时则抛出异常
acquireLock(key);
//调用被装饰对象的getObject方法获取缓存
Object value = delegate.getObject(key);
if (value != null) {
/**
* 如果value不为空，则释放锁。
* 这里很多人肯定会有疑问，如果没有获取到值难道就不释放锁了吗？其实不然，当
* MyBatis获取缓存时没有获取到数据，则会真正执行SQL语句去查询数据库，查询到结果后
* 会紧接着调用缓存的putObject方法，在这个方法中会进行释放锁的操作
*/
releaseLock(key);
}
return value;
}
@Override
public Object removeObject(Object key) {
// despite of its name, this method is called only to release locks
releaseLock(key);
return null;
}
@Override
public void clear() {
delegate.clear();
}
private ReentrantLock getLockForKey(Object key) {
//如果存在key对应的锁则返回已经存在的锁，如果不存在则创建一个并返回
return locks.computeIfAbsent(key, k -> new ReentrantLock());
}
/**
* 尝试获取锁
* @param key 缓存的key，
*/
private void acquireLock(Object key) {
//获取锁对象
Lock lock = getLockForKey(key);
if (timeout > 0) {
//如果锁的获取拥有超时时间
try {
//则尝试在指定时间内获取锁，如果获取到了则返回true，超时仍未获取到则返回false
boolean 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;
}
}
3.2 SynchronizedCache
/**
* 同步装饰器，用于保证缓存的更新操作是线程安全的
*/
public class SynchronizedCache implements Cache {
private final Cache delegate;
public SynchronizedCache(Cache delegate) {
this.delegate = delegate;
}
@Override
public String getId() {
return delegate.getId();
}
@Override
public synchronized int getSize() {
return delegate.getSize();
}
@Override
public synchronized void putObject(Object key, Object object) {
delegate.putObject(key, object);
}
@Override
public synchronized Object getObject(Object key) {
return delegate.getObject(key);
}
@Override
public synchronized Object removeObject(Object key) {
return delegate.removeObject(key);
}
@Override
public synchronized void clear() {
delegate.clear();
}
@Override
public int hashCode() {
return delegate.hashCode();
}
@Override
public boolean equals(Object obj) {
return delegate.equals(obj);
}
}
同步装饰器，用于保证缓存的更新操作是线程安全的。它对所有涉及所有对缓存的操作（读/写）都使用synchronized关键字进行同步。需要注意的是SynchronizedCache装饰器是将整个方法进行了加锁，这在使用的时候就应该在保证线程安全的情况下，尽量的将这个装饰器写在内层，这样可以减小锁的范围，增加系统吞吐量。例如在LoggingCache和SynchronizedCache装饰器同时使用的情况下,LogingCache装饰器最好放在SynchronizedCache装饰器外层。
new LoggingCache( new SynchronizedCache( new PerpetualCache() ) )
3.3 FifoCache
该装饰器用于使缓存具有先进先出淘汰机制，当缓存中缓存的数量到达阈值时，就会触发缓存淘汰，而淘汰的目标就是最先进入缓存的对象。
/**
* 缓存淘汰策略装饰器（先进先出）
*
* @author Clinton Begin
*/
public class FifoCache implements Cache {
/**
* 被装饰对象
*/
private final Cache delegate;
/**
* 双端队列
*/
private final Deque<Object> keyList;
/**
* 缓存的上限个数，触发这个值就会激活缓存淘汰策略
*/
private int size;
public FifoCache(Cache delegate) {
this.delegate = delegate;
this.keyList = new LinkedList<>();
this.size = 1024;
}
...
@Override
public void putObject(Object key, Object value) {
//将缓存键放入队列中，如果队列超长，则删除队首的键，以及其对应的缓存
cycleKeyList(key);
delegate.putObject(key, value);
}
...
/**
* 将缓存键放入队列中，如果队列超长，则删除队首的键，以及其对应的缓存
* @param key
*/
private void cycleKeyList(Object key) {
//在双端队列队尾放入缓存键
keyList.addLast(key);
//如果缓存个数大于了极限值
if (keyList.size() > size) {
//移除双端队列对数的保存的Key
Object oldestKey = keyList.removeFirst();
//通过这个Key删除队首元素
delegate.removeObject(oldestKey);
}
}
}
3.4 LruCache
该装饰器用于使缓存具有LRU（最近最少使用）淘汰机制，当缓存中缓存的数量到达阈值时，就会触发缓存淘汰，而淘汰的目标就是最近最少使用的对象。LruCache中是借助LinkedHashMap来实现LRU淘汰算法的，想要看到LruCache的源码，就需要读者们先去研究一下LinkedHashMap的源码才能理解，这里面的淘汰策略是如何实现的.
/**
* 缓存淘汰策略装饰器（最近最少使用）
*
* @author Clinton Begin
*/
public class LruCache implements Cache {
private final Cache delegate;
//使用LinkedHashMap维护key的使用顺序，个人认为这种实现方式虽然巧妙，但并不算特别优雅
private Map<Object, Object> keyMap;
private Object eldestKey;//最近最久没有使用的Key
public LruCache(Cache delegate) {
this.delegate = delegate;
setSize(1024);
}
...
public void setSize(final int size) {
//匿名内部类
keyMap = new LinkedHashMap<Object, Object>(size, .75F, true) {
private static final long serialVersionUID = 4267176411845948333L;
/**
* 重写LinkedHashMap中的removeEldestEntry方法是实现LRU的核心，
* 这里LRU的实现机制不清楚的话可以研究一下LinkedHashMap源码。
*
* 大致思路：LinkedHashMap继承于HashMap并在HashMap的基础上为每一个Map.Entry添加了一个before和after指针，从而
* 实现链表的功能，并全局维护了一个全局的head 和tail指针，分别指向链表的头和尾。当LinkedHashMap put元素时，会将
* 这个Entry加入链表的末尾。这样链表头始终指向的是最近最久没有使用的元素，在put方法中会调用removeEldestEntry方法
* 判断是否删除最久没有使用的元素，如果返回true则会删除最久没有会用过的元素的元素。
* @param eldest
* @return
*/
@Override
protected boolean removeEldestEntry(Map.Entry<Object, Object> eldest) {
boolean tooBig = size() > size;
if (tooBig) {
//保存最近最久没有使用的key
eldestKey = eldest.getKey();
}
return tooBig;
}
};
}
@Override
public void putObject(Object key, Object value) {
delegate.putObject(key, value);
//增加元素后，进行key的后处理。判断是否触发缓存数极限，如果触发了则清除最老的key对应的缓存
cycleKeyList(key);
}
@Override
public Object getObject(Object key) {
//调用LinkedHashMap.get()方法是为了让这次使用的key移动到链表末尾
keyMap.get(key); // touch
return delegate.getObject(key);
}
private void cycleKeyList(Object key) {
//将key放入keyMap，如果缓存数大于了极限值，则会删除最老Key，并将这个key赋给eldestKey变量
keyMap.put(key, key);
if (eldestKey != null) {
//eldestKey不为空，说明在调用keyMap.put()中触发了删除最老元素的机制，此时需要将真实缓存中对应的key-value删除
delegate.removeObject(eldestKey);
eldestKey = null;
}
}
}
/**
* 将连接对象归还给连接池（实际上是将连接从active队列中移到idle队列中）
*
* @param conn
* @throws SQLException
*/
protected void pushConnection(PooledConnection conn) throws SQLException {
synchronized (state) {
//将当前连接从active队列中移除
state.activeConnections.remove(conn);
if (conn.isValid()) {
//连接是有效的
if (state.idleConnections.size() < poolMaximumIdleConnections && conn.getConnectionTypeCode() == expectedConnectionTypeCode) {
//空闲的数量小于最大空闲值 且 连接对象的typeCode与数据源期望的TypeCode相同
//记录当前连接使用的时间
state.accumulatedCheckoutTime += conn.getCheckoutTime();
if (!conn.getRealConnection().getAutoCommit()) {
//如果连接对象的事务是非自动提交的，则回滚事务
conn.getRealConnection().rollback();
}
//重新封装一个新的代理连接对象
PooledConnection newConn = new PooledConnection(conn.getRealConnection(), this);
//将新建的代理连接对象放入空闲队列
state.idleConnections.add(newConn);
//设置创建的时间戳
newConn.setCreatedTimestamp(conn.getCreatedTimestamp());
//设置最后使用的时间戳
newConn.setLastUsedTimestamp(conn.getLastUsedTimestamp());
//老的代理对象作废
conn.invalidate();
if (log.isDebugEnabled()) {
log.debug("Returned connection " + newConn.getRealHashCode() + " to pool.");
}
//换新在state锁上的等待的线程
state.notifyAll();
} else {
//空闲的数量大于等于最大空闲值 或者 连接对象的typeCode与数据源期望的TypeCode不相同
state.accumulatedCheckoutTime += conn.getCheckoutTime();
if (!conn.getRealConnection().getAutoCommit()) {
conn.getRealConnection().rollback();
}
//关闭这个连接
conn.getRealConnection().close();
if (log.isDebugEnabled()) {
log.debug("Closed connection " + conn.getRealHashCode() + ".");
}
//将代理连接作废
conn.invalidate();
}
} else {
if (log.isDebugEnabled()) {
log.debug("A bad connection (" + conn.getRealHashCode() + ") attempted to return to the pool, discarding connection.");
}
state.badConnectionCount++;
}
}
}
