简介

什么是缓存？
- 缓存是存在于内存中的临时数据。
为什么使用缓存？
- 缓存能够减少和数据库的交互次数，提高执行效率。
什么样的数据适用于缓存，什么样的数据不适用于缓存？
- 适用于缓存：
  - 经常查询，并且不经常改变的数据。
  - 数据的正确与否对最终结果的影响不大。
- 不适用于缓存：
  - 经常改变的数据。
  - 数据的正确与否对最终结果的影响非常大。
像大多数的持久化框架一样，Mybatis 也提供了缓存策略，通过缓存策略来减少数据库的查询次数，从而提
高性能。Mybatis 中缓存分为一级缓存，二级缓存。
- 一级缓存
  - 当我们执行查询操作之后，Mybatis 框架会将在数据库中的查询的结果自动存储到 SqlSession 中为一级缓存划分的一块区域中。（该区域的低层结构是 Map集合）
  - 当我们再次执行同样的查询操作之后，Mybatis 框架会先从 SqlSession 中的一级缓存区域查询。如果存在数据，就直接拿出来；如果不存在数据，才会去数据库中进行查询。
  - 因为一级缓存区域被设置在 SqlSession 中，所以当 SqlSession 消失时，一级缓存也就消失。
- 二级缓存
  - 二级缓存被存储在 SqlSessionFactory 中，同一个 SqlSessionFactory 创建的 SqlSession 共享二级缓存。

目录结构

src

main
- java
  - cn.water.dao
    - UserDao.java（持久层接口）
  - cn.water.domain
    - User.java（实体类）
- resources
  - cn.water.dao
    - UserDao.xml（映射配置文件）
  - SqlMapConfig.xml（MyBatis主配置文件）
  - jdbcConfig.properties（数据库连接信息文件）
test
- java.cn.water
  - MybatisTest.java（测试类）

MyBatis配置文件

jdbcConfig.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis
jdbc.username=root
jdbc.password=root

SqlMapConfig.xml

开启二级缓存

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">


        <!-- mybatis的主配置文件 -->
        <configuration>
    
            <!-- 外部配置 -->
            <properties resource="jdbcConfig.properties"></properties>

            <!-- 配置参数 -->
            <settings>
                <!-- 开启 二级缓存 -->
                <setting name="cacheEnabled" value="true"/>
            </settings>

            <!-- 指定包：实体类-->
            <typeAliases>
                <package name="cn.water.domain"/>
            </typeAliases>

            <!-- 配置环境 -->
            <environments default="mysql">
                <environment id="mysql">
                    <transactionManager type="JDBC"></transactionManager>
                    <dataSource type="POOLED">
                        <!-- 配置连接数据库的4个基本信息 -->
                        <property name="driver" value="${jdbc.driver}"/>
                        <property name="url" value="${jdbc.url}"/>
                        <property name="username" value="${jdbc.username}"/>
                        <property name="password" value="${jdbc.password}"/>
                    </dataSource>
                </environment>
            </environments>

            <!-- 指定包：持久层接口 -->
            <mappers>
                <package name="cn.water.dao"/>
            </mappers>

        </configuration>

实体类

User.java

package cn.water.domain;

import java.io.Serializable;
import java.util.Date;

/**
 * @author Water
 * @date 2019/10/12 - 7:51
 * @description
 */
public class User implements Serializable {

    private Integer id;
    private String username;
    private Date birthday;
    private String sex;
    private String address;

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", birthday=" + birthday +
                ", sex='" + sex + '\'' +
                ", address='" + address + '\'' +
                '}';
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}

持久层接口

UserDao.java

package cn.water.dao;

import cn.water.domain.User;

/**
 * @author Water
 * @date 2019/10/12 - 7:51
 * @description
 */
public interface UserDao {

    /*  */
    User findById(Integer userId);

}

映射配置文件

UserDao.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="cn.water.dao.UserDao">

    <cache></cache>

    <select id="findById" parameterType="INT" resultType="user" useCache="true">
<!--    <select id="findById" parameterType="INT" resultType="user" >-->
        SELECT * FROM user WHERE id = #{userId};
    </select>


</mapper>

测试类

MyBatisTest.java

package cn.water;

import cn.water.dao.UserDao;
import cn.water.domain.User;
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.After;
import org.junit.Before;
import org.junit.Test;

import java.io.IOException;
import java.io.InputStream;

/**
 * @author Water
 * @date 2019/10/12 - 7:56
 * @description
 */
public class MybatisTest {


    /* 成员变量 */
    private InputStream inputStream;
    private SqlSessionFactory factory;
    private SqlSession session;

    /* 初始化操作 */
    @Before
    public void init() throws IOException {
        /* 加载 MyBatis配置文件 */
        inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
        /* 获取 工厂类 */
        factory = new SqlSessionFactoryBuilder().build(inputStream);
        /* 获取 产品类 */
        session = factory.openSession(true);/* 设置自动提交 */
    }

    /* 销毁操作 */
    @After
    public void destroy() throws IOException {
        session.close();
        inputStream.close();
    }

    /** 一级缓存：同一个 SqlSession */
    @Test
    public void test01(){
        UserDao dao = session.getMapper(UserDao.class);
        User user01 = dao.findById(41);
        System.out.println("第一次查询："+user01);
        User user02 = dao.findById(41);
        System.out.println("第二次查询："+user02);
        System.out.println("两次查询结果是否相等："+(user01==user02)); //true
    }

