Mybatis（八）——延迟加载+缓存-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_41553240/article/details/109102599

本文详细介绍了MyBatis中的延迟加载机制，包括association和collection标签的使用，以及延迟加载的三种类型。同时，分析了一级缓存的工作原理和清除缓存的方法，以及在更新数据后的查询行为。此外，还探讨了二级缓存的启用、关闭以及在不同SqlSession间的数据同步问题。二级缓存的使用需要注意类的序列化。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

延迟加载：

<collection property="accounts"
                    ofType="account"
        select="com.itheima.dao.IAccountDao.findAccountByUid"
        column="id"/>

<association property="user" column="uid"
                    javaType="user"
                    select="com.itheima.dao.IUserDao.findById"/>
       <!-- column 传入 select的参数，select  -->

执行一次

这三个是最关键的步骤，第一步，开启延迟加载，在mybatis配置文件中配置

第二步：根据情况：

如果是一对一，就用association

如果是一对多或多对多用 collection

这两个标签中都有

select 属性，关联其他mapper的查询操作，等于联合查询，

column 属性 select 所调用的 dao接口方法的参数值

原理：使用CGLIB为目标对象建立代理对象，当调用目标对象的方法时进入拦截器方法。比如调用a.getb().getName(),拦截器方法invoke()发现a.getb()为null值，会单独发送事先保存好的查询关联b对象的sql语句，把b查询上来然后调用a.setB(b),于是a的对象的属性b就有值了，然后接着调用a.getb().getName(),这就是延迟加载的原理。

注意：

MyBatis根据对关联对象查询的select语句的执行时机，分为三种类型：直接加载、侵入式延迟加载与深度延迟加载。

直接加载：执行完对主加载对象的 select 语句，马上执行对关联对象的 select 查询。
侵入式延迟：执行对主加载对象的查询时，不会执行对关联对象的查询。但当要访问主加载对象的详情属性时，就会马上执行关联对象的select查询。
深度延迟：执行对主加载对象的查询时，不会执行对关联对象的查询。访问主加载对象的详情时也不会执行关联对象的select查询。只有当真正访问关联对象的详情时，才会执行对关联对象的 select 查询。

需要注意的是，延迟加载的应用要求，关联对象的查询与主加载对象的查询必须是分别进行的 select 语句，不能是使用多表连接所进行的select查询。因为多表连接查询，其实质是对一张表的查询，对由多个表连接后形成的一张表的查询。会一次性将多张表的所有信息查询出来。
MyBatis中对于延迟加载设置，只对于resultMap中的collection和association起作用，可以应用到一对一、一对多、多对一、多对多的所有关联关系查询中。

一级缓存：

<!-- 根据id查询用户 -->
    <select id="findById" parameterType="INT" resultType="user" useCache="true">
        select * from user where id = #{uid}
    </select>

@Test
    public void testFindById(){
        User user = userDao.findById(41);
        System.out.println("第一次查询的用户："+user);

        User user2 = userDao.findById(41);

        System.out.println("第二次查询的用户："+user2);
        System.out.println(user == user2);
    }

只查询了一次，useCache=”true” 开启了缓存

分析：

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

执行步骤：

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

/**
     * 测试一级缓存，清除
     */
    @Test
    public void testFirstLevelCache(){
        User user1 = userDao.findById(41);
        System.out.println(user1);

        /**
         * sqlSession.close();
         * sqlSession = factory.openSession();
         */
        sqlSession.clearCache();
        userDao = sqlSession.getMapper(IUserDao.class);

        User user2 = userDao.findById(41);
        System.out.println(user2);
        System.out.println(user1 == user2);
    }

清除缓存后，再重新进行数据库查询

/**
     * cache的同步
     */
    @Test
    public void testClearlCache(){
        User user1 = userDao.findById(41);
        System.out.println(user1);

        /*
            更新用户信息
         */
        user1.setUsername("update user clear cache");
        user1.setAddress("北京市海淀区");
        userDao.updateUser(user1);

        //再次查询id为41的用户
        User user2 = userDao.findById(41);
        System.out.println(user2);

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

更新数据后，再次查询将会重新从数据库查询

二级缓存

首先开启 mybatis 的二级缓存。
sqlSession1 去查询用户信息，查询到用户信息会将查询数据存储到二级缓存中。

如果 SqlSession3 去执行相同 mapper 映射下 sql，执行 commit 提交，将会清空该 mapper 映射下的二级缓存区域的数据。

sqlSession2 去查询与 sqlSession1 相同的用户信息，首先会去缓存中找是否存在数据，如果存在直接从缓存中取出数据。

二级缓存的开启与关闭

package com.itheima.test;

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

public class SecondLevelCacheTest {
    private InputStream in;
    private SqlSessionFactory factory;

    @Before
    public void init() throws IOException {
        in = Resources.getResourceAsStream("SqlMapConfig.xml");

        factory = new SqlSessionFactoryBuilder().build(in);
    }

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

    //测试一级缓存
    @Test
    public void testFirstLevelCache(){
        SqlSession sqlSession = factory.openSession();
        IUserDao dao1 = sqlSession.getMapper(IUserDao.class);
        User user1 = dao1.findById(41);
        System.out.println(user1);
        sqlSession.close(); //一级缓存小时

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

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

第二次查询，并没有执行 sql语句，而是直接从pool中拿取数据，这个数据就是来自我们所说的二级缓存

注意事项：

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