09.Mybatis延迟加载策略、缓存

Mybatis 延迟加载策略

延迟加载策略说明

• 解释：
    就是在需要用到数据时才进行加载，不需要用到数据时就不加载数据。延迟加载也称懒加载
• 好处：
    先从单表查询，需要时再从关联表去关联查询，大大提高数据库性能，因为查询单表要比关联查询多张表速度要快
• 坏处：
    因为只有当需要用到数据时，才会进行数据库查询，这样在大批量数据查询时，因为查询工作也要消耗时间，所以可能造成用户等待时间变长，造成用户体验下降
• 需求：
    查询账户(Account)信息并且关联查询用户(User)信息。如果先查询账户(Account)信息即可满足要 求，当我们需要查询用户(User)信息时再查询用户(User)信息。把对用户(User)信息的按需去查询就是延迟加载
    实现多表操作时，我们使用了resultMap来实现一对一，一对多，多对多关系的操作。主要是通过 association、collection 实现一对一及一对多映射。association、collection 具备延迟加载功能

使用 assocation 实现延迟加载（查询账户信息同时查询用户信息）

• 定义账户信息的实体类

	@Date
	public class Account implements Serializable{
		private Integer id;
		private Integer uid;
		private Double money;
		// 加入User实体类
		private User user; 
	}

• 账户的持久层 DAO 接口

	public interface IAccountUserDao {
		List<Account> findAll();
	}

	public interface IUserDao{
		// 类型是Account
		List<User> findByUserId(Integer id);
	}

• 账户的持久层映射文件

    <resultMap id="accountMap" type="account">
        <id property="id" column="aid"/>
        <result property="uid" column="uid"/>
        <result property="money" column="money"/>
        <!--select：填写我们要调用的 select 映射的 id-->
        <!--column：填写我们要传递给 select 映射的参数-->
        <association property="user" javaType="user" column="uid" select="com.zsc.dao.IUserDao.findByUserId">
        </association>
    </resultMap>
    <select id="findAll" resultMap="accountMap">
        SELECT a.id as aid ,a.uid,a.money FROM  `account` a
    </select>

	<!--com.zsc.dao.IUserDao包下-->
    <select id="findByUserId" resultType="User" parameterType="java.lang.Integer">
        select * from user
        <where>
            <if test="id != null">
                    id = #{id}
            </if>
        </where>
    </select>

• 开启 Mybatis 的延迟加载策略（SqlMapConfig.xml 文件中添加延迟加载的配置）

    <settings>
        <!--开启Mybatis支持延迟加载-->
        <setting name="lazyLoadingEnabled" value="true"/>
        <setting name="aggressiveLazyLoading" value="false"></setting>
        <!--开启二级缓存-->
        <setting name="cacheEnabled" value="true"/>
    </settings>

使用 Collection 实现延迟加载（查询该用户所拥有的账户信息）

• 定义用户信息的实体类

	@Data
	public class User implements Serializable {
	    private Integer id;
	    private String username;
	    private Date birthday;
	    private String sex;
	    private String address;
	    private List<Account> accounts;
	}

• 编写用户和账户持久层接口的方法

	public interface IAccountUserDao{
		List<User> findAll();
	}

	public interface IAccountDao{
		List<Account> findByUid();
	}

• 编写用户持久层映射配置

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

	<select id="findByUid" resultType="account" parameterType="int">  
		select * from account where uid = #{uid} 
	</select> 

• 开启延时加载和上面 assocation 一样

延时加载分析

• 这里只获取Account的id来测试延时加载的效果
  
• 没有使用延迟加载的日志
  
• 配置延时加载，当 aggressiveLazyLoading = “true”
  
• 配置延时加载，当 aggressiveLazyLoading = “false”
  
• 分析：参考lazyLoadingEnabled和aggressiveLazyLoading的使用
    当没有配置延时加载时，不管是否需要user的数据，两条sql语句的全部加载，封装完全部数据之后再输出
    当 aggressiveLazyLoading = "true"时，先一条 sql 获取到数据后再通过uid来获取user的数据再封装，不管是否需要user的数据，当获取一个uid就查询一次user的数据，我的理解是每获取一条user的数据就封装一次
    当 aggressiveLazyLoading = “false”，用的时候才去执行相应的sql

缓存

一级缓存

• 一级缓存是 SqlSession 级别的缓存，只要 SqlSession 没有 flush 或 close，它就存在
• 一级缓存是 SqlSession 范围的缓存，当调用 SqlSession 的修改，添加，删除，commit()，close()等方法时，就会清空一级缓存
• 存储的是对象
• 图示：
  
• 分析：
  1. 第一次发起查询用户 id 为 1 的用户信息，先去找缓存中是否有 id 为 1 的用户信息，如果没有，从数据库查询用户信息
  2. 得到用户信息，将用户信息存储到一级缓存中
  3. 如果 sqlSession 去执行 commit 操作（执行插入、更新、删除），清空 SqlSession 中的一级缓存，这样做的目的为了让缓存中存储的是最新的信息，避免脏读
  4. 第二次发起查询用户 id 为 1 的用户信息，先去找缓存中是否有 id 为 1 的用户信息，缓存中有，直接从缓存中获取用户信息

二级缓存

• 二级缓存是 mapper 映射级别的缓存，多个 SqlSession 去操作同一个 Mapper 映射的 sql 语句，多个 SqlSession 可以共用二级缓存，二级缓存是跨 SqlSession 的
• 存储的是数据
• 注意：实体类一定要实现 java.io.Serializable 接口
• 第一步：在 SqlMapConfig.xml 文件开启二级缓存

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

• 第二步：配置相关的 Mapper 映射文件

<mapper namespace="com.zsc.dao.IUserDao">
    <!--开启二级缓存-->
    <cache/>
</mapper>

• 第三步：配置 statement 上面的 useCache 属性

    <select id="findAll" resultType="User" useCache="true">
        select * from user
    </select>

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