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