mybatis中的查询缓存

查询缓存

一、mybatis的缓存理解

Mybatis的缓存，包括一级缓存和二级缓存：

一级缓存指的就是sqlsession，在sqlsession中有一个数据区域，是map结构，这个区域就是一级缓存区域。

一级缓存中的key是由sql语句、条件、statement等信息组成一个唯一值。一级缓存中的value，就是查询出的结果对象。

二级缓存指的就是同一个namespace下的mapper，二级缓存中，也有一个map结构，这个区域就是一级缓存区域。

一级缓存中的key是由sql语句、条件、statement等信息组成一个唯一值。一级缓存中的value，就是查询出的结果对象。

一级缓存是默认使用的。

二级缓存需要手动开启。

二、一级缓存

1、原理：

理解 :

    第一次发起查询用户id为1的用户的信息,先去找缓存中是否有id为1的用户的信息,假如没有,从数据库查询用户信息。

        得到用户的信息后,将用户的信息存到缓存中。

    假如sqlSession去执行commit操作<执行插入、更新、删除>,清空sqlSession中的一级缓存,原因就是为了使缓存中的信息为          最新的。

    第二次发起查询用户id为1的用户信息,先去找缓存中是否有id为1的用户的信息,缓存中有,直接从缓冲中获取用户信息。

2、测试

测试一：

[java]  view plain  copy

1. @Test  
2.     public void testOneLevelCache() throws Exception {  
3.         // 创建UserMapper对象  
4.         SqlSession sqlSession = sqlSessionFactory.openSession();  
5.         // 由mybatis通过sqlsession来创建代理对象  
6.         UserMapper mapper = sqlSession.getMapper(UserMapper.class);  
7.   
8.         // 第一次查询  
9.         User user1 = mapper.findUserById(1);  
10.         System.out.println(user1);  
11.   
12.         // 第二次查询  
13.         User user2 = mapper.findUserById(1);  
14.         System.out.println(user2);  
15.   
16.         sqlSession.close();  
17.     }  

测试二：

执行添加用户操作：

[java]  view plain  copy

1. @Test  
2.     public void testOneLevelCache() throws Exception {  
3.         // 创建UserMapper对象  
4.         SqlSession sqlSession = sqlSessionFactory.openSession();  
5.         // 由mybatis通过sqlsession来创建代理对象  
6.         UserMapper mapper = sqlSession.getMapper(UserMapper.class);  
7.   
8.         // 第一次查询  
9.         User user1 = mapper.findUserById(1);  
10.         System.out.println(user1);  
11.   
12.         // 执行添加用户操作  
13.         mapper.insertUser(user1);  
14.         // 执行commit时，将一级缓存清空  
15.         sqlSession.commit();  
16.   
17.         // 第二次查询  
18.         User user2 = mapper.findUserById(1);  
19.         System.out.println(user2);  
20.   
21.         sqlSession.close();  
22.     }  

结果：

三、二级缓存

1、原理

2、开启二级缓存

（1）开启二级缓存的总开关

在SqlMapConfig.xml文件中：

[html]  view plain  copy

1. <settings>  
2.         <!-- 二级缓存的总开关 -->  
3.         <setting name="cacheEnabled" value="true"/>  
4. </settings>  

（2）在mapper映射文件中开启二级缓存

[html]  view plain  copy

1. <!-- 开启二级缓存，默认使用了PerpetualCache -->  
2. <cache/>  

3、序列化

要开启二级缓存，还需要将对应的pojo类序列化

[java]  view plain  copy

