Mybatis学习之路 第四篇

Mybatis学习之路 第四篇

• 在第前三篇的基础上，我们继续学习，增加新的功能。
• 本文涉及以下内容：

  1. Mybatis的延时加载策略 。

  2. Mybatis的一级缓存和二级缓存 。

---

1. Mybatis的延时加载策略

• 通过前面的学习，我们已经掌握了 Mybatis 中一对一，一对多，多对多关系的配置及实现，可以实现对象的关联查询。实际开发过程中很多时候我们并不需要总是在加载用户信息时就一定要加载他的账户信息。此时就是我们所说的延迟加载。

1.1 延时加载相关用法和条件

1.1.1 什么是延时加载？什么是立即加载？

• 延时加载就是在需要用到数据时才进行加载，不需要用到数据时就不加载数据。延迟加载也称懒加载。
• 好处：先从单表查询，需要时再从关联表去关联查询，大大提高数据库性能，因为查询单表要比关联查询多张表速
  度要快。
• 坏处：因为只有当需要用到数据时，才会进行数据库查询，这样在大批量数据查询时，因为查询工作也要消耗
  时间，所以可能造成用户等待时间变长
• 立即加载就是不管用不用，只要一调用方法，马上发起查询。

1.1.2 应用的范围

• 一对多，多对多：通常情况下我们都是采用延时加载。
• 多对一，一对一：通常情况下我们都是采用立即加载。

1.1 一对一的延时加载

• 在Account中查找User，所以Account类中要添加User的实体类

1. Account类的代码如下,省略get、set等方法：

   public class Account implements Serializable {
       private Integer id;
       private Integer uid;
       private Double money;
       //从表实体应该包含一个主表实体的对象引用
       private User user;
   }

   2. User类的代码如下，省略get、set等方法：

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

2. IUserDao接口代码如下：

   public interface IUserDao {
       /**
        * 查询所有用户
        * @return
        */
       User findById(Integer userId);
   }

3. IUserDao.xml增加如下代码：

   <select id="findById" parameterType="INT" resultType="User">
       select * from user where id = #{uid};
   </select>

4. 在SqlMapConfig.xml中配置延时加载的参数，在configuretion标签下，增加部分如下：

   <!--配置参数-->
   <settings>
       <!--开启Mybatis支持延时加载-->
       <setting name="lazyLoadingEnabled" value="true"/>
       <setting name="aggressiveLazyLoading" value="false"/>
   </settings>

5. IAccountDao.xml代码如下：

   <!-- 定义封装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="fang.dao.IUserDao.findById"/>
   </resultMap>
   
   <!-- 查询所有 -->
   <select id="findAll" resultMap="accountUserMap">
       select * from account
   </select>

6. AccountTest测试代码如下：

   /**
    * 测试查询所有
    */
   @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());
       }
   }

• 这里的代码中，User部分只有用到的时候才会被加载出来。

---

1.1 一对多的延时加载

• 在User中查找多个Account，所以User类中要添加Account的实体类

1. 在User中代码如下,省略get、set等方法：

   public class User implements Serializable {
       private Integer id;
       private String username;
       private Date birthday;
       private String sex;
       private String address;
       //一对多关系映射：主表实体应该包含从表实体的集合引用
       private List<Account> accounts;
   }

2. 在Account中代码如下：

   public class Account implements Serializable {
       private Integer id;
       private Integer uid;
       private Double money;
   }

3. 在IAccountDao接口中添加如下接口：

   /**
    * 根据用户id查询账户列表
    * @param uid
    * @return
    */
   List<Account> findAccountByUid(Integer uid);

4. 在IAccountDao.xml添加如下部分：

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

5. 在IUserDao.xml中添加如下部分：

   <resultMap id="userAccountMap" type="user">
       <id property="id" column="id"/>
       <result property="username" column="username"/>
       <result property="address" column="address"/>
       <result property="sex" column="sex"/>
       <result property="birthday" column="birthday"/>
       <!--collection 是用于建立一对多中集合属性的对应关系ofType 用于指定集合元素的数据类型-->
       <!--select 是用于指定查询账户的唯一标识（账户的 dao 全限定类名加上方法名称）-->
       <!--column 是用于指定使用哪个字段的值作为条件查询-->
       <collection property="accounts" ofType="Account" column="id" select="fang.dao.IAccountDao.findAccountByUid"/>
   </resultMap>
   
   <select id="findAll" resultMap="userAccountMap">
       select * from user
   </select>

