MyBatis缓存概述：一级缓存和二级缓存

最新推荐文章于 2024-05-06 16:43:07 发布

Jasonix

最新推荐文章于 2024-05-06 16:43:07 发布

阅读量210

点赞数 1

分类专栏： MyBatis学习 MyBatis MyBatis缓存文章标签： MyBatis 缓存 MyBatis缓存一级缓存二级缓存

本文链接：https://blog.csdn.net/weixin_43168190/article/details/103219816

版权

MyBatis学习同时被 3 个专栏收录

3 篇文章 0 订阅

订阅专栏

MyBatis

3 篇文章 0 订阅

订阅专栏

MyBatis缓存

1 篇文章 0 订阅

订阅专栏

MaBatis缓存概述

什么是缓存

存在内存中的临时数据

为什么使用缓存

减少和数据库的交互次数，提高执行效率

什么样的数据适合使用缓存

经常查询，且不经常改变，并且数据的正确与否对最终结果影响不大的。

MyBatis中的一级缓存和二级缓存

一级缓存

概述

它指MyBatis中SqlSession对象的缓存。当我们执行查询之后，查询的结果会同时存入到SqlSession为我们提供的一块区域中。该区域的结构是一个Map。当我们再次查询同样的数据时，MyBatis会先去查询SqlSession中是否已有，如果有就直接拿出来用。如果SqlSession对象消失时，MyBatis的一级缓存也就消失了。

代码实现

首先使用这篇文章中的代码搭建好环境，这里使用xml配置方法。
IDEA 2019 MyBatis环境搭建及入门案例（使用xml方式和注解方式配置）

需要加一些方法，在IUserDao中加入更新数据的方法，如update，insert

package com.cjx.dao;

import com.cjx.entity.User;

import java.util.List;

/**
 * @author ：
 * @date ：Created in 2019/11/8 22:45
 * @description ： dao
 */
public interface IUserDao {
    /**
     * @author      ：
     * @description ：查询所有
     * @param       : []
     * @return      : java.util.List<com.cjx.entity.User>
     * @date        ：Created in 2019/11/8
     */
    List<User> findAll();

    /**
     * @author      ：
     * @description ：保存用户，可以获取自增的id
     * @param       : [user]
     * @return      : void
     * @date        ：Created in 2019/11/8
     */
    void saveUser(User user);

    /**
     * @author      ：
     * @description ：更新用户
     * @param       : [user]
     * @return      : void
     * @date        ：Created in 2019/11/8
     */
    void updateUser(User user);

    /**
     * @author      ：
     * @description ：根据id删除用户
     * @param       : [id]
     * @return      : void
     * @date        ：Created in 2019/11/8
     */
    void deleteUser(int id);

    /**
     * @author      ：
     * @description ：查询一个
     * @param       : [id]
     * @return      : com.cjx.entity.User
     * @date        ：Created in 2019/11/8
     */
    User findById(int id);

    /**
     * @author      ：
     * @description ：根据名称模糊查询用户信息
     * @param       : [username]
     * @return      : java.util.List<com.cjx.entity.User>
     * @date        ：Created in 2019/11/8
     */
    List<User> findByName(String username);

    /**
     * @author      ：
     * @description ：查询总用户数
     * @param       : []
     * @return      : int
     * @date        ：Created in 2019/11/8
     */
    int findTotal();
}

IUserDao.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.cjx.dao.IUserDao">


    <!-- 当实体类属性和数据库列名不一致时，配置查询结果的列名和实体类的列名对应关系 -->
    <resultMap id="userMap" type="com.cjx.entity.User">
        <!-- 配置主键字段对应 -->
        <id property="userId" column="id"/>
        <!-- 配置非主键字段对应 -->
        <result property="userSex" column="sex"/>
    </resultMap>
    <!-- 有了这个以后下面的resultType就没用了，要用resultMap -->


    <!-- 配置查询所有 -->
<!--    <select id="findAll" resultType="com.cjx.entity.User">-->
    <select id="findAll" resultMap="userMap">
        select * from user;
    </select>

    <!-- 配置保存用户 -->
    <insert id="saveUser" parameterType="com.cjx.entity.User">
        <!-- 配置插入操作后获取key -->
