mybatis——缓存

前面研究Executor时，里面有一级缓存和二级缓存的使用，这里深入研究一下缓存

一、一级缓存

1、一级缓存初始化

一级缓存指的是在BaseExecutor初始化的时候创建的，是一个PerpetualCache类型的对象.

  protected BaseExecutor(Configuration configuration, Transaction transaction) {
    ...
    this.localCache = new PerpetualCache("LocalCache");//实际就是BaseExecutor.localCache
    ...
  }

  private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
    ...
    localCache.putObject(key, list);//实际数据存放在PerpetualCache.cache中这个是一个Map<Object, Object>类型。
    ...
  }

一级缓存的初始化与数据存放比较简单，SqlSessionFactory.openSession()每创建一个Session时就会创建一个Executor，一级缓存存储在BaseExecutor.localCache中

/* org.apache.ibatis.session.defaults.DefaultSqlSessionFactory#openSessionFromDataSource */
  private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
    Transaction tx = null;
    try {
      final Environment environment = configuration.getEnvironment();
      final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
      tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
      final Executor executor = configuration.newExecutor(tx, execType);
      return new DefaultSqlSession(configuration, executor, autoCommit);
    } catch (Exception e) {
      closeTransaction(tx); // may have fetched a connection so lets call close()
      throw ExceptionFactory.wrapException("Error opening session.  Cause: " + e, e);
    } finally {
      ErrorContext.instance().reset();
    }
  }

2、总结一下

对应关系:是一个sqlSession对应一个Executor，一个BaseExecutor创建一个一级缓存localCache，然后结合上文的update()、事务提交回退都会清空一级缓存localCache，因此

① 同个session的两次相同查询：mybatis只查询一次数据库

② 同个session的两次不同查询：mybatis查询两次数据库

③ 同个session一个查询、一次更新、然后执行相同查询：mybatis查询两次数据库

④ 同个session一次查询、一次事务提交、然后执行相同查询：mybatis查询两次数据库

⑤ 不同session的两次相同查询：mybatis查询两次数据库

二、二级缓存

1、二级缓存的初始化

二级缓存对应的Configuration.caches是一个Map<String,Cache>类型的对象。Map中的<String,Cache>实例是在解析mapper.xml中的<cache>标签时创建的。即一个mapper.xml对应一个cache。所以尽管mybatis默认的Executor是new CachingExecutor(new SimpleExecutor)，但是<mapper>中没加<cache>标签的话，二级缓存默认还是关闭的。

/* org.apache.ibatis.session.Configuration#newExecutor(org.apache.ibatis.transaction.Transaction, org.apache.ibatis.session.ExecutorType) */
  public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
    executorType = executorType == null ? defaultExecutorType : executorType;
    executorType = executorType == null ? ExecutorType.SIMPLE : executorType;
    Executor executor;
    if (ExecutorType.BATCH == executorType) {
      executor = new BatchExecutor(this, transaction);
    } else if (ExecutorType.REUSE == executorType) {
      executor = new ReuseExecutor(this, transaction);
    } else {
      executor = new SimpleExecutor(this, transaction);
    }
    if (cacheEnabled) {//默认为true
      executor = new CachingExecutor(executor);
    }
    executor = (Executor) interceptorChain.pluginAll(executor);
    return executor;
  }

mapper.xml中 <mapper>标签解析+<cache>标签解析

/* org.apache.ibatis.builder.xml.XMLMapperBuilder#parse */
  public void parse() {
    if (!configuration.isResourceLoaded(resource)) {
      configurationElement(parser.evalNode("/mapper"));
      configuration.addLoadedResource(resource);
      bindMapperForNamespace();
    }

    parsePendingResultMaps();
    parsePendingCacheRefs();
    parsePendingStatements();
  }

  private void configurationElement(XNode context) {
    try {
      String namespace = context.getStringAttribute("namespace");
      if (namespace == null || namespace.equals("")) {
        throw new BuilderException("Mapper's namespace cannot be empty");
      }
      builderAssistant.setCurrentNamespace(namespace);
      cacheRefElement(context.evalNode("cache-ref"));
      cacheElement(context.evalNode("cache"));
      parameterMapElement(context.evalNodes("/mapper/parameterMap"));
      resultMapElements(context.evalNodes("/mapper/resultMap"));
      sqlElement(context.evalNodes("/mapper/sql"));
      buildStatementFromContext(context.evalNodes("select|insert|update|delete"));
    } catch (Exception e) {
      throw new BuilderException("Error parsing Mapper XML. The XML location is '" + resource + "'. Cause: " + e, e);
    }
  }

  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();
      builderAssistant.useNewCache(typeClass, evictionClass, flushInterval, size, readWrite, blocking, props);
    }
  }

/* org.apache.ibatis.builder.MapperBuilderAssistant#useNewCache */
  public Cache useNewCache(Class<? extends Cache> typeClass,
      Class<? extends Cache> evictionClass,
      Long flushInterval,
      Integer size,
      boolean readWrite,
      boolean blocking,
      Properties props) {
      //建造器模式创建cache
    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();
    configuration.addCache(cache);
    currentCache = cache;
    return cache;
  }

2、二级缓存出现的原因

源自官网：在一级缓存中，不同session进行相同SQL查询的时候，是查询两次数据库的。显然这是一种浪费，既然SQL查询相同，就没有必要再次查库了，直接利用缓存数据即可，这种思想就是MyBatis二级缓存的初衷。

