MyBatis-缓存机制

MyBatis 包含一个非常强大的查询缓存特性,它可以非常方便地配置和定制。缓存可以极大的提升查询效率。
 MyBatis系统中默认定义了两级缓存。
 一级缓存和二级缓存。
     一级缓存：(本地缓存):SqlSession级别的缓存，一级缓存是一致开启的，没法关闭。方法之间不共用！
      与数据库同一次会话期间查询到的数据放在本地缓存中。
   以后如果需要获取相同的数据，直接从缓存中拿，没必要再去查询数据库；
  二级缓存(全局缓存)：
  
  –1、默认情况下，只有一级缓存（SqlSession级别的缓存，也称为本地缓存）开启。
  –2、二级缓存需要手动开启和配置，他是基于namespace级别的缓存。
  –3、为了提高扩展性。MyBatis定义了缓存接口Cache。我们可以通过实现Cache接口来自定义二级缓存。
   
  案例：
   测试一级缓存【默认是开启的本地缓存的】：

@Test
            public void testGetEmployee(){
                EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
                
                Employee emp = mapper.getEmployeeById(2);
                System.out.println(emp);
                Employee emp2 = mapper.getEmployeeById(2);
                System.out.println(emp2);
                
                System.out.println(emp == emp2);
            }
View Code

一级缓存失效的情况【4种】(没有使用到当前一级缓存的情况，效果就是,还需要再向数据库发出查询)；
    1.sqlSession不同。

@Test
public void testGetEmployee() throws IOException{
    SqlSessionFactory sessionFactory = testBefore();
    SqlSession openSession= sessionFactory.openSession();
    EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
    Employee emp = mapper.getEmployeeById(2);
    System.out.println(emp);
                    
    SqlSession openSession2= sessionFactory.openSession();
    EmployeeMapper mapper2 = openSession2.getMapper(EmployeeMapper.class);
    Employee emp2 = mapper2.getEmployeeById(2);
    System.out.println(emp2);            
    System.out.println(emp == emp2);
                
    openSession.close();
        openSession2.close();
}
View Code

    2.SqlSession相同，但是查询条件不一样[当前缓存中还没有这个数据]

@Test
                public void testGetEmployee() throws IOException{
                    SqlSessionFactory sessionFactory = testBefore();
                    SqlSession openSession= sessionFactory.openSession();
                    EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
                    Employee emp = mapper.getEmployeeById(2);
                    System.out.println(emp);

                    Employee emp2 = mapper.getEmployeeById(3);
                    System.out.println(emp2);    
                    System.out.println(emp == emp2);
                    openSession.close();
                }
View Code

    3.SqlSession相同，但是两次查询之间执行了增删改操作【这次增删改可能对当前数据有影响】。

@Test
                public void testGetEmployee() throws IOException{
                    SqlSessionFactory sessionFactory = testBefore();
                    SqlSession openSession= sessionFactory.openSession();
                    EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
                    Employee emp = mapper.getEmployeeById(2);
                    System.out.println(emp);
                    mapper.updateEmp(new Employee(1, 1, "张三丰","zhangsanfeng@163.com", new Department(1)));
                    Employee emp2 = mapper.getEmployeeById(2);
                    System.out.println(emp2);    
                    System.out.println(emp == emp2);
                    openSession.close();
                }
View Code

   4.SqlSession相同,手动清除了一级缓存[缓存清空]。

@Test
                public void testGetEmployee() throws IOException{
                    SqlSessionFactory sessionFactory = testBefore();
                    SqlSession openSession= sessionFactory.openSession();
                    EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
                    Employee emp = mapper.getEmployeeById(2);
                    System.out.println(emp);
                    //手动清空缓存
                    openSession.clearCache();
                    Employee emp2 = mapper.getEmployeeById(2);
                    System.out.println(emp2);    
                    System.out.println(emp == emp2);
                    openSession.close();
                }
View Code

