【MyBatis 】之Mybatis 延迟加载策略-10

最新推荐文章于 2024-07-15 22:27:18 发布

CodeDove

最新推荐文章于 2024-07-15 22:27:18 发布

阅读量137

点赞数

分类专栏： Mybatis 文章标签： mybatis java

本文链接：https://blog.csdn.net/ShangPanGe/article/details/119719300

版权

Mybatis 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

Mybatis

1. Mybatis 延迟加载策略

1. Mybatis 延迟加载策略

1.1 延迟加载

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

1.2 实现需求

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

1.3 使用 assocation 实现延迟加载

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

1.3.1 用户和账户的实体类

package com.spg.entity;

import java.util.Date;
import java.util.List;

public class User {

    private Integer id;
    private String username;
    private String address;
    private String sex;
    private Date birthday;

    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 +
                '}';
    }
}

package com.spg.entity;

public class Account {

    private Integer id;
    private Integer uid;
    private Double money;

    //从表实体应该包含一个主表实体的对象引用
    private User user;

    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }

    public Integer getId() {
        return id;
    }

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

    public Integer getUid() {
        return uid;
    }

    public void setUid(Integer uid) {
        this.uid = uid;
    }

    public Double getMoney() {
        return money;
    }

    public void setMoney(Double money) {
        this.money = money;
    }

    @Override
    public String toString() {
        return "Account{" +
                "id=" + id +
                ", uid=" + uid +
                ", money=" + money +
                '}';
    }
}

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

package com.spg.dao;

import com.spg.entity.Account;
import java.util.List;

/**
 * 账户的持久层接口
 */
public interface AccountDao {
    /**
     * 查询所有账户，同时获取账户的所属用户名称以及它的地址信息
     * @return
     */
    List<Account> findAll();
}

<?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="com.spg.dao.AccountDao">

    <!-- 建立对应关系 -->
    <resultMap type="com.spg.entity.Account" id="accountMap">
        <id column="aid" property="id"/>
        <result column="uid" property="uid"/>
        <result column="money" property="money"/>
        <!-- 它是用于指定从表方的引用实体属性的
			select： 填写我们要调用的 select 映射的 id
			column ： 填写我们要传递给 select 映射的参数
		 -->
        <association property="user" javaType="com.spg.entity.User"
                     select="com.spg.dao.UserDao.findById"
                     column="uid">
        </association>
    </resultMap>

    <select id="findAll" resultMap="accountMap">
        select * from account
    </select>
</mapper>

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

package com.spg.dao;

import com.spg.entity.User;
/**
 * 用户的业务层接口
 */
public interface UserDao {
    /**
     * 根据 id 查询
     * @param userId
     * @return
     */
    User findById(Integer userId);
}

<?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="com.spg.dao.UserDao">
    <!-- 根据 id 查询 -->
    <select id="findById" resultType="com.spg.entity.User" parameterType="int" >
        select * from user where id = #{userId}
    </select>
</mapper>

1.3.4 开启 Mybatis 的延迟加载策略

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<!-- mybatis的主配置文件 -->
<configuration>

    <!-- 配置连接数据库的信息 -->
    <!--<properties url="file:///E:/Users/IdeaProjects/mybatis_idea/mybatis_day02_curd/src/main/resources/jdbcConfig.properties"/>
    --><properties resource="jdbcConfig.properties"/>

    <!-- 开启延迟加载的支持 -->
    <settings>
        <setting name="lazyLoadingEnabled" value="true"/>
        <setting name="aggressiveLazyLoading" value="false"/>
    </settings>

    <!-- 配置环境 -->
    <environments default="mysql">
        <!-- 配置mysql的环境-->
        <environment id="mysql">
            <!-- 配置事务的类型-->
            <transactionManager type="JDBC"/>
            <!-- 配置数据源（连接池） -->
            <dataSource type="POOLED">
                <!-- 配置连接数据库的4个基本信息 -->
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>

    <!-- 指定映射配置文件的位置，映射配置文件指的是每个dao独立的配置文件 -->
    <mappers>
        <mapper resource="mapper/UserDao.xml"/>
        <mapper resource="mapper/AccountDao.xml"/>
    </mappers>

</configuration>

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

package dao;

import com.spg.dao.AccountDao;
import com.spg.entity.Account;
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.InputStream;
import java.util.List;

public class AccountDaoTest {

