Mybatis延迟加载：association和collection实现延迟加载

Mybatis中的延迟加载，缓存机制

1.Mybatis中的延迟加载
	什么是延迟加载
	什么是立即加载
2.Mybatis中的缓存
	什么是缓存
	为什么使用缓存
	什么样的数据能使用缓存，什么样的数据不能使用缓存
	Mybatis中的一级缓存和二级缓存
3.Mybatis中的注解开发
	环境搭建
	单表CRUD查询(代理Dao方式)
	多表查询操作
	缓存的配置

在延迟加载中，有一个问题：在一对多中，当我们有一个用户，它有100个账户
	在查询用户的时候，要不要把关联的账户查出来？
	在查询账户的时候，要不要把关联的用户查出来？
	
	在查询用户时，用户下的账户信息应该是，什么时候使用，什么时候查询的
	在查询账户时，账户的所属用户信息应该是随着账户查询时一起查询出来的。
	
什么是延迟加载？
	在真正使用数据的时候才发起查询，不用的时候不查询，按需加载(懒加载)
什么是立即加载？
	不管用不用，只要一调用方法，马上发起查询。
在对应的四种表关系中：一对多，多对一，一对一，多对多
	一对多，多对多；通常情况下我们都是采用延迟加载。
	多对一，一对一；通常情况下我们都是采用立即加载。

什么是缓存?
	存在于内存中的临时数据。
为什么使用缓存?
	减少和数据库的交互次数，提高执行效率。
什么样的数据能用缓存，什么样的数据不能使用缓存？
	适用于缓存：
		经常查询并且不经常改变的。
		数据的正确与否对最终结果影响不大的。
	不适用于缓存：
		经常改变的数据
		数据的正确与否对最终结果影响很大的。
		例如：商品的库存，银行的汇率，股市的牌价。
Mybatis中的一级缓存和二级缓存：
	一级缓存：
		它指的是Mybatis中SqlSession对象的缓存。
		当我们执行查询之后，查询的结果会同时存入到SqlSession为我们提供一片区域中。
		该区域的结构是一个Map,当我们再次查询同样的数据，mybatis会先去sqlSession中查询是否有，有的话直接拿出来用。
		当sqlSession对象消失时，mybatis的一级缓存也就消失了。
	二级缓存：
		它指的是Mybatis中SqlSessionFactory对象的缓存，由同一个SqlSessionFactory对象创建的SqlSession共享其缓存。
		二级缓存的使用步骤：
			第一步：让Mybatis框架支持二级缓存(在SqlMapperConfig.xml中配置)
			第二步：让当前的映射配制文件支持二级缓存(在IUserDao.xml中配置)
			第三步：让当前的操作支持二级缓存(在select标签中配置)

什么是延迟加载

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

实现需求

需求：
	查询账户(Account)信息并且关联查询用户(User)信息。如果先查询账户(Account)信息即可满足要求，当我们查询用户(User)信息时再查询用户(User)信息。把对用户(User)信息的按需去查询就是延迟加载。
	mybatis第三天实现多表操作时，我们使用了resultMap来实现一对一，一对多，多对多关系的操作。主要是通过association,collection实现一对一及一对多映射，association,collection具备延迟加载功能。

使用association实现延迟加载

需求：
	查询账户信息的同时查询用户信息。

账户的持久层DAO接口

public interface IAccountDao {
    //查询所有账户,同时还要获取到当前用账户的所属用户信息
    List<Account> findAll();
    //根据用户id查询账户信息
    List<Account> findAccountByUid(Integer uid);
}

账户的持久层映射文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.itheima.dao.IAccountDao">
    <!--定义一个封装account和user的resultMap-->
    <resultMap id="accountMap" 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" resultType="com.itheima.domain.Account">
        select * from account2
    </select>
    <select id="findByUid" resultType="com.itheima.domain.Account" parameterType="java.lang.Integer">
        SELECT * FROM account WHERE uid= #{aid}
    </select>
</mapper>

用户的持久层接口和映射文件

/*
* 用户的持久层接口
* */
public interface IUserDao {
    //查询所有的用户,同时获取到用户下所有账户的信息
    List<User> findAll();
    //查询方法，根据id进行查询用户信息
    User findById(Integer userId);
}
-------------------------------------------------------
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.itheima.dao.IUserDao">
    <!--定义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">
            <id property="id" column="id"></id>
            <result property="uid" column="uid"></result>
            <result property="money" column="money"></result>
        </collection>
    </resultMap>
    <!--查询所有-->
    <select id="findAll" resultType="com.itheima.domain.User">
        select * from user
    </select>
    <!--根据id查询用户-->
    <!--这里需要一个返回值类型，因此得写上resultType-->
    <select id="findById" parameterType="java.lang.Integer" resultType="com.itheima.domain.User">
        select * from user where id=#{uid}
    </select>
