MyBatis源码解析(四) Cache模块

MyBatis的二级缓存

MyBatis的缓存分为一级缓存和二级缓存，一级缓存是 SqlSession 级别的缓存，二级缓存是mapper级别的缓存。但是这篇博客主要是介绍mybaits中缓存接口和缓存键接口，以及一些缓存实现。

之前写过一篇博客简单介绍了一下Hibernate的两级缓存。

链接： https://blog.csdn.net/Let_me_tell_you/article/details/80876767

Cache接口

源码位置：org.apache.ibatis.cache.Cache

缓存容器接口，自定义操作方法，其他缓存实现类需要实现这个接口。

UML类图

Cache接口UML类图.png

上图中列出来的就是Cache接口的实现类，实现不同的缓存功能。

接口的源码很简单，就是定义了一些增删改查缓存的方法，和一个获取容器中缓存数量和获得读写锁的方法。我精简了下注释，源码内容如下。Cache接口其实是一个缓存容器，有点类似于一个HashMap（有一些实现类就是使用HashMap来保存操作缓存数据的）。

public interface Cache {

  /**
   * 获取标识
   */
  String 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

源码位置：org.apache.ibatis.cache.impl.PerpetualCache

永不过期的缓存，使用HashMap来保存和操作数据，重写了 equals() 和 hashCode() 方法，其他缓存操作都是直接调用的HashMap方法。

LoggingCache

源码位置：org.apache.ibatis.cache.decorators.LoggingCache

这是一个支持打印日志的 Cache 实现，代码也很简单，加了一些注释。

public class LoggingCache implements Cache {

  /**
   * mybaits log 对象
   */
  private final Log log;
  /**
   * 装饰的 Cache 对象
   */
  private final Cache delegate;
  /**
   * 统计请求缓存的次数
   */
  protected int requests = 0;
  /**
   * 命中缓存的次数
   */
  protected int hits = 0;

  public LoggingCache(Cache delegate) {
    this.delegate = delegate;
    this.log = LogFactory.getLog(getId());
  }

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

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

  @Override
  public void putObject(Object key, Object object) {
    delegate.putObject(key, object);
  }

  @Override
  public Object getObject(Object key) {
    //请求次数加 1
    requests++;
    final Object value = delegate.getObject(key);
    if (value != null) {
      //命中缓存，命中次数加 1
      hits++;
    }
    if (log.isDebugEnabled()) {
      //打印该缓存命中次数
      log.debug("Cache Hit Ratio [" + getId() + "]: " + getHitRatio());
    }
    return value;
  }

  @Override
  public Object removeObject(Object key) {
    return delegate.removeObject(key);
  }

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

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

  @Override
  public boolean equals(Object obj) {
    return delegate.equals(obj);
  }

  /**
   * 计算命中比例
   * @return
   */
  private double getHitRatio() {
    //算法： 命中次数 / 请求缓存次数
    return (double) hits / (double) requests;
  }

}

BlockingCache

源码位置：org.apache.ibatis.cache.decorators.BlockingCache

阻塞的Cache实现类，这个实现不同的逻辑是在加锁上。当一个线程去获取缓存事，缓存不存在则会阻塞后续线程获取，当前线程则去添加缓存值，避免后续线程重复添加缓存。需要注意的是这个实现里 removeObject 方法并不是删除缓存值，而是移除锁。

public class BlockingCache implements Cache {

  /**
   * 阻塞等待超时时间
   */
  private long timeout;
  /**
   * 装饰的Cache对象
   */
  private final Cache delegate;
  /**
   * 缓存键 与  ReentrantLock 对象映射
   */
  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);
    //获得缓存执
    Object value = delegate.getObject(key);
    if (value != null) {
      //释放锁
      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();
  }

  /**
   * 获得 ReentrantLock 对象，如果不存在，则进行添加
   * @param key
   * @return
   */
  private ReentrantLock getLockForKey(Object key) {
    return locks.computeIfAbsent(key, k -> new ReentrantLock());
  }

