11【MyBatis的缓存机制】

最新推荐文章于 2024-07-23 15:38:42 发布
最新推荐文章于 2024-07-23 15:38:42 发布
阅读量273 收藏 2
点赞数 2
分类专栏： # 《SSM框架系列》 文章标签： mybatis 缓存 java
緑水長流原创出品，未经许可禁止转载！
本文链接：https://blog.csdn.net/Bb15070047748/article/details/128102081
版权

文章目录

二、Mybatis缓存机制

2.1 缓存介绍

像大多数的持久化框架一样， Mybatis 也提供了缓存策略，通过缓存策略来减少数据库的查询次数，从而提高性能。Mybatis 中缓存分为一级缓存，二级缓存。

1、默认情况下，只有一级缓存（session级别的缓存，也称为本地缓存）开启。

2、二级缓存需要手动开启和配置（默认支持状态），他是基于Mapper级别的缓存。

3、为了提高扩展性。MyBatis定义了缓存接口Cache。我们可以通过实现Cache接口来自定义二级缓存

在这里插入图片描述

从图中我们可以看出：一级缓存是基于SqlSessoion的缓存，一级缓存的内容不能跨sqlsession。由MyBatis自动维护。二级缓存是基于映射文件的缓存，缓存范围比一级缓存更大。不同的sqlsession可以访问二级缓存的内容。哪些数据放入二级缓存需要自己指定。

2.2 一级缓存

一级缓存，也叫本地缓存，作用域默认为当前的SqlSession，也就是说不同的SqlSession的缓存是不同的。当 Session flush 或 close 后, 该Session中的一级缓存将被清空。一级缓存是MyBatis维护的，并且默认开启，且不能被关闭，但可以调用clearCache()来清空缓存，或者改变缓存的作用域；

2.2.1 一级缓存相关参数

  • localCacheScope：
    • SESSION：会话级别缓存，默认值
    • STATEMENT：语句级别缓存，缓存只对当前执行的语句生效（相当于关闭一级缓存）
<!--一级缓存的作用域-->
<setting name="localCacheScope" value="SESSION"/>

在这里插入图片描述

2.2.2 一级缓存测试

  • 实体类：
package com.dfbz.entity;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Emp implements Serializable {
    private Integer id;
    private String name;
    private Integer age;
    private String addr;
    private Double salary;
    private Integer deptId;
}
  • 在EmpDao中准备方法：
package com.dfbz.dao;

import com.dfbz.entity.Emp;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public interface EmpDao {

    Emp findById(Integer id);

    void save(Emp emp);
}
  • EmpDao.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">

