MyBatis 中的缓存分为一级缓存、二级缓存，但在本质上是相同的，它们使用的都是 Cache 接口 的实现。MyBatis 缓存模块 的设计，使用了装饰器模式，这里不对此进行过多解析，以后会专门开一篇博文分析常用框架中使用到的设计模式。

1 Cache 组件

MyBatis 中缓存模块相关的代码位于 org.apache.ibatis.cache 包 下，其中 Cache 接口 是缓存模块中最核心的接口，它定义了所有缓存的基本行为。

  1. public interface Cache {
  3.   /**
  4.    * 获取当前缓存的 Id
  5.    */
  6.   String getId();
  8.   /**
  9.    * 存入缓存的 key 和 value，key 一般为 CacheKey对象
  10.    */
  11.   void putObject(Object key, Object value);
  13.   /**
  14.    * 根据 key 获取缓存值
  15.    */
  16.   Object getObject(Object key);
  18.   /**
  19.    * 删除指定的缓存项
  20.    */
  21.   Object removeObject(Object key);
  23.   /**
  24.    * 清空缓存
  25.    */
  26.   void clear();
  28.   /**
  29.    * 获取缓存的大小
  30.    */
  31.   int getSize();
  33.   /**
  34.    * ！！！！！！！！！！！！！！！！！！！！！！！！！！
  35.    * 获取读写锁，可以看到，这个接口方法提供了默认的实现！！
  36.    * 这是 Java8 的新特性！！只是平时开发时很少用到！！！
  37.    * ！！！！！！！！！！！！！！！！！！！！！！！！！！
  38.    */
  39.   default ReadWriteLock getReadWriteLock() {
  40.     return null;
  41.   }
  42. }

如下图所示，Cache 接口 的实现类有很多，但大部分都是装饰器，只有 PerpetualCache 提供了 Cache 接口 的基本实现。

avatar

1.1 PerpetualCache

PerpetualCache（Perpetual：永恒的，持续的）在缓存模块中扮演着被装饰的角色，其实现比较简单，底层使用 HashMap 记录缓存项，也是通过该 HashMap 对象 的方法实现的 Cache 接口 中定义的相应方法。

  1. public class PerpetualCache implements Cache {
  3.   // Cache对象 的唯一标识
  4.   private final String id;
  6.   // 其所有的缓存功能实现，都是基于 JDK 的 HashMap 提供的方法
  7.   private Map<Object, Object> cache = new HashMap<>();
  9.   public PerpetualCache(String id) {
  10.     this.id = id;
  11.   }
  13.   @Override
  14.   public String getId() {
  15.     return id;
  16.   }
  18.   @Override
  19.   public int getSize() {
  20.     return cache.size();
  21.   }
  23.   @Override
  24.   public void putObject(Object key, Object value) {
  25.     cache.put(key, value);
  26.   }
  28.   @Override
  29.   public Object getObject(Object key) {
  30.     return cache.get(key);
  31.   }
  33.   @Override
  34.   public Object removeObject(Object key) {
  35.     return cache.remove(key);
  36.   }
  38.   @Override
  39.   public void clear() {
  40.     cache.clear();
  41.   }
  43.   /**
  44.    * 其重写了 Object 中的 equals() 和 hashCode()方法，两者都只关心 id字段
  45.    */
  46.   @Override
  47.   public boolean equals(Object o) {
  48.     if (getId() == null) {
  49.       throw new CacheException("Cache instances require an ID.");
  50.     }
  51.     if (this == o) {
  52.       return true;
  53.     }
  54.     if (!(o instanceof Cache)) {
  55.       return false;
  56.     }
  58.     Cache otherCache = (Cache) o;
  59.     return getId().equals(otherCache.getId());
  60.   }
  62.   @Override
  63.   public int hashCode() {
  64.     if (getId() == null) {
  65.       throw new CacheException("Cache instances require an ID.");
  66.     }
  67.     return getId().hashCode();
  68.   }
  69. }