二级缓存：【全局缓存】：基于namespace级别的缓存:一个namespace对应一个二级缓存。
    【一级缓存的范围还是太小了，每次SqlSession一关闭，一级缓存中的数据就消失】
    所以从这个角度讲:能跨sqlSession的缓存为二级缓存！
    
  工作机制：
      1、一个会话，查询一条数据，这个数据就会被放在当前会话的一级缓存中。
      2.如果会话关闭，一级缓存中的数据会被保存到二级缓存中；新的会话查询信息，就可以参照二级缓存中。
      3.SqlSession  === EmployeeMapper   ===> Employee
         DepartmentMapper ===> Department
        不同namespace查出的数据会放在自己对应的缓存中(map) 
       效果：数据会从二级缓存中获取
             查出的数据都会被默认先放在一级缓存中。
          只有会话提交或者关闭之后，一级缓存中的数据才会转移到二级缓存中。
      需要注意的是：在哪个Mapper.xml文件中开启了<cache>缓存标签，哪个Mapper中就开启了二级缓存。
        
  使用：
   1).开启全局二级缓存配置:<setting name="cacheEnabled" value="true"/>
   2).去mapper.xml中配置使用二级缓存:
    <cache eviction="FIFO" flushInterval="60000" readOnly="false" size="1024" type=""></cache>
     <!--
      ?eviction=“FIFO”：缓存回收策略：
       ?LRU –最近最少使用的：移除最长时间不被使用的对象。
       ?FIFO –先进先出：按对象进入缓存的顺序来移除它们。
       ?SOFT –软引用：移除基于垃圾回收器状态和软引用规则的对象。
       ?WEAK –弱引用：更积极地移除基于垃圾收集器状态和弱引用规则的对象。
       ?默认的是LRU。
      ?flushInterval：缓存刷新间隔
       ?缓存多长时间清空一次，默认不清空，设置一个毫秒值。
      ?size：引用数目，正整数
        ?代表缓存最多可以存储多少个对象，太大容易导致内存溢出
      ?readOnly：是否只读，true/false 
       ?true：只读缓存；mybatis认为所有从缓存中获取数据的操作都是只读操作，不会修改数据。
           mybatis为了加快获取速度，直接就会将数据在缓存中的引用交给用户。不安全，速度快。
       ?false：非只读:mybatis觉得获取的数据可能会被修改。
            mybatis会利用序列化&反序列化的技术克隆一份。安全，速度慢。
        ?type:指定自定义缓存的全类名
            实现cache接口即可！
      -->
   3）.我们的POJO需要实现序列化接口[implements Serializable]
   
   测试二级缓存【测试代码】：

@Test
                    public void testGetEmployee() throws IOException{
                        SqlSessionFactory sessionFactory = testBefore();
                        //开启两个会话
                        SqlSession openSession= sessionFactory.openSession();
                        SqlSession openSession2 = sessionFactory.openSession();
                        //利用两个openSession对象获取两个mapper对象
                        EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
                        EmployeeMapper mapper2 = openSession2.getMapper(EmployeeMapper.class);
                        //用第一个openSession获取的mapper对象查询2号员工信息
                        Employee emp = mapper.getEmployeeById(2);
                        System.out.println(emp);
                        //关闭第一个openSession对象
                        openSession.close();
                        //用第二个openSession获取的mapper对象查询2号员工信息
                        Employee emp2 = mapper2.getEmployeeById(2);
                        System.out.println(emp2);    
                        openSession2.close();
                        
                    }
View Code

 //可以看到只发送了一次SQL语句，第二次查询时从二级缓存中拿到的数据，并没有发送新的sql语句。
     //需要注意的是：只有一级缓存中关闭的情况下，二级缓存才会被使用

    
   需要注意的是：在哪个Mapper.xml文件中开启了<cache>缓存标签，哪个Mapper中就开启了二级缓存。可用DepartmentMapper.xml验证
   
   
   和缓存有关的设置/属性：
           1）cacheEnabled="true": false:关闭缓存（二级缓存关闭）【一级缓存一直可用】
           2）每个select标签都有useCache="true"；
                  false:不使用缓存(一级缓存依然使用，二级缓存不使用)
           3）每个增删改标签都有一个flushCache="true"：增删改执行完成后就会清楚缓存【一级二级缓存都会被清空】
         查询标签：flushCache = "false"
                如果flushCache = true；每次查询之前都会清空缓存，缓存是没有被使用!

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/Ysuwade/p/7488010.html