  private void acquireLock(Object key) {
    //获得键对应的 ReentrantLock 对象
    Lock lock = getLockForKey(key);
    //获得锁，直到超时
    if (timeout > 0) {
      try {
        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 对象
    ReentrantLock lock = locks.get(key);
    if (lock.isHeldByCurrentThread()) {
      //如果当前线程持有锁，进行释放
      lock.unlock();
    }
  }

  public long getTimeout() {
    return timeout;
  }

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

SynchronizedCache

源码位置：org.apache.ibatis.cache.decorators.SynchronizedCache

同步Cache实现，内部也是使用装饰的Cache来实现缓存操作。不过这个实现在 getSize putObject getObject removeObject clear 这几个方法上添加了 synchronized关键字。

SerializedCache

源码位置：org.apache.ibatis.cache.decorators.SerializedCache

支持序列化值，其实就是在添加缓存的时候对值进行序列化，获取值的时候反序列化。

public class SerializedCache implements Cache {
  //装饰的 Cache
  private final Cache delegate;

  public SerializedCache(Cache delegate) {
    this.delegate = delegate;
  }

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

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

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

  @Override
  public Object getObject(Object key) {
    Object object = delegate.getObject(key);
      //取值进行反序列化
    return object == null ? null : deserialize((byte[]) object);
  }

  @Override
  public Object removeObject(Object key) {
    return delegate.removeObject(key);
  }

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

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

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

    @Override
    protected Class<?> resolveClass(ObjectStreamClass desc) throws ClassNotFoundException {
      return Resources.classForName(desc.getName());
    }

  }

}

ScheduledCache

源码位置：org.apache.ibatis.cache.decorators.ScheduledCache

定时清空整个 Cache 的缓存，在每次操作缓存之前判断是否全部清空缓存

public class ScheduledCache implements Cache {

  /**
   * 装饰的 Cache 对象
   */
  private final Cache delegate;
  /**
   * 清空间隔，单位：毫秒
   */
  protected long clearInterval;
  /**
   * 最后清空时间，单位：毫秒
   */
  protected long lastClear;

  public ScheduledCache(Cache delegate) {
    this.delegate = delegate;
    //默认清空间隔 一小时
    this.clearInterval = 60 * 60 * 1000; // 1 hour
    this.lastClear = System.currentTimeMillis();
  }

  public void setClearInterval(long clearInterval) {
    this.clearInterval = clearInterval;
  }

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

  @Override
  public int getSize() {
    //判断是否需要全部清空
    clearWhenStale();
    return delegate.getSize();
  }

  @Override
  public void putObject(Object key, Object object) {
    //判断是否需要全部清空
    clearWhenStale();
    delegate.putObject(key, object);
  }

  @Override
  public Object getObject(Object key) {
    //判断是否需要全部清空
    return clearWhenStale() ? null : delegate.getObject(key);
  }

  @Override
  public Object removeObject(Object key) {
    //判断是否需要全部清空
    clearWhenStale();
    return delegate.removeObject(key);
  }

  @Override
  public void clear() {
    //记录清空时间
    lastClear = System.currentTimeMillis();
    delegate.clear();
  }

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

  @Override
  public boolean equals(Object obj) {
    return delegate.equals(obj);
  }

  /**
   * 判断是否需要全部清空
   * @return
   */
  private boolean clearWhenStale() {
    if (System.currentTimeMillis() - lastClear > clearInterval) {
      //全部清空
      clear();
      return true;
    }
    return false;
  }

}

FifoCache

源码位置：org.apache.ibatis.cache.decorators.FifoCache

基于先进先出淘汰机制的Cache实现，此实现在删除缓存时并不会删除缓存key，所以旧的 key 也依旧会继续存在。

除此之外在添加key的时候该实现也不会去判断key是否已经存在，只会判断当前长度是否超过了队列上上限，所以重复添加就会在队列里存在多个相同的key，这个不能说是bug，只能说是允许重复的key，但是如果你在使用中发现同一个key拿到的缓存不止一个，可能就需要检查一下你使用的是不是 FifoCache 实现了。

public class FifoCache implements Cache {

  /**
   * 装饰的 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 String getId() {
    return delegate.getId();
  }

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

  public void setSize(int size) {
    this.size = size;
  }

  @Override
  public void putObject(Object key, Object value) {
    //循环 keyList
    cycleKeyList(key);
    delegate.putObject(key, value);
  }

  @Override
  public Object getObject(Object key) {
    return delegate.getObject(key);
  }

  @Override
  public Object removeObject(Object key) {
    //删除缓存，未清空keyList中的数据
    return delegate.removeObject(key);
  }

  @Override
  public void clear() {
    //清空缓存时，同时清空维护的 keyList
    delegate.clear();
    keyList.clear();
  }

  private void cycleKeyList(Object key) {
    //添加到 keyList
    keyList.addLast(key);
    if (keyList.size() > size) {
      //如果添加新 key 之后 ketList 的长度大于 队列上线，将队列的首位移除
      Object oldestKey = keyList.removeFirst();
      delegate.removeObject(oldestKey);
    }
  }

}

LruCache

源码位置：org.apache.ibatis.cache.decorators.LruCache

此实现是基于最少使用的淘汰机制的 Cache 实现，简单说就是当添加缓存时发现已经达到上限的时候，淘汰掉最少使用的 key 以及对应的缓存。使用 LinkedHashMap 的淘汰机制，具体源码的解析请参考下面的源码。

public class LruCache implements Cache {

  /**
   * 装饰的 Cache 对象
   */
  private final Cache delegate;
  /**
   * 基于 LinkedHashMap 实现淘汰机制
   */
  private Map<Object, Object> keyMap;
  /**
   * 最老/最少被使用的键，即将被淘汰的 key
   */
  private Object eldestKey;

  public LruCache(Cache delegate) {
    this.delegate = delegate;
    //初始化 keyMap 对象
    setSize(1024);
  }

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

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

  /**
   * 初始化keyMap，但是此方法的权限标识是 public ，也就是说可以通过这个方法来指定 keyMap的长度，默认是1024，可以根据自己的需求来变更
   * @param size
   */
  public void setSize(final int size) {
    //LinkedHasmp的一个构造函数，当参数 accessOrder 为 true 时，即会按照访问的顺序排序，最近访问的在最前，最早访问的在最后
    keyMap = new LinkedHashMap<Object, Object>(size, .75F, true) {
      private static final long serialVersionUID = 4267176411845948333L;

      @Override
      protected boolean removeEldestEntry(Map.Entry<Object, Object> eldest) {
        //重写 LinkedHashMapLinkedHashMap 的删除元素方法，当满足一定条件的时候删除元素，LinkedHashMap中默认是不删除
        //这里判断的条件就是 keyMap 长度大于初始化 keyMap 时给定的值，满足条件时将最少使用的 key 设置为待删除，
        // 等下次添加新key的时候判断 eldestKey 参数不为空则对 eldestKey 进行移除
        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) {
    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) {
      //移除 eldestKey
      delegate.removeObject(eldestKey);
      //置空
      eldestKey = null;
    }
  }

}

WeakCache

源码位置：org.apache.ibatis.cache.decorators.WeakCache

基于 java.lang.ref.WeakReference 的Cache实现类，主要是基于内部维护的一个强引用和mybatis基于 java.lang.ref.WeakReference 扩展的WeakEntry来实现缓存淘汰。在这个实现里，一样存在key多次添加会导致重复key的问题。

public class WeakCache implements Cache {
  //强引用的键的队列
  private final Deque<Object> hardLinksToAvoidGarbageCollection;
  //被GC回收的 WeakEntry 集合，避免被 GC
  private final ReferenceQueue<Object> queueOfGarbageCollectedEntries;
  //装饰的 Cache 对象
  private final Cache delegate;
  //hardLinksToAvoidGarbageCollection 的大小
  private int numberOfHardLinks;

  public WeakCache(Cache delegate) {
    this.delegate = delegate;
    this.numberOfHardLinks = 256;
    this.hardLinksToAvoidGarbageCollection = new LinkedList<>();
    this.queueOfGarbageCollectedEntries = new ReferenceQueue<>();
  }

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

  @Override
  public int getSize() {
    //移除已经被 GC 回收的WeakEntry
    removeGarbageCollectedItems();
    return delegate.getSize();
  }

  public void setSize(int size) {
    this.numberOfHardLinks = size;
  }

  @Override
  public void putObject(Object key, Object value) {
    //移除已经被 GC 回收的 WeakEntry
    removeGarbageCollectedItems();
    //添加缓存
    delegate.putObject(key, new WeakEntry(key, value, queueOfGarbageCollectedEntries));
  }

  @Override
  public Object getObject(Object key) {
    Object result = null;
    @SuppressWarnings("unchecked") // assumed delegate cache is totally managed by this cache
    //获得值的 WeakReference 对象
    WeakReference<Object> weakReference = (WeakReference<Object>) delegate.getObject(key);
    if (weakReference != null) {
      //获得值
      result = weakReference.get();
      if (result == null) {
        //值为空，表示已经被GC回收，移除缓存
        delegate.removeObject(key);
      } else {
        //非空，添加到 hardLinksToAvoidGarbageCollection 队列首部，未做key唯一性判断，所以存在重复添加的情况 ，避免被 GC
        hardLinksToAvoidGarbageCollection.addFirst(result);
        if (hardLinksToAvoidGarbageCollection.size() > numberOfHardLinks) {
          //如果长度超出上限，则移除队列尾部的元素
          hardLinksToAvoidGarbageCollection.removeLast();
        }
      }
    }
    return result;
  }

  @Override
  public Object removeObject(Object key) {
    //移除已经被 GC 回收的 WeakEntry
    removeGarbageCollectedItems();
    //移除缓存
    return delegate.removeObject(key);
  }

  @Override
  public void clear() {
    //清空 hardLinksToAvoidGarbageCollection
    hardLinksToAvoidGarbageCollection.clear();
    //移除已经被 GC 回收的 WeakEntry
    removeGarbageCollectedItems();
    //清空缓存
    delegate.clear();
  }

  /**
   * 移除已经被 GC 回收的键
   */
  private void removeGarbageCollectedItems() {
    WeakEntry sv;
    while ((sv = (WeakEntry) queueOfGarbageCollectedEntries.poll()) != null) {
      delegate.removeObject(sv.key);
    }
  }

  /**
   * 继承自 WeakReference ，增加缓存key属性，
   */
  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

源码位置：org.apache.ibatis.cache.decorators.SoftCache

基于java.lang.ref.SoftReference 的Cache实现，SoftCache内部实现了SoftEntry，其他基本上与WeakCache基本上是差不多的，只是在一些操作中会对 hardLinksToAvoidGarbageCollection 加锁。

public class WeakCache implements Cache {
  //强引用的键的队列
  private final Deque<Object> hardLinksToAvoidGarbageCollection;
  //被GC回收的 WeakEntry 集合，避免被 GC
  private final ReferenceQueue<Object> queueOfGarbageCollectedEntries;
  //装饰的 Cache 对象
  private final Cache delegate;
  //hardLinksToAvoidGarbageCollection 的大小
  private int numberOfHardLinks;

  public WeakCache(Cache delegate) {
    this.delegate = delegate;
    this.numberOfHardLinks = 256;
    this.hardLinksToAvoidGarbageCollection = new LinkedList<>();
    this.queueOfGarbageCollectedEntries = new ReferenceQueue<>();
  }

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

  @Override
  public int getSize() {
    //移除已经被 GC 回收的WeakEntry
    removeGarbageCollectedItems();
    return delegate.getSize();
  }

  public void setSize(int size) {
    this.numberOfHardLinks = size;
  }

  @Override
  public void putObject(Object key, Object value) {
    //移除已经被 GC 回收的 WeakEntry
    removeGarbageCollectedItems();
    //添加缓存
    delegate.putObject(key, new WeakEntry(key, value, queueOfGarbageCollectedEntries));
  }

  @Override
  public Object getObject(Object key) {
    Object result = null;
    @SuppressWarnings("unchecked") // assumed delegate cache is totally managed by this cache
    //获得值的 WeakReference 对象
    WeakReference<Object> weakReference = (WeakReference<Object>) delegate.getObject(key);
    if (weakReference != null) {
      //获得值
      result = weakReference.get();
      if (result == null) {
        //值为空，表示已经被GC回收，移除缓存
        delegate.removeObject(key);
      } else {
        //非空，添加到 hardLinksToAvoidGarbageCollection 队列首部，未做key唯一性判断，所以存在重复添加的情况 ，避免被 GC
        hardLinksToAvoidGarbageCollection.addFirst(result);
        if (hardLinksToAvoidGarbageCollection.size() > numberOfHardLinks) {
          //如果长度超出上限，则移除队列尾部的元素
          hardLinksToAvoidGarbageCollection.removeLast();
        }
      }
    }
    return result;
  }

  @Override
  public Object removeObject(Object key) {
    //移除已经被 GC 回收的 WeakEntry
    removeGarbageCollectedItems();
    //移除缓存
    return delegate.removeObject(key);
  }

  @Override
  public void clear() {
    //清空 hardLinksToAvoidGarbageCollection
    hardLinksToAvoidGarbageCollection.clear();
    //移除已经被 GC 回收的 WeakEntry
    removeGarbageCollectedItems();
    //清空缓存
    delegate.clear();
  }

  /**
   * 移除已经被 GC 回收的键
   */
  private void removeGarbageCollectedItems() {
    WeakEntry sv;
    while ((sv = (WeakEntry) queueOfGarbageCollectedEntries.poll()) != null) {
      delegate.removeObject(sv.key);
    }
  }

  /**
   * 继承自 WeakReference ，增加缓存key属性，
   */
  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;
    }
  }

}

CachKey

源码位置：org.apache.ibatis.cache.CacheKey

mybaits中的缓存键，不只是单纯的String字符串，而是由多个对象组成，共同计算缓存键。CacheKey中封装了多个影响缓存的属性。

public class CacheKey implements Cloneable, Serializable {

  private static final long serialVersionUID = 1146682552656046210L;

  //单例 空缓存键
  public static final CacheKey NULL_CACHE_KEY = new NullCacheKey();

  //multiplier 的值
  private static final int DEFAULT_MULTIPLYER = 37;
  //hashcode 的值
  private static final int DEFAULT_HASHCODE = 17;

  //hashcode求值的系数
  private final int multiplier;
  //缓存键的hashcode
  private int hashcode;
  //校验和
  private long checksum;
  //updateList 的长度
  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.
  //计算 hashcode 的对象的集合
  private List<Object> updateList;

  public CacheKey() {
    this.hashcode = DEFAULT_HASHCODE;
    this.multiplier = DEFAULT_MULTIPLYER;
    this.count = 0;
    this.updateList = new ArrayList<>();
  }

  public CacheKey(Object[] objects) {
    this();
    //基于 objects ，更新相关属性
    updateAll(objects);
  }

  public int getUpdateCount() {
    return updateList.size();
  }

  public void update(Object object) {
    //方法参数 object 的 hashcode
    int baseHashCode = object == null ? 1 : ArrayUtil.hashCode(object);

    count++;
    //checksum 为 baseHashCode 求和
    checksum += baseHashCode;
    //计算hashcode值
    baseHashCode *= count;
    hashcode = multiplier * hashcode + baseHashCode;
    //添加 object(缓存key) 到updateList中
    updateList.add(object);
  }

  public void updateAll(Object[] objects) {
    //遍历 objects 数组，调用 update 方法，更新相关属性
    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;

    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;
  }

  @Override
  public String toString() {
    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();
  }

  @Override
  public CacheKey clone() throws CloneNotSupportedException {
    //克隆 CacheKey 对象
    CacheKey clonedCacheKey = (CacheKey) super.clone();
    //创建 updateList 数组，避免原数组修改
    clonedCacheKey.updateList = new ArrayList<>(updateList);
    return clonedCacheKey;
  }
    
}

NullCacheKey

源码位置：org.apache.ibatis.cache.NullCacheKey

继承自 CacheKey ，空缓存键。

public final class NullCacheKey extends CacheKey {

  private static final long serialVersionUID = 3704229911977019465L;

  public NullCacheKey() {
    super();
  }

  @Override
  public void update(Object object) {
    throw new CacheException("Not allowed to update a NullCacheKey instance.");
  }

  @Override
  public void updateAll(Object[] objects) {
    throw new CacheException("Not allowed to update a NullCacheKey instance.");
  }
}public final class NullCacheKey extends CacheKey {

  private static final long serialVersionUID = 3704229911977019465L;

  public NullCacheKey() {
    super();
  }

  @Override
  public void update(Object object) {
    throw new CacheException("Not allowed to update a NullCacheKey instance.");
  }

  @Override
  public void updateAll(Object[] objects) {
    throw new CacheException("Not allowed to update a NullCacheKey instance.");
  }
}

本文由博客一文多发平台 OpenWrite 发布！

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 213,335评论 6赞 492
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 90,895评论 3赞 387
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 158,766评论 0赞 348
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 56,918评论 1赞 285
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 66,042评论 6赞 385
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 50,169评论 1赞 291
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 39,219评论 3赞 412
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 37,976评论 0赞 268
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 44,393评论 1赞 304
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 36,711评论 2赞 328
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 38,876评论 1赞 341
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 34,562评论 4赞 336
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 40,193评论 3赞 317
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 30,903评论 0赞 21
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 32,142评论 1赞 267
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 46,699评论 2赞 362
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 43,764评论 2赞 351