06 MyBatis缓存

悠悠 2023-09-28 16:09 97阅读 0赞

**目录**

一、MyBatis缓存介绍

介绍：

1.什么是缓存？

2.缓存有什么作用？

3.什么样的数据使用缓存？

4.MyBatis缓存分为哪几类？

5.如何判断两次Sql是否相同？

二、MyBatis一级缓存

1.一级缓存三个知识点：

2.测试一级缓存

1.使用同一个SqlSession对象进行查询

2.使用不同的SqlSession对象进行查询

三、清除一级缓存

介绍：

1.清空MyBatis一级缓存的三种操作：

（1）SqlSession调用close（）：

（2）SqlSession调用clearCache（）/commit（）：

（3）SqlSession调用增删改方法：

2.测试清空一级缓存

四、MyBatis二级缓存

1.二级缓存四个知识点：

2.开启二级缓存

（1）POJO类实现Serializable接口

（2）在MyBatis核心配置文件中（SqlMapConfig.xml）添加如下设置

（3）在映射文件添加 标签，该映射文件下的所有方法都支持二级缓存

3.测试二级缓存

--------------------

> ## 一、MyBatis缓存介绍 ##
> 
> ![3f0db59c133b4ac4b91ca52ffc3f6833.png][]
> 
> #### 介绍： ####
> 
> 缓存是内存当中一块存储数据的区域，为提高**查询**效率。MyBatis会将查询结果存储在缓存当中，当下次执行**相同**的SQL时不访问数据库，而是直接从缓存中获取结果，从而减少服务器的压力。
> 
> #### 1.什么是缓存？  ####
> 
>  缓存是存在于内存中的一块数据。 
> 
> #### 2.缓存有什么作用？  ####
> 
>  缓存可以减少程序和数据库的交互，提高查询效率，降低服务器和数据库的压力。 
> 
> #### 3.什么样的数据使用缓存？  ####
> 
>  经常查询但不常改变的，改变后对结果影响不大的数据。 
> 
> #### 4.MyBatis缓存分为哪几类？  ####
> 
>  一级缓存和二级缓存 
> 
> #### 5.如何判断两次Sql是否相同？  ####
> 
> （1）查询的Sql 语句是否相同 
> 
> （2）  传递的参数值是否相同 
> 
> （3） 对结果集的要求是否相同 
> 
> （4）预编译的模板Id是否 相同

## 二、**MyBatis****一级缓存** ##

![a584f2a98a6a4674aca90a543a271980.png][]

> ### 1.一级缓存三个知识点： ###
> 
> （1）MyBatis 一级缓存也叫**本地缓存**。 SqlSession 对象中包含一个Executor对象， Executor 对象中包含一个 PerpetualCache 对象，在该对象存放一级缓存数据。**（所以一级缓存存在SqlSession中）**
> 
> （2）由于一级缓存是在 SqlSession 对象中，所以**只有使用同一个SqlSession对象操作数据库时才能共享一级缓存。** 
> 
> （3）MyBatis 的**一级缓存是默认开启的**，不需要任何的配置。

### 2.测试一级缓存 ###

#### 1.使用同一个SqlSession对象进行查询 ####

#### （1） 测试方法 ####

/**
         * 使用同一个SqlSession对象操作数据库可以共享一级缓存，否则不共享一级缓存
         * 其本质是缓存SqlSession对象，所以同一个SqlSession对象共享
         */
        @Test
        public void testCache1() throws IOException {
            InputStream is = Resources.getResourceAsStream("SqlMapConfig.xml");
            SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
            SqlSessionFactory factory = builder.build(is);
            SqlSession session = factory.openSession();
    
    //        使用同一个SqlSession对象查询
            UserMapper mapper1 = session.getMapper(UserMapper.class);
            UserMapper mapper2 = session.getMapper(UserMapper.class);
    
            User user1 = mapper1.findById(1);
            System.out.println(user1);
            System.out.println(user1.hashCode());
            System.out.println("---------------------------------------");
            User user2 = mapper2.findById(1);
            System.out.println(user2);
            System.out.println(user2.hashCode());
        }

#### （2）执行结果 ####

![662aedfbc9e94be7b878bae77aec596a.png][]

> #### （3）结论 ####
> 
> 由执行结果我们可以看出，数据库只执行了一次查询操作，并返回结果集；当第二次执行同样的sql语句时，数据库没有执行查询操作，而是直接返回了结果集。**通过两个User对象的HashCode值一样我们可以知道是同一个对象，也就是说使用同一个SqlSession对象操作数据库时可以共享一级缓存。**