<!--namespace 名称空间，指定对哪个接口进行映射-->
<mapper namespace="com.dfbz.dao.EmpDao">

    <select id="findById" resultType="emp">
        select * from emp where id=#{id}
    </select>
    
    <insert id="save">
        insert into emp(id,name) values(null,#{name});
    </insert>
</mapper>
  • 测试类：
/**
 * 测试一级缓存
 */
@Test
public void test1() {

    // 获取session(开启一级缓存)
    SqlSession session = factory.openSession();

    EmpDao mapper = session.getMapper(EmpDao.class);

    // 发送SQL查询数据,将数据存入一级缓存
    Emp emp = mapper.findById(1);
    System.out.println(emp);

    // 从一级缓存中获取数据(没有发送SQL)
    Emp emp2 = mapper.findById(1);
    System.out.println(emp2);
    System.out.println(emp == emp2);            // true

    // session关闭,一级缓存清空
    session.close();
}

观察日志：

在这里插入图片描述

2.2.3 一级缓存清空

一级缓存在如下情况下，会情况：

  • 1）将一级缓存的作用域设置为语句级别（localCacheScope设置为STATEMENT）
  • 2）清空缓存（clearCache）
  • 3）执行任何增删改操作都会导致整个一级缓存
  • 4）刷新缓存（flushCache）
  • 5）session关闭，一级缓存清空
2.2.3.1 设置localCacheScope
<!--日志配置-->
<settings>
    <setting name="logImpl" value="STDOUT_LOGGING"/>

    <!--
    更改一级缓存的作用域
        SESSION: 会话级别缓存,默认值
        STATEMENT: 语句级别缓存,缓存只对当前执行的语句生效(类似于关闭一级缓存)
	-->
    <setting name="localCacheScope" value="STATEMENT"/>
</settings>
  • 再次执行上述的测试代码：
/**
 * 测试一级缓存
 */
@Test
public void test1() {

    // 获取session(开启一级缓存)
    SqlSession session = factory.openSession();

    EmpDao mapper = session.getMapper(EmpDao.class);

    // 发送SQL查询数据
    Emp emp = mapper.findById(1);
    System.out.println(emp);

    // 发送SQL查询数据
    Emp emp2 = mapper.findById(1);
    System.out.println(emp2);
    System.out.println(emp == emp2);            // false

    // session关闭
    session.close();
}

执行程序，观察控制台：

在这里插入图片描述

2.2.3.2 clearCache

一级缓存清空测试：

@Test
public void test2() throws Exception {          // 测试clearCache

    // 开启一级缓存
    SqlSession session = factory.openSession();

    EmpDao mapper = session.getMapper(EmpDao.class);

    // 首先从一级缓存里面查询,没查询到,然后去数据库查询,将查询的结果放入一级缓存
    Emp emp = mapper.findById(1);
    System.out.println(emp);

    session.clearCache();           // 清空一级缓存

    // 首先从一级缓存里面查询(没有),去数据库查询,将查询的结果放入一级缓存
    Emp emp2 = mapper.findById(1);
    System.out.println(emp2);

    System.out.println(emp == emp2);        // false

    // 关闭session(一级缓存清空)
    session.close();
}

执行结果，查看控制台：

在这里插入图片描述

2.2.3.3 关闭session清空缓存

一级缓存是基于session级别的，如果session关闭，那么一级缓存将会失效！

  • 测试代码：
@Test
public void test3() throws Exception {          // 测试session关闭清空一级缓存

    // 开启一级缓存
    SqlSession session = factory.openSession();

    EmpDao mapper = session.getMapper(EmpDao.class);

    // 将查询的结果放入一级缓存
    Emp emp = mapper.findById(1);
    System.out.println(emp);

    // session关闭一级缓存清空(session关闭了代表与数据库的会话一级结束了,不可以再发送任何的SQL语句了)
    session.close();

    // 重新获取一次会话
    SqlSession session2 = factory.openSession();
    EmpDao mapper2 = session2.getMapper(EmpDao.class);

    // 新的session的一级缓存中并没有数据,发送SQL去数据库查询
    Emp emp2 = mapper2.findById(1);
    System.out.println(emp2);
    System.out.println(emp == emp2);

    // session关闭,一级缓存清空
    session2.close();
}

执行程序，查看控制台：

在这里插入图片描述

2.2.3.4 执行任何的增删改清空缓存

在MyBatis中，执行任何的增删改都会导致一级缓存清空！

  • 测试代码：
@Test
public void test4() throws Exception {          // 测试增删改清空缓存

    // 开启一级缓存
    SqlSession session = factory.openSession();

    EmpDao mapper = session.getMapper(EmpDao.class);

    // 将查询结果放入一级缓存
    Emp emp = mapper.findById(1);
    System.out.println(emp);

    Emp saveEmp = new Emp();
    saveEmp.setName("test");

    mapper.save(saveEmp);           // 任何的增删改都会导致缓存失效

    // 首先从一级缓存里面查询(没有),去数据库查询,将查询的结果放入一级缓存
    Emp emp2 = mapper.findById(1);
    System.out.println(emp2);

    System.out.println(emp == emp2);        // false

    // 关闭session(一级缓存清空)
    session.close();
}

在这里插入图片描述

2.2.3.5 flushCache清空缓存

flushCache属性用于控制执行完操作后是否要刷新缓存，对于增删改语句，flushCache的值默认是true，对于查询语句，flushCache的值默认是false，但是MyBatis不支持将任何的增删改语句设置为false；

  • EmpDao.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.dfbz.dao.EmpDao">

    <!--
        flushCache="true":每次执行完这个查询语句都清空一级缓存
    -->
    <select id="findById" resultType="emp" flushCache="true">
        select * from emp where id=#{id}
    </select>

    <!--
        flushCache: 执行完本次SQL语句是否要刷新缓存
            insert/update/delete:默认为true,对于增删改的操作,MyBatis不支持将其设置为false
            select:默认为false
    -->
    <insert id="save" flushCache="false">
        insert into emp values(null,#{name},#{age},#{addr},#{salary},null)
    </insert>
</mapper>

Tips：在MyBatis中，不支持将任何的增删改语句的flushCache属性设置为false

  • 测试代码：
@Test
public void test5() throws Exception {          // 测试flushCache清空缓存(对于增删改操作无法设置为false)

    // 开启一级缓存
    SqlSession session = factory.openSession();

    EmpDao mapper = session.getMapper(EmpDao.class);

    Emp emp = mapper.findById(1);
    System.out.println(emp);

    Emp emp2 = mapper.findById(1);
    System.out.println(emp2);

    System.out.println(emp == emp2);

    // 关闭session(一级缓存清空)
    session.close();
}

执行程序，观察控制台：

在这里插入图片描述

需要注意的是MyBatis并不支持将任何的增删改语句的flushCache设置为false

  • 测试代码（此时save语句的flushCache为false）：
/**
 * 测试增删改的flushCache属性
 */
@Test
public void test6() {

    // 开启一级缓存
    SqlSession session = factory.openSession();

    EmpDao empDao = session.getMapper(EmpDao.class);

    // 将查询到的结果存入一级缓存缓存(发送一次SQL)
    Emp emp = empDao.findById(1);       // flushCache="true",因此会清空一级缓存
    System.out.println(emp);

    // 进行增删改操作(一级缓存清空,即使设置了flushCache=false也不管用)
    empDao.save(new Emp(null, "test", 20, null, null, null));

    // 重新发送SQL语句
    Emp emp2 = empDao.findById(1);
    System.out.println(emp2);

    // session关闭,一级缓存清空
    session.close();
}

在这里插入图片描述

2.2.4 一级缓存的引用

MyBatis将数据存入一级缓存时，是将对象的引用（内存地址）存入一级缓存；在获取一级缓存中的数据时，MyBatis将返回当初存入一级缓存的那个内存地址值，也就是说，一级缓存中的数据是同一个；这样一来就会出现内存地址值引用问题；

  • 测试代码：
// 缓存的引用
@Test
public void test7() throws Exception {

    // 开启一级缓存
    SqlSession session = factory.openSession();

    EmpDao mapper = session.getMapper(EmpDao.class);

    // 去数据库查询,将查询结果存入一级缓存
    Emp emp = mapper.findById(1);
    System.out.println(emp);                // name=张三

    // 修改emp对象的name为abc(一级缓存中的emp也会修改)
    emp.setName("abc");

    // 从一级缓存中查询emp对象
    Emp emp2 = mapper.findById(1);
    System.out.println(emp2);               // name=abc

    System.out.println(emp == emp2);

    // 关闭session(一级缓存清空)
    session.close();
}

2.2.5 PerpetualCache缓存类

MyBatis 跟缓存相关的类都在cache 包里面，其中有一个Cache 接口，只有一个默认的实现类 PerpetualCache，改类是MyBatis的缓存实现类；包括一级缓存和二级缓存都是采用PerpetualCache类来实现的；

在这里插入图片描述

  • 测试代码：
@Test
public void test1() throws Exception {
    // 开启一级缓存
    SqlSession session = factory.openSession();

    EmpDao mapper = session.getMapper(EmpDao.class);

    /*
        首先从一级缓存里面查询
            查询到了: 返回
            没查询到: 去数据库查询,之后将查询的结果放入一级缓存
     */
    Emp emp = mapper.findById(1);
    System.out.println(emp);

    /*
        从一级缓存里面查询,直接返回
     */
    Emp emp2 = mapper.findById(1);
    System.out.println(emp2);

    System.out.println(emp == emp2);        // true

    // 关闭session(一级缓存清空)
    session.close();
}

一级缓存执行流程：

在这里插入图片描述

2.3 二级缓存

我们刚刚学习完了一级缓存，一级缓存是session级别的缓存，不同的session一级缓存是不能共享的；

二级缓存是mapper级别的缓存，多个session去操作同一个Mapper映射的SQL语句时，多个session可以共用二级缓存，二级缓存是跨SqlSession 的。

当二级缓存和一级缓存同时存在时，先查询二级缓存，再查询一级缓存；

在这里插入图片描述

2.3.1 二级缓存相关配置

  • 全局配置：

MyBatis默认是开启二级缓存的，我可以通过cacheEnabled参数来控制二级缓存的开关；此配置默认开启

  • 修改SqlMapConfig配置文件：
<settings>
    <!--日志配置-->
    <setting name="logImpl" value="STDOUT_LOGGING"/>

    <!--开启二级缓存,默认是开启状态,false为关闭二级缓存-->
    <setting name="cacheEnabled" value="true"/>
</settings>
  • Mapper配置以及SQL语句配置：

在MyBatis核心配置文件中开启二级缓存后（此配置默认开启状态），还需要在对应的mapper.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.dfbz.dao.EmpDao">
    <!--
    <cache />: 开启当前Mapper的二级缓存
        eviction: 缓存的回收策略
            • LRU  – 最近最少使用的：移除最长时间不被使用的对象。
		    • FIFO – 先进先出：按对象进入缓存的顺序来移除它们。
		    • SOFT – 软引用：移除基于垃圾回收器状态和软引用规则的对象。
		    • WEAK – 弱引用：更积极地移除基于垃圾收集器状态和弱引用规则的对象。
        flushInterval:缓存刷新间隔,缓存多长时间清空一次，默认不清空，可以通过此参数设置一个毫秒值
        readOnly:是否只读
		    true：只读；mybatis认为所有从缓存中获取数据的操作都是只读操作，不会修改数据。
				 mybatis为了加快获取速度，直接就会将数据在缓存中的引用交给用户。不安全，速度快
		    false：非只读：mybatis觉得获取的数据可能会被修改。
				mybatis会利用序列化&反序列的技术克隆一份新的数据给你。安全，速度慢
		size：二级缓存中最大能够缓存存放多少元素
		type:指定自定义缓存的全类名(实现Cache接口)
    -->
    <cache />
    
      <!--
        useCache: 当一级缓存关闭时,是否将本次SQL语句的结果集存入二级缓存
            true: 存入(默认值)
            false: 不存入
    -->
    <select id="findById" resultType="emp">
        select * from emp where id=#{id}
    </select>

    <insert id="save" >
        insert into emp(id,name) values(null,#{name});
    </insert>
</mapper>

存入二级缓存中的对象必须实现序列化接口：

在这里插入图片描述

2.3.2 二级缓存测试

2.3.2.1 二级缓存代码测试

当二级缓存和一级缓存同时存在时，先查询二级缓存，再查询一级缓存；

当session关闭时，将一级缓存中的数据写入二级缓存；

@Test
public void test1() throws Exception {          // 测试二级缓存

    // 开启一级缓存
    SqlSession session = factory.openSession();

    EmpDao mapper = session.getMapper(EmpDao.class);

/*
    先从二级缓存里面查询-->再查询一级缓存-->再查询数据库(查询到了把结果放入一级缓存)
 */
    Emp emp = mapper.findById(1);
    System.out.println(emp);

    // 关闭一级缓存,把数据写入二级缓存(这个时候才会把数据写入二级缓存(序列化))
    session.close();
//        session.clearCache();               // session关闭才会将一级缓存的内容写入二级缓存,clearCache并不会

    // 开启一级缓存
    SqlSession session2 = factory.openSession();

    EmpDao mapper2 = session2.getMapper(EmpDao.class);

    // 先查询二级缓存(有),反序列化
    Emp emp2 = mapper2.findById(1);
    System.out.println(emp2);
    System.out.println(emp == emp2);            // false ,两个对象的属性值一样,但是内存地址值不一样(反序列化出来的)

    session2.close();
}

观察日志：

在这里插入图片描述

2.3.2.2 useCache参数

useCache可以控制当前SQL语句的结果集是否要存入二级缓存；默认情况下为true

<!--
    useCache: 当前SQL语句的结果集是否存入二级缓存(需要当前的Mapper.xml开启二级缓存useCache才会生效)
        true: 存
        false: 不存
-->
<select id="findById" resultType="emp" useCache="true">
    select * from emp where id=#{id}
</select>

Tips：

  • 1）useCache只能控制二级缓存，并不会影响一级缓存；
  • 2）useCache需要当前的mapper.xml开启二级缓存功能后才能使用；

2.3.3 二级缓存失效情况

二级缓存在如下情况下，会情况：

  • 1）执行任何增删改操作
  • 2）刷新缓存（flushCache）
2.3.3.1 执行增删改

执行任何的增删改操作，不仅会导致一级缓存清空，也会导致二级缓存清空！

  • 测试代码：
/**
 * 测试任何增删改清空二级缓存
 */
@Test
public void test2() throws Exception {

    // 开启一级缓存
    SqlSession session = factory.openSession(true);

    EmpDao mapper = session.getMapper(EmpDao.class);

    // 先从二级缓存里面查询,再从一级缓存里面查询,再从数据库查询(发送SQL),将查询到的结果集存入一级缓存
    Emp emp = mapper.findById(1);
    System.out.println(emp);

    // 关闭一级缓存,把数据写入二级缓存(这个时候才会把数据写入二级缓存(序列化))
    session.close();

    // 开启一级缓存
    SqlSession session2 = factory.openSession(true);

    EmpDao mapper2 = session2.getMapper(EmpDao.class);

    Emp saveEmp = new Emp();
    saveEmp.setName("aaa");

    mapper2.save(saveEmp);                  // 执行任何的增删改清空所有缓存(一级缓存和二级缓存)

    // 查询二级缓存(没有),一级缓存(没有),发送SQL
    Emp emp2 = mapper2.findById(1);
    System.out.println(emp2);

    session2.close();
}

执行程序，日志如下：

Created connection 368342628.
Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@15f47664]
==>  Preparing: select * from dept where id=?			# 第一次发送SQL
==> Parameters: 1(Integer)
<==    Columns: id, name, location
<==        Row: 1, 研发部, 中国台湾
<==      Total: 1
研发部
Resetting autocommit to true on JDBC Connection [com.mysql.jdbc.JDBC4Connection@15f47664]
Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@15f47664]		# 关闭session,将数据写入二级缓存
Returned connection 368342628 to pool.
Opening JDBC Connection
Checked out connection 368342628 from pool.
Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@15f47664]
==>  Preparing: insert into dept values(null,?,?)			# 执行任何增删改清空一级/二级缓存
==> Parameters: test(String), test(String)
<==    Updates: 1
Cache Hit Ratio [com.dfbz.dao.DeptDao]: 0.5
==>  Preparing: select * from dept where id=?				# 再次发送SQL查询
==> Parameters: 1(Integer)
<==    Columns: id, name, location
<==        Row: 1, 研发部, 中国台湾
<==      Total: 1
false		# 返回false
Rolling back JDBC Connection [com.mysql.jdbc.JDBC4Connection@15f47664]
Resetting autocommit to true on JDBC Connection [com.mysql.jdbc.JDBC4Connection@15f47664]
Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@15f47664]
Returned connection 368342628 to pool.
Disconnected from the target VM, address: '127.0.0.1:58814', transport: 'socket'

