【MyBatis 】之Mybatis 缓存-11

1. Mybatis缓存

Mybatis 也提供了缓存策略，通过缓存策略来减少数据库的查询次数， 从而提高性能。
Mybatis 中缓存分为一级缓存，二级缓存。

1.1 Mybatis一级缓存

一级缓存是 SqlSession 级别的缓存，只要 SqlSession 没有 flush 或 close，它就存在。

1.1.1 证明一级缓存是否存在

（1）编写实体类

package com.spg.entity;

import java.util.Date;

public class User implements Serializable {
    private Integer id;
    private String username;
    private String address;
    private String sex;
    private Date birthday;

    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 String getAddress() {
        return address;
    }

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

    public String getSex() {
        return sex;
    }

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

    public Date getBirthday() {
        return birthday;
    }

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

（2）编写用户持久层 Dao 接口

package com.spg.dao;

import com.spg.entity.User;

/**
 * 用户的业务层接口
 */
public interface UserDao {
    /**
     * 根据 id 查询
     * @param userId
     * @return
     */
    User findById(Integer userId);
}

（3）编写用户持久层映射文件

<?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.spg.dao.UserDao">
    <!-- 根据 id 查询 -->
    <select id="findById" resultType="User" parameterType="int" useCache="true">
        select * from user where id = #{userId}
    </select>
</mapper>

（4）mybatis-config.xml文件配置

# Set root category priority to INFO and its only appender to CONSOLE.
#log4j.rootCategory=INFO, CONSOLE            debug   info   warn error fatal
log4j.rootCategory=debug, CONSOLE, LOGFILE

# Set the enterprise logger category to FATAL and its only appender to CONSOLE.
log4j.logger.org.apache.axis.enterprise=FATAL, CONSOLE

# CONSOLE is set to be a ConsoleAppender using a PatternLayout.
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=%d{ISO8601} %-6r [%15.15t] %-5p %30.30c %x - %m\n

# LOGFILE is set to be a File appender using a PatternLayout.
log4j.appender.LOGFILE=org.apache.log4j.FileAppender
log4j.appender.LOGFILE.File=d:\axis.log
log4j.appender.LOGFILE.Append=true
log4j.appender.LOGFILE.layout=org.apache.log4j.PatternLayout
log4j.appender.LOGFILE.layout.ConversionPattern=%d{ISO8601} %-6r [%15.15t] %-5p %30.30c %x - %m\n

jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis_db?serverTimezone=UTC
jdbc.username=root
jdbc.password=root

<?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-->
    <properties resource="jdbcConfig.properties"/>

    <!--使用typeAliases配置别名，它只能配置entity中类的别名 -->
    <typeAliases>
        <!--<package name="com.spg.entity"/> -->
        <typeAlias type="com.spg.entity.User" alias="User"/>
    </typeAliases>

    <!-- 配置环境 -->
    <environments default="mysql">
        <!-- 配置mysql的环境-->
        <environment id="mysql">
            <!-- 配置事务的类型-->
            <transactionManager type="JDBC"/>
            <!-- 配置数据源（连接池） -->
            <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>

    <!-- 指定映射配置文件的位置，映射配置文件指的是每个dao独立的配置文件 -->
    <mappers>
        <!--<package name="com.spg.dao"/>-->
        <mapper resource="mapper/UserDao.xml"/>
    </mappers>

</configuration>

（5）编写测试方法

package com.spg.dao;

import com.spg.entity.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.InputStream;

public class UserDaoTest {

    private InputStream in;
    private SqlSessionFactory factory;
    private SqlSession sqlSession;
    private UserDao userDao;

    @Before//用于在测试方法执行之前执行
    public void init()throws Exception{
        // 1.读取配置文件，生成字节输入流
        in = Resources.getResourceAsStream("mybatis-config.xml");
        // 2.创建构建者对象
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        // 3.创建 SqlSession 工厂对象
        factory = builder.build(in);
        // 4.创建 SqlSession 对象
        sqlSession = factory.openSession();
        // 5.获取dao的代理对象
        userDao = sqlSession.getMapper(UserDao.class);
    }

