Mybatis 一级缓存和二级缓存

一级缓存[SqlSession级别]

基本原理

1. 一级缓存是SqlSession级别的缓存。在操作数据库时需要构造 sqlSession对象，在对象中有一个(内存区域)数据结构（HashMap）用于存储缓存数据。

2. 不同的sqlSession之间的缓存数据区域（HashMap）是互相不影响的。

3. Mybatis**默认开启一级缓存**

组织原则

1. MyBatis只是一个MyBatis对外的接口，SqlSession将它的工作交给了Executor执行器这个角色来完成，负责完成对数据库的各种操作

2. 当创建了一个SqlSession对象时，MyBatis会为这个SqlSession对象创建一个新的Executor执行器，而缓存信息就被维护在这个Executor执行器中

3. MyBatis将缓存和对缓存相关的操作封装成了Cache接口中。

4. Session级别的一级缓存实际上就是使用PerpetualCache维护的。PerpetualCache实现原理是通过一个简单的HashMap

package org.apache.ibatis.cache.impl;  import java.util.HashMap;  import java.util.Map;  import java.util.concurrent.locks.ReadWriteLock;  import org.apache.ibatis.cache.Cache;  import org.apache.ibatis.cache.CacheException;  /**  * 使用简单的HashMap来维护缓存  * @author Clinton Begin  */  public class PerpetualCache implements Cache {    private String id;    private Map<Object, Object> cache = new HashMap<Object, Object>();    public PerpetualCache(String id) {      this.id = id;    }    public String getId() {      return id;    }    public int getSize() {      return cache.size();    }    public void putObject(Object key, Object value) {      cache.put(key, value);    }    public Object getObject(Object key) {      return cache.get(key);    }    public Object removeObject(Object key) {      return cache.remove(key);    }    public void clear() {      cache.clear();    }    public ReadWriteLock getReadWriteLock() {      return null;    }    public boolean equals(Object o) {      if (getId() == null) throw new CacheException("Cache instances require an ID.");      if (this == o) return true;      if (!(o instanceof Cache)) return false;      Cache otherCache = (Cache) o;      return getId().equals(otherCache.getId());    }    public int hashCode() {      if (getId() == null) throw new CacheException("Cache instances require an ID.");      return getId().hashCode();    }  }  

生命周期

a. MyBatis在开启一个数据库会话时，会创建一个新的SqlSession对象，SqlSession对象中会有一个新的Executor对象，Executor对象中持有一个新的PerpetualCache对象；当会话结束时，SqlSession对象及其内部的Executor对象还有PerpetualCache对象也一并释放掉。

b. 如果SqlSession调用了close()方法，会释放掉一级缓存PerpetualCache对象，一级缓存将不可用；

c. 如果SqlSession调用了clearCache()，会清空PerpetualCache对象中的数据，但是该对象仍可使用；

d.SqlSession中执行了任何一个update操作(update()、
delete()、insert()) ，都会清空PerpetualCache对象的数据，但是该对象可以继续使用

确定一次查询的特征值

Cache最核心的实现其实就是一个Map，将本次查询使用的特征值作为key，将查询结果作为value存储到Map中。

MyBatis认为，对于两次查询，如果以下条件都完全一样，那么就认为它们是完全相同的两次查询：

1. 传入的 statementId

   对于MyBatis而言，你要使用它，必须需要一个statementId，它代表着你将执行什么样的Sql；

2. 查询时要求的结果集中的结果范围 （结果的范围通过rowBounds.offset和rowBounds.limit表示）

   MyBatis自身提供的分页功能是通过RowBounds来实现的，它通过rowBounds.offset和rowBounds.limit来过滤查询出来的结果集，这种分页功能是基于查询结果的再过滤，而不是进行数据库的物理分页；

3. 这次查询所产生的最终要传递给JDBC Java.sql.Preparedstatement的Sql语句字符串（boundSql.getSql() ）

   由于MyBatis底层还是依赖于JDBC实现的，那么，对于两次完全一模一样的查询，MyBatis要保证对于底层JDBC而言，也是完全一致的查询才行。而对于JDBC而言，两次查询，只要传入给JDBC的SQL语句完全一致，传入的参数也完全一致，就认为是两次查询是完全一致的。

