MyBatis：一级缓存与二级缓存的介绍

淡淡的烟草味﹌ 2023-09-28 14:41 131阅读 0赞

*  声明：
 *  原作者主页：https://www.jianshu.com/u/5f70a16b98e7
 *  原文链接：https://www.jianshu.com/p/bb4469aab0ad  
    
    
    ### 文章目录 ###
    
     *  二、一级缓存
     *   *  2.1 定义
         *  2.2 一级缓存的工作原理
         *  2.3 使用一级缓存
     *  三、二级缓存
     *   *  3.1 定义
         *  3.2 二级缓存工作原理
         *  3.3 使用二级缓存
     *  四、总结
     *   *  注意点：

一、缓存概述  
======

*  缓存是一般的ORM 框架都会提供的功能，目的就是提升查询的效率和减少数据库的压力,合理使用缓存是优化中最常见的，将从数据库中查询出来的数据放入缓存中，下次使用时不必从数据库查询，而是直接从缓存中读取，避免频繁操作数据库，减轻数据库的压力，同时提高系统性能。
 *  # 二、一级缓存 #
    
    ## 2.1 定义 ##
    
     *  一级缓存是 **SqlSession** 级别的缓存。在操作数据库时需要构造 **SqlSession**对象，在对象中有一个数据结构用于存储缓存数据。不同的 **SqlSession** 之间的缓存数据区域是互相不影响的。也就是他只能作用在同一个 **SqlSession** 中，不同 **SqlSession** 中的缓存是互相不能读取的。
    
    ## 2.2 一级缓存的工作原理 ##
    
    ![8a0c14a5b4cc6a5e521ea7031a2dab28.png][]
    
     *  用户发起查询请求，查找某条数据，SqlSession 先去缓存中查找，是否有该数据，如果有，读取；如果没有，从数据库中查询，并将查询到的数据放入一级缓存区域，供下次查找使用。
    
    ## 2.3 使用一级缓存 ##
    
     *  一级缓存默认有效，不需要任何配置，我们主要验证调用两次查询语句，实际sql执行情况
    
    **xml配置：**
    
        <?xml version="1.0" encoding="UTF-8" ?>
        <!DOCTYPE mapper
                PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
                "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
        <mapper namespace="com.atguigu.mapper.UserMapper">
        
            <select id="selectById" parameterType="int" resultType="User">
                select * from user where id = #{id}
            </select>
        
            <update id="update" parameterType="User" >
                update user set name=#{name} ,age=#{age} where id= #{id}
            </update>
        
        </mapper>
    
    **接口：**
    
        public interface UserMapper {
              
            public User selectById(int id);
        
            public void update(User user);
        }
    
    **测试：**
    
        @Test
            public void testMybatis(){
              
                try {
              
                   //获取SqlSession对象
                    SqlSession sqlSession = sqlSessionFactory.openSession();
                    //通过SqlSession创建UserMapper的对象
                    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
                    User user = userMapper.selectById(11);
                    System.out.println(user);
                    User user2 = userMapper.selectById(11);
                    System.out.println(user2);
        
                    //提交事务
                    sqlSession.commit();
                } catch (Exception e) {
              
                    e.printStackTrace();
                }
            }
    
    **结果：** 查看如下结果，查询两次用户记录，sql只执行一次，另一次直接从session的缓存中获取数据，说明session缓存生效。
    
        [10:55:31.437] [DEBUG] [main] [org.apache.ibatis.datasource.pooled.PooledDataSource] [Created connection 1846406218.]
        [10:55:31.438] [DEBUG] [main] [org.apache.ibatis.transaction.jdbc.JdbcTransaction] [Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@6e0dec4a]]
        [10:55:31.444] [DEBUG] [main] [com.atguigu.mapper.UserMapper.selectById] [==>  Preparing: select * from user where id = ?]
        [10:55:31.480] [DEBUG] [main] [com.atguigu.mapper.UserMapper.selectById] [==> Parameters: 11(Integer)]
        [10:55:31.503] [DEBUG] [main] [com.atguigu.mapper.UserMapper.selectById] [<==      Total: 1]
        User{id=11, name='尚硅谷', age=1}
        User{id=11, name='尚硅谷', age=1}
    
    **注意：**但是有以下几种情况,一级缓存将失效
    
    **情况1：当关闭session时，一级缓存失效**
    
        @Test
            public void testMybatisCloseSession(){
              
                try {
              
                    //获取SqlSession对象
                    SqlSession sqlSession = sqlSessionFactory.openSession();
                    //通过SqlSession创建UserMapper的对象
                    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
                    User user = userMapper.selectById(11);
                    System.out.println(user);
                    //关闭session
                    sqlSession.close();
                    User user2 = userMapper.selectById(11);
                    System.out.println(user2);
                    //提交事务
                    sqlSession.commit();
                } catch (Exception e) {
              
                    e.printStackTrace();
                }
            }
    
    ![7852c6d26826b9e2b5b4572ab9441d48.png][]
    
    **情况2：当执行update语句时，一级缓存失效**
    
        @Test
            public void testMybatisUpdate() {
              
                try {
              
                    //获取SqlSession对象
                    SqlSession sqlSession = sqlSessionFactory.openSession();
                    //通过SqlSession创建UserMapper的对象
                    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
                    User user = userMapper.selectById(11);
                    System.out.println(user);
                    //更新当前记录  前一次查询的缓存失效
                    user.setAge(20);
                    userMapper.update(user);
                    User user2 = userMapper.selectById(11);
                    System.out.println(user2);
                    //提交事务
                    sqlSession.commit();
                } catch (Exception e) {
              
                    e.printStackTrace();
                }
            }
    
    ![29a01f537d7420f9e8e5283fcc844139.png][]
    
    **情况3：当手动清理缓存，一级缓存失效**
    
        @Test
            public void testMybatisClearCache() {
              
                try {
              
                    //获取SqlSession对象
                    SqlSession sqlSession = sqlSessionFactory.openSession();
                    //通过SqlSession创建UserMapper的对象
                    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
                    User user = userMapper.selectById(11);
                    System.out.println(user);
                    //清空缓存，一级缓存失效
                    sqlSession.clearCache();
                    User user2 = userMapper.selectById(11);
                    System.out.println(user2);
        
                    //提交事务
                    sqlSession.commit();
                } catch (Exception e) {
              
                    e.printStackTrace();
                }
            }
    
    ![f5ef7728371e5967e20770c3346c39c8.png][]
    
    # 三、二级缓存 #
    
    ## 3.1 定义 ##
    
     *  二级缓存是Mybatis提供的比一级缓存范围更大的便于开放接口的缓存，当查询的sql存放在一个namespace下时，它们可以使用二级缓存，二级缓存需要手动开启 ，默认二级缓存是关闭的。
    
    ## 3.2 二级缓存工作原理 ##
    
     *  二级缓存是mapper级别的缓存，多个SqlSession去操作同一个Mapper的sql语句，多个SqlSession可以共用二级缓存，二级缓存是跨SqlSession的。
    
    ![8ccfcec2681b21c6500dbe5ed7833548.png][]
    
     *  UserMapper有一个二级缓存区域（按namespace分），其它mapper也有自己的二级缓存区域（按namespace分）。每一个namespace的mapper都有一个二级缓存区域，两个mapper的namespace如果相同，这两个mapper执行sql查询到数据将存在相同的二级缓存区域中。
    
    ## 3.3 使用二级缓存 ##
    
    **在MyBatis的配置文件中加入：**
    
    **在sqlconfig.xml中**
    
            
            <setting name="cacheEnabled" value="true"/>
    
    在需要开启二级缓存的mapper.xml中加入caceh标签
    
        <cache/>
    
    让使用二级缓存的POJO类实现Serializable接口
    
        public class User implements Serializable {
              }
    
    测试
    
        @Test  
        public void testCache2() throws Exception {
               
        
            SqlSession sqlSession1 = sqlSessionFactory.openSession();  
            SqlSession sqlSession2 = sqlSessionFactory.openSession();  
            UserMapper userMapper1 = sqlSession1.getMapper(UserMapper.class);  
            User user1 = userMapper1.findUserById(1);  
            System.out.println(user1);  
            sqlSession1.close();  
            UserMapper userMapper2 = sqlSession2.getMapper(UserMapper.class);  
            User user2 = userMapper2.findUserById(1);  
            System.out.println(user2);  
            sqlSession2.close();  
        }
    
    输出结果
    
        DEBUG [main] - Opening JDBC Connection  
        DEBUG [main] - Created connection 103887628.  
        DEBUG [main] - Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@631330c]  
        DEBUG [main] - ==>  Preparing: SELECT * FROM user WHERE id=?   
        DEBUG [main] - ==> Parameters: 1(Integer)  
        DEBUG [main] - <==      Total: 1  
        User [id=1, username=张三, sex=1, birthday=null, address=null]  
        DEBUG [main] - Resetting autocommit to true on JDBC Connection [com.mysql.jdbc.JDBC4Connection@631330c]  
        DEBUG [main] - Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@631330c]  
        DEBUG [main] - Returned connection 103887628 to pool.  
        DEBUG [main] - Cache Hit Ratio [com.iot.mybatis.mapper.UserMapper]: 0.5  
        User [id=1, username=张三, sex=1, birthday=null, address=null]
    
     *  我们可以从打印的信息看出，两个sqlSession，去查询同一条数据，只发起一次select查询语句，第二次直接从Cache中读取。
     *  Spring和MyBatis整合时， 每次查询之后都要进行关闭sqlSession，关闭之后数据被清空。所以spring整合之后，如果没有事务，一级缓存是没有意义的。那么如果开启二级缓存，关闭sqlsession后，会把该sqlsession一级缓存中的数据添加到namespace的二级缓存中。这样，缓存在sqlsession关闭之后依然存在。
    
    # 四、总结 #
    
     *  对于查询多 commit 少且用户对查询结果实时性要求不高，此时采用mybatis二级缓存技术降低数据库访问量，提高访问速度。
    
    ## 注意点： ##
    
     *  但不能滥用二级缓存，二级缓存也有很多弊端，从MyBatis默认二级缓存是关闭的就可以看出来。
     *  二级缓存是建立在同一个namespace下的，如果对表的操作查询可能有多个namespace，那么得到的数据就是错误的。

[8a0c14a5b4cc6a5e521ea7031a2dab28.png]: https://img-blog.csdnimg.cn/img_convert/8a0c14a5b4cc6a5e521ea7031a2dab28.png
[7852c6d26826b9e2b5b4572ab9441d48.png]: https://img-blog.csdnimg.cn/img_convert/7852c6d26826b9e2b5b4572ab9441d48.png
[29a01f537d7420f9e8e5283fcc844139.png]: https://img-blog.csdnimg.cn/img_convert/29a01f537d7420f9e8e5283fcc844139.png
[f5ef7728371e5967e20770c3346c39c8.png]: https://img-blog.csdnimg.cn/img_convert/f5ef7728371e5967e20770c3346c39c8.png
[8ccfcec2681b21c6500dbe5ed7833548.png]: https://img-blog.csdnimg.cn/img_convert/8ccfcec2681b21c6500dbe5ed7833548.png