    private InputStream in ;
    private SqlSessionFactory factory;
    private SqlSession sqlSession;
    private AccountDao accountDao;

    @Before//在测试方法执行之前执行
    public void init() throws Exception {
        //1.读取配置文件
        in = Resources.getResourceAsStream("mybatis-config.xml");
        //2.创建构建者对象
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        //3.创建 SqlSession 工厂对象
        factory = builder.build(in);
        //4.创建 SqlSession 对象
        sqlSession = factory.openSession();
        //5.创建 Dao 的代理对象
        accountDao = sqlSession.getMapper(AccountDao.class);
    }

    @After//在测试方法执行完成之后执行
    public void destroy() throws Exception {
        sqlSession.commit();
        //7.释放资源
        sqlSession.close();
        in.close();
    }

    @Test
    public void findAll1() {
        //6.执行操作
        List<Account> accountList = accountDao.findAll();
    }
}

测试结果：
在这里插入图片描述
因为本次只是将 Account对象查询出来放入 List 集合中，并没有涉及到 User对象，所以就没有发出 SQL 语句查询账户所关联的 User 对象的查询。

1.4 使用 Collection 实现延迟加载

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

1.4.1 在 User 实体类中加入 List属性

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

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

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

1.4.2 编写用户持久层接口和映射文件

package com.spg.dao;

import com.spg.entity.Account;
import com.spg.entity.User;

import java.util.List;

/**
 * 用户的业务层接口
 */
public interface UserDao {
    /**
     * 查询所有用户，同时获取出每个用户下的所有账户信息
     * @return
     */
    List<User> findAll();
}

<?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="com.spg.dao.UserDao">
    <!-- 建立对应关系 -->
    <resultMap type="com.spg.entity.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="com.spg.entity.Account"
                    select="com.spg.dao.AccountDao.findByUid"
                    column="id">
        </collection>
    </resultMap>
    <!-- 配置查询所有操作 -->
    <select id="findAll" resultMap="userMap">
        select * from user
    </select>
</mapper>

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

1.4.3 编写账户持久层接口和映射文件

package com.spg.dao;

import com.spg.entity.Account;
import java.util.List;

/**
 * 账户的持久层接口
 */
public interface AccountDao {
    /**
     * 根据用户 id 查询账户信息
     * @param uid
     * @return
     */
    List<Account> findByUid(Integer uid);
}

<?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="com.spg.dao.AccountDao">

    <!-- 根据用户 id 查询账户信息 -->
    <select id="findByUid" resultType="com.spg.entity.Account" parameterType="int">
        select * from account where uid = #{uid}
    </select>
</mapper>

1.4.5 测试只加载用户信息

package com.spg.dao;

import com.spg.entity.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.InputStream;
import java.util.List;

public class UserDaoTest {

    private InputStream in ;
    private SqlSessionFactory factory;
    private SqlSession sqlSession;
    private UserDao userDao;

    @Before//在测试方法执行之前执行
    public void init() throws Exception {
        //1.读取配置文件
        in = Resources.getResourceAsStream("mybatis-config.xml");
        //2.创建构建者对象
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        //3.创建 SqlSession 工厂对象
        factory = builder.build(in);
        //4.创建 SqlSession 对象
        sqlSession = factory.openSession();
        //5.创建 Dao 的代理对象
        userDao = sqlSession.getMapper(UserDao.class);
    }

    @After//在测试方法执行完成之后执行
    public void destroy() throws Exception {
//        sqlSession.commit();
        //7.释放资源
        sqlSession.close();
        in.close();
    }

    @Test
    public void testFindAll() {
        //6.执行操作
        List<User> users = userDao.findAll();
    }
}

测试结果：
在这里插入图片描述
由运行结果来看并没有加载 Account 账户信息。

CodeDove

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【MyBatis 】之Mybatis 延迟加载策略-10

Mybatis1. Mybatis 延迟加载策略1.1 延迟加载1.2 实现需求1.3 使用 assocation 实现延迟加载1.3.1 账户的持久层接口和映射文件1.3.2 用户的持久层接口和映射文件1.3.3 开启 Mybatis 的延迟加载策略1.3.4 编写测试只查账户信息不查用户信息。1.4 使用 Collection 实现延迟加载1.4.1 在 User 实体类中加入 List属性1.4.2 编写用户持久层接口和映射文件1.4.3 编写账户持久层接口和映射文件1.4.5 测试只加载用户信息1
复制链接

扫一扫