另外，Spring和MyBatis整合时，每次查询之后都要进行关闭sqlsession，关闭之后数据被清空。所以MyBatis和Spring整合之后，一级缓存是没有意义的。如果开启二级缓存，关闭sqlsession后，会把该sqlsession一级缓存中的数据添加到mapper namespace的二级缓存中。这样，缓存在sqlsession关闭之后依然存在。

3、二级缓存的使用

<mapper namespace="org.study.mapper.UserMapper">
<!-- 在mapper下加入cache标签 -->
<!-- <cache/> -->

由于上面说的spring+mybatis每次查询都会关闭sqlSession，所以一级缓存没有意义，连续两次查询

 加上<cache/>后

 补充一下属性讲解：

<cache eviction="LRU" flushInterval="60000" size="512" readOnly="true"/>

eviction="LRU"：缓存过期置换策略，其实默认的是LRU（LruCache），还有FIFO（FIFOCache）多个装饰者模式的增强PerpetualCache的Cache。

flushInterval="60000":缓存过期时间，装饰者模式，外面加了一层ScheduleCache。控制缓存的有效时间。

size="512"：缓存大小，判断Map.size()，不是内存大小是key的个数。

readOnly="true"：只读的缓存会给所有调用者返回缓存对象的相同实例。 因此这些对象不能被修改。这就提供了可观的性能提升。而可读写的缓存会（通过序列化）返回缓存对象的拷贝。速度上会慢一些，但是更安全，因此默认值是 false。

4、总结

① 二级缓存的目的：解决一级缓存不能跨sqlSession的弊病，二级缓存可以跨sqlSession。

② 二级缓存默认是关闭的，默认开启的是CachingExecutor，所以仅需要在mapper.xml中设置<cache/>标签的可以开启二级缓存了。

③ 一级缓存二级缓存的cacheKey相同，但是一级缓存对应一个sqlSession，二级缓存对应一个mapper.xml命名空间（可跨sqlSession）。

④ 写操作都会引起缓存清空。但一级缓存是整体清空，二级缓存清空的是操作的mapper.xml命名空间下对应的缓存，其他命名空间不受影响

⑤ 过期策略。由于最终存储对象都是PerpetualCache中的Map中，所以理论上是都不会过期的。但是一级缓存flush频繁，二级缓存可以通过flushInterval设置过期时间，需要注意的是flushInterval对自定义的Cache不起作用。

⑥ 默认的二级缓存是是JVM层面的缓存，在分布式架构中应用不佳，不能保证缓存数据的一致性。但是可以自定义分布式cache，例如使用redis实现二级缓存。

三、mybatis缓存结构

默认单机：

分布式：

 

 四、补充

1、redis实现分布式二级缓存

package org.study.mappercache;

import com.alibaba.fastjson.JSONObject;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import org.apache.ibatis.cache.Cache;
import org.springframework.util.StringUtils;
import org.study.redis.RedisUtils;
import redis.clients.jedis.params.SetParams;

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class MappedRedisCache implements Cache {

    /**
     * redisCache 装饰者模式：增强过期时间控制
     */
    private Cache cache;

    public MappedRedisCache(String id){
        cache = new RedisCache("mybatis_" + id);
    }

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

    @Override
    public void putObject(Object key, Object value) {
        if (key != null && value != null){
            //key转hashCode存储 节省空间
            RedisUtils.getJedisCluster().set(key.toString().hashCode()+"","1",new SetParams().ex(600));
            cache.putObject(key,value);
        }
    }

    @Override
    public Object getObject(Object key) {
        if (key == null){
            return null;
        }
        if(!StringUtils.isEmpty(RedisUtils.getJedisCluster().get(key.toString()))){
            RedisUtils.getJedisCluster().set(key.toString().hashCode()+"","1",new SetParams().ex(600));
            cache.getObject(key);
        }
        cache.removeObject(key);
        return null;
    }

    @Override
    public Object removeObject(Object key) {
        if (key == null){
            return null;
        }
        RedisUtils.getJedisCluster().del(key.toString());
        Object obj =  cache.getObject(key);
        cache.removeObject(key);
        return obj;
    }

    @Override
    public void clear() {
        Set<String> keySet = RedisUtils.getJedisCluster().hkeys(getId());
        if(keySet != null && keySet.size() != 0){
            keySet.forEach(key -> RedisUtils.getJedisCluster().del(key));
        }
        cache.clear();
    }

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

    @Override
    public ReadWriteLock getReadWriteLock() {
        return cache.getReadWriteLock();
    }

    private class RedisCache implements Cache{

        private String id;
        public RedisCache(String id){
            this.id = id;
        }
        @Override
        public String getId() {
            return id;
        }

        @Override
        public void putObject(Object key, Object value) {
            if (key != null && value != null){
                RedisUtils.getJedisCluster().hset(getId(),key.toString().hashCode()+"",JSONObject.toJSONString(value));
            }
        }

        @Override
        public Object getObject(Object key) {
            if (key != null){
                return RedisUtils.getJedisCluster().hget(getId(),key.toString());
            }
            return null;
        }

        @Override
        public Object removeObject(Object key) {
            if (key != null){
                return RedisUtils.getJedisCluster().hdel(getId(),key.toString());
            }
            return null;
        }

        @Override
        public void clear() {
            RedisUtils.getJedisCluster().del(getId());
        }

        @Override
        public int getSize() {
            return RedisUtils.getJedisCluster().hlen(getId()).intValue();
        }

        @Override
        public ReadWriteLock getReadWriteLock() {
            return this.lock;
        }

        private final ReadWriteLock lock = new ReentrantReadWriteLock();
    }

}