MyBatis的缓存机制

cache缓存

缓存是一般的ORM框架都会提供的功能，目的就是提升查询xiaolv和较少数据库的压力。在MyBatis中有一级缓存和二级缓存，并且预留了集成第三方缓存的接口。

MyBatis的缓存体系结构

MyBatis缓存相关的类都在cache包里，其中有一个接口Cache，他只有一个默认的实现类PerpetualCache，其内部使用HashMap实现数据存储的。
PerpetualCache叫做基础缓存，因为它一定会被创建，除了基础缓存之外，MyBatis也定义了很多的装饰器，同样实现了Cache接口，通过这些装饰器可以额外实现很多的功能。
类图：


继承关系

在通常情况下，我们在debug源码的时候会发现基础缓存会被装饰四五层，当然不管怎么对它装饰，最底层使用的还是基础的实现类（PerpetualCache）
所有的缓存实现类总体上分为三类：基本缓存、淘汰算法缓存、装饰器缓存


image.png

一级缓存

一级缓存也叫本地缓存（Local Cache），MyBatis的一级缓存是在会话（SqlSession）层面实现缓存的，MyBatis的一级缓存是默认开启的，不需要任何的配置，（可以通过在配置文件中设置 localCacheScope设置为STATEMENT关闭一级缓存）

      if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
        // issue #482
        clearLocalCache();
      }

在MyBatis执行的流程中，涉及到这么多的对象，那么我们想缓存PerpetualCache应该放到哪个对象里面去维护呢？
因为本地缓存是在同一个会话中共享的，所以我们可以想到它应该是放在了qlSession对象里的，这样的话，当同一个会话查询缓存的时候就不需要说再去别的地方匹配相应的编号获取了。
DefaultSqlSession是SqlSession的默认实现类，它里面有两个对象属性，分别是Configuration和Executor，然而Configuration是全局唯一的，不完全是属于SqlSession，所以缓存只能放到Executor里面维护，而实际上在基础执行器SimpleExecutor、ReuseExecutor、BatchExecutor的父类BaseExecutor的构造方法中持有了PerpetualCache。

public abstract class BaseExecutor implements Executor {

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

  protected Transaction transaction;
  protected Executor wrapper;

  protected ConcurrentLinkedQueue<DeferredLoad> deferredLoads;
  protected PerpetualCache localCache;
  protected PerpetualCache localOutputParameterCache;
  protected Configuration configuration;

  protected int queryStack;
  private boolean closed;

  protected BaseExecutor(Configuration configuration, Transaction transaction) {
    this.transaction = transaction;
    this.deferredLoads = new ConcurrentLinkedQueue<>();
    this.localCache = new PerpetualCache("LocalCache");
    this.localOutputParameterCache = new PerpetualCache("LocalOutputParameterCache");
    this.closed = false;
    this.configuration = configuration;
    this.wrapper = this;
  }
...

在同一个会话中，多次执行同一个SQL语句，执行器会直接从内存取到缓存的结果，不会再去访问数据库；但是在不同的会话里执行相同的SQL语句是不会使用到一级缓存的。


image.png

代码验证

接下来验证一下，MyBatis的一级缓存到底是不是只能在一个会话中共享，以及跨会话操作相同的SQL语句会不会使用到一级缓存。
注意：演示一级缓存需要先关闭二级缓存，在配置文件中将localCacheScope设置为SESSION。

  • <setting name="cacheEnabled" value="false"/>

  • <setting name="localCacheScope" value="SESSION"/>

判断缓存是否命中：当再次发送SQL到数据库执行（控制台打印了SQL语句）说明没有命中缓存，如果直接打印对象，说明是从缓存中取到了结果。

