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

简介

• 什么是缓存？
  • 缓存是存在于内存中的临时数据。
• 为什么使用缓存？
  • 缓存能够减少和数据库的交互次数，提高执行效率。
• 什么样的数据适用于缓存，什么样的数据不适用于缓存？
  • 适用于缓存：
    • 经常查询，并且不经常改变的数据。
    • 数据的正确与否对最终结果的影响不大。
  • 不适用于缓存：
    • 经常改变的数据。
    • 数据的正确与否对最终结果的影响非常大。
• 像大多数的持久化框架一样，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主配置文件

1. 开启二级缓存支持

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

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

映射配置文件

2. 设置 <cache> 标签

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

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

    <cache></cache>

</mapper>

3. <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语句，所以此时的数据就只能是来自于我们所说的二级缓存。

一级缓存


一级缓存和二级缓存