下面来看一下 cache.decorators 包 下提供的装饰器，它们都直接实现了 Cache 接口，扮演着装饰器的角色。这些装饰器会在 PerpetualCache 的基础上提供一些额外的功能，通过多个组合后满足一个特定的需求。

1.2 BlockingCache

BlockingCache 是阻塞版本的缓存装饰器，它会保证只有一个线程到数据库中查找指定 key 对应的数据。

  1. public class BlockingCache implements Cache {
  3.   // 阻塞超时时长
  4.   private long timeout;
  5.   // 持有的被装饰者
  6.   private final Cache delegate;
  7.   // 每个 key 都有其对应的 ReentrantLock锁对象
  8.   private final ConcurrentHashMap<Object, ReentrantLock> locks;
  10.   // 初始化 持有的持有的被装饰者 和 锁集合
  11.   public BlockingCache(Cache delegate) {
  12.     this.delegate = delegate;
  13.     this.locks = new ConcurrentHashMap<>();
  14.   }
  15. }

假设 线程 A 在 BlockingCache 中未查找到 keyA 对应的缓存项时，线程 A 会获取 keyA 对应的锁，这样，线程 A 在后续查找 keyA 时，其它线程会被阻塞。

  1.   // 根据 key 获取锁对象，然后上锁
  2.   private void acquireLock(Object key) {
  3.     // 获取 key 对应的锁对象
  4.     Lock lock = getLockForKey(key);
  5.     // 获取锁，带超时时长
  6.     if (timeout > 0) {
  7.       try {
  8.         boolean acquired = lock.tryLock(timeout, TimeUnit.MILLISECONDS);
  9.         if (!acquired) { // 超时，则抛出异常
  10.           throw new CacheException("Couldn't get a lock in " + timeout + " for the key " +  key + " at the cache " + delegate.getId());
  11.         }
  12.       } catch (InterruptedException e) {
  13.         // 如果获取锁失败，则阻塞一段时间
  14.         throw new CacheException("Got interrupted while trying to acquire lock for key " + key, e);
  15.       }
  16.     } else {
  17.       // 上锁
  18.       lock.lock();
  19.     }
  20.   }
  22.   private ReentrantLock getLockForKey(Object key) {
  23.     // Java8 新特性，Map系列类 中新增的方法
  24.     // V computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction)
  25.     // 表示，若 key 对应的 value 为空，则将第二个参数的返回值存入该 Map集合 并返回
  26.     return locks.computeIfAbsent(key, k -> new ReentrantLock());
  27.   }

假设 线程 A 从数据库中查找到 keyA 对应的结果对象后，将结果对象放入到 BlockingCache 中，此时 线程 A 会释放 keyA 对应的锁，唤醒阻塞在该锁上的线程。其它线程即可从 BlockingCache 中获取 keyA 对应的数据，而不是再次访问数据库。

  1.   @Override
  2.   public void putObject(Object key, Object value) {
  3.     try {
  4.       // 存入 key 和其对应的缓存项
  5.       delegate.putObject(key, value);
  6.     } finally {
  7.       // 最后释放锁
  8.       releaseLock(key);
  9.     }
  10.   }
  12.   private void releaseLock(Object key) {
  13.     ReentrantLock lock = locks.get(key);
  14.     // 锁是否被当前线程持有
  15.     if (lock.isHeldByCurrentThread()) {
  16.       // 是，则释放锁
  17.       lock.unlock();
  18.     }
  19.   }

1.3 FifoCache 和 LruCache