• < collection>标签：主要用于加载关联的集合对象
• select属性：用于指定查询 account 列表的 sql 语句，所以填写的是该 sql 映射的 id
• column属性：用于指定 select 属性的 sql 语句的参数来源，上面的参数来自于 user 的 id 列，所以就写成 id 这一
  个字段名了

6. SqlMapConfig.xml中的settings标签配置信息和上面一样。
7. 编写UserTest测试类如下：

   /**
    * 测试查询所有操作
    */
   @Test
   public void testFindAll() {
       List<User> users = userDao.findAll();
       for(User user: users) {
           System.out.println("====================");
           System.out.println(user);
           System.out.println(user.getAccounts());
       }
   }

• 这里的Account是按需加载，没用到时不会加载。

2. Mybatis的一级缓存和二级缓存

2.1 一级缓存

• 一级缓存是 SqlSession 级别的缓存，只要 SqlSession 没有 flush 或 close，它就存在。
• 当我们执行查询之后，查询的结果会同时存入到SqlSession为我们提供的一块区域中。该区域是一个Map。当我们再次查询同样的数据，mybatis会先去sqlsession中查询是否存在，有的话直接拿来用。
• 当调用 SqlSession 的修改，添加，删除，commit()，close()等方法时，就会清空一级缓存。

1. 在UserTest测试类中测试：

• user和user2是一样的，证明一级缓存存在。

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

2. 测试一级缓存的清空：

   @Test
   public void testClearCache() {
       User user = userDao.findById(41);
       System.out.println("第一次查询的用户："+user);
       
       //sqlSession.close();
       //再次获取 SqlSession 对象
       //sqlSession = factory.openSession();
       
       sqlSession.clearCache();//此方法也可以清空缓存
       
       userDao = sqlSession.getMapper(IUserDao.class);
       User user2 = userDao.findById(41);
       System.out.println("第二次查询用户："+user2);
       System.out.println(user == user2);
   }

3. 调用修改，添加，删除，commit()，close()等方法时，就会清空一级缓存：

   @Test
   public void testClearCache() {
       User user = userDao.findById(41);
       System.out.println("第一次查询的用户："+user);
   
       user.setUsername("haha");
       user.updateUser(user);
       
       User user2 = userDao.findById(41);
       System.out.println("第二次查询用户："+user2);
       System.out.println(user == user2);
   }

• 此时user与user2不再相等。

---

2.2 二级缓存

• 二级缓存是 mapper 映射级别的缓存，多个 SqlSession 去操作同一个 Mapper 映射的 sql 语句，多个SqlSession 可以共用二级缓存，二级缓存是跨 SqlSession 的。
• 二级缓存指的是Mybatis中SqlSessionFactory对象的缓存。由同一个SqlSessionFactory对象创建的SqlSession共享其缓存。
• 二级缓存的使用步骤：
  • 第一步：让Mybatis框架支持二级缓存（在SqlMapConfig.xml中配置）
  • 第二步：让当前的映射文件支持二级缓存（在IUserDao.xml中配置）
  • 第三步：让当前的操作支持二级缓存（在select标签中配置）

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

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

2. 第二步和第三步：让当前的映射文件支持二级缓存（在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="fang.dao.IUserDao">
       <!--开启user支持二级缓存-->
       <cache/>
       <!--根据id查询用户信息-->
       <!--因为传入的参数就一个，所以这里的uid可以随便写名称-->
       <select id="findById" parameterType="INT" resultType="User" useCache="true">
           select * from user where id = #{uid};
       </select>
   
   </mapper>

3. UserTest测试代码部分：

   /**
    * 测试二级缓存
    */
   @Test
   public void testFirstLevelCache(){
       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);
   }

• 经过上面的测试，我们发现执行了两次查询，并且在执行第一次查询后，我们关闭了一级缓存，再去执行第二次查询时，我们发现并没有对数据库发出 sql 语句，所以此时的数据就只能是来自于我们所说的二级缓存。
• 上面结果仍然为false，是由于二级缓存保存的是数据，不是对象。
• 当我们在使用二级缓存时，所缓存的类一定要实现 java.io.Serializable 接口，这种就可以使用序列化方式来保存对象。

---