</mapper>

开启Mybatis的延迟加载策略

设置名	描述	有效值	默认值
lazyLoadingEnabled	延迟加载的全局开关。当开启时，所有关联对象都会延迟加载。特定关联关系中可通过设置 fetchType属性来覆盖该项的开关状态。	true/false	false
aggressiveLazyLoading	开启时，任一方法的调用都会加载该对象的所有延迟加载属性。否则，每个延迟加载属性会按需加载（参考 lazyLoadTriggerMethods)。	true/false	false

我们需要在Mybatis的配制文件SqlMapperConfig.xml文件中添加延迟加载的配置。
<!--配置参数:开启延迟加载的支持-->
    <settings>
        <!--首先开启mybatis支持延迟加载的开关-->
        <setting name="lazyLoadingEnabled" value="true"/>
        <setting name="aggressiveLazyLoading" value="false"/>
    </settings>

编写测试类只查账户信息不查用户信息

public class MybatisTest {
    private InputStream resourceAsStream;
    private SqlSession sqlSession;
    private IAccountDao accountDao;
    @Before
    public void init() throws IOException {
        //读取配制文件，生成字节输入流
        resourceAsStream = Resources.getResourceAsStream("SqlMapperConfig.xml");
        //获取SqlSessionFactory
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        //获取SqlSession对象
        //如果这里传入一个参数true，那么就可以自动实现提交事务。后面就不需要再commit事务了。
        sqlSession = factory.openSession(true);
        //sqlSession = factory.openSession();
        //获取dao的代理对象
        accountDao = this.sqlSession.getMapper(IAccountDao.class);
    }
    @After
    public void destory() throws IOException {
        //提交事务
        //sqlSession.commit();//这里就不要再提交事务了
        //释放资源
        sqlSession.close();
        resourceAsStream.close();
    }
    //测试查询所有
    @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());
        }
    }
}
测试结果如下：
	我们发现，因为本次只是将Account对象查询出来放入List集合中，并没有涉及到User对象，所以就没有发出SQL语句查询账户所关联的User对象的查询。

使用Collection实现延迟加载

我们在一对多关系配置的<collection>结点中配置延迟加载策略。
<collection>结点中也有select属性，column属性。
需求：
	完成加载用户对象后，查询该账户所拥有的账户信息。

在User实体类中加入List(Account)属性

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

    //一对多关系映射，主表实体应该包含从表实体的集合引用
    private List<Account> accounts;

    public List<Account> getAccounts() {
        return accounts;
    }

    public void setAccounts(List<Account> accounts) {
        this.accounts = accounts;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", address='" + address + '\'' +
                ", sex='" + sex + '\'' +
                ", birthday=" + birthday +
                '}';
    }
}

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

public interface IAccountDao {
    //查询所有账户,同时还要获取到当前用账户的所属用户信息
    List<Account> findAll();
    //根据用户id查询账户信息
    List<Account> findAccountByUid(Integer uid);
}

编写用户持久层映射配置

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.itheima.dao.IUserDao">
    <!--定义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"
                    column="id"
                    select="com.itheima.dao.IAccountDao.findAccountByUid">
        </collection>
    </resultMap>
    <!--查询所有-->
    <select id="findAll" resultType="com.itheima.domain.User">
        select * from user
    </select>

    <!--根据id查询用户-->
    <!--这里需要一个返回值类型，因此得写上resultType-->
    <select id="findById" parameterType="java.lang.Integer" resultType="com.itheima.domain.User">
        select * from user where id=#{uid}
    </select>
</mapper>

-------------------------------------------

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

编写账户持久层映射配置

<!--查询用户id查询账户列表-->
    <select id="findAccountByUid" resultType="com.itheima.domain.Account">
        select a.*,u.username,u.address from account2 a,user u where u.id=a.uid
    </select>

测试只加载用户信息

public class UserTest {
    private InputStream resourceAsStream;
    private SqlSession sqlSession;
    private IUserDao userDao;
    @Before
    public void init() throws IOException {
        //读取配制文件，生成字节输入流
        resourceAsStream = Resources.getResourceAsStream("SqlMapperConfig.xml");
        //获取SqlSessionFactory
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        //获取SqlSession对象
        //如果这里传入一个参数true，那么就可以自动实现提交事务。后面就不需要再commit事务了。
        sqlSession = factory.openSession(true);
        //sqlSession = factory.openSession();
        //获取dao的代理对象
        userDao = this.sqlSession.getMapper(IUserDao.class);
    }
    @After
    public void destory() throws IOException {
        //提交事务
        //sqlSession.commit();//这里就不要再提交事务了
        //释放资源
        sqlSession.close();
        resourceAsStream.close();
    }
    //测试查询所有
    @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());
        }*/
    }
}
测试结果如下：