mybatis 一级缓存和二级缓存简介

正如大多数持久层框架一样，MyBatis 同样提供了一级缓存和二级缓存的支持

1.一级缓存: 基于PerpetualCache 的 HashMap本地缓存，其存储作用域为 Session，当 Session flush 或 close 之后，该Session中的所有 Cache 就将清空。

2. 二级缓存与一级缓存其机制相同，默认也是采用 PerpetualCache，HashMap存储，不同在于其存储作用域为 Mapper(Namespace)，并且可自定义存储源，如 Ehcache。作用域为namespance是指对该namespance对应的配置文件中所有的select操作结果都缓存，这样不同线程之间就可以共用二级缓存。

启动二级缓存：在mapper配置文件中：<cache readOnly="true"/>。

二级缓存可以设置返回的缓存对象策略：<cache readOnly="true">。当readOnly="true"时，表示二级缓存返回给所有调用者同一个缓存对象实例，调用者可以update获取的缓存实例，但是这样可能会造成其他调用者出现数据不一致的情况（因为所有调用者调用的是同一个实例）。当readOnly="false"时，返回给调用者的是二级缓存总缓存对象的拷贝，即不同调用者获取的是缓存对象不同的实例，这样调用者对各自的缓存对象的修改不会影响到其他的调用者，即是安全的，所以默认是readOnly="false";

　　3. 对于缓存数据更新机制，当某一个作用域(一级缓存Session/二级缓存Namespaces)的进行了 C/U/D 操作后，默认该作用域下所有 select 中的缓存将被clear。

　一级缓存：是SQlSession级别的缓存。在操作数据库时需要构造SqlSession对象，在对象中有一个数据结构（HashMap）用于存储缓存数据。不同的SqlSession之间的缓存数据区域（HashMap）是互相不影响的。

        二级缓存：是mapper级别的缓存，多个SqlSession去操作同一个mapper的sql语句，多个SqlSession可以共用二级缓存，二级缓存是跨SqlSession的。

先来个小实例：因为MyBatis默认支持一级缓存，不需要任何的配置，所以直接看测试方法

[java] view plain copy

1. <span style="font-family:Comic Sans MS;">package cn.itcast.mybatis.mapper;  
2.   
3. import java.io.InputStream;  
4. import java.util.ArrayList;  
5. import java.util.List;  
6.   
7. import org.apache.ibatis.io.Resources;  
8. import org.apache.ibatis.session.SqlSession;  
9. import org.apache.ibatis.session.SqlSessionFactory;  
10. import org.apache.ibatis.session.SqlSessionFactoryBuilder;  
11. import org.junit.Before;  
12. import org.junit.Test;  
13.   
14. import cn.itcast.mybatis.po.User;  
15. import cn.itcast.mybatis.po.UserCustom;  
16. import cn.itcast.mybatis.po.UserQueryVo;  
17.   
18. public class UserMapperTest {  
19.   
20.     private SqlSessionFactory sqlSessionFactory;  
21.   
22.     // 此方法是在执行testFindUserById之前执行  
23.     @Before  
24.     public void setUp() throws Exception {  
25.         // 创建sqlSessionFactory  
26.   
27.         // mybatis配置文件  
28.         String resource = "SqlMapConfig.xml";  
29.         // 得到配置文件流  
30.         InputStream inputStream = Resources.getResourceAsStream(resource);  
31.   
32.         // 创建会话工厂，传入mybatis的配置文件信息  
33.         sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);  
34.     }  
35.   
36.     @Test  
37.     public void testFindUserById() throws Exception {  
38.   
39.         SqlSession sqlSession = sqlSessionFactory.openSession();  
40.   
41.         // 创建UserMapper对象，mybatis自动生成mapper代理对象  
42.         UserMapper userMapper = sqlSession.getMapper(UserMapper.class);  
43.   
44.         // 调用userMapper的方法  
45.         // 第一次查询（先去缓存中查找，有则直接获取，没有则执行SQL语句查询）  
46.         User user = userMapper.findUserById(1);  
47.   
48.         System.out.println(user);  
49.         // 第二次查询（先去缓存中查找，有则直接获取，没有则执行SQL语句查询）  
50.         User user2 = userMapper.findUserById(1);  
51.   
52.         System.out.println(user1);  
53.   
54.     }  
55. }</span>  

