mybatis 一、二级缓存

最新推荐文章于 2024-06-18 20:03:30 发布

周星猩

最新推荐文章于 2024-06-18 20:03:30 发布

阅读量154

点赞数

分类专栏： mybatis

本文链接：https://blog.csdn.net/hong10086/article/details/96766271

版权

mybatis 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

MyBatis的缓存分为两种：

一级缓存，一级缓存是SqlSession级别的缓存，对于相同的查询，会从缓存中返回结果而不是查询数据库
二级缓存，二级缓存是Mapper级别的缓存，定义在Mapper文件的<cache>标签中并需要开启此缓存，多个Mapper文件可以共用一个缓存，依赖<cache-ref>标签配置

一、开启二级缓存

1、在核心配置文件SqlMapConfig.xml中加入以下内容（开启二级缓存总开关）：cacheEnabled设置为 true

2、在映射文件中，加入以下内容，开启二级缓存：

3、实现序列化，由于二级缓存的数据不一定都是存储到内存中，它的存储介质多种多样，所以需要给缓存的对象执行序列化。

禁用二级缓存

该statement中设置userCache=false可以禁用当前select语句的二级缓存，即每次查询都是去数据库中查询，默认情况下是true，即该statement使用二级缓存。

刷新二级缓存

二、二级缓存实现的原理

2.1、创建二级缓存

Cache接口：

public interface Cache {

  String getId();

  void putObject(Object key, Object value);

  Object getObject(Object key);

  Object removeObject(Object key);

  void clear();

  int getSize();
  
  ReadWriteLock getReadWriteLock();

}

实现类PerpetualCache：

public class PerpetualCache implements Cache {

  private final String id;

  private Map<Object, Object> cache = new HashMap<Object, Object>();

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

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

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

  @Override
  public ReadWriteLock getReadWriteLock() {
    return null;
  }
}

<cache/>配置在 mapper.xml文件中，该文件被读取后就马上开始了解析：

public class XMLMapperBuilder {

  /**
   * 解析<cache type=""  blocking="" eviction="" flushInterval="" readOnly="" size=""/> 节点。
   * type：          缓存核心类，默认使用PerpetualCache，其通过HashMap进行缓存。如果 type 为自定义缓存类，下面的所有参数都将失效。
   * blocking：      是否使用阻塞缓存， 默认为false。
   *                    当指定为true时将采用BlockingCache进行封装，blocking，阻塞的意思，使用BlockingCache会在查询缓存时锁住对应的Key，如果缓存命中了则会释放对应的锁，
   *                    否则会在查询数据库以后再释放锁这样可以阻止并发情况下多个线程同时查询数据，详情可参考BlockingCache的源码。
   * eviction：      回收策略， 默认的是 LRU
   *                    1.LRU – 最近最少使用的:移除最长时间不被使用的对象。
   *                    2.FIFO – 先进先出:按对象进入缓存的顺序来移除它们。
   *                    3.SOFT – 软引用:移除基于垃圾回收器状态和软引用规则的对象。
   *                    4.WEAK – 弱引用:更积极地移除基于垃圾收集器状态和弱引用规则的对象。
   * flushInterval： 清空缓存的时间间隔，单位毫秒，可以被设置为任意的正整数。  默认情况是不设置，也就是没有刷新间隔，缓存仅仅调用语句时刷新
   * readOnly：      属性可以被设置为true或false。只读的缓存会给所有调用者返回缓存对象的相同实例。因此这些对象不能被修改。这提供了很重要的性能优势。
   *                    可读写的缓存会返回缓存对象的拷贝（通过序列化）。这会慢一些，但是安全，因此默认是false。
   * size：          可以被设置为任意正整数，要记住你缓存的对象数目和你运行环境的可用内存资源数目。默认值是1024
   *
   *
   * @param context
   * @throws Exception
   */
  private void cacheElement(XNode context) throws Exception {
    if (context != null) {
      String type = context.getStringAttribute("type", "PERPETUAL");
      Class<? extends Cache> typeClass = typeAliasRegistry.resolveAlias(type);
      String eviction = context.getStringAttribute("eviction", "LRU");
      Class<? extends Cache> evictionClass = typeAliasRegistry.resolveAlias(eviction);
      Long flushInterval = context.getLongAttribute("flushInterval");
      Integer size = context.getIntAttribute("size");
      boolean readWrite = !context.getBooleanAttribute("readOnly", false);
      boolean blocking = context.getBooleanAttribute("blocking", false);
      Properties props = context.getChildrenAsProperties();
      //创建 cache
      builderAssistant.useNewCache(typeClass, evictionClass, flushInterval, size, readWrite, blocking, props);
    }
  }
}