Process finished with exit code 0
2.3.3.2 flushCache

flushCache不仅会清空一级缓存，而且还会清空二级缓存

在这里插入图片描述

Tips：flushCache控制二级缓存时可以设置任何的增删改查是否清空二级缓存

  • 测试代码：
/*
    测试flushCache
 */
@Test
public void test4() throws Exception {

    // 开启一级缓存
    SqlSession session = factory.openSession();

    EmpDao mapper = session.getMapper(EmpDao.class);

    // 先从二级缓存里面查询,再从一级缓存里面查询,再从数据库查询(发送SQL),之后flushCache,一级缓存数据清空
    Emp emp = mapper.findById(1);
    System.out.println(emp);

    // 一级缓存关闭,将一级缓存的数据写入二级缓存(此时一级缓存并没有数据)
    session.close();

    // 获取session,开启新的一级缓存
    SqlSession session2 = factory.openSession();

    EmpDao mapper2 = session2.getMapper(EmpDao.class);

    // 此时二级缓存,一级缓存均没有数据,最终去数据库查询
    Emp emp2 = mapper2.findById(1);
    System.out.println(emp2);

    session2.close();
}

执行程序，日志如下：

Created connection 527829831.
Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@1f760b47]
==>  Preparing: select * from emp where id=?			# 发送SQL语句查询,并没有将结果存入一级缓存(flushCache)
==> Parameters: 1(Integer)
<==    Columns: id, name, age, addr, salary, dept_id
<==        Row: 1, 张三, 20, 广西来宾, 7600.00, 1
<==      Total: 1
Emp(id=1, name=张三, age=20, addr=广西来宾, salary=7600.0, deptId=null)
Resetting autocommit to true on JDBC Connection [com.mysql.jdbc.JDBC4Connection@1f760b47]