在很多场景中，为了控制缓存的大小，系统需要按照一定的规则清理缓存。FifoCache 是先入先出版本的装饰器，当向缓存添加数据时，如果缓存项的个数已经达到上限，则会将缓存中最老（即最早进入缓存）的缓存项删除。

  1. public class FifoCache implements Cache {
  3.   // 被装饰对象
  4.   private final Cache delegate;
  5.   // 用一个 FIFO 的队列记录 key 的顺序，其具体实现为 LinkedList
  6.   private final Deque<Object> keyList;
  7.   // 决定了缓存的容量上限
  8.   private int size;
  10.   // 国际惯例，通过构造方法初始化自己的属性，缓存容量上限默认为 1024个
  11.   public FifoCache(Cache delegate) {
  12.     this.delegate = delegate;
  13.     this.keyList = new LinkedList<>();
  14.     this.size = 1024;
  15.   }
  17.   @Override
  18.   public String getId() {
  19.     return delegate.getId();
  20.   }
  22.   @Override
  23.   public int getSize() {
  24.     return delegate.getSize();
  25.   }
  27.   public void setSize(int size) {
  28.     this.size = size;
  29.   }
  31.   @Override
  32.   public void putObject(Object key, Object value) {
  33.     // 存储缓存项之前，先在 keyList 中注册
  34.     cycleKeyList(key);
  35.     // 存储缓存项
  36.     delegate.putObject(key, value);
  37.   }
  39.   private void cycleKeyList(Object key) {
  40.     // 在 keyList队列 中注册要添加的 key
  41.     keyList.addLast(key);
  42.     // 如果注册这个 key 会超出容积上限，则把最老的一个缓存项清除掉
  43.     if (keyList.size() > size) {
  44.       Object oldestKey = keyList.removeFirst();
  45.       delegate.removeObject(oldestKey);
  46.     }
  47.   }
  49.   @Override
  50.   public Object getObject(Object key) {
  51.     return delegate.getObject(key);
  52.   }
  54.   @Override
  55.   public Object removeObject(Object key) {
  56.     return delegate.removeObject(key);
  57.   }
  59.   // 除了清理缓存项，还要清理 key 的注册列表
  60.   @Override
  61.   public void clear() {
  62.     delegate.clear();
  63.     keyList.clear();
  64.   }
  66. }

LruCache 是按照”近期最少使用算法”（Least Recently Used, LRU）进行缓存清理的装饰器，在需要清理缓存时，它会清除最近最少使用的缓存项。

  1. public class LruCache implements Cache {
  3.   // 被装饰者
  4.   private final Cache delegate;
  5.   // 这里使用的是 LinkedHashMap，它继承了 HashMap，但它的元素是有序的
  6.   private Map<Object, Object> keyMap;
  7.   // 最近最少被使用的缓存项的 key
  8.   private Object eldestKey;
  10.   // 国际惯例，构造方法中进行属性初始化
  11.   public LruCache(Cache delegate) {
  12.     this.delegate = delegate;
  13.     // 这里初始化了 keyMap，并定义了 eldestKey 的取值规则
  14.     setSize(1024);
  15.   }
  17.   public void setSize(final int size) {
  18.     // 初始化 keyMap，同时指定该 Map 的初始容积及加载因子，第三个参数true 表示 该LinkedHashMap
  19.     // 记录的顺序是 accessOrder，即，LinkedHashMap.get()方法 会改变其中元素的顺序
  20.     keyMap = new LinkedHashMap<Object, Object>(size, .75F, true) {
  21.       private static final long serialVersionUID = 4267176411845948333L;
  23.       // 当调用 LinkedHashMap.put()方法 时，该方法会被调用
  24.       @Override
  25.       protected boolean removeEldestEntry(Map.Entry<Object, Object> eldest) {
  26.         boolean tooBig = size() > size;
  27.         if (tooBig) {
  28.           // 当已达到缓存上限，更新 eldestKey字段，后面将其删除
  29.           eldestKey = eldest.getKey();
  30.         }
  31.         return tooBig;
  32.       }
  33.     };
  34.   }
  36.   // 存储缓存项
  37.   @Override
  38.   public void putObject(Object key, Object value) {
  39.     delegate.putObject(key, value);
  40.     // 记录缓存项的 key，超出容量则清除最久未使用的缓存项
  41.     cycleKeyList(key);
  42.   }
  44.   private void cycleKeyList(Object key) {
  45.     keyMap.put(key, key);
  46.     // eldestKey 不为空，则表示已经达到缓存上限
  47.     if (eldestKey != null) {
  48.       // 清除最久未使用的缓存
  49.       delegate.removeObject(eldestKey);
  50.       // 制空
  51.       eldestKey = null;
  52.     }
  53.   }
  55.   @Override
  56.   public Object getObject(Object key) {
  57.     // 访问 key元素 会改变该元素在 LinkedHashMap 中的顺序
  58.     keyMap.get(key); //touch
  59.     return delegate.getObject(key);
  60.   }
  62.   @Override
  63.   public String getId() {
  64.     return delegate.getId();
  65.   }
  67.   @Override
  68.   public int getSize() {
  69.     return delegate.getSize();
  70.   }
  72.   @Override
  73.   public Object removeObject(Object key) {
  74.     return delegate.removeObject(key);
  75.   }
  77.   @Override
  78.   public void clear() {
  79.     delegate.clear();
  80.     keyMap.clear();
  81.   }
  83. }