4. 传递给java.sql.Statement要设置的参数值

综上所述,CacheKey由以下条件决定：

 statementId  + rowBounds  + 传递给JDBC的SQL  + 传递给JDBC的参数值

性能分析

1. MyBatis对会话（Session）级别的一级缓存设计的比较简单，就简单地使用了HashMap来维护，并没有对HashMap的容量和大小进行限制。

2. 一级缓存是一个粗粒度的缓存，没有更新缓存和缓存过期的概念

Example

package cache;import com.hqq.entity.User;import com.hqq.utils.MyBatisUtils;import org.apache.ibatis.session.SqlSession;import org.junit.Test;import java.util.Date;/** * TestLevelOneCache * 一级缓存 * 基于PerpetualCache 的 HashMap本地缓存 * 其存储作用域为【Session】 * 当 Session flush 或 close 之后，该Session中的所有 Cache 就将清空。 * Created by heqianqian on 2017/4/28. */public class TestLevelOneCache {    @Test    public void testCache1() throws Exception {        SqlSession sqlSession = MyBatisUtils.getSqlSession();        String statement = "com.hqq.entity.User.getUser";        System.out.println("===第一次查询===");        Date first = new Date();        User user = sqlSession.selectOne(statement, 1);        System.out.println(user);        System.out.println("第一次查询花费时间: "+String.valueOf(new Date().getTime()-first.getTime())+" ms");        //默认使用一级缓存        System.out.println("===第二次查询：默认使用一级缓存===");        Date second = new Date();        user = sqlSession.selectOne(statement,1);        System.out.println(user);        System.out.println("第二次查询花费时间: "+String.valueOf(new Date().getTime()-second.getTime())+" ms");        sqlSession.close();        //必须是同一个Session,如果session对象已经close()过了就不可能用了        System.out.println("===第三次查询：sqlsession关闭后清空一级缓存===");        Date third = new Date();        sqlSession = MyBatisUtils.getSqlSession();        user = sqlSession.selectOne(statement,1);        System.out.println(user);        System.out.println("第三次查询花费时间: "+String.valueOf(new Date().getTime()-third.getTime())+" ms");        ////查询条件是一样的        System.out.println("===第四次查询：查询语句不变，参数变化===");        Date forth = new Date();        user = sqlSession.selectOne(statement,3);        System.out.println(user);        System.out.println("第四次查询花费时间: "+String.valueOf(new Date().getTime()-forth.getTime())+" ms");        //没有执行过session.clearCache()清理缓存        System.out.println("===第五次查询：调用clearCache后进行查询===");        sqlSession.clearCache();        Date fifth = new Date();        user = sqlSession.selectOne(statement,3);        System.out.println(user);        System.out.println("第五次查询花费时间: "+String.valueOf(new Date().getTime()-fifth.getTime())+" ms");        //没有执行过增删改操作(这些操作都会清理缓存)        System.out.println("===第六次查询：执行增删改方法后再进行查询===");        sqlSession.update("com.hqq.entity.User.updUser"                    ,new User(3,"user",2));        Date sixth = new Date();        user=sqlSession.selectOne(statement,3);        System.out.println(user);        System.out.println("第六次查询花费时间: "+String.valueOf(new Date().getTime()-sixth.getTime())+" ms");    }}

二级缓存[Mapper级别]

基本原理

如果用户配置了"cacheEnabled=true"，那么MyBatis在为SqlSession对象创建Executor对象时，会对Executor对象加上一个装饰者：CachingExecutor，这时SqlSession使用CachingExecutor对象来完成操作请求。

CachingExecutor对于查询请求，会先判断该查询请求在Application级别的二级缓存中是否有缓存结果

如果有查询结果，则直接返回缓存结果；

如果缓存中没有，再交给真正的Executor对象来完成查询操作，之后CachingExecutor会将真正Executor返回的查询结果放置到缓存中，然后在返回给用户。

划分

MyBatis并不是简单地对整个Application就只有一个Cache缓存对象，它将缓存划分的更细，即是Mapper级别的，即

每一个Mapper都可以拥有一个Cache对象

具体如下：

a.为每一个Mapper分配一个Cache缓存对象（使用<cache>节点配置）

b.多个Mapper共用一个Cache缓存对象（使用<cache-ref>节点配置）

使用

1.MyBatis支持二级缓存的总开关：全局配置变量参数 cacheEnabled=true

<!--开启二级缓存-->    <settings>        <!--对在此配置文件下的所有Cache进行全局性开关设置-->        <setting name="cacheEnabled" value="true"/>    </settings>

2.该select语句所在的Mapper，配置了<cache> 或<cached-ref>节点，并且有效

<mapper namespace="com.hqq.entity.User">    <cache/>    ...</mapper>

3.该select语句的参数 useCache=true

<select id="getUser" parameterType="int" resultType="com.hqq.entity.User" useCache="true">        select * from users where id=#{id};</select>

MyBatis查询数据的顺序是：

 二级缓存    ———> 一级缓存——> 数据库

使用MyBatis的二级缓存有三个选择:

 1.MyBatis自身提供的缓存实现； 2.用户自定义的Cache接口实现； 3.跟第三方内存缓存库的集成；

Example

使用ehcache

1.添加依赖

 <!--ehcache--> <dependency>      <groupId>net.sf.ehcache</groupId>      <artifactId>ehcache-core</artifactId>      <version>2.6.11</version>  </dependency>  <dependency>      <groupId>org.mybatis</groupId>      <artifactId>mybatis-ehcache</artifactId>      <version>1.0.0</version>  </dependency>

2.在mybatis配置文件中打开二级缓存总开关

  <!--开启二级缓存-->    <settings>        <!--对在此配置文件下的所有Cache进行全局性开关设置-->        <setting name="cacheEnabled" value="true"/>    </settings>

3.在相应的mapper.xml文件配置

    <!--开启本namespace下的二级缓存-->    <!--type:执行cache接口实现类 默认使用PerpetualCache-->    <cache type="org.mybatis.caches.ehcache.EhcacheCache">        <!--缓存参数-->        <property name="timeToIdleSeconds" value="3600"/>        <property name="timeToLiveSeconds" value="3600"/>        <!-- 同ehcache参数maxElementsInMemory-->        <property name="maxEntriesLocalHeap" value="1000"/>        <!-- 同ehcache参数maxElementsOnDisk -->        <property name="maxEntriesLocalDisk" value="10000000"/>        <property name="memoryStoreEvictionPolicy" value="LRU"/>    </cache>

<select id="getUser" parameterType="int" resultType="com.hqq.entity.User" useCache="true">        select * from users where id=#{id};    </select>

4.在classpath下添加ehcache.xml配置文件

<ehcache>    <!--指定数据在磁盘中的存储位置-->    <diskStore path="F:\ehcache"/>    <!--当借助CacheManager.add("demoCache")创建Cache时，EhCache便会采用<defalutCache/>指定的的管理策略-->    <defaultCache            maxElementsInMemory="1000"            maxElementsOnDisk="10000000"            eternal="false"            overflowToDisk="false"            timeToIdleSeconds="120"            timeToLiveSeconds="120"            diskExpiryThreadIntervalSeconds="120"            memoryStoreEvictionPolicy="LRU">   <!--必选参数        1.maxElementsInMemory：在内存中缓存的element的最大数目        2.maxElementsOnDisk：在磁盘上缓存的element的最大数目，若是0表示无穷大        3.eternal：设定缓存的elements是否永远不过期            如果为true，则缓存的数据始终有效            如果为false那么还要根据timeToIdleSeconds，timeToLiveSeconds判断        4.overflowToDisk：设定当内存缓存溢出的时候是否将过期的element缓存到磁盘上   -->   <!--可选参数        1.timeToIdleSeconds:当缓存在EhCache中的数据前后两次访问的时间超过timeToIdleSeconds的属性取值时，这些数据便会删除，默认值是0,也就是可闲置时间无穷大        2.timeToLiveSeconds:缓存element的有效生命期，默认是0.,也就是element存活时间无穷大        3.diskSpoolBufferSizeMB:设置DiskStore(磁盘缓存)的缓存区大小.默认是30MB.每个Cache都应该有自己的一个缓冲区        4.diskPersistent:在VM重启的时候是否启用磁盘保存EhCache中的数据，默认是false        5.diskExpiryThreadIntervalSeconds:磁盘缓存的清理线程运行间隔，默认是120秒。每个120s，相应的线程会进行一次EhCache中数据的清理工作        6.memoryStoreEvictionPolicy:当内存缓存达到最大，有新的element加入的时候，移除缓存中element的策略。                默认是LRU（最近最少使用）                可选的有LFU（最不常使用）和FIFO（先进先出）   --></defaultCache></ehcache>

5.编写测试方法

注意：

package cache;import com.hqq.entity.User;import com.hqq.utils.MyBatisUtils;import org.apache.ibatis.session.SqlSession;import org.apache.ibatis.session.SqlSessionFactory;import org.junit.Test;import java.util.Date;/** * TestLevelTwoCache * 测试二级缓存 * 二级缓存与一级缓存其机制相同，默认也是采用 PerpetualCache，HashMap存储， * 不同在于其存储作用域为 【Mapper(Namespace)】，并且可【自定义存储源】，如 Ehcache。 * Created by heqianqian on 2017/4/28. */public class TestLevelTwoCache {    @Test    public void testCache2() throws Exception {        SqlSessionFactory sqlSessionFactory = MyBatisUtils.getSqlSessionFactory();        String statement = "com.hqq.entity.User.getUser";        //开启两个不同的SqlSession        SqlSession sqlSession1 = sqlSessionFactory.openSession();        SqlSession sqlSession2 = sqlSessionFactory.openSession();        //使用二级缓存时，User类必须实现一个Serializable接口===> User implements Serializable        System.out.println("===第一次查询===");        Date first = new Date();        User user = sqlSession1.selectOne(statement, 1);        sqlSession1.commit();        System.out.println("user=" + user);        System.out.println("第一次查询花费时间:"+String.valueOf(new Date().getTime()-first.getTime()));        //由于使用的是两个不同的SqlSession对象，所以即使查询条件相同，一级缓存也不会开启使用        System.out.println("===第二次查询===");        Date second = new Date();        user = sqlSession2.selectOne(statement, 1);        System.out.println("user2=" + user);        System.out.println("第二次查询查询花费时间:"+String.valueOf(new Date().getTime()-second.getTime()));    }}

测试结果

===第一次查询===user=User{id=1, name='heqianqian', age=20}第一次查询花费时间:371===第二次查询===user2=User{id=1, name='heqianqian', age=20}第二次查询查询花费时间:0

二级缓存需要查询结果映射的pojo对象实现Java.io.Serializable接口实现序列化和反序列化操作，注意如果存在父类、成员pojo都需要实现序列化接口。

pojo类实现序列化接口是为了将缓存数据取出执行反序列化操作，因为二级缓存数据存储介质多种多样，不一定在内存有可能是硬盘或者远程服务器。

应用场景

对于访问多的查询请求且用户对查询结果实时性要求不高，此时可采用mybatis二级缓存技术降低数据库访问量，提高访问速度，业务场景比如：耗时较高的统计分析sql、电话账单查询sql等。

实现方法如下：通过设置刷新间隔时间，由mybatis每隔一段时间自动清空缓存，根据数据变化频率设置缓存刷新间隔flushInterval，比如设置为30分钟、60分钟、24小时等，根据需求而定

---

参考文章:

http://blog.csdn.net/luanlouis/article/details/41408341
http://blog.csdn.net/u012373815/article/details/47069223