# sesison关闭,将一级缓存的数据写入二级缓存(此时一级缓存中并没有数据)
Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@1f760b47]	
Returned connection 527829831 to pool.
Cache Hit Ratio [com.dfbz.dao.EmpDao]: 0.5
Opening JDBC Connection									# 重新开启一个session
Checked out connection 527829831 from pool.
Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@1f760b47]
# 先查询二级缓存(没查询到),再查询一级缓存(没查询到),最终去查询数据库
==>  Preparing: select * from emp where id=?			
==> Parameters: 1(Integer)
<==    Columns: id, name, age, addr, salary, dept_id
<==        Row: 1, 张三, 20, 广西来宾, 7600.00, 1
<==      Total: 1
Emp(id=1, name=张三, age=20, addr=广西来宾, salary=7600.0, deptId=null)
Resetting autocommit to true on JDBC Connection [com.mysql.jdbc.JDBC4Connection@1f760b47]
Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@1f760b47]
Returned connection 527829831 to pool.
Disconnected from the target VM, address: '127.0.0.1:52082', transport: 'socket'

Process finished with exit code 0

flushCache不仅会清空一级缓存，而且也会清空二级缓存

  • 扩展一个方法：
Emp findByName(String name);
  • EmpDao.xml：
<select id="findByName" resultType="emp" >
    select * from emp where name=#{name}
</select>

在这里插入图片描述

  • 测试代码：
@Test
public void test5() throws Exception {

    // 开启一级缓存
    SqlSession session = factory.openSession();

    EmpDao mapper = session.getMapper(EmpDao.class);

    // 先从二级缓存里面查询,再从一级缓存里面查询,再从数据库查询(发送SQL),将查询到的结果集存入一级缓存
    Emp emp = mapper.findByName("小明");
    System.out.println(emp);

    // 一级缓存关闭,将一级缓存的数据写入二级缓存
    session.close();

    // 获取session,开启新的一级缓存
    SqlSession session2 = factory.openSession();

    EmpDao mapper2 = session2.getMapper(EmpDao.class);

    // flushCache清空一级缓存(会清空二级缓存)
    Emp emp2 = mapper2.findById(1);
    System.out.println(emp2);

    // 去二级缓存查询,查询不到,从一级缓存查询,查询不到,发送SQL语句
    Emp emp3 = mapper2.findByName("小明");
    System.out.println(emp3);

    session2.close();
}

执行程序，日志如下：

Created connection 527829831.
Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@1f760b47]

# 将数据写入一级缓存
==>  Preparing: select * from emp where name=?
==> Parameters: 小明(String)
<==    Columns: id, name, age, addr, salary, dept_id
<==        Row: 3, 小明, 25, 广东云浮, 6600.00, 2
<==      Total: 1
Emp(id=3, name=小明, age=25, addr=广东云浮, salary=6600.0, deptId=null)
Resetting autocommit to true on JDBC Connection [com.mysql.jdbc.JDBC4Connection@1f760b47]

# 连接关闭,将数据写入二级缓存
Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@1f760b47]
Returned connection 527829831 to pool.
Cache Hit Ratio [com.dfbz.dao.EmpDao]: 0.0
Opening JDBC Connection
Checked out connection 527829831 from pool.
Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@1f760b47]

# 执行findById(flushCache清空一级缓存和二级缓存)
==>  Preparing: select * from emp where id=?
==> Parameters: 1(Integer)
<==    Columns: id, name, age, addr, salary, dept_id
<==        Row: 1, 张三, 20, 广西来宾, 7600.00, 1
<==      Total: 1
Emp(id=1, name=张三, age=20, addr=广西来宾, salary=7600.0, deptId=null)
Cache Hit Ratio [com.dfbz.dao.EmpDao]: 0.3333333333333333