    @After//用于在测试方法执行之后执行
    public void destroy()throws Exception{
        // 7.释放资源
        sqlSession.close();
        in.close();
    }

    @Test
    public void findById(){
        // 6. 执行操作
        User user1 = userDao.findById(41);
        System.out.println("第一次查询用户：" + user1);
        User user2 = userDao.findById(41);
        System.out.println("第二次查询用户：" + user2);
        System.out.println(user1 == user2);
    }
}

测试结果：

DEBUG ansaction.jdbc.JdbcTransaction  - Opening JDBC Connection
DEBUG source.pooled.PooledDataSource  - Created connection 593687897.
DEBUG ansaction.jdbc.JdbcTransaction  - Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@2362f559]
DEBUG   com.spg.dao.UserDao.findById  - ==>  Preparing: select * from user where id = ? 
DEBUG   com.spg.dao.UserDao.findById  - ==> Parameters: 41(Integer)
DEBUG   com.spg.dao.UserDao.findById  - <==      Total: 1
第一次查询用户：com.spg.entity.User@7b02881e
第二次查询用户：com.spg.entity.User@7b02881e
true

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

1.1.2 一级缓存的分析

一级缓存是 SqlSession 范围的缓存，当调用 SqlSession 的修改，添加，删除，commit()， close()等方法时，就会清空一级缓存。

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

1.1.3 测试一级缓存的清空

    /**
     * 测试一级缓存
     */
    @Test
    public void testFirstLevelCache(){
        User user1 = userDao.findById(41);
        System.out.println(user1);
        // sqlSession.close();
        //再次获取 SqlSession 对象
        // sqlSession = factory.openSession();
        sqlSession.clearCache();//此方法也可以清空缓存
        userDao = sqlSession.getMapper(UserDao.class);
        User user2 = userDao.findById(41);
        System.out.println(user2);
        System.out.println(user1 == user2);
    }

测试结果：

- Opening JDBC Connection
- Created connection 187472540.
- Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@b2c9a9c]
- ==>  Preparing: select * from user where id = ? 
- ==> Parameters: 41(Integer)
- <==      Total: 1
com.spg.entity.User@7b02881e
- ==>  Preparing: select * from user where id = ? 
- ==> Parameters: 41(Integer)
- <==      Total: 1
com.spg.entity.User@3c0be339
false
- Resetting autocommit to true on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@b2c9a9c]
- Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@b2c9a9c]
- Returned connection 187472540 to pool.

    /**
     * 测试缓存的同步
     */
    @Test
    public void testClearCache(){
        //1.根据 id 查询用户
        User user1 = userDao.findById(41);
        System.out.println(user1);
        //2.更新用户信息
        user1.setUsername("update user clear cache");
        user1.setAddress("北京市海淀区");
        userDao.update(user1);
        //3.再次查询 id 为 41 的用户
        User user2 = userDao.findById(41);
        System.out.println(user2);
        System.out.println(user1 == user2);
    }

测试结果：

- Opening JDBC Connection
- Created connection 187472540.
- Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@b2c9a9c]
- ==>  Preparing: select * from user where id = ? 
- ==> Parameters: 41(Integer)
- <==      Total: 1
com.spg.entity.User@7b02881e
- ==>  Preparing: update user set username=?, address=?, sex=? where id=? 
- ==> Parameters: update user clear cache(String), 北京市海淀区(String), 男(String), 41(Integer)
- <==    Updates: 1
- ==>  Preparing: select * from user where id = ? 
- ==> Parameters: 41(Integer)
- <==      Total: 1
com.spg.entity.User@15ca7889
false
- Rolling back JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@b2c9a9c]
- Resetting autocommit to true on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@b2c9a9c]
- Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@b2c9a9c]
- Returned connection 187472540 to pool.