#### 2.使用不同的SqlSession对象进行查询 ####

#### （1）测试方法 ####

@Test
        public void testCache2() throws IOException {
            InputStream is = Resources.getResourceAsStream("SqlMapConfig.xml");
            SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
            SqlSessionFactory factory = builder.build(is);
            SqlSession session1 = factory.openSession();
            SqlSession session2 = factory.openSession();
    
    //        使用不同的SqlSession对象查询
            UserMapper mapper1 = session1.getMapper(UserMapper.class);
            UserMapper mapper2 = session2.getMapper(UserMapper.class);
    
            User user1 = mapper1.findById(1);
            System.out.println(user1);
            System.out.println(user1.hashCode());
            System.out.println("---------------------------------------");
            User user2 = mapper2.findById(1);
            System.out.println(user2);
            System.out.println(user2.hashCode());
        }

#### （2）执行结果 ####

![388e168b4a504ab5a57b99d9b8e243ea.png][]

> #### （3）结论 ####
> 
> 由执行结果我们可以看出，两次SQL语句查询操作都是访问数据库；第一次执行sql语句后访问的是数据库，并返回结果集；随后又第二次执行SQL语句，访问的也是数据库，并返回结果集。**通过两个User对象的HashCode值不一样我们可以知道，不是同一个SqlSession对象，也就是说使用不同SqlSession对象操作数据库时不可以共享一级缓存。**

> ## 三、清除一级缓存 ##
> 
> ![2169013cc11c465f93e78767b0f63d43.png][]
> 
> ### 介绍： ###
> 
> 一级缓存就像我们的微信一样，长期不清理内存会将内存撑暴
> 
> ### 1.清空MyBatis一级缓存的三种操作： ###
> 
> #### （1）SqlSession调用close（）： ####
> 
>  操作后SqlSession 对象不可用，该对象的缓存数据也不可用。 
> 
> #### （2）SqlSession调用clearCache（）/commit（）： ####
> 
> 操作会清空一级缓存数据。
> 
> #### （3）SqlSession调用增删改方法： ####
> 
> 操作会清空一级缓存数据，因为增删改后数据库发生改变，缓存数据将不准确。
> 
> ### 2.测试清空一级缓存 ###
> 
> #### （1）测试方法 ####
> 
>     //    测试清空一级缓存
>         @Test
>         public void testCache3() throws IOException {
>             InputStream is = Resources.getResourceAsStream("SqlMapConfig.xml");
>             SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
>             SqlSessionFactory factory = builder.build(is);
>             SqlSession session = factory.openSession();
>     
>     //        使用同一个SqlSession对象查询
>             UserMapper mapper1 = session.getMapper(UserMapper.class);
>             UserMapper mapper2 = session.getMapper(UserMapper.class);
>     
>             User user1 = mapper1.findById(1);
>             System.out.println(user1);
>             System.out.println(user1.hashCode());
>     //        session.close();
>     //        session.clearCache();
>             session.commit();
>     //        mapper1.delete(2);
>             System.out.println("---------------------------------------");
>             User user2 = mapper2.findById(1);
>             System.out.println(user2);
>             System.out.println(user2.hashCode());
>         }
> 
> #### （2）执行结果 ####
> 
> ![b9b021a0ac9c49f3b9dcdbe13cbb4345.png][]
> 
> #### 3.结论： ####
> 
> 由执行结果我们可以看出，两次SQL语句查询操作都是访问数据库；第一次执行sql语句后访问的是数据库，并返回结果集；随后又第二次执行SQL语句，访问的也是数据库，并返回结果集。**通过两个User对象的HashCode值不一样我们可以知道，执行清空一级缓存操作后，再次执行相同sql语句时要重新访问数据库。**