    /** 一级缓存：不同 SqlSession */
    @Test
    public void test02(){
        UserDao dao = session.getMapper(UserDao.class);
        User user01 = dao.findById(41);
        System.out.println("第一次查询："+user01);

        /* commit()（执行插入、更新、删除）、close() */
        session.close();
        session = factory.openSession();

        UserDao dao02 = session.getMapper(UserDao.class);
        User user02 = dao02.findById(41);
        System.out.println("第二次查询："+user02);
        System.out.println("两次查询结果是否相等："+(user01==user02));//false
    }


}

一级缓存

测试类

/** 一级缓存：同一个 SqlSession */
@Test
public void test01(){
    UserDao dao = session.getMapper(UserDao.class);
    User user01 = dao.findById(41);
    System.out.println("第一次查询："+user01);
    User user02 = dao.findById(41);
    System.out.println("第二次查询："+user02);
    System.out.println("两次查询结果是否相等："+(user01==user02));
}

运行结果

一级缓存是SqlSession级别的缓存，只要SqlSession没有flush或close，它就存在。
- 我们可以发现，在测试一中虽然我们查询了两次，但最后只执行了一次数据库操作，这就是Mybatis提供给我们的一级缓存在起作用了。
- 因为一级缓存的存在，导致第二次查询id为41的记录时，并没有发出sql语句从数据库中查询数据，而是从一级缓存中查询。

一级缓存的清空

测试类

/** 一级缓存：不同 SqlSession */
@Test
public void test02(){
    UserDao dao = session.getMapper(UserDao.class);
    User user01 = dao.findById(41);
    System.out.println("第一次查询："+user01);
    /* commit()（执行插入、更新、删除）、close() */
    session.close();
    session = factory.openSession();
    UserDao dao02 = session.getMapper(UserDao.class);
    User user02 = dao02.findById(41);
    System.out.println("第二次查询："+user02);
    System.out.println("两次查询结果是否相等："+(user01==user02));
}

运行结果

一级缓存是SqlSession范围的缓存，当调用SqlSession的commit()（修改，添加，删除），close()等方法时，就会清空一级缓存。
第一次发起查询用户id为1的用户信息，先去找缓存中是否有id为1的用户信息，如果没有，从数据库查
询用户信息。得到用户信息，将用户信息存储到一级缓存中。如果sqlSession去执行commit操作（执行插入、更新、删除），清空SqlSession中的一级缓存，这样做的目的为了让缓存中存储的是最新的信息，避免脏读。
第二次发起查询用户id为1的用户信息，先去找缓存中是否有id为1的用户信息，缓存中有，直接从缓存中获取用户信息。

二级缓存

当我们在使用二级缓存时，所缓存的类一定要实现 java.io.Serializable接口，这种就可以使用序列化
方式来保存对象。

开启二级缓存

二级缓存的使用步骤：
- 第一步：让Mybatis框架支持二级缓存（在SqlMapConfig.xml中配置）
- 第二步：让当前的映射文件支持二级缓存（在IUserDao.xml中配置
- 第三步：让当前的操作支持二级缓存（在select标签中配置）

MyBatis主配置文件

开启二级缓存支持

cacheEnabled 默认值为 true（此配置可以省略）

<!-- 配置参数 -->
<settings>
    <!-- 开启 延迟加载 -->
    <setting name="lazyLoadingEnabled" value="true"/>
    <setting name="aggressiveLazyLoading" value="false"/>
    <!-- 开启 二级缓存 -->
    <setting name="cacheEnabled" value="true"/>
</settings>

映射配置文件

设置 <cache> 标签

表示当前 mapper 映射将使用二级缓存，区分的标准为 mapper 标签的 namespace 值。

<mapper namespace="cn.water.dao.UserDao">

    <cache></cache>

</mapper>

<select> 标签设置 useCache=”true” 属性

注意：针对每次查询都需要最新的数据sql，要设置成useCache=false，禁用二级缓存。

<mapper namespace="cn.water.dao.UserDao">

    <cache></cache>
    
    <select id="findById" parameterType="INT" resultType="user" useCache="true" >
        SELECT * FROM user WHERE id = #{userId};
    </select>


</mapper>

测试类

依然执行 Test02()

 @Test
    public void test02(){
        UserDao dao = session.getMapper(UserDao.class);
        User user01 = dao.findById(41);
        System.out.println("第一次查询："+user01);

        /* commit()（执行插入、更新、删除）、close() */
        session.close();
        session = factory.openSession();

        UserDao dao02 = session.getMapper(UserDao.class);
        User user02 = dao02.findById(41);
        System.out.println("第二次查询："+user02);
        System.out.println("两次查询结果是否相等："+(user01==user02));//false
    }

运行结果

经过上面的测试，我们发现执行了两次查询，并且在执行第一次查询后，我们关闭了一级缓存，再去执行第二
次查询时，我们发现并没有对数据库发出sql语句，所以此时的数据就只能是来自于我们所说的二级缓存。

一级缓存

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bQWezfwy-1580952138442)(11.缓存\控制台证明一级缓存02.png)]

一级缓存和二级缓存

在这里插入图片描述

water1127

发布了68 篇原创文章 · 获赞 2 · 访问量 1913

私信关注

MyBatis框架（11） —— 缓存机制

简介

目录结构

MyBatis配置文件

jdbcConfig.properties

SqlMapConfig.xml

实体类

User.java

持久层接口

UserDao.java

映射配置文件

UserDao.xml

测试类

MyBatisTest.java

一级缓存

测试类

运行结果

一级缓存的清空

测试类

运行结果

二级缓存

开启二级缓存

MyBatis主配置文件

映射配置文件

测试类

运行结果

一级缓存

一级缓存和二级缓存

猜你喜欢