  1. 在同一个会话中共享
 @Test
    public void testCache() throws IOException {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

        SqlSession session1 = sqlSessionFactory.openSession();
        SqlSession session2 = sqlSessionFactory.openSession();
        try {
            BlogMapper mapper0 = session1.getMapper(BlogMapper.class);
            BlogMapper mapper1 = session1.getMapper(BlogMapper.class);
            Blog blog = mapper0.selectBlogById(1);
            System.out.println(blog);

            System.out.println("第二次查询，相同会话，获取到缓存了吗？");
            System.out.println(mapper1.selectBlogById(1));

        } finally {
            session1.close();
        }
    }

结果：可以看出第二次查询没有打印SQL语句，直接得到了结果，说明是从缓存中拿到了数据

==>  Preparing: select * from blog where bid = ? 
==> Parameters: 1(Integer)
<==    Columns: bid, name, author_id
<==        Row: 1, 今天你学习了吗, 1001
<==      Total: 1
Blog{bid=1, name='今天你学习了吗', authorId='1001'}
第二次查询，相同会话，获取到缓存了吗？
Blog{bid=1, name='今天你学习了吗', authorId='1001'}
Resetting autocommit to true on JDBC Connection [com.mysql.jdbc.JDBC4Connection@4f83df68]
Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@4f83df68]
Returned connection 1334042472 to pool.
  1. 不同会话中是否共享
    @Test
    public void testCache() throws IOException {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

        SqlSession session1 = sqlSessionFactory.openSession();
        SqlSession session2 = sqlSessionFactory.openSession();
        try {
            BlogMapper mapper0 = session1.getMapper(BlogMapper.class);
            BlogMapper mapper1 = session1.getMapper(BlogMapper.class);
            Blog blog = mapper0.selectBlogById(1);
            System.out.println(blog);

            System.out.println("第二次查询，相同会话，获取到缓存了吗？");
            System.out.println(mapper1.selectBlogById(1));

            System.out.println("第三次查询，不同会话，获取到缓存了吗？");
            BlogMapper mapper2 = session2.getMapper(BlogMapper.class);
            System.out.println(mapper2.selectBlogById(1));

        } finally {
            session1.close();
        }
    }

结果：第三次查询是不一样的SqlSession，在控制台可以看出，第三次查询打印了SQL语句，说明它是从数据库中读取数据的，没有用到缓存，说明了，在不同的会话（SqlSession）中执行相同的SQL语句缓存是不会跨会话共享的。

==>  Preparing: select * from blog where bid = ? 
==> Parameters: 1(Integer)
<==    Columns: bid, name, author_id
<==        Row: 1, 今天你学习了吗, 1001
<==      Total: 1
Blog{bid=1, name='今天你学习了吗', authorId='1001'}
第二次查询，相同会话，获取到缓存了吗？
Blog{bid=1, name='今天你学习了吗', authorId='1001'}
第三次查询，不同会话，获取到缓存了吗？
Opening JDBC Connection
Sun Aug 09 23:25:24 GMT+08:00 2020 WARN: Establishing SSL connection without server's identity verification is not recommended. According to MySQL 5.5.45+, 5.6.26+ and 5.7.6+ requirements SSL connection must be established by default if explicit option isn't set. For compliance with existing applications not using SSL the verifyServerCertificate property is set to 'false'. You need either to explicitly disable SSL by setting useSSL=false, or set useSSL=true and provide truststore for server certificate verification.
Created connection 1984975621.
Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@76505305]
==>  Preparing: select * from blog where bid = ? 
==> Parameters: 1(Integer)
<==    Columns: bid, name, author_id
<==        Row: 1, 今天你学习了吗, 1001
<==      Total: 1
Blog{bid=1, name='今天你学习了吗', authorId='1001'}

源码分析一级缓存的存入与取出

