Mybatis学习之路（四）Mybatis源码分析三

• • 一、缓存机制
  • • 1.1 缓存类
    • • 1.1.1 PerpetualCache
      • 1.1.2 LruCache
      • 1.1.3 BlockingCache
    • 1.2 CacheKey
    • 1.3 一级缓存
    • 1.4 二级缓存
  • 二、插件机制
  • • 2.1 插件机制原理
    • • 2.1.1 植入插件逻辑
      • 2.1.2 执行插件逻辑
    • 2.2 实现一个分页插件

本系列文章：
  Mybatis学习之路（一）理论基础和使用介绍
  Mybatis学习之路（二）Mybatis源码分析一
  Mybatis学习之路（三）Mybatis源码分析二
  Mybatis学习之路（四）Mybatis源码分析三

  通常我们都会用 Redis 或 memcached 等缓存中间件，拦截大量奔向数据库的请求，以减轻数据库压力。MyBatis自然也在内部提供了相应的支持。通过在框架层面增加缓存功能，可减轻数据库的压力，同时又可以提升查询速度，可谓一举两得。MyBatis 缓存结构由一级缓存和二级缓存构成，这两级缓存均是使用 Cache 接口的实现类。

  在 MyBatis 中，Cache 是缓存接口，定义了一些基本的缓存操作。MyBatis 内部提供了丰富的缓存实现类，比如具有基本缓存功能的PerpetualCache ，具有 LRU 策略的缓存 LruCache ，以及可保证线程安全的缓存SynchronizedCache 和具备阻塞功能的缓存 BlockingCache 等。
  MyBatis 在实现缓存模块的过程中，使用了装饰模式。

  PerpetualCache（位于org.apache.ibatis.cache.impl） 是一个具有基本功能的缓存类，内部使用了 HashMap 实现缓存功能。

public class PerpetualCache implements Cache {

  	private final String id;

  	private final Map cache = new HashMap<>();

  	public PerpetualCache(String id) {
    	this.id = id;
  	}

  	@Override
  	public String getId() {
    	return id;
  	}

  	@Override
  	public int getSize() {
    	return cache.size();
  	}

  	@Override
  	public void putObject(Object key, Object value) {
    	// 存储键值对到 HashMap
    	cache.put(key, value);
  	}

  	@Override
  	public Object getObject(Object key) {
    	// 查找缓存项
    	return cache.get(key);
  	}

  	@Override
  	public Object removeObject(Object key) {
    	// 移除缓存项
    	return cache.remove(key);
  	}

  	@Override
  	public void clear() {
    	cache.clear();
  	}

  	@Override
  	public 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;
    	}

    	Cache otherCache = (Cache) o;
    	return getId().equals(otherCache.getId());
  	}

  	@Override
  	public int hashCode() {
    	if (getId() == null) {
      		throw new CacheException("Cache instances require an ID.");
    	}
    	return getId().hashCode();
  	}
}

  LruCache（位于org.apache.ibatis.cache.decorators），顾名思义，是一种具有 LRU 策略的缓存实现类。

public class LruCache implements Cache {

  	private final Cache delegate;
  	private Map keyMap;
  	private Object eldestKey;

  	public LruCache(Cache delegate) {
   	 	this.delegate = delegate;
    	setSize(1024);
  	}

  	@Override
  	public String getId() {
    	return delegate.getId();
  	}

  	@Override
  	public int getSize() {
    	return delegate.getSize();
  	}

  	public void setSize(final int size) {
    	// 初始化 keyMap，注意，keyMap 的类型继承自 linkedHashMap，
		// 并覆盖了 removeEldestEntry 方法
    	keyMap = new linkedHashMap(size, .75F, true) {
      		private static final long serialVersionUID = 4267176411845948333L;
      		// 覆盖 linkedHashMap 的 removeEldestEntry 方法
      		@Override
      		protected boolean removeEldestEntry(Map.Entry eldest) {
        		boolean tooBig = size() > size;
        		if (tooBig) {
          			// 获取将要被移除缓存项的键值
          			eldestKey = eldest.getKey();
        		}
        		return tooBig;
      		}
    	};
  	}

  	@Override
  	public void putObject(Object key, Object value) {
    	// 存储缓存项
    	delegate.putObject(key, value);
    	cycleKeyList(key);
  	}

  	@Override
  	public Object getObject(Object key) {
    	// 刷新 key 在 keyMap 中的位置
    	keyMap.get(key); // touch
    	// 从被装饰类中获取相应缓存项
    	return delegate.getObject(key);
  	}

  	@Override
  	public Object removeObject(Object key) {
    	// 从被装饰类中移除相应的缓存项
    	return delegate.removeObject(key);
  	}

  	@Override
  	public void clear() {
    	delegate.clear();
    	keyMap.clear();
  	}