# 再次发送SQL去数据库查询
==>  Preparing: select * from emp where name=?
==> Parameters: 小明(String)
<==    Columns: id, name, age, addr, salary, dept_id
<==        Row: 3, 小明, 25, 广东云浮, 6600.00, 2
<==      Total: 1
Emp(id=3, name=小明, age=25, addr=广东云浮, salary=6600.0, deptId=null)
Resetting autocommit to true on JDBC Connection [com.mysql.jdbc.JDBC4Connection@1f760b47]
Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@1f760b47]
Returned connection 527829831 to pool.
Disconnected from the target VM, address: '127.0.0.1:52207', transport: 'socket'

Process finished with exit code 0

前面我们学习一级缓存的时候，flushCache对于增删改语句是无法设置为false（设置了不生效），即执行任何增删改的时候一定会清空一级缓存，但flushCache却可以控制二级缓存的增删改；

将insert语句的flushCache设置为false（不清空缓存）：

在这里插入图片描述

  • 测试代码：
@Test
public void test6() throws Exception {

    // 开启一级缓存
    SqlSession session = factory.openSession();

    EmpDao mapper = session.getMapper(EmpDao.class);

    // 先从二级缓存里面查询,再从一级缓存里面查询,再从数据库查询(发送SQL),将查询到的结果集存入一级缓存
    Emp emp = mapper.findByName("小明");
    System.out.println(emp);

    // 一级缓存关闭,将一级缓存的数据写入二级缓存
    session.close();

    // 获取session,开启新的一级缓存
    SqlSession session2 = factory.openSession();

    EmpDao mapper2 = session2.getMapper(EmpDao.class);

    // 执行新增(flushCache为false,并不会清空二级缓存)
    mapper2.save(new Emp(null,"xxx",null,null,null,null));

    // 先查询二级缓存(查询到了)
    Emp emp2 = mapper2.findByName("小明");
    System.out.println(emp2);

    session2.close();
}

日志如下：

Created connection 527829831.
Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@1f760b47]
==>  Preparing: select * from emp where name=?
==> Parameters: 小明(String)
<==    Columns: id, name, age, addr, salary, dept_id
<==        Row: 3, 小明, 25, 广东云浮, 6600.00, 2
<==      Total: 1
Emp(id=3, name=小明, age=25, addr=广东云浮, salary=6600.0, deptId=null)
Resetting autocommit to true on JDBC Connection [com.mysql.jdbc.JDBC4Connection@1f760b47]
Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@1f760b47]
Returned connection 527829831 to pool.
Opening JDBC Connection
Checked out connection 527829831 from pool.
Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@1f760b47]
==>  Preparing: insert into emp(id,name) values(null,?);
==> Parameters: xxx(String)
<==    Updates: 1
Cache Hit Ratio [com.dfbz.dao.EmpDao]: 0.5
Emp(id=3, name=小明, age=25, addr=广东云浮, salary=6600.0, deptId=null)
Rolling back JDBC Connection [com.mysql.jdbc.JDBC4Connection@1f760b47]
Resetting autocommit to true on JDBC Connection [com.mysql.jdbc.JDBC4Connection@1f760b47]
Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@1f760b47]
Returned connection 527829831 to pool.
Disconnected from the target VM, address: '127.0.0.1:52373', transport: 'socket'

Process finished with exit code 0

2.3.4 PerpetualCache的二级缓存

PerpetualCache不仅是MyBaits的一级缓存类，同时MyBatis也将二级缓存的数据存储在PerpetualCache中；在MyBatis加载时（创建session工厂时）就已经创建好了二级缓存，只不过需要等到session关闭时，本次session的一级缓存的数据才会写入二级缓存；

  • 测试代码：
package com.dfbz.mybatis;

import com.dfbz.dao.EmpDao;
import com.dfbz.entity.Emp;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo02_一级缓存和二级缓存 {

    public static void main(String[] args) throws Exception {

        // 创建Session工厂构建对象
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();

        // 通过构建对象来构建一个session工厂(创建二级缓存)
        SqlSessionFactory factory = builder.build(Resources.getResourceAsStream("SqlMapConfig.xml"));

        // 获取session(创建一级缓存)
        SqlSession session = factory.openSession();

        // 获取mapper类
        EmpDao mapper = session.getMapper(EmpDao.class);

        // 查询二级缓存,没查询到,再查询一级缓存,没查询到,最后发送SQL去数据库查询,然后将数据放入一级缓存
        Emp emp = mapper.findById(1);
        System.out.println(emp);

        // 查询二级缓存,没查询到,再查询一级缓存,查询到了,返回(没有发送SQL)
        Emp emp2 = mapper.findById(1);
        System.out.println(emp2);

        System.out.println(emp == emp2);        // true

        session.close();
    }
}

一级缓存和二级缓存查询流程：

在这里插入图片描述

2.4 MyBatis二级缓存相关配置

2.4.1 二级缓存配置

  • <cache />：开启当前Mapper的二级缓存
    • eviction：当内存使用紧张时，缓存的回收策略缓存的回收策略
      • LRU：最近最少使用的：移除最长时间不被使用的对象。
      • FIFO：先进先出：按对象进入缓存的顺序来移除它们。
      • SOFT：软引用：移除基于垃圾回收器状态和软引用规则的对象。
      • WEAK：弱引用：更积极地移除基于垃圾收集器状态和弱引用规则的对象。
    • flushInterval：缓存刷新间隔,缓存多长时间清空一次，默认不清空，可以通过此参数设置一个毫秒值
    • readOnly：是否只读
      • true：只读；mybatis认为所有从缓存中获取数据的操作都是只读操作，不会修改数据。
      • false：非只读（默认值）；mybatis觉得获取的数据可能会被修改。
    • size：二级缓存中最大能够缓存存放多少元素
    • type：指定自定义缓存的全类名(实现Cache接口)
2.4.1.1 缓存大小

修改配置：

<cache size="1"/>
  • 测试代码：