<!--        <selectKey keyProperty="id" keyColumn="id" resultType="int" order="AFTER">-->
        <selectKey keyProperty="userId" keyColumn="id" resultType="int" order="AFTER">
            select last_insert_id();
        </selectKey>
        insert into user(username, birthday, sex, address) values(#{username},#{birthday},#{userSex},#{address});
    </insert>

    <!-- 配置更新用户 -->
<!--    <update id="updateUser" parameterType="com.cjx.entity.User">-->
    <update id="updateUser" parameterType="com.cjx.entity.User">
        update user set username = #{username}, address = #{address}, sex = #{userSex}, birthday = #{birthday} where id = #{userId};
    </update>

    <delete id="deleteUser" parameterType="int">
        delete from user where id = #{id};
    </delete>

<!--    <select id="findById" parameterType="int" resultType="com.cjx.entity.User">-->
    <select id="findById" parameterType="int" resultMap="userMap">
        select * from user where id = #{id};
    </select>

<!--    <select id="findByName" parameterType="String" resultType="com.cjx.entity.User">-->
    <select id="findByName" parameterType="String" resultMap="userMap">
        select * from user where username like #{username};
    </select>

    <select id="findTotal" resultType="int">
        select COUNT(user.id) from user;
    </select>
</mapper>

这里为了比较两次取出的user对象，删掉重写的toString方法。
然后创建如下测试类：

package com.cjx.test;

import com.cjx.dao.IUserDao;
import com.cjx.entity.QueryVo;
import com.cjx.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;
import java.util.Date;
import java.util.List;

/**
 * @author ：
 * @date ：Created in 2019/11/8 22:54
 * @description ： test
 */
public class MybatisTest {
    private InputStream in;
    private SqlSession session;
    private IUserDao userDao;

    @Before
    public void init() throws Exception{
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        session = factory.openSession();
        userDao = session.getMapper(IUserDao.class);
    }

    @After
    public void destroy() throws Exception{
        session.close();
        in.close();
    }

    @Test
    public void testFirstLevelCache(){
        User user1 = userDao.findById(1);
        System.out.println(user1);
        User user2 = userDao.findById(1);
        System.out.println(user2);

        System.out.println(user1 == user2);
    }
}

运行结果如下：
在这里插入图片描述
可以发现这两个user是完全一样的。
再看看详细的日志信息：

整个过程中只执行了一次sql语句的查询。
如果把SqlSession重新启动，结果又会是如何呢，把测试函数改为以下代码：（factory自行改为类变量）

    @Test
    public void testFirstLevelCache(){
        User user1 = userDao.findById(1);
        System.out.println(user1);
        //关闭SqlSession对象
        session.close();
        //再次获取
        session = factory.openSession();
        userDao = session.getMapper(IUserDao.class);
        User user2 = userDao.findById(1);
        System.out.println(user2);

        System.out.println(user1 == user2);
    }

结果如下：
在这里插入图片描述
可以看到两个对象不同了，并且执行了两次sql语句。这就说明一级缓存消失了。如果不想关闭再开启，session.clearCache()方法也可以清空缓存，有相同的效果。

触发情况一级缓存的情况

调用SqlSession的修改、添加、删除、commit()、close()等方法时，就会清空一级缓存。（还有上面讲的clearCache()方法）

二级缓存

概述

它指MyBatis中SqlSessionFactory对象的缓存。由同一个SqlSessionFactory对象创建的SqlSession共享缓存。

使用步骤

让MyBatis框架支持二级缓存。在SqlMapConfig.xml中Configuration标签下配置settings。

	<settings>
        <setting name="cacheEnabled" value="true"/>
    </settings>

让当前的映射文件支持二级缓存。在IUserDao.xml中mapper标签下配置。

    <!-- 开启支持二级缓存 -->
    <cache/>

让当前的操作支持二级缓存。在select标签中配置属性useCache为true。

   <select id="findAll" resultMap="userMap" useCache="true">
        select * from user;
    </select>

测试是否成功

新建一个测试类

package com.cjx.test;

import com.cjx.dao.IUserDao;
import com.cjx.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;

/**
 * @author ：
 * @date ：Created in 2019/11/25 22:01
 * @description ： 二级缓存
 */
public class SecondCacheTest {

    private InputStream in;
    private SqlSessionFactory factory;

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

    @After
    public void destroy() throws Exception{
        in.close();
    }

    @Test
    public void testSecondLevelCache(){
        SqlSession session1 = factory.openSession();
        IUserDao dao1 = session1.getMapper(IUserDao.class);
        User user1 = dao1.findById(1);
        System.out.println(user1);
        session1.close();

        SqlSession session2 = factory.openSession();
        IUserDao dao2 = session2.getMapper(IUserDao.class);
        User user2 = dao2.findById(1);
        System.out.println(user2);
        session2.close();

        System.out.println(user1 == user2);
    }

}

运行结果如下：
测试结果
可以看到只执行了一次sql语句，下面这个是从缓存获取。
但是为什么user1 == user2的值是false？
因为二级缓存存放的内容是数据而不是对象，比如{“id”:“1”,“name”:“user”}，他取二级缓存是就是取出数据，对象还是会重新生成的。

Jasonix

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
MyBatis缓存概述：一级缓存和二级缓存

MyBatis缓存MaBatis缓存概述什么是缓存为什么使用缓存什么样的数据适合使用缓存MyBatis中的一级缓存和二级缓存一级缓存MaBatis缓存概述什么是缓存存在内存中的临时数据为什么使用缓存减少和数据库的交互次数，提高执行效率什么样的数据适合使用缓存经常查询，且不经常改变，并且数据的正确与否对最终结果影响不大的。MyBatis中的一级缓存和二级缓存一级缓存它指...
复制链接

扫一扫