Mybatis的一级缓存和二级缓存

缓存

文件的读取速度慢于内存，所以有些查询过一次的数据，会临时存储在内存中。

二次查询会先判断内存里是否存在，存在的话就直接读取内在的数据，不存在才去读数据库

Emp实体类：

[java] view plain copy

1. package cn.et.mybatis.lesson05.buff;  
2.   
3. import java.io.Serializable;  
4.   
5. public class Emp implements Serializable{  
6.   
7.     private String empno;  
8.       
9.     private String ename;  
10.   
11.     private String sal;  
12.   
13.     public String getEmpno() {  
14.         return empno;  
15.     }  
16.   
17.     public void setEmpno(String empno) {  
18.         this.empno = empno;  
19.     }  
20.   
21.     public String getEname() {  
22.         return ename;  
23.     }  
24.   
25.     public void setEname(String ename) {  
26.         this.ename = ename;  
27.     }  
28.   
29.     public String getSal() {  
30.         return sal;  
31.     }  
32.   
33.     public void setSal(String sal) {  
34.         this.sal = sal;  
35.     }  
36.   
37.     @Override  
38.     public String toString() {  
39.         return "Emp [empno=" + empno + ", ename=" + ename + ", sal=" + sal  
40.                 + "]";  
41.     }  
42.   
43.       
44.       
45.       
46.       
47. }  

EmpMapper接口

[java] view plain copy

1. package cn.et.mybatis.lesson05.buff;  
2.   
3.   
4.   
5. public interface EmpMapper {  
6.   
7.     /** 
8.      * 测试一级缓存 
9.      * @param empno 
10.      * @return 
11.      */  
12.     public Emp queryEmp(String empno);  
13.       
14.     /** 
15.      * 测试二级缓存 
16.      * @param empno 
17.      * @return 
18.      */  
19.     public Emp queryEmp2(String empno);  
20.       
21. }  

emp_mapper.xml配置文件

[html] view plain copy

1. <?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. <!--   
7.     接口映射  
8.     namespace必需跟接口的全名一致  
9.  -->  
10. <mapper namespace="cn.et.mybatis.lesson05.buff.EmpMapper">  
11.       
12.       
13.   <select id="queryEmp" resultType="cn.et.mybatis.lesson05.buff.Emp">  
14.     select * from emp where empno=#{0}  
15.   </select>  
16.     
17.   <!--   
18.          加上cache标签就开启mybatis的二级缓存了  
19.       eviction属性  
20.       FIFO 将队列最右端的数据T出内在  为先进先去  
21.       LFU  使用次数最少的T出内存   这个在这里不支持  
22.       LRU  最近使用次数最少的  
23.    -->  
24.   <cache eviction="LRU"></cache>  
25.    <select id="queryEmp2" resultType="cn.et.mybatis.lesson05.buff.Emp">  
26.     select * from emp where empno=#{0}  
27.   </select>  
28.       
29.       
30. </mapper>  

TestMybatis测试类

[java] view plain copy

1. package cn.et.mybatis.lesson05.buff;  
2.   
3. import java.io.InputStream;  
4. import org.apache.ibatis.session.SqlSession;  
5. import org.apache.ibatis.session.SqlSessionFactory;  
6. import org.apache.ibatis.session.SqlSessionFactoryBuilder;  
7. import org.junit.Test;  
8.   
9. public class TestMybatis {  
10.       
11.     public static SqlSessionFactory getSqlSessionFactory(){  
12.         String resource = "/cn/et/mybatis/lesson05/mybatis.xml";  
13.         InputStream inputStream = TestMybatis.class.getResourceAsStream(resource);  
14.         SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);  
15.         return sqlSessionFactory;  
16.     }  
17.       
18.     /** 
19.      * 测试一级缓存 
20.      * 一级缓存是session级别的缓存  数据被缓存在session对象中 
21.      * 必须使用同一个session 
22.      * 发起了二次请求，第一次是去数据库查找，查完之后就会缓存在 
23.      * session对象中，第二查询的时候会先去session对象中查找，看有没有 
24.      * 这个数据，如果有的话就直接返回出去，不会再去数据库中查询。 
25.      * 增加了效率 
26.      * 测试动态Where 
27.      */  
28. //  @Test  
29.     public void testOneBuff(){  
30.         SqlSession session = getSqlSessionFactory().openSession();;  
31.         EmpMapper emp = session.getMapper(EmpMapper.class);  
32.           
33.         Emp result1 = emp.queryEmp("8000");  
34.           
35.         Emp result2 = emp.queryEmp("8000");  
36.           
37.         System.out.println(result1==result2);  
38.     }  
39.   
40.     /** 
41.      * 测试二级缓存 
42.      * 二级缓存就是缓存在SqlSessionFactory对象里 
43.      * 这里我们先生成了一个SqlSession对象，并查询了一条语句 
44.      * 然后陈SqlSession对象关闭了，那么这时缓存在SqlSession对象 
45.      * 里的数据就会丢给SqlSessionFactory对象。 
46.      *  
47.      * 在查询条二件sql语句的时候会先去当前的SqlSession里看有没有需要查询的数据 
48.      * 然后再去SqlSessionFactory对象中找，这时SqlSessionFactory有这条数据， 
49.      * 便直接返回回去了，第二次查询没有再去数据库查询了 
50.      *  
51.      * Emp实体类要实现Serializable接口，不然会报错 
52.      * 二个对象的地址是不相等的，但实际只去数据库查询了一次。 
53.      */  
54.     @Test  
55.     public void testTwoBuff(){  
56.         SqlSessionFactory Factory = getSqlSessionFactory();  
57.           
58.         SqlSession session1 = Factory.openSession();  
59.         EmpMapper emp1 = session1.getMapper(EmpMapper.class);  
60.         Emp result1 = emp1.queryEmp2("8000");  
61.         session1.close();  
62.           
63.         SqlSession session2 = Factory.openSession();  
64.         EmpMapper emp2 = session2.getMapper(EmpMapper.class);  
65.         Emp result2 = emp2.queryEmp2("8000");  
66.           
67.         System.out.println(result1==result2);  
68.     }  
69.       
70.       
71. }