@Test
public void test1() throws Exception {
    // 开启一级缓存
    SqlSession session = factory.openSession();

    EmpDao mapper = session.getMapper(EmpDao.class);

    // 数据存入一级缓存
    Emp emp = mapper.findById(1);
    System.out.println(emp);

    // 数据存入一级缓存
    Emp emp2 = mapper.findById(2);
    System.out.println(emp2);

    System.out.println(emp == emp2);        // true

    // 关闭session,将数据写入二级缓存(此时一级缓存的大小为1)
    session.close();

    SqlSession session1 = factory.openSession();

    EmpDao mapper1 = session1.getMapper(EmpDao.class);
    Emp emp3 = mapper1.findById(2);         // 二级缓存不存在,一级缓存也不存在,发送SQL去查询

    session1.close();
}

执行日志如下：

Created connection 527829831.
Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@1f760b47]
==>  Preparing: select * from emp where id=?
==> Parameters: 1(Integer)
<==    Columns: id, name, age, addr, salary, dept_id
<==        Row: 1, 张三, 20, 广西来宾, 7600.00, 1
<==      Total: 1
Emp(id=1, name=张三, age=20, addr=广西来宾, salary=7600.0, deptId=null)
Cache Hit Ratio [com.dfbz.dao.EmpDao]: 0.0
==>  Preparing: select * from emp where id=?
==> Parameters: 2(Integer)
<==    Columns: id, name, age, addr, salary, dept_id
<==        Row: 2, 李四, 22, 浙江绍兴, 6800.00, 4
<==      Total: 1
Emp(id=2, name=李四, age=22, addr=浙江绍兴, salary=6800.0, deptId=null)
false
Resetting autocommit to true on JDBC Connection [com.mysql.jdbc.JDBC4Connection@1f760b47]

# 关闭session将数据写入二级缓存,只能存储一条
Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@1f760b47]
Returned connection 527829831 to pool.
Cache Hit Ratio [com.dfbz.dao.EmpDao]: 0.0
Opening JDBC Connection
Checked out connection 527829831 from pool.
Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@1f760b47]

# 再次查询二级缓存发现没有，然后查询一级缓存也没有，最终发送SQL去查询数据库
==>  Preparing: select * from emp where id=?
==> Parameters: 2(Integer)
<==    Columns: id, name, age, addr, salary, dept_id
<==        Row: 2, 李四, 22, 浙江绍兴, 6800.00, 4
<==      Total: 1
Resetting autocommit to true on JDBC Connection [com.mysql.jdbc.JDBC4Connection@1f760b47]
Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@1f760b47]
Returned connection 527829831 to pool.
Disconnected from the target VM, address: '127.0.0.1:51525', transport: 'socket'
2.4.1.2 缓存只读

之前我们学一级缓存的时候提到过，一级缓存里面存储的是对象的引用（内存地址），当对象内容修改了，一级缓存里面存储的那个对象内容也会随之修改，而二级缓存里面存储的是对象序列化之后的值，换句话来说就是类似与拷贝了一份新的数据到二级缓存；因此修改原有对象不会影响二级缓存里面的对象内容；

  • 测试代码：
@Test
public void test2() throws Exception {
    // 开启一级缓存
    SqlSession session = factory.openSession();

    EmpDao mapper = session.getMapper(EmpDao.class);

    // 数据存入一级缓存
    Emp emp = mapper.findById(1);
    System.out.println("------------emp1: " + emp);                 // name=张三

    // 关闭session,将一级缓存的数据序列化(拷贝)到二级缓存
    session.close();

    // 修改emp对象的属性值
    emp.setName("abc");

    SqlSession session1 = factory.openSession();

    EmpDao mapper1 = session1.getMapper(EmpDao.class);

    // 从二级缓存中反序列化出来
    Emp emp2 = mapper1.findById(1);
    System.out.println("------------emp2: " + emp2);                // name=张三

    // 因为是反序列化出来的对象,和原有对象不是同一个,返回false
    System.out.println(emp == emp2);                                
    session1.close();
}

执行日志：

在这里插入图片描述

而这样带来的弊端就是每次session关闭的时候都需要将数据序列化一份，这不仅从时间角度上效率低了，从空间角度上效率也会变低，因为每次都在序列化（拷贝）新的对象；如果我们对数据的修改并不敏感，或者不会对数据进行修改，那么我们可以将二级缓存的readOnly设置为true；此时二级缓存里面存储的是对象的引用，并不会采用序列化技术，此时的对象也不需要实现序列化接口了；

  • 修改二级缓存配置：
<cache readOnly="true"/>
  • 测试代码：
@Test
public void test2() throws Exception {
    // 开启一级缓存
    SqlSession session = factory.openSession();

    EmpDao mapper = session.getMapper(EmpDao.class);

    // 数据存入一级缓存
    Emp emp = mapper.findById(1);
    System.out.println("------------emp1: " + emp);                 // name=张三

    // 关闭session,将一级缓存的数据序列化(拷贝)到二级缓存
    session.close();

    // 修改emp对象的属性值
    emp.setName("abc");

    SqlSession session1 = factory.openSession();

    EmpDao mapper1 = session1.getMapper(EmpDao.class);

    // 从二级缓存中反序列化出来
    Emp emp2 = mapper1.findById(1);
    System.out.println("------------emp2: " + emp2);                // name=abc

    // true
    System.out.println(emp == emp2);
    session1.close();
}

执行日志：

在这里插入图片描述

2.5 Redis替换二级缓存

查看Cache接口：

package org.apache.ibatis.cache;

import java.util.concurrent.locks.ReadWriteLock;

public interface Cache {
    String getId();

    void putObject(Object var1, Object var2);

    Object getObject(Object var1);

    Object removeObject(Object var1);

    void clear();

    int getSize();

    default ReadWriteLock getReadWriteLock() {
        return null;
    }
}

2.5.1 自定义缓存

我们可以自定义一个类，重写Cache接口，让MyBatis存入二级缓存的数据交给我们来处理！

  • 1）引入相关依赖：
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>2.9.1</version>
</dependency>

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.62</version>
</dependency>
  • 2）重写Cache接口：
package com.dfbz.cache;

import com.alibaba.fastjson.JSON;
import com.dfbz.entity.Emp;
import org.apache.ibatis.cache.Cache;
import redis.clients.jedis.Jedis;