运行结果：

      上述运行结果可以看出，第一次发起查询用户ID为1的用户时，先去找缓存中是否有相应的用户信息，没有，才从数据库查询。得到用户信息后，将信息存储到一级缓存中。第二查询用户ID为1的用户信息时，根本没有执行查询语句，而是直接从缓存中查找，有，就直接获取用户信息。

再来看一个测试实例：

[java] view plain copy

1. <span style="font-family:Comic Sans MS;">package cn.itcast.mybatis.mapper;  
2.   
3. import java.io.InputStream;  
4. import java.util.ArrayList;  
5. import java.util.Date;  
6. import java.util.List;  
7.   
8. import org.apache.ibatis.io.Resources;  
9. import org.apache.ibatis.session.SqlSession;  
10. import org.apache.ibatis.session.SqlSessionFactory;  
11. import org.apache.ibatis.session.SqlSessionFactoryBuilder;  
12. import org.junit.Before;  
13. import org.junit.Test;  
14.   
15. import cn.itcast.mybatis.po.User;  
16. import cn.itcast.mybatis.po.UserCustom;  
17. import cn.itcast.mybatis.po.UserQueryVo;  
18.   
19. public class UserMapperTest {  
20.   
21.     private SqlSessionFactory sqlSessionFactory;  
22.   
23.     // 此方法是在执行testFindUserById之前执行  
24.     @Before  
25.     public void setUp() throws Exception {  
26.         // 创建sqlSessionFactory  
27.   
28.         // mybatis配置文件  
29.         String resource = "SqlMapConfig.xml";  
30.         // 得到配置文件流  
31.         InputStream inputStream = Resources.getResourceAsStream(resource);  
32.   
33.         // 创建会话工厂，传入mybatis的配置文件信息  
34.         sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);  
35.     }  
36.   
37.     @Test  
38.     public void testFindUserById() throws Exception {  
39.   
40.         SqlSession sqlSession = sqlSessionFactory.openSession();  
41.   
42.         // 创建UserMapper对象，mybatis自动生成mapper代理对象  
43.         UserMapper userMapper = sqlSession.getMapper(UserMapper.class);  
44.   
45.         // 调用userMapper的方法  
46.         // ①第一次查询（先去缓存中查找，有则直接获取，没有则执行SQL语句查询）  
47.         User user1 = userMapper.findUserById(1);  
48.   
49.         System.out.println(user1);  
50.   
51.         // ②插入用户对象  
52.         User user = new User();  
53.         user.setUsername("王二小");  
54.         user.setBirthday(new Date());  
55.         user.setSex("1");  
56.         user.setAddress("河北廊坊");  
57.   
58.         sqlSession.insert("test.insertUser", user);  
59.   
60.         // 提交事务  
61.         sqlSession.commit();  
62.           
63.         // ③第二次查询（先去缓存中查找，有则直接获取，没有则执行SQL语句查询）  
64.         User user2 = userMapper.findUserById(1);  
65.   
66.         System.out.println(user2);  
67.   
68.     }  
69. }</span>  

运行结果：

      上述运行结果可以看出，第一次发起查询用户ID为1的用户时，依然先去找缓存中是否有相应的用户信息，没有，才从数据库查询。得到用户信息后，将信息存储到一级缓存中。这期间SqlSession执行了一次commit操作，清空了SqlSession中的一级缓存，这样做的目的是为了让缓存中的数据总是最新的数据，避免脏读。之后，再次进行第二查询用户ID为1的用户信息时，依然是先从缓存中查找，没有，所以执行了sql查询语句，从数据库中获取了最新的数据。另外，当SqlSession关闭时，也会清空一级缓存。

【二级缓存】

      当开启MyBatis的二级缓存之后，SqlSession1去查询用户ID为1的用户信息，查询到用户信息会将数据存储到二级缓存中。SqlSession2去查询用户ID为1的用户信息，先去缓存中找是否有相应数据，有则直接获取。

MyBatis的二级缓存是mapper范围级别的，所以除了在SQLMapConfig.xml设置二级缓存的总开关，还要在具体的mapper.xml中开启二级缓存。如下：

1.在核心配置文件SQLMapConfig.xml中的全局设置中开启二级缓存，将value设为true。如下：

[html] view plain copy

1. <span style="font-family:Comic Sans MS;"><settings>  
2.     <!-- 开启二级缓存 -->  
3.     <setting name="cacheEnabled" value="true"/>  
4. </settings></span>  