因为一级缓存是在BaseExecutor中进行管理的，所以我们可以在这个对象中寻找答案，在SqlSession中最终会调用BaseExecutor中的query方法，下面是在SQL语句执行过程中对缓存操作的代码，下面简单的分析一下流程：首先会判断我们在配置中是否设置了fushCache为true，为true时表示即时执行的是查询语句也会对缓存进行清空操作clearLocalCache()，然后会先从一级缓存中去查询获取数据，如果查询到数据则直接包装结果，如果没有则直接查询数据库，调用queryFromDatabase方法，list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
对于某个查询，根据statementId,params,rowBounds来构建一个key值，根据这个key值作为缓存Cache的key值存储查询结果，

  public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
    // 异常体系之 ErrorContext
    ErrorContext.instance().resource(ms.getResource()).activity("executing a query").object(ms.getId());
    if (closed) {
      throw new ExecutorException("Executor was closed.");
    }
    if (queryStack == 0 && ms.isFlushCacheRequired()) {
      // flushCache="true"时，即使是查询，也清空一级缓存
      clearLocalCache();
    }
    List<E> list;
    try {
      // 防止递归查询重复处理缓存
      queryStack++;
      // 查询一级缓存
      // ResultHandler 和 ResultSetHandler的区别
      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
        clearLocalCache();
      }
    }
    return list;
  }

private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
    List<E> list;
    // 先占位
    localCache.putObject(key, EXECUTION_PLACEHOLDER);
    try {
      // 三种 Executor 的区别，看doUpdate
      // 默认Simple
      list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
    } finally {
      // 移除占位符
      localCache.removeObject(key);
    }
    // 写入一级缓存
    localCache.putObject(key, list);
    if (ms.getStatementType() == StatementType.CALLABLE) {
      localOutputParameterCache.putObject(key, parameter);
    }
    return list;
  }

一级缓存什么时候会被清空呢？

在同一个会话中，update操作（包括delete）会导致一级缓存被清空，还有我们上面提到的在配置文件中或者在映射文件中设置了fushCache为true。源码中当在同一个会话中调用update操作会无条件的情况缓存。

  public int update(MappedStatement ms, Object parameter) throws SQLException {
    ErrorContext.instance().resource(ms.getResource()).activity("executing an update").object(ms.getId());
    if (closed) {
      throw new ExecutorException("Executor was closed.");
    }
    clearLocalCache();
    return doUpdate(ms, parameter);
  }

一级缓存的不足：

使用一级缓存的时候，因为它是不能跨会话共享的，在不同会话之间相同的数据可能有不一样的缓存，在别的会话更新数据的时候，自己会话中的缓存不会被清空，这就会造成查到过时的数据。（二级缓存可以解决）

二级缓存

  • 二级缓存是用来解决一级缓存不能跨会话共享的问题的，范围是namespace级别的，可以被多个SqlSession共享，只要是在同一个接口中，它的生命周期与应用同步。
  • 二级缓存作为一个作业范围更广的缓存，而且被多个SqlSession共享，所以它应该是在SqlSession外层的，当查询语句执行的时候会先到二级缓存中查找，没有才会到会话中的一级缓存去取，没有则查询数据库。
  • 那么这个二级缓存是在哪个对象里来维护的呢，因为二级缓存是可以动态开启和关闭的，所以在代码中怎么做到开启则使用对象，关闭则不使用呢，这时候就用到装饰器模式了，而MyBatis就是使用一个装饰器类CachingExecutor来维护二级缓存的，如果开启二级缓存，MyBatis在创建Executor对象的时候会对Executor进行装饰。
  • 工作原理：CachingExecutor会对查询请求先做判断二级缓存中是否有缓存的对象，有则直接返回，没有就委派给真正的Executor实现类去执行查询。
image.png

二级缓存的开启方式

首先，在MyBatis-config.xml文件中配置（可以不做配置，因为默认事true）

  •  <setting name="cacheEnabled" value="false"/>

只要我们没有将cacheEnabled设置为false，MyBatis都会用CachingExecutor去装饰基本的执行器Executor。
注意虽然二级缓存的开关是默认开启的，但是对于每一个Mapper的二级缓存则是默认关闭的，而我们需要使用二级缓存的话，需要在映射文件中配置。
在Mapper.xml中配置<cache>标签：