import java.util.List;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class MyCache implements Cache {
    private Jedis jedis = new Jedis();

    @Override
    public String getId() {
        return id;
    }

    /**
     * 添加缓存
     *
     * @param key: 缓存的key
     * @param val: 需要存储到缓存的值(是一个List类型)
     */
    @Override
    public void putObject(Object key, Object val) {

        jedis.set(key.toString(), JSON.toJSONString(val));

        System.out.println("putObject..............");
    }

    /**
     * 获取缓存中的内容
     *
     * @param key
     * @return
     */
    @Override
    public Object getObject(Object key) {

        System.out.println("getObject................");

        String jsonStr = jedis.get(key.toString());

        List<Emp> list = JSON.parseArray(jsonStr, Emp.class);

        return list;
    }

    /**
     * 删除缓存
     *
     * @param key
     * @return
     */
    @Override
    public Object removeObject(Object key) {
        System.out.println("removeObject................");
        return jedis.del(key.toString());
    }

    /**
     * 清空缓存
     */
    @Override
    public void clear() {
        System.out.println("clear................");
        jedis.flushDB();
    }

    /**
     * 获取缓存中的key数量
     *
     * @return
     */
    @Override
    public int getSize() {
        System.out.println("getSize................");
        return Integer.parseInt(jedis.dbSize() + "");
    }
}
  • 3）在EmpDao.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.dfbz.dao.EmpDao">

    <!--替换为我们自定义的缓存-->
    <cache type="com.dfbz.cache.MyCache"></cache>

    <select id="findById" resultType="Emp">
        select * from emp where id=#{id}
    </select>
</mapper>

在这里插入图片描述

2.5.2 测试Redis替代二级缓存

package com.dfbz.mybatis;

import com.dfbz.dao.EmpDao;
import com.dfbz.entity.Emp;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Before;
import org.junit.Test;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo01 {
    SqlSessionFactory factory;

    @Before
    public void before() throws Exception {
        factory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("SqlMapConfig.xml"));
    }

    @Test
    public void test1() throws Exception {

        // 开启一级缓存
        SqlSession session = factory.openSession();

        EmpDao mapper = session.getMapper(EmpDao.class);

        // 先从二级缓存里面查询,再从一级缓存里面查询,再从数据库查询(发送SQL),将查询到的结果集存入一级缓存
        Emp emp = mapper.findById(1);
        System.out.println(emp);

        // 关闭一级缓存,把数据写入二级缓存(写入到redis)
        session.close();

        // 开启一级缓存
        SqlSession session2 = factory.openSession();

        EmpDao mapper2 = session2.getMapper(EmpDao.class);

        // 先从二级缓存里面获取(从redis里面获取)
        Emp emp2 = mapper2.findById(1);
        System.out.println(emp2);
        System.out.println(emp == emp2);            // false ,两个对象的属性值一样,但是内存地址值不一样(反序列化出来的)

        session2.close();
    }
}

在这里插入图片描述

2.6 MyBatis缓存总结

一级缓存和二级缓存的执行顺序为：二级缓存---->一级缓存---->数据库

查询语句始终是由一级缓存发送的，一级缓存默认由MyBatis维护，我们只需了解使用即可

二级缓存需要我们可以修改配置：

1、在MyBatis中，二级缓存是默认开启（支持）状态，在SqlMapConfig.xml中设置二级缓存的支持情况

<settings>
    <!--开启二级缓存支持 -->
    <setting name="cacheEnabled" value="true"/>
</settings>

2、在mapper文件中加入<cache>标签代表激活本mapper文件的二级缓存，并保证useCache不为false(默认为true)

<cache></cache>
<select id="findById" parameterType="int" resultType="user" useCache="true">
    select * from user where id=#{id}
</select>

3、MyBatis的二级缓存默认采用序列化/反序列化来保证对象的存取，所以所有的entity对象都应该实现serializable接口