1.4 SoftCache 和 WeakCache

在分析 SoftCache 和 WeakCache 实现之前，我们再温习一下 Java 提供的 4 种引用类型，强引用 StrongReference、软引用 SoftReference、弱引用 WeakReference 和虚引用 PhantomReference。

  • 强引用 平时用的最多的，如 Object obj ＝ new Object()，新建的 Object 对象 就是被强引用的。如果一个对象被强引用，即使是 JVM 内存空间不足，要抛出 OutOfMemoryError 异常，GC 也绝不会回收该对象。
  • 软引用 仅次于强引用的一种引用，它使用类 SoftReference 来表示。当 JVM 内存不足时，GC 会回收那些只被软引用指向的对象，从而避免内存溢出。软引用适合引用那些可以通过其他方式恢复的对象，例如， 数据库缓存中的对象就可以从数据库中恢复，所以软引用可以用来实现缓存，下面要介绍的 SoftCache 就是通过软引用实现的。
    另外，由于在程序使用软引用之前的某个时刻，其所指向的对象可能己经被 GC 回收掉了，所以通过 Reference.get()方法 来获取软引用所指向的对象时，总是要通过检查该方法返回值是否为 null，来判断被软引用的对象是否还存活。
  • 弱引用 弱引用使用 WeakReference 表示，它不会阻止所引用的对象被 GC 回收。在 JVM 进行垃圾回收时，如果指向一个对象的所有引用都是弱引用，那么该对象会被回收。 所以，只被弱引用所指向的对象，其生存周期是 两次 GC 之间 的这段时间，而只被软引用所指向的对象可以经历多次 GC，直到出现内存紧张的情况才被回收。
  • 虚引用 最弱的一种引用类型，由类 PhantomReference 表示。虚引用可以用来实现比较精细的内存使用控制，但很少使用。
  • 引用队列（ReferenceQueue ) 很多场景下，我们的程序需要在一个对象被 GC 时得到通知，引用队列就是用于收集这些信息的队列。在创建 SoftReference 对象 时，可以为其关联一个引用队列，当 SoftReference 所引用的对象被 GC 时， JVM 就会将该 SoftReference 对象 添加到与之关联的引用队列中。当需要检测这些通知信息时，就可以从引用队列中获取这些 SoftReference 对象。不仅是 SoftReference，弱引用和虚引用都可以关联相应的队列。