> ## 四、MyBatis二级缓存 ##
> 
> ![ebf378e2967b4ffab1869863cdaf9bbb.png][]
> 
> ### 1.二级缓存四个知识点： ###
> 
> （1）MyBatis 二级缓存也叫**全局缓存**。**数据存放在** **SqlSessionFactory中**，**只要是同一个工厂对象创建的SqlSession** **，在进行查询时都能共享数据。**一般在项目中只有一个SqlSessionFactory 对象， 所以二级缓存的数据是全项目共享的。 
> 
> （2）MyBatis **一级缓存存放的是对象，二级缓存存放的是对象的数据**。所以要求二级缓存存放的POJO 必须是可序列化的，也就是**POJO实体类要实现Serializable** **接口**。 
> 
> （3）MyBatis **二级缓存默认不开启**，**手动开启后数据先存放在一级缓存中，只有一级缓存数据清空后，数据才会存到二级缓存中。**
> 
> **4.SqlSession 调用 clearCache() 无法将数据存到二级缓存中。**
> 
> ### 2.开启二级缓存 ###
> 
> #### （1）POJO类实现Serializable接口 ####
> 
>     public class User implements Serializable {
>         private int id;
>         private String username;
>         private String sex;
>         private String address;
>     //  省略有参/无参构造器、setter、getter方法、toString方法
>     }
> 
> #### （2）在MyBatis核心配置文件中（SqlMapConfig.xml）添加如下设置 ####
> 
>     
>         <settings>
>             <setting name="cacheEnabled" value="true"/>
>         </settings>
> 
> 由于CacheEnabled默认值是true，所以value=“true”可以省略
> 
> #### （3）在映射文件添加 <cache /> 标签，该映射文件下的所有方法都支持二级缓存 ####
> 
>  注意：如果查询到的集合中对象过多，二级缓存只能缓存1024 个对象引用。可以通过 
> 
> <cache />  标签的 size 属性修改该数量。
> 
>     
>         
>         <cache size="2048"/>
> 
> ### 3.测试二级缓存 ###
> 
> #### （1）测试方法 ####
> 
>     //    测试二级缓存
>     //    要先清空一级缓存，才会将数据转为二级缓存；但清空数据不能用clearCache（）
>     @Test
>     public void testCache4() throws IOException {
>         InputStream is = Resources.getResourceAsStream("SqlMapConfig.xml");
>         SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
>         SqlSessionFactory factory = builder.build(is);
>         SqlSession session1 = factory.openSession();
>         SqlSession session2 = factory.openSession();
>     
>     //        使用不同的SqlSession对象查询
>         UserMapper mapper1 = session1.getMapper(UserMapper.class);
>         UserMapper mapper2 = session2.getMapper(UserMapper.class);
>     
>         User user1 = mapper1.findById(1);
>         System.out.println(user1);
>         System.out.println(user1.hashCode());
>         session1.close();
>         System.out.println("---------------------------------------");
>         User user2 = mapper2.findById(1);
>         System.out.println(user2);
>         System.out.println(user2.hashCode()); 
>         }
> 
> #### （2）执行结果 ####
> 
> ![e89ce9b661084e668bf2546624c8ac17.png][]
> 
> #### （3）结论： ####
> 
> 由执行结果我们可以看出，查询操作只访问了一次数据库，并返回结果集；清空一级缓存之后，当第二次执行同样的sql语句时，数据库没有执行查询操作，而是直接返回了结果集，**也就是说数据来源于二级缓存中。****数据存放在****SqlSessionFactory中**，**只要是同一个工厂对象创建的SqlSession****，在进行查询时都能共享数据。****之所以两个User对象的HashCode值不一样，是因为二级缓存存取的是数据不是对象，HashCode值是由数据转化的，所以不一样。**

[3f0db59c133b4ac4b91ca52ffc3f6833.png]: https://img-blog.csdnimg.cn/3f0db59c133b4ac4b91ca52ffc3f6833.png
[a584f2a98a6a4674aca90a543a271980.png]: https://img-blog.csdnimg.cn/a584f2a98a6a4674aca90a543a271980.png
[662aedfbc9e94be7b878bae77aec596a.png]: https://img-blog.csdnimg.cn/662aedfbc9e94be7b878bae77aec596a.png
[388e168b4a504ab5a57b99d9b8e243ea.png]: https://img-blog.csdnimg.cn/388e168b4a504ab5a57b99d9b8e243ea.png
[2169013cc11c465f93e78767b0f63d43.png]: https://img-blog.csdnimg.cn/2169013cc11c465f93e78767b0f63d43.png
[b9b021a0ac9c49f3b9dcdbe13cbb4345.png]: https://img-blog.csdnimg.cn/b9b021a0ac9c49f3b9dcdbe13cbb4345.png
[ebf378e2967b4ffab1869863cdaf9bbb.png]: https://img-blog.csdnimg.cn/ebf378e2967b4ffab1869863cdaf9bbb.png
[e89ce9b661084e668bf2546624c8ac17.png]: https://img-blog.csdnimg.cn/e89ce9b661084e668bf2546624c8ac17.png