MyBatis的缓存支持

深碍√TFBOYSˉ_ 2024-04-19 08:03 54阅读 0赞

MyBatis提供了两个级别的缓存策略：本地缓存和二级缓存，二级缓存中的内容优先级高于本地缓存。

本地缓存在创建SqlSession时被创建，执行过的查询结果会被缓存起来，目的是提高在同一事务中循环、嵌套查询的效率，所以该功能是默认开启的。本地缓存会在DML执行、事务提交、事务关闭、session关闭和主动清空时被清空。官方也特别友情提醒，在缓存引用和查询结果对象是同一个时，对查询结果做出更改会影响到同一个session的其他线程的查询结果，有可能会导致程序出现Bug。

二级缓存作用于SQL Mapping语句，如果说本地缓存被用于MyBatis以及提高其内部查询效率，那么二级缓存才是真正意义上的应用级缓存。

### 一、本地缓存 ###

缓存的数据结构基本是key-value形式的，MyBatis也是采用key-value数据结构做缓存的。CacheKey就是MyBatis缓存的key对象，在每次查询BaseExecutor的createCacheKey()时都会返回一个本地缓存需要的CacheKey。

本地缓存是在BaseExecutor中实现的，如前文所述，BaseExecutor是在SqlSession创建时被创建的，它与SqlSession一一对应。在BaseExecutor中有两个属性：localCache，localOutputParameterCache，BaseExecutor主要靠这两个属性来实现本地缓存。

protected PerpetualCache localCache;
     protected PerpetualCache localOutputParameterCache;

PerpetualCache实现了Cache接口，PerpetualCache实现了Cache接口的一下方法。

// 向缓存中添加数据
    @Override
      public void putObject(Object key, Object value) {
        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();
      }

为了保证缓存的有效性，BaseExecutor的clearLocalCache()会在执行几种方法后进行缓存清空操作。

（1）commit()：事务提交之前。

（2）update()：更新执行之前。

（3）rollback()：事务回滚之前。

（4）query()：递归查询第一次执行时，MyBatis配置localCacheScope为STATEMENT在执行查询后缓存会被清空。

### 二、二级缓存 ###

若在Configuration配置文件中配置了<setting name="cacheEnabled" value="true">，则MyBatis在构建好SimpleExecutor后，还会为SimpleExecutor外层装饰一个CachingExecutor对象。CachingExecutor的大部分逻辑会被委托给SimpleExecutor实现，自己专注于实现二级缓存。

在setting开启了cache配置后，因为二级缓存是基于SQL Mapper的，所以Cache类的对象是在SQL Mapper构建阶段生成的。

org.apache.ibatis.cache.Cache是MyBatis定义缓存功能的接口它有以下实现。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMjk4MzUx_size_16_color_FFFFFF_t_70][]

（1）PerpetualCache：为本地缓存和二级缓存的默认实现。

（2）LruCache：为回收策略eviction的一种，在进行缓存回收时会优先淘汰最近最少使用的缓存内容。内部实现了LinkedHashMap的对象keyMap，重写了LinkedHashMap的removeEldestEntry()方法，该方法在put()或keyMap大小超过设定的大小时返回true，此时会移除keyMap中最老的键和值。

public void setSize(final int size) {
        keyMap = new LinkedHashMap<Object, Object>(size, .75F, true) {
          private static final long serialVersionUID = 4267176411845948333L;
    
          @Override
          protected boolean removeEldestEntry(Map.Entry<Object, Object> eldest) {
            // 判断缓存大小是否超出限制，获取最早被缓存的key
            boolean tooBig = size() > size;
            if (tooBig) {
              eldestKey = eldest.getKey();
            }
            // 在缓存超出大小限制后执行删除操作
            return tooBig;
          }
        };
      }
    
    private void cycleKeyList(Object key) {
        keyMap.put(key, key);
        if (eldestKey != null) {
          // 清空缓冲
          delegate.removeObject(eldestKey);
          eldestKey = null;
        }
      }

（3）FifoCache：为回收策略eviction的一种，先进先出。利用java.util.Deque实现队列的先进先出。

private void cycleKeyList(Object key) {
        keyList.addLast(key);
        if (keyList.size() > size) {
          // 移除队列
          Object oldestKey = keyList.removeFirst();
          //清空缓存
          delegate.removeObject(oldestKey);
        }
      }

（4）SoftCache和WeakCache：为回收策略eviction的一种，移除基于垃圾回收器状态规则的对象。

（5）LoggingCache：标准装饰器，记录cacheId对应的命中次数并打印debug日志。

@Override
      public Object getObject(Object key) {
        requests++;
        final Object value = delegate.getObject(key);
        if (value != null) {
          hits++;
        }
        if (log.isDebugEnabled()) {
          log.debug("Cache Hit Ratio [" + getId() + "]: " + getHitRatio());
        }
        return value;
      }

（6）SynchronizedCache：标准装饰器。方法全为synchronized修饰。

（7）ScheduledCache：可配置装饰器，被配置在flushInterval中。Cache在被创建时生成变量lastClear，值为当前时间。之后在对缓存进行操作时根据当前时间减去lastClear后是否大于设置的时间来判断是否超时，如果超时则清空缓存，并在清空缓存后将当前时间重新写到lastClear中。

@Override
      public void clear() {
        lastClear = System.currentTimeMillis();
        delegate.clear();
      }
    
    private boolean clearWhenStale() {
        if (System.currentTimeMillis() - lastClear > clearInterval) {
          clear();
          return true;
        }
        return false;
      }

（8）SerializedCache：将查询结果序列化后放入缓存中，在获取缓存时会将缓存的字节反序列化成对象，缓存的value实际是对象序列化后的byte\[\]。

private byte[] serialize(Serializable value) {
        /*
    try-with-resources机制，将实现了 java.lang.AutoCloseable 接口的资源定义在 try 后面的小括号中
    不管 try 块是正常结束还是异常结束，这个资源都会被自动关闭。 try 小括号里面的部分称为 
    try-with-resources 块。
        */
        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;
      }

（9）BlockingCache：为Ehcache的一个阻塞式缓存的简单实现，在并发环境要求查询结果一致的场景下可以选择阻塞式缓存。在缓存内没有数据、多个读线程并发的情况下，抢到锁的线程在执行查询后不放锁。其他读线程会被锁住。抢到锁的线程在查询到结果后会调用putObject()方法释放锁，其他线程在按顺序获取锁执行查询，在查询到缓存数据时会释放锁，其它线程才会读到缓存数据。MyBatis为了保证多个key使用同一把锁而不是整个缓存map使用一把锁，用ConcurrentHashMap实现了key对lock的映射。

// 使用ConcurrentHashMap实现
    private final ConcurrentHashMap<Object, ReentrantLock> locks;
    
    @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;
      }
    
    private ReentrantLock getLockForKey(Object key) {
        return locks.computeIfAbsent(key, k -> new ReentrantLock());
     }

（10）TransactionalCache：要作用是保存SqlSession在事务中需要向某个二级缓存提交的缓存数据（因为事务过程中的数据可能会回滚，所以不能直接把数据就提交二级缓存，而是暂存在TransactionalCache中，在事务提交后再将过程中存放在其中的数据提交到二级缓存，如果事务回滚，则将数据清除掉）

Cache的子类除默认实现外都是采用了装饰者模式实现。

**如果本文对您有很大的帮助，还请点赞关注一下。**

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMjk4MzUx_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/283537cb81c5429b90b6ff12588a03d9.png