緑水長流*z
关注
专栏目录
mybatis 一级缓存 二级缓存
inooll的博客
07-09 476
一级缓存 Mybatis的一级缓存在session里 只要通过session查过的数据，都会放在session上，下一次再查询相同id的数据，都直接从缓存中取出来 Category c1 = session.selectOne("getCategory", 1); System.out.println(c1); Category c2 = session.selectOne("getCategory", 1); System.out.print
Mybatis缓存机制
weixin_55558933的博客
03-12 805
1、一级缓存和二级缓存 MyBatis 内置了一个强大的事务性查询缓存机制，它可以非常方便地配置和定制。 我们查询时，如果缓存中存在数据，那么我们就可以直接从缓存中获取，而不是再去向数据库进行请求。 一级缓存默认开启，缓存范围仅为单个SqlSession会话内，不能串缓存 二级缓存需要手动开启，范围属于Mapper Namespace 二级缓存的运行规则: 二级缓存默认所有查询操作均使用缓存 useCache = "true" 写操作commit提交时对该namespace缓存会强制清空 .
MyBatis一级缓存和二级缓存全面详解
緑水長流*z
05-24 1036
MyBait的一级缓存，二级缓存的使用与配置；包括一级缓存相关参数，一级缓存作用域，clearCache，flushCache，一级缓存各种场景测试；二级缓存的使用场景，实际使用案例，二级缓存执行流程，二级缓存相关配置，useCache，标签的配置详解，二级缓存失效场景，Redis等缓存组件替换二级缓存等...
《深入理解mybatis原理》 MyBatis的二级缓存的设计原理
热门推荐
我的程序人生(亦山札记)
11-23 4万+
MyBatis的二级缓存是Application级别的缓存，它可以提高对数据库查询的效率，以提高应用的性能。本文将全面分析MyBatis的二级缓存的设计原理。
Mybatis 一级缓存、二级缓存（转）
qq_39809613的博客
06-11 138
查询缓存 首先，我们先看一下这个标题“查询缓存”，那就说明跟增、删、改是没有任何关联的，只有在查询时，才会遇到缓存，增删改不涉及！ 查询缓存目前Mybatis中提供了两个，分别是：一级缓存、二级缓存； 一级缓存 先说一下一级缓存的范围：同一个SqlSession对象，也就说，我们是同一个SqlSession对象，又要进行同样的查询操作，那么，我们就可以去缓存中获取； 所以，SqlSess...
Mybatis 的一级缓存与二级缓存
x_023的博客
02-29 2455
缓存即的临时数据，利用缓存可以减少与数据库的交互次数、提高效率；应该考虑缓存Mybaits 支持的缓存有如下几个特点。
Mybatis的缓存机制
weixin_71107289的博客
08-25 2259
Mybatis 包含一个非常强大的查询缓存特性,它可以非常方便地配置和定制，缓存可以极大的提升查询效率。 MyBatis中默认定义了两级缓存，分别是一级缓存和二级缓存。 （1） 默认情况下，只有一级缓存（SqlSession级别的缓存，也称为本地缓存）开启。 （2）二级缓存需要手动开启和配置，二级缓存是基于Mapper（namespace）级别的缓存。 （3）为了提高扩展性，MyBatis定义了缓存接口Cache。我们可以通过实现Cache接口来自定义二级缓存...
Mybatis缓存机制案例
08-03
Mybatis缓存机制是数据库操作中的重要组成部分，它能够提高数据访问效率，减少对数据库的重复查询。在Mybatis中，缓存分为一级缓存和二级缓存，这两种缓存各有其特点和应用场景。 一级缓存是SqlSession级别的缓存，...
MyBatis之缓存机制
yandao的博客
05-18 1454
缓存即为存在内存中的临时数据.将用户经常查询的数据存放在缓存(内存)中,用户去查询数据就不用去每次去数据库中查询,而是去缓存中查询,从而提高了查询的效率,解决了高并发系统的性能问题.MyBatis提供了两种缓存机制：一级缓存（本地）和二级缓存（全局）1、默认情况下，只有一级缓存( SqlSession级别的缓存也称为本地缓存)开启。2、二级缓存需要手动开启和配置，他是基于namespace级别的缓存。3、为了提高扩展性。MyBatis定义了缓存接口Cache。
【Mybatis】Mybatis缓存机制
keeper42的博客
02-03 265
MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以使用简单的 XML 或注解来配置和映射原生信息，将接口和 Java 的 POJOs(Plain Old Java Objects,普通的 Java对象)映射成数据库中的记录。 背景介绍 MyBatis是支持普通 SQL查询，存储过程和高级映射的优秀持久层框架。MyBatis 消除了几乎所有的JDBC代码和参数的手工设置以及结
mybatis中的缓存（一级缓存、二级缓存）
最新发布
m0_62943934的博客
07-23 3698
在计算机的世界中，缓存无处不在，重要性不言而喻。作为一款优秀的ORM框架，MyBatis中又岂能少得了缓存，本博客基于mybatis 3.5.11版本，全面介绍mybatis一级缓存、二级缓存以及自定义缓存的使用方法、实现原理、应用场景、优缺点等，并进行验证，带你彻底掌握MyBatis缓存。
【MyBatis】一级缓存 二级缓存详解
Le vent se lève, il faut tenter de vivre
08-16 1286
学mybatis缓存，看这篇文章就够了~
MyBatis 的一级缓存和二级缓存
猎人在吃肉
04-22 7125
文章目录一、前言二、一级缓存三、二级缓存3.1、开启二级缓存：四、测试一下五、总结： 一、前言 先说缓存，合理使用缓存是优化中最常见的，将从数据库中查询出来的数据放入缓存中，下次使用时不必从数据库查询，而是直接从缓存中读取，避免频繁操作数据库，减轻数据库的压力，同时提高系统性能。 二、一级缓存 一级缓存 是 SqlSession级别的缓存。在操作数据库时需要构造sqlSession对象，在对象中有...
Mybatis 一级缓存 二级缓存
qq_38444415的博客
02-10 637
先上结论： Mybatis默认开启一级缓存是，需要配置开启二级缓存。mybatis的的一级缓存是SqlSession级别的缓存，一级缓存缓存的是对象，当SqlSession提交、关闭以及其他的更新数据库的操作发生后，一级缓存就会清空；二级缓存是SqlSessionFactory级别的缓存，同一个SqlSessionFactory产生的SqlSession都共享一个二级缓存，二级缓存中存储的是数据，当命中二级缓存时，通过存储的数据构造对象返回。 查询数据的时候，查询的流程是二级缓存>一级缓存>
mybatis的一级缓存和二级缓存
林夕
06-14 2643
什么是缓存 [ Cache ]？存在内存中的临时数据。将用户经常查询的数据放在缓存（内存）中，用户去查询数据就不用从磁盘上(关系型数据库数据文件)查询，从缓存中查询，从而提高查询效率，解决了高并发系统的性能问题。为什么使用缓存？减少和数据库的交互次数，减少系统开销，提高系统效率。什么样的数据能使用缓存？经常查询并且不经常改变的数据。
MyBatis(十一)——MyBatis缓存（一级缓存和二级缓存）
weixin_43180675的博客
12-23 198
一级缓存 Mybatis对缓存提供支持，但是在没有配置的默认情况下，它只开启一级缓存，一级缓存只是相对于同一个SqlSession而言。所以在参数和SQL完全一样的情况下，我们使用同一个SqlSession对象调用一个Mapper方法，往往只执行一次SQL，因为使用SelSession第一次查询后，MyBatis会将其放在缓存中，以后再查询的时候，如果没有声明需要刷新，并且缓存没有超时的情况下，S...
Mybatis 中一级缓存与二级缓存
荣山的博客
01-17 2897
Mybatis 中一级缓存与二级缓存
【MyBatis】基础篇(十三) MyBatis缓存策略
不想当架构师的程序员不是好程序员
08-19 858
MyBatis系列之基础篇(十三) MyBatis缓存策略 1.MyBatis中的缓存 像大多数的持久化框架一样，Mybatis 也提供了缓存策略，通过缓存策略来减少数据库的查询次数，从而提高性能。 MyBatis 中缓存分为一级缓存和二级缓存 2. 一级缓存 一级缓存是 SqlSession 级别的缓存，只要 SqlSession 没有 flush 或 close，它就存在 2.1...
MyBatis缓存机制详解与优化策略
理解并掌握MyBatis的一级缓存和二级缓存机制，以及如何针对分页查询进行优化，是提升MyBatis应用性能的重要环节。正确使用缓存能够显著减少数据库压力，提高系统的响应速度，但同时也需要关注数据一致性问题，防止...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

緑水長流*z

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值