一级缓存[SqlSession级别]
基本原理
一级缓存是SqlSession级别的缓存。在操作数据库时需要构造 sqlSession对象,在对象中有一个(内存区域)数据结构(HashMap)用于存储缓存数据。
不同的sqlSession之间的缓存数据区域(HashMap)是互相不影响的。
Mybatis**默认开启一级缓存**
组织原则
MyBatis只是一个MyBatis对外的接口,SqlSession将它的工作交给了Executor执行器这个角色来完成,负责完成对数据库的各种操作
当创建了一个SqlSession对象时,MyBatis会为这个SqlSession对象创建一个新的Executor执行器,而缓存信息就被维护在这个Executor执行器中
MyBatis将缓存和对缓存相关的操作封装成了Cache接口中。
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认为,对于两次查询,如果以下条件都完全一样,那么就认为它们是完全相同的两次查询:
传入的 statementId
对于MyBatis而言,你要使用它,必须需要一个statementId,它代表着你将执行什么样的Sql;
查询时要求的结果集中的结果范围 (结果的范围通过rowBounds.offset和rowBounds.limit表示)
MyBatis自身提供的分页功能是通过RowBounds来实现的,它通过rowBounds.offset和rowBounds.limit来过滤查询出来的结果集,这种分页功能是基于查询结果的再过滤,而不是进行数据库的物理分页;
这次查询所产生的最终要传递给JDBC Java.sql.Preparedstatement的Sql语句字符串(boundSql.getSql() )
由于MyBatis底层还是依赖于JDBC实现的,那么,对于两次完全一模一样的查询,MyBatis要保证对于底层JDBC而言,也是完全一致的查询才行。而对于JDBC而言,两次查询,只要传入给JDBC的SQL语句完全一致,传入的参数也完全一致,就认为是两次查询是完全一致的。
传递给java.sql.Statement要设置的参数值
综上所述,CacheKey由以下条件决定:
statementId + rowBounds + 传递给JDBC的SQL + 传递给JDBC的参数值
性能分析
MyBatis对会话(Session)级别的一级缓存设计的比较简单,就简单地使用了HashMap来维护,并没有对HashMap的容量和大小进行限制。
一级缓存是一个粗粒度的缓存,没有更新缓存和缓存过期的概念
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