当执行sqlSession.close()后，再次获取sqlSession并查询id=41的User对象时，又重新执行了sql。语句，从数据库进行了查询操作。

1.2 Mybatis二级缓存

1.2.1 二级缓存结构图

首先开启 mybatis 的二级缓存。
sqlSession1 去查询用户信息，查询到用户信息会将查询数据存储到二级缓存中。
如果 SqlSession3 去执行相同 mapper 映射下 sql，执行 commit 提交， 将会清空该 mapper 映射下的二级缓存区域的数据。
sqlSession2 去查询与 sqlSession1 相同的用户信息， 首先会去缓存中找是否存在数据，如果存在直接从缓存中取出数据。

1.2.2 二级缓存开启与关闭

（1）在 mybatis-config.xml 文件开启二级缓存

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

因为 cacheEnabled 的取值默认就为 true，所以这一步可以省略不配置。为 true 代表开启二级缓存；为false 代表不开启二级缓存。
（2）配置相关的 Mapper 映射文件
<cache>标签表示当前这个 mapper 映射将使用二级缓存，区分的标准就看 mapper 的 namespace 值。

<?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.spg.dao.UserDao">
	<!-- 开启二级缓存的支持 -->
	<cache></cache>
</mapper>

（3）配置 statement 上面的 useCache 属性

<!-- 根据 id 查询 -->
<select id="findById" resultType="User" parameterType="int" useCache="true">
	select * from user where id = #{userId}
</select>

将 UserDao.xml 映射文件中的<select>标签中设置 useCache="true"代表当前这个 statement 要使用二级缓存，如果不使用二级缓存可以设置为 false。

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

1.2.3 二级缓存测试

public class SecondLevelCacheTest {
	
	private InputStream in;
	private SqlSessionFactory factory;
	
	@Before//用于在测试方法执行之前执行
	public void init()throws Exception{
		//1.读取配置文件，生成字节输入流
		in = Resources.getResourceAsStream("mybatis-config.xml");
		//2.获取 SqlSessionFactory
		factory = new SqlSessionFactoryBuilder().build(in);
	} 
	
	@After//用于在测试方法执行之后执行
	public void destroy()throws Exception{
		in.close();
	}
	
	/**
	* 测试一级缓存
	*/
	@Test
	public void testFirstLevelCache(){
		SqlSession sqlSession1 = factory.openSession();
		UserDao dao1 = sqlSession1.getMapper(UserDao.class);
		User user1 = dao1.findById(41);
		System.out.println(user1);
		sqlSession1.close();//一级缓存消失
		SqlSession sqlSession2 = factory.openSession();
		UserDao dao2 = sqlSession2.getMapper(UserDao.class);
		User user2 = dao2.findById(41);
		System.out.println(user2);
		sqlSession2.close();
		System.out.println(user1 == user2);
	}
}

测试结果：

- Opening JDBC Connection
- Created connection 187472540.
- Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@b2c9a9c]
- ==>  Preparing: select * from user where id = ? 
- ==> Parameters: 41(Integer)
- <==      Total: 1
com.spg.entity.User@7b02881e
- Resetting autocommit to true on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@b2c9a9c]
- Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@b2c9a9c]
- Returned connection 187472540 to pool.
- Opening JDBC Connection
- Checked out connection 187472540 from pool.
- Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@b2c9a9c]
- ==>  Preparing: select * from user where id = ? 
- ==> Parameters: 41(Integer)
- <==      Total: 1
com.spg.entity.User@3c0be339
- Resetting autocommit to true on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@b2c9a9c]
- Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@b2c9a9c]
- Returned connection 187472540 to pool.
false

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

1.2.4 二级缓存注意事项

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

public class User implements Serializable {
	private Integer id;
	private String username;
	private Date birthday;
	private String sex;
	private String address;
}