<cache type="org.apache.ibatis.cache.impl.PerpetualCache"
               size="1024"
               eviction="LRU"
               flushInterval="120000"
               readOnly="false"/>

cache属性详解：

  • type 缓存实现类 需要实现Cache接口，默认事PerptualCache，可以使用第三方缓存。
  • size 最多缓存对象个数 默认事1024
  • eviction: 缓存的回收策略，默认是LRU
    LRU - 最近最少使用的：移除最长时间不被使用的对象
    FIFO - 先进先出策略：按对象进入缓存的顺序来移除它们
    SOFT - 软引用：移除基于垃圾回收器状态和软引用规则的对象
    WEAK - 弱引用：更积极地移除基于垃圾收集器状态和弱引用规则的对象
  • flushInterval：缓存的刷新间隔，默认是不刷新的
  • readOnly：缓存的只读设置，默认是false
    true:只读 mybatis认为只会对缓存中的数据进行读取操作，不会有修改操作为了加快数据的读取，直接将缓存中对象的引用交给用户
    false：不只读 mybatis认为不仅会有读取数据，还会有修改操作。
    会通过序列化和反序列化的技术克隆一份新的数据交给用户
  • blocking： 启用阻塞缓存 ，给get/put方式加锁
    在Mapper.xml中配置了<cache>，二级缓存就生效了，select（）查询会被缓存，但是update、delete、insert操作依旧会刷新缓存。
    再次说明，如果cacheEnabled=true，而Mapper.xml没有配置<cache>标签，二级缓存还是相当于开启的，只是没有起到作用，
    在源码中CachingExecutor的query()方法中有这么一个判断 if (cache != null)这个cache是否为空，而这个cache对象是在前期扫描Mapper.xml映射文件获取的，没有配置则就为空，也就是说不会走到if方法里，也就不会使用二级缓存。
  public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
      throws SQLException {
    Cache cache = ms.getCache();
    // cache 对象是在哪里创建的？  XMLMapperBuilder类 xmlconfigurationElement()
    // 由 <cache> 标签决定
    if (cache != null) {
      // flushCache="true" 清空一级二级缓存 >>
      flushCacheIfRequired(ms);
      if (ms.isUseCache() && resultHandler == null) {
        ensureNoOutParams(ms, boundSql);
        // 获取二级缓存
        // 缓存通过 TransactionalCacheManager、TransactionalCache 管理
        @SuppressWarnings("unchecked")
        List<E> list = (List<E>) tcm.getObject(cache, key);
        if (list == null) {
          list = delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
          // 写入二级缓存
          tcm.putObject(cache, key, list); // issue #578 and #116
        }
        return list;
      }
    }
    // 走到 SimpleExecutor | ReuseExecutor | BatchExecutor
    return delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
  }

如果一个Mapper需要开启二级缓存，但是这里面的某些查询对数据的实时性要求很高，不想走缓存，那么我们可以在单个Statement ID上配置关闭二级缓存

  •  <select id="selectBlogById" resultMap="BaseResultMap" statementType="PREPARED" useCache="false">

因为在CachingExecutor中的query方法里有对它的检验

  •  if (ms.isUseCache() && resultHandler == null)

验证

    @Test
    public void testCache() throws IOException {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

        SqlSession session1 = sqlSessionFactory.openSession();
        SqlSession session2 = sqlSessionFactory.openSession();
        try {
            BlogMapper mapper1 = session1.getMapper(BlogMapper.class);
            System.out.println(mapper1.selectBlogById(1));
            // 事务不提交的情况下，二级缓存会写入吗？
           // session1.commit();
            System.out.println("第二次查询");
            BlogMapper mapper2 = session2.getMapper(BlogMapper.class);
            System.out.println(mapper2.selectBlogById(1));
        } finally {
            session1.close();
        }
    }

