MyBatis笔记08 延迟加载与缓存
coconutnut
 2020-04-02 15:54:43      

https://www.bilibili.com/video/BV1Db411s7F5

P60~67

延迟加载

延迟加载：在真正使用数据时才发起查询，不用的时候不查询，按需加载（懒加载）

立即加载：不管用不用，只要一调用方法，马上发起查询

一般一对多、多对多采用延迟加载；多对一、一对一采用立即加载

查官网文档

找到延迟加载的全局开关

在全局配置文件中

1
2
3
4
5
6
<!--配置参数-->
<settings>
  <!--开启Mybatis支持延迟加载-->
  <setting name="lazyLoadingEnabled" value="true"/>
  <setting name="aggressiveLazyLoading" value="false"></setting>
</settings>

一对一实现延迟加载

仍然是IAccountDao的findAll方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<!-- 定义封装account和user的resultMap -->
<resultMap id="accountUserMap" type="account">
  <id property="id" column="id"></id>
  <result property="uid" column="uid"></result>
  <result property="money" column="money"></result>
  <!-- 一对一的关系映射：配置封装user的内容
        select属性指定的内容：查询用户的唯一标识：
        column属性指定的内容：用户根据id查询时，所需要的参数的值
        -->
  <association property="user" column="uid" javaType="user" select="com.itheima.dao.IUserDao.findById"></association>
</resultMap>

<!-- 查询所有 -->
<select id="findAll" resultMap="accountUserMap">
  select * from account
</select>

IUserDao.xml中需要配

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

测试时

1
2
3
4
5
6
7
8
9
@Test
public void testFindAll(){
  List<Account> accounts = accountDao.findAll();
  //        for(Account account : accounts){
  //            System.out.println("--------每个account的信息------------");
  //            System.out.println(account);
  //            System.out.println(account.getUser());
  //        }
}

当把打印用户信息注释掉，调用只findAll()时不会加载每个用户信息

只有实际用到User的时候才会执行查询用户的操作

一对多实现延迟加载

IUserDao.xml中

不再使用left outer join

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<!-- 定义User的resultMap-->
<resultMap id="userAccountMap" type="user">
  <id property="id" column="id"></id>
  <result property="username" column="username"></result>
  <result property="address" column="address"></result>
  <result property="sex" column="sex"></result>
  <result property="birthday" column="birthday"></result>
  <!-- 配置user对象中accounts集合的映射 -->
  <collection property="accounts" ofType="account" select="com.itheima.dao.IAccountDao.findAccountByUid" column="id"></collection>
</resultMap>

<!-- 查询所有 -->
<select id="findAll" resultMap="userAccountMap">
  select * from user
</select>

IAccountDao.xml中需要

1
2
3
4
<!-- 根据用户id查询账户列表 -->
<select id="findAccountByUid" resultType="account">
  select * from account where uid = #{uid}
</select>

实际上都是在要用的时候才去调另一个类中具体的查询方法

缓存

适用于缓存的数据：经常查询且不常修改、数据的正确与否对最终结果影响不大

MyBatis中的一级缓存

指的是MyBatis中的SqlSession对象的缓存

执行查询后，查询结果会同时存入SqlSession提供的一块区域中，改区域的结构是一个Map

再次查询同样的数据时，MyBatis会先去SqlSession中查询是否有结果，有的话直接拿出来用

当SqlSession对象消失时，一级缓存也消失

测试

1
2
3
4
5
6
7
8
9
10
11
12
@Test
public void testFirstLevelCache(){
  // 根据id查询用户
  User user1 = userDao.findById(41);
  System.out.println(user1);

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

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

打印发现user1和user2是同一个，且日志信息中只记录了一次查询

说明user2是直接从缓存中取的

如果在两次查询中关闭SqlSession

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@Test
public void testFirstLevelCache(){
  // 根据id查询用户
  User user1 = userDao.findById(41);
  System.out.println(user1);

  // 关闭并重新获取Session
  sqlSession.close();
  sqlSession = factory.openSession();
  userDao = sqlSession.getMapper(IUserDao.class);
  
  // 再次查询同一用户
  User user2 = userDao.findById(41);
  System.out.println(user2);

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

这次两个对象不同了

sqlSession.clearCache() 可以清缓存，两个对象也不同

触发清空一级缓存的情况

调用SqlSession的修改、添加、删除、提交、关闭等方法时，会清空一级缓存

如在两次查询中更新用户

配置文件中加更新方法

1
2
3
4
<!-- 更新用户信息-->
<update id="updateUser" parameterType="user">
  update user set username=#{username},address=#{address} where id=#{id}
</update>

测试时

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@Test
public void testClearlCache(){
  // 1.根据id查询用户
  User user1 = userDao.findById(41);
  System.out.println(user1);

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

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

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

更新之后再查询，会发起一次新的查询

MyBatis中的二级缓存

指的是MyBatis中SqlSessionFactory对象的缓存，由同一个SqlSessionFactory对象创建的SqlSession共享其缓存

使用步骤：

  1. 让MyBatis框架支持二级缓存（在SqlMapConfig.xml中配置）

    1
    2
    3
    <settings>
      <setting name="cacheEnabled" value="true"/>
    </settings>

    （不配也行，默认是true）

  2. 让当前的映射文件支持二级缓存（在IUserDao.xml中配置）

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

  3. 让当前的操作支持二级缓存（在select标签中配置）

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

测试

1
2
3
4
5
6
7
8
9
10
11
12
13
SqlSession sqlSession1 = factory.openSession();
IUserDao dao1 = sqlSession1.getMapper(IUserDao.class);
User user1 = dao1.findById(41);
System.out.println(user1);
sqlSession1.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);

发现第二次并没有查询，直接从缓存中获取

但是打印结果为false

因为二级缓存中存放的是数据，而不是对象