  	private void cycleKeyList(Object key) {
    	// 存储 key 到 keyMap 中
    	keyMap.put(key, key);
    	if (eldestKey != null) {
      		// 从被装饰类中移除相应的缓存项
      		delegate.removeObject(eldestKey);
      		eldestKey = null;
    	}
  	}
}

  LruCache 的 keyMap 属性是实现 LRU 策略的关键，该属性类型继承自linkedHashMap，并覆盖了 removeEldestEntry 方法。linkedHashMap 可保持键值对的插入顺序，当插入一个新的键值对时，linkedHashMap 内部的 tail 节点会指向最新插入的节点。head 节点则指向第一个被插入的键值对，也就是最久未被访问的那个键值对。默认情况下，linkedHashMap 仅维护键值对的插入顺序。若要基于 linkedHashMap 实现 LRU 缓存，还需通过构造方法将 linkedHashMap 的 accessOrder 属性设为 true，此时 linkedHashMap会维护键值对的访问顺序。比如，上面代码中 getObject 方法中执行了这样一句代码keyMap.get(key) ，目的是刷新 key 对应的键值对在 linkedHashMap 的位置。
  linkedHashMap 会将 key 对应的键值对移动到链表的尾部，尾部节点表示最久刚被访问过或者插入的节点。除了需将 accessOrder 设为 true，还需覆盖 removeEldestEntry 方法。linkedHashMap 在插入新的键值对时会调用该方法，以决定是否在插入新的键值对后，移除老的键值对。在上面的代码中，当被装饰类的容量超出了 keyMap 的所规定的容量（由构造方法传入）后，keyMap 会移除最长时间未被访问的键，并将该键保存到 eldestKey 中，然后由 cycleKeyList 方法将 eldestKey 传给被装饰类的 removeObject 方法，移除相应的缓存项目。

  BlockingCache（位于org.apache.ibatis.cache.decorators） 实现了阻塞特性，该特性是基于 Java 重入锁实现的。同一时刻下，BlockingCache 仅允许一个线程访问指定 key 的缓存项，其他线程将会被阻塞住。

public class BlockingCache implements Cache {

  	private long timeout;
  	private final Cache delegate;
  	private final ConcurrentHashMap 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);
    	Object value = delegate.getObject(key);
    	// 若缓存命中，则释放锁。需要注意的是，未命中则不释放锁
    	if (value != null) {
      		// 释放锁
      		releaseLock(key);
    	}
   	 	return value;
  	}

  	@Override
  	public Object removeObject(Object key) {
    	// 释放锁
    	releaseLock(key);
    	return null;
  	}

  	@Override
  	public void clear() {
    	delegate.clear();
  	}

  	private void acquireLock(Object key) {
    	CountDownLatch newLatch = new CountDownLatch(1);
    	while (true) {
      		CountDownLatch latch = locks.putIfAbsent(key, newLatch);
      		if (latch == null) {
        		break;
      		}
      		try {
        		if (timeout > 0) {
          			boolean acquired = latch.await(timeout, TimeUnit.MILLISECONDS);
          			if (!acquired) {
            			throw new CacheException(
                			"Couldn't get a lock in " + timeout + " for the key " + key + " at the cache " + delegate.getId());
          				}
        			} else {
          				latch.await();
        			}
      		} catch (InterruptedException e) {
        		throw new CacheException("Got interrupted while trying to acquire lock for key " + key, e);
      		}
    	}
  	}

  	private void releaseLock(Object key) {
    	CountDownLatch latch = locks.remove(key);
    	if (latch == null) {
      		throw new IllegalStateException("Detected an attempt at releasing unacquired lock. This should never happen.");
    	}
    	latch.countDown();
  	}

  	public long getTimeout() {
    	return timeout;
  	}

  	public void setTimeout(long timeout) {
    	this.timeout = timeout;
  	}
}

  在查询缓存时，getObject 方法会先获取与 key 对应的锁，并加锁。若缓存命中，getObject 方法会释放锁，否则将一直锁定。getObject 方法若返回 null，表示缓存未命中。此时 MyBatis 会向数据库发起查询请求，并调用 putObject 方法存储查询结果。此时，putObject 方法会将指定 key 对应的锁进行解锁，这样被阻塞的线程即可恢复运行。

   MyBatis 中，引入缓存的目的是为提高查询效率，降低数据库压力。value 的内容是 SQL 的查询结果，key是一种复合对象，能涵盖可影响查询结果的因子。在 MyBatis 中，这种复合对象就是 CacheKey（位于org.apache.ibatis.cache）。

public class CacheKey implements Cloneable, Serializable {
  	private static final int DEFAULT_MULTIPLIER = 37;
  	private static final int DEFAULT_HASHCODE = 17;
  	// 乘子，默认为 37
  	private final int multiplier;
  	// CacheKey 的 hashCode，综合了各种影响因子
  	private int hashcode;
  	// 校验和
  	private long checksum;
  	// 影响因子个数
  	private int count;
  	// 影响因子集合
  	private List