1. public class User implements Serializable{  
2.     private int id;  
3.     private String username;// 用户姓名  
4.     private String sex;// 性别  
5.     private Date birthday;// 生日  
6.     private String address;// 地址  
7.       

4、测试

测试一：

[java]  view plain  copy

1. @Test  
2.     public void testTwoLevelCache() throws Exception {  
3.         // 创建UserMapper对象  
4.         SqlSession sqlSession1 = sqlSessionFactory.openSession();  
5.         SqlSession sqlSession2 = sqlSessionFactory.openSession();  
6.         SqlSession sqlSession3 = sqlSessionFactory.openSession();  
7.   
8.         // 由mybatis通过sqlsession来创建代理对象  
9.         UserMapper mapper1 = sqlSession1.getMapper(UserMapper.class);  
10.         UserMapper mapper2 = sqlSession2.getMapper(UserMapper.class);  
11.         UserMapper mapper3 = sqlSession3.getMapper(UserMapper.class);  
12.   
13.         // 第一次查询  
14.         User user1 = mapper1.findUserById(1);  
15.         System.out.println(user1);  
16.         // 在close的时候，才会将数据写入到二级缓存中  
17.         sqlSession1.close();  
18.   
19.         // 第二次查询  
20.         User user2 = mapper2.findUserById(1);  
21.         System.out.println(user2);  
22.         sqlSession2.close();  
23.   
24.         // 关闭资源  
25.         sqlSession3.close();  
26.     }  

结果：

测试二：

[java]  view plain  copy

1. @Test  
2.     public void testTwoLevelCache() throws Exception {  
3.         // 创建UserMapper对象  
4.         SqlSession sqlSession1 = sqlSessionFactory.openSession();  
5.         SqlSession sqlSession2 = sqlSessionFactory.openSession();  
6.         SqlSession sqlSession3 = sqlSessionFactory.openSession();  
7.   
8.         // 由mybatis通过sqlsession来创建代理对象  
9.         UserMapper mapper1 = sqlSession1.getMapper(UserMapper.class);  
10.         UserMapper mapper2 = sqlSession2.getMapper(UserMapper.class);  
11.         UserMapper mapper3 = sqlSession3.getMapper(UserMapper.class);  
12.   
13.         // 第一次查询  
14.         User user1 = mapper1.findUserById(1);  
15.         System.out.println(user1);  
16.         // 在close的时候，才会将数据写入到二级缓存中  
17.         sqlSession1.close();  
18.   
19.         // 执行添加用户操作  
20.          mapper3.insertUser(user1);  
21.         // 执行commit时，将一级缓存清空  
22.          sqlSession3.commit();  
23.   
24.         // 第二次查询  
25.         User user2 = mapper2.findUserById(1);  
26.         System.out.println(user2);  
27.         sqlSession2.close();  
28.   
29.         // 关闭资源  
30.         sqlSession3.close();  
31.     }  

结果：

5、禁用缓存

默认值是true

在映射文件UserMapper.xml中添加useCache

[html]  view plain  copy

1. <!-- 根据用户ID查询用户信息 -->  
2.     <select id="findUserById" parameterType="int" resultType="User" useCache="false">  
3.         SELECT * FROM USER WHERE id =#{id}  
4.     </select>  

6、刷新缓存

[html]  view plain  copy

1. <!-- 根据用户ID查询用户信息 -->  
2.     <!-- flushCache:刷新缓存，在select语句中，默认值是false，在增删改语句中，默认值是true -->  
3.     <select id="findUserById" parameterType="int" resultType="User" flushCache="true">  
4.         SELECT * FROM USER WHERE id =#{id}  
5.     </select>  

7、整合ehcache

Mybatis本身是一个持久层框架，它不是专门的缓存框架，所以它对缓存的实现不够好，不能支持分布式。

Ehcache是一个分布式的缓存框架。

7.1分布式：

系统为了提高性能，通常会对系统采用分布式部署（集群部署方式）

注意:mybatis无法实现分布式缓存,需要和其他分布式缓存框架进行整合

7.2整合思路

Mybatis提供了一个cache的接口,如果要实现自己的缓存逻辑,实现cache接口开发即可。

Cache是一个接口，它的默认实现是mybatis的PerpetualCache。如果想整合mybatis的二级缓存，那么实现Cache接口即可。

7.3添加jar包(依赖jar包)

1.     <dependency>  
2.         <groupId>net.sf.ehcache</groupId>  
3.         <artifactId>ehcache-core</artifactId>  
4.         <version>2.6.6</version>  
5.     </dependency>  
6.         <dependency>  
7.         <groupId>org.mybatis</groupId>  
8.         <artifactId>mybatis-ehcache</artifactId>  
9.         <version>1.0.0</version>  
10.     </dependency>  

7.4设置映射文件

设置映射文件中cache标签的type值为ehcache的实现类：

[html]  view plain  copy

1. <!-- 整合ehcache缓存框架-->  
2. <cache type="org.mybatis.caches.ehcache.EhcacheCache"/>  

7.5添加ehcache的配置文件

在config下，创建ehcache.xml

[html]  view plain  copy

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

7.6测试ehcache的二级缓存

[java]  view plain  copy

1. @Test  
2.     public void testTwoLevelCache() throws Exception {  
3.         // 创建UserMapper对象  
4.         SqlSession sqlSession1 = sqlSessionFactory.openSession();  
5.         SqlSession sqlSession2 = sqlSessionFactory.openSession();  
6.         SqlSession sqlSession3 = sqlSessionFactory.openSession();  
7.   
8.         // 由mybatis通过sqlsession来创建代理对象  
9.         UserMapper mapper1 = sqlSession1.getMapper(UserMapper.class);  
10.         UserMapper mapper2 = sqlSession2.getMapper(UserMapper.class);  
11.         UserMapper mapper3 = sqlSession3.getMapper(UserMapper.class);  
12.   
13.         // 第一次查询  
14.         User user1 = mapper1.findUserById(1);  
15.         System.out.println(user1);  
16.         // 在close的时候，才会将数据写入到二级缓存中  
17.         sqlSession1.close();  
18.   
19.         // 执行添加用户操作  
20. //       mapper3.insertUser(user1);  
21. //      // 执行commit时，将一级缓存清空  
22. //       sqlSession3.commit();  
23.   
24.         // 第二次查询  
25.         User user2 = mapper2.findUserById(1);  
26.         System.out.println(user2);  
27.         sqlSession2.close();  
28.   
29.         // 关闭资源  
30.         sqlSession3.close();  
31.     }  

结果：

8、应用场景

使用场景：对于访问响应速度要求高，但是实时性不高的查询，可以采用二级缓存技术。

注意：在使用二级缓存的时候，要设置一下刷新间隔（cache标签中有一个flashInterval属性）来定时刷新二级缓存，

这个刷新间隔根据具体需求来设置，比如设置30分钟、60分钟等，单位为毫秒。

9、局限性

Mybatis二级缓存对细粒度的数据，缓存实现不好。

场景：对商品信息进行缓存，由于商品信息查询访问量大，但是要求用户每次查询都是最新的商品信息，此时如果使用二级缓存，

就无法实现当一个商品发生变化只刷新该商品的缓存信息而不刷新其他商品缓存信息，因为二级缓存是mapper级别的，

当一个商品的信息发送更新，所有的商品信息缓存数据都会清空。

解决此类问题，需要在业务层根据需要对数据有针对性的缓存。

比如可以对经常变化的数据操作单独放到另一个namespace的mapper中。