结果

  ==>  Preparing: select * from blog where bid = ? 
==> Parameters: 1(Integer)
<==    Columns: bid, name, author_id
<==        Row: 1, 今天你学习了吗, 1001
<==      Total: 1
Blog{bid=1, name='今天你学习了吗', authorId='1001'}
第二次查询
Opening JDBC Connection
Mon Aug 10 21:31:12 GMT+08:00 2020 WARN: Establishing SSL connection without server's identity verification is not recommended. According to MySQL 5.5.45+, 5.6.26+ and 5.7.6+ requirements SSL connection must be established by default if explicit option isn't set. For compliance with existing applications not using SSL the verifyServerCertificate property is set to 'false'. You need either to explicitly disable SSL by setting useSSL=false, or set useSSL=true and provide truststore for server certificate verification.
Created connection 1984975621.
Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@76505305]
==>  Preparing: select * from blog where bid = ? 
==> Parameters: 1(Integer)
<==    Columns: bid, name, author_id
<==        Row: 1, 今天你学习了吗, 1001
<==      Total: 1
Blog{bid=1, name='今天你学习了吗', authorId='1001'}

这结果似乎有点奇怪哦，结果控制台对每一查询都打印了SQL语句，说明没有命中缓存，这是不是出乎意料了呢，这是为什么呢，如果细心一点的话应该会发现在代码中我把事务的提交注释了，这就是原因所在，因为事务不提交，二级缓存不生效。
原因：因为二级缓存使用了TransactionlCacheManager（TCM）来管理，最后调用TransactionlCache的getObject()、putObject()he commit()方法，TransactionlCache里持有了经过层层装饰的真正的Cache对象，在getObject的时候，只是添加到了entriesToAddOnCommit里面，只有它的commit()方法被调用的时候才会调用flushPendingEntries()真正的写到缓存中。而它的调用就是在DefaultSqlSession调用commit()的时候被调用的。

验证同一个namespace中其它的SqlSession中执行增删改操作，二级缓存会被刷新吗

    @Test
    public void testCacheInvalid() throws IOException {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

        SqlSession session1 = sqlSessionFactory.openSession();
        SqlSession session2 = sqlSessionFactory.openSession();
        SqlSession session3 = sqlSessionFactory.openSession();
        try {
            BlogMapper mapper1 = session1.getMapper(BlogMapper.class);
            BlogMapper mapper2 = session2.getMapper(BlogMapper.class);
            BlogMapper mapper3 = session3.getMapper(BlogMapper.class);
            System.out.println(mapper1.selectBlogById(1));
            session1.commit();

            // 是否命中二级缓存
            System.out.println("是否命中二级缓存？");
            System.out.println(mapper2.selectBlogById(1));

            Blog blog = new Blog();
            blog.setBid(1);
            blog.setName("2020年8月10日21:43:38");
            mapper3.updateByPrimaryKey(blog);
            session3.commit();

            System.out.println("更新后再次查询，是否命中二级缓存？");
            // 在其他会话中执行了更新操作，二级缓存是否被清空？
            System.out.println(mapper2.selectBlogById(1));

        } finally {
            session1.close();
            session2.close();
            session3.close();
        }
    }

结果