现在来看一下 SoftCache 的具体实现。

  1. public class SoftCache implements Cache {
  3.   // 这里使用了 LinkedList 作为容器，在 SoftCache 中，最近使用的一部分缓存项不会被 GC
  4.   // 这是通过将其 value 添加到 hardLinksToAvoidGarbageCollection集合 实现的（即，有强引用指向其value）
  5.   private final Deque<Object> hardLinksToAvoidGarbageCollection;
  6.   // 引用队列，用于记录已经被 GC 的缓存项所对应的 SoftEntry对象
  7.   private final ReferenceQueue<Object> queueOfGarbageCollectedEntries;
  8.   // 持有的被装饰者
  9.   private final Cache delegate;
  10.   // 强连接的个数，默认为 256
  11.   private int numberOfHardLinks;
  13.   // 构造方法进行属性的初始化
  14.   public SoftCache(Cache delegate) {
  15.     this.delegate = delegate;
  16.     this.numberOfHardLinks = 256;
  17.     this.hardLinksToAvoidGarbageCollection = new LinkedList<>();
  18.     this.queueOfGarbageCollectedEntries = new ReferenceQueue<>();
  19.   }
  21.   private static class SoftEntry extends SoftReference<Object> {
  22.     private final Object key;
  24.     SoftEntry(Object key, Object value, ReferenceQueue<Object> garbageCollectionQueue) {
  25.       // 指向 value 的引用是软引用，并且关联了 引用队列
  26.       super(value, garbageCollectionQueue);
  27.       // 强引用
  28.       this.key = key;
  29.     }
  30.   }
  32.   @Override
  33.   public void putObject(Object key, Object value) {
  34.     // 清除已经被 GC 的缓存项
  35.     removeGarbageCollectedItems();
  36.     // 添加缓存
  37.     delegate.putObject(key, new SoftEntry(key, value, queueOfGarbageCollectedEntries));
  38.   }
  40.   private void removeGarbageCollectedItems() {
  41.     SoftEntry sv;
  42.     // 遍历 queueOfGarbageCollectedEntries集合，清除已经被 GC 的缓存项 value
  43.     while ((sv = (SoftEntry) queueOfGarbageCollectedEntries.poll()) != null) {
  44.       delegate.removeObject(sv.key);
  45.     }
  46.   }
  48.   @Override
  49.   public Object getObject(Object key) {
  50.     Object result = null;
  51.     @SuppressWarnings("unchecked") // assumed delegate cache is totally managed by this cache
  52.       // 用一个软引用指向 key 对应的缓存项
  53.       SoftReference<Object> softReference = (SoftReference<Object>) delegate.getObject(key);
  54.     // 检测缓存中是否有对应的缓存项
  55.     if (softReference != null) {
  56.       // 获取 softReference 引用的 value
  57.       result = softReference.get();
  58.       // 如果 softReference 引用的对象已经被 GC，则从缓存中清除对应的缓存项
  59.       if (result == null) {
  60.         delegate.removeObject(key);
  61.       } else {
  62.         synchronized (hardLinksToAvoidGarbageCollection) {
  63.           // 将缓存项的 value 添加到 hardLinksToAvoidGarbageCollection集合 中保存
  64.           hardLinksToAvoidGarbageCollection.addFirst(result);
  65.           // 如果 hardLinksToAvoidGarbageCollection 的容积已经超过 numberOfHardLinks
  66.           // 则将最老的缓存项从 hardLinksToAvoidGarbageCollection 中清除，FIFO
  67.           if (hardLinksToAvoidGarbageCollection.size() > numberOfHardLinks) {
  68.             hardLinksToAvoidGarbageCollection.removeLast();
  69.           }
  70.         }
  71.       }
  72.     }
  73.     return result;
  74.   }
  76.   @Override
  77.   public Object removeObject(Object key) {
  78.     // 清除指定的缓存项之前，也会先清理被 GC 的缓存项
  79.     removeGarbageCollectedItems();
  80.     return delegate.removeObject(key);
  81.   }
  84.   @Override
  85.   public void clear() {
  86.     synchronized (hardLinksToAvoidGarbageCollection) {
  87.       // 清理强引用集合
  88.       hardLinksToAvoidGarbageCollection.clear();
  89.     }
  90.     // 清理被 GC 的缓存项
  91.     removeGarbageCollectedItems();
  92.     // 清理最底层的缓存项
  93.     delegate.clear();
  94.   }
  96.   @Override
  97.   public String getId() {
  98.     return delegate.getId();
  99.   }
  101.   @Override
  102.   public int getSize() {
  103.     removeGarbageCollectedItems();
  104.     return delegate.getSize();
  105.   }
  107.   public void setSize(int size) {
  108.     this.numberOfHardLinks = size;
  109.   }
  111. }