2.在对应的Mapper.xml中开启二级缓存，即：

[html] view plain copy

1. <span style="font-family:Comic Sans MS;"><?xml version="1.0" encoding="UTF-8" ?>  
2. <!DOCTYPE mapper  
3. PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"  
4. "http://mybatis.org/dtd/mybatis-3-mapper.dtd">  
5.   
6. <!-- namespace命名空间，作用就是对sql进行分类化管理，理解sql隔离   
7. 注意：使用mapper代理方法开发，namespace有特殊重要的作用，namespace等于mapper接口地址  
8. -->  
9. <mapper namespace="cn.itcast.mybatis.mapper.UserMapper">  
10.   
11.     <!-- 开启本mapper的namespace下的二缓存  
12.     type：指定cache接口的实现类的类型，mybatis默认使用PerpetualCache  
13.     要和ehcache整合，需要配置type为ehcache实现cache接口的类型  
14.      -->  
15.     <cache />  
16. <!-- 下面的一些SQL语句暂时略 -->  
17. </mapper></span>  

3.测试方法：

[java] view plain copy

1. <span style="font-family:Comic Sans MS;">package cn.itcast.mybatis.mapper;  
2.   
3. import java.io.InputStream;  
4. import java.util.ArrayList;  
5. import java.util.Date;  
6. import java.util.List;  
7.   
8. import org.apache.ibatis.io.Resources;  
9. import org.apache.ibatis.session.SqlSession;  
10. import org.apache.ibatis.session.SqlSessionFactory;  
11. import org.apache.ibatis.session.SqlSessionFactoryBuilder;  
12. import org.junit.Before;  
13. import org.junit.Test;  
14.   
15. import cn.itcast.mybatis.po.User;  
16. import cn.itcast.mybatis.po.UserCustom;  
17. import cn.itcast.mybatis.po.UserQueryVo;  
18.   
19. public class UserMapperTest {  
20.   
21.     private SqlSessionFactory sqlSessionFactory;  
22.   
23.     // 此方法是在执行testFindUserById之前执行  
24.     @Before  
25.     public void setUp() throws Exception {  
26.         // 创建sqlSessionFactory  
27.   
28.         // mybatis配置文件  
29.         String resource = "SqlMapConfig.xml";  
30.         // 得到配置文件流  
31.         InputStream inputStream = Resources.getResourceAsStream(resource);  
32.   
33.         // 创建会话工厂，传入mybatis的配置文件信息  
34.         sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);  
35.     }  
36.   
37.     @Test  
38.     public void testFindUserById() throws Exception {  
39.   
40.         SqlSession sqlSession1 = sqlSessionFactory.openSession();  
41.         SqlSession sqlSession2 = sqlSessionFactory.openSession();  
42.         SqlSession sqlSession3 = sqlSessionFactory.openSession();  
43.         // 创建代理对象  
44.         UserMapper userMapper1 = sqlSession1.getMapper(UserMapper.class);  
45.         // 第一次发起请求，查询id为1的用户  
46.         User user1 = userMapper1.findUserById(1);  
47.         System.out.println(user1);  
48.           
49.         //这里执行关闭操作，将sqlsession中的数据写到二级缓存区域  
50.         sqlSession1.close();  
51.   
52.         UserMapper userMapper2 = sqlSession2.getMapper(UserMapper.class);  
53.         // 第二次发起请求，查询id为1的用户  
54.         User user2 = userMapper2.findUserById(1);  
55.         System.out.println(user2);  
56.   
57.         sqlSession2.close();  
58.   
59.   
60.     }  
61. }</span>  

运行结果为：

      很明显，测试方法中在第一次查询结束后关闭了SqlSession。第二次查询的结果是从缓存中直接获取的数据。这就证明了二级缓存比一级缓存的范围大，只要是同一个mapper，都可以从二级缓存中得到数据。

需要注意的一点是，在一级缓存中也提到过，当我们对数据库进行增删改的时候，数据库数据就进行了修改，这时任何缓存中的数据都需要被清楚，以免造成数据库的查询出现脏读。所以我们需要在每一次的insert、update、delete操作后都进行缓存刷新（即清空），也就是在Statement配置中配置flushCache属性，如下：

<insertid="insertUser" parameterType="cn.itcast.mybatis.po.User"flushCache="true">