==>  Preparing: select * from blog where bid = ? 
==> Parameters: 1(Integer)
<==    Columns: bid, name, author_id
<==        Row: 1, 你今天学习了吗, 1001
<==      Total: 1
Blog{bid=1, name='你今天学习了吗', authorId='1001'}
是否命中二级缓存？
Cache Hit Ratio [com.gupaoedu.mapper.BlogMapper]: 0.5
Blog{bid=1, name='你今天学习了吗', authorId='1001'}
Opening JDBC Connection
Mon Aug 10 21:58:41 GMT+08:00 2020 WARN: Establishing SSL connection without server's identity verification is not recommended. According to MySQL 5.5.45+, 5.6.26+ and 5.7.6+ requirements SSL connection must be established by default if explicit option isn't set. For compliance with existing applications not using SSL the verifyServerCertificate property is set to 'false'. You need either to explicitly disable SSL by setting useSSL=false, or set useSSL=true and provide truststore for server certificate verification.
Created connection 442987331.
Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@1a677343]
==>  Preparing: update blog SET name = ? where bid = ? 
==> Parameters: 2020年8月10日21:43:38(String), 1(Integer)
<==    Updates: 1
Committing JDBC Connection [com.mysql.jdbc.JDBC4Connection@1a677343]
更新后再次查询，是否命中二级缓存？
Cache Hit Ratio [com.gupaoedu.mapper.BlogMapper]: 0.3333333333333333
Opening JDBC Connection
Mon Aug 10 21:58:41 GMT+08:00 2020 WARN: Establishing SSL connection without server's identity verification is not recommended. According to MySQL 5.5.45+, 5.6.26+ and 5.7.6+ requirements SSL connection must be established by default if explicit option isn't set. For compliance with existing applications not using SSL the verifyServerCertificate property is set to 'false'. You need either to explicitly disable SSL by setting useSSL=false, or set useSSL=true and provide truststore for server certificate verification.
Created connection 2087258327.
Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@7c6908d7]
==>  Preparing: select * from blog where bid = ? 
==> Parameters: 1(Integer)
<==    Columns: bid, name, author_id
<==        Row: 1, 2020年8月10日21:43:38, 1001
<==      Total: 1

结果中不同SqlSession中查询同一个sql语句使用到了二级缓存，而当第三个SqlSession中执行了更新操作后，第四次的查询直接是从数据库中获取的，说明二级缓存被刷新了。
原因：
在CachingExecutor的update()方法里会调用flushCachelfRequired(ms)，isFlushCacheRequired就是从标签里面取到的flushCache的值，而增删改操作的flushCache属性默认是true，也就是说，如果不需要清空二级缓存的话，可以将flushCache属性修改为false，不过这样会造成过时数据问题。默认是false

  • <select id="selectBlogById" resultMap="BaseResultMap" statementType="PREPARED" flushCache="false" >

二级缓存开启选择

一级缓存是默认打开的，二级缓存需要我们配置才会开启，那么在什么情况下才有必要开启二级缓存呢？

  1. 因为所有的增删改都会刷新二级缓存，所以适合在以查询为主的应用中，比如，历史交易，历史订单等查询。
  2. 如果多个namespace中有针对同一个表的操作，如果在一个namespace中刷新了缓存，另一个namespace中就没有刷新，这样会出现读到脏数据的情况，所以，推荐在一个Mapper里面只操作单表的情况使用。
    跨namespace的缓存共享设置
  • <cache-ref namespace="另一个的namespace"/>

cache-ref 代表引用别的命名空间的Cache配置，表示两个命名空间使用同一个Cache，在关联的表比较少，或按照业务可以对表进行分组的时候使用。
注意，这两个Mapper中只要有增删改等操作都会刷新缓存，缓存的意义就不大了。

第三方做二级缓存

除了MyBatis自带的二级缓存外，我们也可以通过实现Cache接口来定义二级缓存。
MyBatis官方提供了一些第三方缓存集成方式，如：ehcache和redis
pom中引入依赖：

<dependency>
            <groupId>org.mybatis.caches</groupId>
            <artifactId>mybatis-redis</artifactId>
            <version>1.0.0-beta2</version>
        </dependency>

Mapper.xml配置，type使用RedisCache

<cache type="org.mybatis.caches.redis.RedisCache"
           eviction="FIFO" flushInterval="60000" size="512" readOnly="true"/>

然后在配置redis的连接配置

host=localhost
port=6379
connectionTimeout=5000
soTimeout=5000
database=0

这就集成Redis做二级缓存了，在分布式中可以使用独立的缓存服务器，可以不使用MyBatis自带的二级缓存。

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