WeakCache 的实现与 SoftCache 基本类似，唯一的区别在于其中使用 WeakEntry（继承了 WeakReference）封装真正的 value 对象，其他实现完全一样。

另外，还有 ScheduledCache、LoggingCache、SynchronizedCache、SerializedCache 等。ScheduledCache 是周期性清理缓存的装饰器，它的 clearInterval 字段 记录了两次缓存清理之间的时间间隔，默认是一小时，lastClear 字段 记录了最近一次清理的时间戳。 ScheduledCache 的 getObject()、putObject()、removeObject() 等核心方法，在执行时都会根据这两个字段检测是否需要进行清理操作，清理操作会清空缓存中所有缓存项。

LoggingCache 在 Cache 的基础上提供了日志功能，它通过 hit 字段 和 request 字段 记录了 Cache 的命中次数和访问次数。在 LoggingCache.getObject()方法 中，会统计命中次数和访问次数 这两个指标，井按照指定的日志输出方式输出命中率。

SynchronizedCache 通过在每个方法上添加 synchronized 关键字，为 Cache 添加了同步功能，有点类似于 JDK 中 Collections 的 SynchronizedCollection 内部类。

SerializedCache 提供了将 value 对象 序列化的功能。SerializedCache 在添加缓存项时，会将 value 对应的 Java 对象 进行序列化，井将序列化后的 byte[]数组 作为 value 存入缓存 。 SerializedCache 在获取缓存项时，会将缓存项中的 byte[]数组 反序列化成 Java 对象。不使用 SerializedCache 装饰器 进行装饰的话，每次从缓存中获取同一 key 对应的对象时，得到的都是同一对象，任意一个线程修改该对象都会影响到其他线程，以及缓存中的对象。而使用 SerializedCache 每次从缓存中获取数据时，都会通过反序列化得到一个全新的对象。 SerializedCache 使用的序列化方式是 Java 原生序列化。

2 CacheKey