cache 还可以配置许多属性,这写属性都是有默认值的。这些属性通过装饰模式的形式发挥着作用。

cache 节点都使用默认值的情况下：

默认会使用5种 cache：SysnchronizedCache=>LoggingCache=>SerializedCache=>LruCache=>PerpetualCache。

下面看一下实现的：上文中调用了builderAssistant.useNewCache(……）创建 cache


public class MapperBuilderAssistant {

  public Cache useNewCache(Class<? extends Cache> typeClass,Class<? extends Cache> evictionClass,Long flushInterval,Integer size,boolean readWrite,boolean blocking,Properties props) {
    Cache cache = new CacheBuilder(currentNamespace)
        .implementation(valueOrDefault(typeClass, PerpetualCache.class))
        .addDecorator(valueOrDefault(evictionClass, LruCache.class))
        .clearInterval(flushInterval)
        .size(size)
        .readWrite(readWrite)
        .blocking(blocking)
        .properties(props)
        .build();// build创建
    //将创建的 cache 放入 configuration 中
    configuration.addCache(cache);
    currentCache = cache;

    return cache;
  }
}

又通过 CacheBuilder创建：


public class CacheBuilder {
  private final String id;
  private Class<? extends Cache> implementation;
  private final List<Class<? extends Cache>> decorators;
  private Integer size;
  private Long clearInterval;
  private boolean readWrite;
  private Properties properties;
  private boolean blocking;

  public CacheBuilder(String id) {
    this.id = id;
    this.decorators = new ArrayList<Class<? extends Cache>>();
  }

  public CacheBuilder addDecorator(Class<? extends Cache> decorator) {
    if (decorator != null) {
      this.decorators.add(decorator);
    }
    return this;
  }

 
  public Cache build() {
    setDefaultImplementations();
    Cache cache = newBaseCacheInstance(implementation, id);
    setCacheProperties(cache);
    // 装饰器不应用于自定义缓存, do not apply decorators to custom caches
    if (PerpetualCache.class.equals(cache.getClass())) {
      //设置装饰器
      for (Class<? extends Cache> decorator : decorators) {
        cache = newCacheDecoratorInstance(decorator, cache);
        setCacheProperties(cache);
      }
      //设置标准装饰器
      cache = setStandardDecorators(cache);
    } 
    return cache;
  }



  private Cache setStandardDecorators(Cache cache) {
    try {
      MetaObject metaCache = SystemMetaObject.forObject(cache);
      if (size != null && metaCache.hasSetter("size")) {
        metaCache.setValue("size", size);
      }
      if (clearInterval != null) {
        cache = new ScheduledCache(cache);
        ((ScheduledCache) cache).setClearInterval(clearInterval);
      }
      if (readWrite) {
        cache = new SerializedCache(cache);//SerializedCache
      }
      cache = new LoggingCache(cache);//LoggingCache
      cache = new SynchronizedCache(cache);//SynchronizedCache
      if (blocking) {
        cache = new BlockingCache(cache);
      }
      return cache;
    } catch (Exception e) {
      throw new CacheException("Error building standard cache decorators.  Cause: " + e, e);
    }
  }

  ……
}

到此二级缓存创建完毕，二级缓存是在我们程序初始化时就创建了，并放在了 configuration 中。

2.2、二级缓存使用

执行器Executor

　　什么是执行器？所有我们在应用层通过sqlSession执行的各类selectXXX和增删改操作在做了动态sql和参数相关的封装处理后，都被委托给具体的执行器去执行，包括一、二级缓存的管理，事务的具体管理，Statement和具体JDBC层面优化的实现等等。所以执行器比较像是sqlSession下的各个策略工厂实现，用户通过配置决定使用哪个策略工厂。

从上述可以看出，mybatis提供了两种类型的执行器，缓存执行器与非缓存执行器（使用哪个执行器是通过配置文件中settings下的属性defaultExecutorType控制的，默认是SIMPLE），是否使用缓存执行器则是通过执行cacheEnabled控制的，默认是true。
缓存执行器不是真正功能上独立的执行器，而是非缓存执行器的装饰器模式。

CachingExector：

public class CachingExecutor implements Executor {

  private final Executor delegate;
  private final TransactionalCacheManager tcm = new TransactionalCacheManager();


  @Override
  public int update(MappedStatement ms, Object parameterObject) throws SQLException {
    flushCacheIfRequired(ms);//增删改默认会先清除二级缓存，不是真的清除。
    return delegate.update(ms, parameterObject);
  }

  
  @Override
  public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
      throws SQLException {
    Cache cache = ms.getCache();//获取二级缓存
    if (cache != null) {//二级缓存在，说明开始了二级缓存
      flushCacheIfRequired(ms);//查询默认不会先清除二级缓存。
      if (ms.isUseCache() && resultHandler == null) {
        ensureNoOutParams(ms, boundSql);
        @SuppressWarnings("unchecked")
        List<E> list = (List<E>) tcm.getObject(cache, key);//从二级缓存中获取
        if (list == null) {
          list = delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
          tcm.putObject(cache, key, list); // issue #578 and #116
        }
        return list;
      }
    }
    return delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
  }

  private void flushCacheIfRequired(MappedStatement ms) {
    Cache cache = ms.getCache();
    if (cache != null && ms.isFlushCacheRequired()) {      
      tcm.clear(cache);
    }
  }

  ……
}

缓存执行器相对于其他执行器的差别在于，首先是在query()方法中判断是否使用二级缓存(也就是mapper级别的缓存)。虽然mybatis默认启用了CachingExecutor，但是如果在mapper层面没有明确设置二级缓存的话，就退化为SimpleExecutor了。二级缓存的维护由TransactionalCache(事务化缓存)负责，当在TransactionalCacheManager(事务化缓存管理器)中调用putObject的时候并不是马上就把对象存放到缓存或者从缓存中删除，而是先把这个对象放到entriesToAddOnCommit里，然后当执行commit/rollback方法时再真正地把对象存放到缓存或者从缓存中删除。

**
 * TransactionalCacheManager 维护了所有的 Cache。
 * 其内部通过 HashMap 存储，key 为cache，value 为 new TransactionalCache(cache) 
 * @author Clinton Begin
 */
public class TransactionalCacheManager {

  private final Map<Cache, TransactionalCache> transactionalCaches = new HashMap<Cache, TransactionalCache>();

  public void clear(Cache cache) {
    getTransactionalCache(cache).clear();
  }

  public Object getObject(Cache cache, CacheKey key) {
    return getTransactionalCache(cache).getObject(key);
  }
  
  public void putObject(Cache cache, CacheKey key, Object value) {
    getTransactionalCache(cache).putObject(key, value);
  }

  public void commit() {
    for (TransactionalCache txCache : transactionalCaches.values()) {
      txCache.commit();
    }
  }

  public void rollback() {
    for (TransactionalCache txCache : transactionalCaches.values()) {
      txCache.rollback();
    }
  }

  private TransactionalCache getTransactionalCache(Cache cache) {
    TransactionalCache txCache = transactionalCaches.get(cache);
    if (txCache == null) {
      txCache = new TransactionalCache(cache);
      transactionalCaches.put(cache, txCache);
    }
    return txCache;
  }

}

public class TransactionalCache implements Cache {

  private static final Log log = LogFactory.getLog(TransactionalCache.class);

  private final Cache delegate;
  private boolean clearOnCommit;//为 true 时，事务中如果出现增、删、改
  private final Map<Object, Object> entriesToAddOnCommit;//事务新增的缓存记会先暂存在这，commit成功再写入缓存中，rollback 则清除。
  private final Set<Object> entriesMissedInCache;//缓存未命中的数据，事务commit时，也会放入二级缓存（key,null）

  public TransactionalCache(Cache delegate) {
    this.delegate = delegate;
    this.clearOnCommit = false;
    this.entriesToAddOnCommit = new HashMap<Object, Object>();
    this.entriesMissedInCache = new HashSet<Object>();
  }

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

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

  @Override
  public Object getObject(Object key) {
    // issue #116
    Object object = delegate.getObject(key);
    if (object == null) {
      //保存未命中的数据
      entriesMissedInCache.add(key);
    }
    // issue #146
    if (clearOnCommit) {//事务中已经出现增、删、改时，返回 null，就会从数据库中读取，不再使用缓存。
      return null;
    } else {
      return object;
    }
  }

  @Override
  public ReadWriteLock getReadWriteLock() {
    return null;
  }

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

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

  //清除缓存，这事务中如果出现增、删、改
  @Override
  public void clear() {
    clearOnCommit = true;
    entriesToAddOnCommit.clear();
  }

  public void commit() {
    if (clearOnCommit) {
      delegate.clear();
    }
    //将数据刷新到二级缓存
    flushPendingEntries();
    reset();
  }

  public void rollback() {
    unlockMissedEntries();
    reset();
  }

  private void reset() {
    clearOnCommit = false;
    entriesToAddOnCommit.clear();
    entriesMissedInCache.clear();
  }
  //将数据刷新到二级缓存
  private void flushPendingEntries() {
    for (Map.Entry<Object, Object> entry : entriesToAddOnCommit.entrySet()) {
      delegate.putObject(entry.getKey(), entry.getValue());
    }
    for (Object entry : entriesMissedInCache) {
      if (!entriesToAddOnCommit.containsKey(entry)) {
        delegate.putObject(entry, null);
      }
    }
  }

  private void unlockMissedEntries() {
    for (Object entry : entriesMissedInCache) {
      try {
         delegate.removeObject(entry);
      } catch (Exception e) {
        log.warn("Unexpected exception while notifiying a rollback to the cache adapter."
            + "Consider upgrading your cache adapter to the latest version.  Cause: " + e);
      }
    }
  }

}

三、一级缓存的实现：

BaseExecutor implements Executor {

    protected PerpetualCache localCache;

    @Override
    public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
        // 首先根据传递的参数获取BoundSql对象，对于不同类型的SqlSource，对应的getBoundSql实现不同.
        BoundSql boundSql = ms.getBoundSql(parameter);
        // 创建缓存key
        CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);
        // 委托给重载的query
        return query(ms, parameter, rowBounds, resultHandler, key, boundSql);
    }

    @Override
    public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
        ErrorContext.instance().resource(ms.getResource()).activity("executing a query").object(ms.getId());
        if (closed) {
            throw new ExecutorException("Executor was closed.");
        }
        //如果需要刷新缓存(默认DML需要刷新,也可以语句层面修改), 且queryStack(应该是用于嵌套查询的场景)=0
        if (queryStack == 0 && ms.isFlushCacheRequired()) {
            // 如果<select>节点配置了flushCache为true的话，清空一级缓存
            clearLocalCache();
        }
        List<E> list;
        try {
            queryStack++;
            // 如果查询不需要应用结果处理器,则先从缓存获取,这样可以避免数据库查询。
            // 我们后面会分析到localCache是什么时候被设置进去的.
            list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;
            if (list != null) {

                handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
            } else {
                // 不管是因为需要应用结果处理器还是缓存中没有,都从数据库中查询
                list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
            }
        } finally {
            queryStack--;
        }
        if (queryStack == 0) {
            for (DeferredLoad deferredLoad : deferredLoads) {
                deferredLoad.load();
            }
            // issue #601
            deferredLoads.clear();
            if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
                // issue #482
                // 如果设置了一级缓存是STATEMENT级别而非默认的SESSION级别，一级缓存就去掉了
                clearLocalCache();
            }
        }
        return list;
    }
}