在 Cache 中唯一确定一个缓存项，需要使用缓存项的 key 进行比较，MyBatis 中因为涉及 动态 SQL 等多方面因素， 其缓存项的 key 不能仅仅通过一个 String 表示，所以 MyBatis 提供了 CacheKey 类 来表示缓存项的 key，在一个 CacheKey 对象 中可以封装多个影响缓存项的因素。 CacheKey 中可以添加多个对象，由这些对象共同确定两个 CacheKey 对象 是否相同。

  1. public class CacheKey implements Cloneable, Serializable {
  3.   private static final long serialVersionUID = 1146682552656046210L;
  5.   public static final CacheKey NULL_CACHE_KEY = new NullCacheKey();
  7.   private static final int DEFAULT_MULTIPLYER = 37;
  8.   private static final int DEFAULT_HASHCODE = 17;
  10.   // 参与计算hashcode，默认值DEFAULT_MULTIPLYER = 37
  11.   private final int multiplier;
  12.   // 当前CacheKey对象的hashcode，默认值DEFAULT_HASHCODE = 17
  13.   private int hashcode;
  14.   // 校验和
  15.   private long checksum;
  16.   private int count;
  18.   // 由该集合中的所有元素 共同决定两个CacheKey对象是否相同，一般会使用一下四个元素
  19.   // MappedStatement的id、查询结果集的范围参数（RowBounds的offset和limit）
  20.   // SQL语句（其中可能包含占位符"?"）、SQL语句中占位符的实际参数
  21.   private List<Object> updateList;
  23.   // 构造方法初始化属性
  24.   public CacheKey() {
  25.     this.hashcode = DEFAULT_HASHCODE;
  26.     this.multiplier = DEFAULT_MULTIPLYER;
  27.     this.count = 0;
  28.     this.updateList = new ArrayList<>();
  29.   }
  31.   public CacheKey(Object[] objects) {
  32.     this();
  33.     updateAll(objects);
  34.   }
  36.   public void update(Object object) {
  37.     int baseHashCode = object == null ? 1 : ArrayUtil.hashCode(object);
  38.     // 重新计算count、checksum和hashcode的值
  39.     count++;
  40.     checksum += baseHashCode;
  41.     baseHashCode *= count;
  42.     hashcode = multiplier * hashcode + baseHashCode;
  43.     // 将object添加到updateList集合
  44.     updateList.add(object);
  45.   }
  47.   public int getUpdateCount() {
  48.     return updateList.size();
  49.   }
  51.   public void updateAll(Object[] objects) {
  52.     for (Object o : objects) {
  53.       update(o);
  54.     }
  55.   }
  57.   /**
  58.    * CacheKey重写了 equals() 和 hashCode()方法，这两个方法使用上面介绍
  59.    * 的 count、checksum、hashcode、updateList 比较两个 CacheKey对象 是否相同
  60.    */
  61.   @Override
  62.   public boolean equals(Object object) {
  63.     // 如果为同一对象，直接返回 true
  64.     if (this == object) {
  65.       return true;
  66.     }
  67.     // 如果 object 都不是 CacheKey类型，直接返回 false
  68.     if (!(object instanceof CacheKey)) {
  69.       return false;
  70.     }
  72.     // 类型转换一下
  73.     final CacheKey cacheKey = (CacheKey) object;
  75.     // 依次比较 hashcode、checksum、count，如果不等，直接返回 false
  76.     if (hashcode != cacheKey.hashcode) {
  77.       return false;
  78.     }
  79.     if (checksum != cacheKey.checksum) {
  80.       return false;
  81.     }
  82.     if (count != cacheKey.count) {
  83.       return false;
  84.     }
  86.     // 比较 updateList 中的元素是否相同，不同直接返回 false
  87.     for (int i = 0; i < updateList.size(); i++) {
  88.       Object thisObject = updateList.get(i);
  89.       Object thatObject = cacheKey.updateList.get(i);
  90.       if (!ArrayUtil.equals(thisObject, thatObject)) {
  91.         return false;
  92.       }
  93.     }
  94.     return true;
  95.   }
  97.   @Override
  98.   public int hashCode() {
  99.     return hashcode;
  100.   }
  102.   @Override
  103.   public String toString() {
  104.     StringJoiner returnValue = new StringJoiner(":");
  105.     returnValue.add(String.valueOf(hashcode));
  106.     returnValue.add(String.valueOf(checksum));
  107.     updateList.stream().map(ArrayUtil::toString).forEach(returnValue::add);
  108.     return returnValue.toString();
  109.   }
  111.   @Override
  112.   public CacheKey clone() throws CloneNotSupportedException {
  113.     CacheKey clonedCacheKey = (CacheKey) super.clone();
  114.     clonedCacheKey.updateList = new ArrayList<>(updateList);
  115.     return clonedCacheKey;
  116.   }
  118. }

3 小结

至此 Mybatis 的基础支持层的主要模块就分析完了。本模块首先介绍了 MyBatis 对 Java 反射机制的封装；然后分析了类型转换 TypeHandler 组件，了解了 MyBatis 如何实现数据在 Java 类型 与 JDBC 类型 之间的转换。

之后分析了 MyBatis 提供的 DataSource 模块 的实现和原理，深入解析了 MyBatis 自带的连接池 PooledDataSource 的详细实现；后面紧接着介绍了 Transaction 模块 的功能。然后分析了 binding 模块 如何将 Mapper 接口 与映射配置信息相关联，以及其中的原理。最后介绍了 MyBatis 的缓存模块，分析了 Cache 接口 以及多个实现类的具体实现，它们是 Mybatis 中一级缓存和二级缓存的基础。