MyBatis声明式延迟加载

最新推荐文章于 2024-10-08 13:19:19 发布
最新推荐文章于 2024-10-08 13:19:19 发布
阅读量101 收藏
点赞数
文章标签： mybatis java xml
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43625140/article/details/107865777
版权

1. 延迟加载

描述：延迟加载又名懒加载、按需加载，即我们需要这个数据的时候才去加载这个数据。在MyBatis框架中通过设置或标签的fetchType属性值为lazy来指按需加载。

需求：在用户与账户一对一关联查询的基础上，查询指定用户信息及其账户信息，对账户信息的查询实现延迟加载。

2. 数据库环境

2.1 表的创建

# 创建用户表
CREATE TABLE IF NOT EXISTS `user`(
  `id` INT AUTO_INCREMENT,
  `username` VARCHAR(32) NOT NULL,
  `birthday` DATETIME NOT NULL,
  `sex` CHAR(1) NOT NULL,
  `address` VARCHAR(256),
  CONSTRAINT pk_user PRIMARY KEY(`id`)
);

# 添加用户数据
INSERT  INTO `user`(`id`,`username`,`birthday`,`sex`,`address`) VALUES 
(NULL,'周瑜','2020-02-27 17:47:08','男','吴国'),
(NULL,'大乔','2020-02-27 15:09:37','女','吴国'),
(NULL,'小乔','2020-02-27 11:34:34','女','吴国'),
(NULL,'陆逊','2020-02-27 12:04:06','男','吴国'),
(NULL,'孙策','2020-02-27 17:37:26','男','东吴'),
(NULL,'孙尚香','2020-02-27 11:44:00','女','吴国'),
(NULL,'曹操','2020-07-29 16:36:26','男','魏国');

# 创建账户表
CREATE TABLE IF NOT EXISTS `account`(
  `id` INT AUTO_INCREMENT,
  `user_id` INT NOT NULL,
  `money` DOUBLE NOT NULL,
  CONSTRAINT pk_account PRIMARY KEY(`id`),
  CONSTRAINT fk_account_user FOREIGN KEY(`user_id`) REFERENCES `user`(`id`)
);

# 添加账户数据
INSERT  INTO `account`(`id`,`user_id`,`money`) VALUES 
(1,6,1000),
(2,3,1000),
(3,1,2000);

2.2 表与表的关系

在这里插入图片描述

3. 用户实体类

package zw.mybatis.bean.domain;

import java.io.Serializable;
import java.util.Date;

/**
 * @className UserDO
 * @description 用户实体类
 * @author 周威
 * @date 2020-07-31 14:14
 **/
public class UserDO implements Serializable
{
    /* 用户编号 */
    private Integer id;
    /* 用户姓名 */
    private String userName;
    /* 用户生日 */
    private Date birthday;
    /* 用户性别 */
    private String sex;
    /* 用户地址 */
    private String address;

    /* Getter和Setter方法 */
    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 Date getBirthday()
    {
        return birthday;
    }

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

    public String getSex()
    {
        return sex;
    }

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

    public String getAddress()
    {
        return address;
    }

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

    /* toString()方法 */
    @Override
    public String toString()
    {
        return "UserDO{" + "id=" + id + ", userName='" + userName + '\'' + ", birthday=" + birthday + ", sex='" + sex + '\'' + ", address='" + address + '\'' + '}';
    }
}

4. 账户实体类

package zw.mybatis.bean.domain;

import java.io.Serializable;

/**
 * @className AccountDO
 * @description 账户实体类
 * @author 周威
 * @date 2020-08-07 14:03
 **/
public class AccountDO implements Serializable
{
    /* 账户编号 */
    private Integer id;
    /* 用户编号 */
    private Integer userId;
    /* 账户金额 */
    private Double money;

    /* Getter和Setter方法 */
    public Integer getId()
    {
        return id;
    }

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

    public Integer getUserId()
    {
        return userId;
    }

    public void setUserId(Integer userId)
    {
        this.userId = userId;
    }

    public Double getMoney()
    {
        return money;
    }

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

    /* toString()方法 */
    @Override
    public String toString()
    {
        return "AccountDO{" + "id=" + id + ", userId=" + userId + ", money=" + money + '}';
    }
}

5. 用户展示实体类

package zw.mybatis.bean.vo;

import zw.mybatis.bean.domain.AccountDO;
import zw.mybatis.bean.domain.UserDO;
import java.io.Serializable;

/**
 * @className UserVO
 * @description 用户展示实体类
 * @author 周威
 * @date 2020-08-03 18:31
 **/
public class UserVO extends UserDO implements Serializable
{
    /* 账户信息 */
    private AccountDO accountDO;

    /* Getter和Setter方法 */
    public AccountDO getAccountDO()
    {
        return accountDO;
    }

    public void setAccountDO(AccountDO accountDO)
    {
        this.accountDO = accountDO;
    }

    /* toString()方法 */
    @Override
    public String toString()
    {
        return "UserVO{userDO="+ super.toString() + "accountDO=" + accountDO + '}';
    }
}

6. 账户持久层接口

package zw.mybatis.mapper;

import zw.mybatis.bean.domain.AccountDO;

/**
 * @className AccountMapper
 * @description 账户持久层接口
 * @author 周威
 * @date 2020-08-07 14:06
 **/
public interface AccountMapper
{
    /**
     * 查询账户信息，根据用户编查询指定账户信息
     * @param userId
     * @return 账户信息
     */
    AccountDO findAccountInformationByUserId(Integer userId);
}

7. 账户映射文件

<?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="zw.mybatis.mapper.AccountMapper">
    <!-- 输出映射 -->
    <resultMap id="accountDOResultMap" type="zw.mybatis.bean.domain.AccountDO">
        <id column="id" property="id" javaType="java.lang.Integer"/>
        <result column="userId" property="userId" javaType="java.lang.Integer"/>
        <result column="money" property="money" javaType="java.lang.Double"/>
    </resultMap>

    <!-- 查询账户信息，根据用户编查询指定账户信息 -->
    <select id="findAccountInformationByUserId" parameterType="java.lang.Integer" resultMap="accountDOResultMap">
        select
         id id,
         user_id userId,
         money money
        from
         account
        where
         user_id = #{userId}
    </select>
</mapper>

8. 用户持久层接口

package zw.mybatis.mapper;

import zw.mybatis.bean.vo.UserVO;

/**
 * @className UserMapper
 * @description 用户持久层接口
 * @author 周威
 * @date 2020-07-31 14:18
 **/
public interface UserMapper
{
    /**
     * 查询用户信息，根据用户编号查询用户信息及其账户信息，实现账户信息查询的延迟加载
     * @param userId
     * @return 用户信息
     */
    UserVO findUserInformationAndAccountByUserId(Integer userId);
}

9. 用户映射文件

<?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="zw.mybatis.mapper.UserMapper">
    <!-- 输出映射 -->
    <resultMap id="userVOResultMap" type="zw.mybatis.bean.vo.UserVO">
        <!-- 用户信息映射 -->
        <id column="id" property="id" javaType="java.lang.Integer"/>
        <result column="userName" property="userName" javaType="java.lang.String"/>
        <result column="birthday" property="birthday" javaType="java.util.Date"/>
        <result column="sex" property="sex" javaType="java.lang.String"/>
        <result column="address" property="address" javaType="java.lang.String"/>
        <!-- 用户与账户一对一映射 -->
        <association column="id" property="accountDO" javaType="zw.mybatis.bean.domain.AccountDO" fetchType="lazy" select="zw.mybatis.mapper.AccountMapper.findAccountInformationByUserId"></association>
    </resultMap>
    <!-- 查询用户信息，根据用户编号查询用户信息及其账户信息，实现账户信息查询的延迟加载 -->
    <select id="findUserInformationAndAccountByUserId" parameterType="java.lang.Integer" resultMap="userVOResultMap">
        select
         id id,
         username userName,
         birthday birthday,
         sex sex,
         address address
        from
         user
        where id = #{userId}
    </select>
</mapper>

10. 用户持久层测试类

package zw.mybatis.mapper;

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.Test;
import zw.mybatis.bean.vo.UserVO;
import java.io.IOException;
import java.io.InputStream;

/**
 * @className UserMapperTest
 * @description 用户持久层测试类
 * @author 周威
 * @date 2020-07-31 14:27
 **/
public class UserMapperTest
{
    @Test
    public void findUserInformationAndRoleByUserIdTest()
    {
        InputStream is = null;
        SqlSession sqlSession = null;
        try
        {
            // 读取配置文件
            is = Resources.getResourceAsStream("mybatis/mybatis.xml");
            // 创建SqlSessionFactoryBuilder对象
            SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
            // 获取SqlSessionFactory对象
            SqlSessionFactory factory = builder.build(is);
            // 获取SqlSession对象
            sqlSession = factory.openSession();
            // 获取代理对象
            UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
            // 查询数据记录
            UserVO userVO = userMapper.findUserInformationAndAccountByUserId(1);

            // 打印用户信息
            System.out.println("---------------用户信息---------------");
            System.out.println("用户编号：" + userVO.getId());
            System.out.println("用户姓名：" + userVO.getUserName());
            System.out.println("用户生日：" + userVO.getBirthday());
            System.out.println("用户性别：" + userVO.getSex());
            System.out.println("用户住址：" + userVO.getAddress());

            // 打印账户信息
            System.out.println("---------------角色信息---------------");
            System.out.println("账户编号：" + userVO.getAccountDO().getId());
            System.out.println("用户编号：" + userVO.getAccountDO().getUserId());
            System.out.println("账户金额：" + userVO.getAccountDO().getMoney());
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
        finally
        {
            try
            {
                // 关闭资源
                if(sqlSession != null)
                    sqlSession.close();
                if(is != null)
                    is.close();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
        }
    }
}

11. 运行结果

在这里插入图片描述

-无事小神仙-
关注
MyBatis延迟加载介绍——控制pojo对象延迟加载
AI天才研究院
07-28 1103
在分布式系统中，应用服务器将数据库的数据通过网络传输到客户端时，在数据传输过程中会存在网络延迟、客户端处理慢等问题。为了避免这些问题发生，延迟加载（Lazy Loading）是一种常用的优化策略。它允许对象中所需字段的数据先不进行加载，直到需要用到的时候才从数据库中查询加载。MyBatis中的延迟加载实现了该功能。本文主要介绍 MyBatis 框架对延迟加载的支持及其配置方法，并结合具体代码实例演示延迟加载的使用方法。
MyBatis懒加载（延迟加载）
04-06
然后在Mapper接口中，你可以声明一个返回父对象的方法，父对象中包含一个`Child`类型的属性，MyBatis会自动处理懒加载。 5. **注意事项**：懒加载虽然能提高性能，但过度依赖可能会导致N+1问题。如果在循环中多次...
【MyBatis学习11】MyBatis中的延迟加载
热门推荐
武哥聊编程
06-15 4万+
1. 什么是延迟加载 　　举个例子：如果查询订单并且关联查询用户信息。如果先查询订单信息即可满足要求，当我们需要查询用户信息时再查询用户信息。把对用户信息的按需去查询就是延迟加载。 所以延迟加载即先从单表查询、需要时再从关联表去关联查询，大大提高数据库性能，因为查询单表要比关联查询多张表速度要快。 　　我们来对比一下： 关联查询：SELECT orders.*, user.use
Mybatis源码学习——延迟加载
weixin_50545075的博客
09-27 235
mybatis延迟加载 cglib动态代理 javassist动态代理
MyBatis（三）：延迟加载，缓存，注解应用
bier_zm的博客
09-24 883
MyBatis 加载策略 什么是延迟加载？ 实际开发过程中很多时候并不需要总是在加载用户信息时就一定要加载他的订单信息。此时就是我们所说的延迟加载。 在一对多中，当有一个用户，它有个100个订单；在查询用户时，用户下的订单应该是，什么时候用，什么时候查询；在查询订单时，订单所属的用户信息应该是随着订单一起查询出来。 延迟加载：就是在需要用到数据时才进行加载，不需要用到数据时就不加载数据。延迟加载也称懒加载。 优点：先从单表查询，需要时再从关联表去关联查询，大大提高数据库性能，因为查询单表要比
六、MyBatis中的延迟加载
学习笔记
05-24 225
延迟加载又叫做懒加载，就是在需要用到数据时才进行加载，不需要用到数据时就不加载数据。 好处： 先从单表查询，需要时再从关联表去关联查询，大大提高数据库性能，因为查询单表要比关联查询多张表速度要快。 坏处： 因为只有当需要用到数据时，才会进行数据库查询，这样在大批量数据查询时，因为查询工作也要消耗 时间，所以可能造成用户等待时间变长，造成用户体验下降。 -------------------------------------------------------------------------------
Java：63-Mybatis加载策略
qq_59609098的博客
04-15 1063
*在一对多中，当我们有一个用户，它有个100个订单在查询用户的时候，要不要把关联的订单查出来？在查询订单的时候，要不要把关联的用户查出来？回答在查询用户时，用户下的订单应该是，什么时候用，什么时候查询在查询订单时，订单所属的用户信息应该是随着订单一起查询出来*/--开启全局延迟加载功能，那么就不用添加fetchType="lazy"来启动延迟加载了--> < setting name = " lazyLoadingEnabled " value = " true " />
关于Mybatis延迟加载和缓存
zSoaring的博客
06-23 178
延迟加载 延迟加载：在真正使用数据时才发起查询，不用的时候不查询，按需加载（懒加载），以免造成不必要的浪费。 立即加载：不管用不用，只要一调用方法，马上发起查询。 还是之前的Account表和User表我们来举例，一个账户一定对应一个用户，并且在之前讲多表查询的时候，我们已经将各种配置都设置好了，并已经将User封装到了Account实体类中。现在学习延迟加载，我们需要做的任务就是，在查询account表时，对其对应的用户信息进行延迟加载。 本质上我们还是多表查询，只是将多次查询做了处理。 select
Mybatis延迟加载的实现以及使用场景
jarniyy的博客
12-18 922
　　首先我们先思考一个问题，假设：在一对多中，我们有一个用户，他有100个账户。 　　问题1：在查询用户的时候，要不要把关联的账户查出来？ 　　问题2：在查询账户的时候，要不要把关联的用户查出来？ 　　解答：在查询用户的时候，用户下的账户信息应该是我们什么时候使用，什么时候去查询。 　　　　　在查询账户的时候，账户的所属用户信息应该是随着账户查询时一起查询出来。 　　搞清楚这两个简单的问题后，我们就可以引出延迟加载和立即加载的特性。 　　延迟加载：在真正使用数据的时候才发起查询，不用的时候不查询关联的数据.
mybatis的延迟加载和一级缓存和二级缓存
m0_52307083的博客
09-10 104
二级缓存：也是基于 PerpetualCache 的 HashMap 本地缓存，不同在于其存储作用域为 Mapper 级别的，如果多个SQLSession之间需要共享缓存，则需要使用到二级缓存，并且二级缓存可自定义存储源，如 Ehcache。一级缓存：基于 PerpetualCache 的 HashMap 本地缓存，它的声明周期是和 SQLSession 一致的，有多个 SQLSession 或者分布式的环境中数据库操作，可能会出现脏数据。默认情况下，延迟加载是关闭的。在 MyBatis 配置文件中配置。
mybatis-3.2.7.zip
08-31
- MyBatis允许自定义事务管理器，通常结合Spring框架进行声明式事务管理，通过`@Transactional`注解控制事务边界。 10. **插件支持**： - MyBatis支持插件拦截，可以通过实现`Interceptor`接口创建自定义插件，...
MyBatis中的延迟加载
在MyBatis中，延迟加载可以通过配置来实现。 ## 1.2 延迟加载的优势和应用场景 延迟加载的主要优势是减少数据库查询和提升系统性能。当一个对象关联的数据量非常大时，如果不采用延迟加载，一次性将所有数据加载到...
MybatisPlus的LambdaQueryWrapper用法
2301_79693537的博客
08-21 5382
【代码】MybatisPlus的LambdaQueryWrapper用法。
C++学习笔记----8、掌握类与对象（四）---- 不同类型的数据成员（1）
weixin_71738303的博客
10-05 907
c++对于数据成员给了你许多选项。除了在类中声明简单的数据成员，可以生成静态数据成员供所有类的对象共享，const成员，引用成员，reference-to-const成员，等等。本节我们解释一下这些不同类型的数据成员的细节。
JDK1.0主要特性
FoolRabbit的专栏
10-06 338
JDK1.0主要特性。
==与equals比较
最新发布
suuijbd的博客
10-08 333
在JVM中，内存分为堆内存跟栈内存。他们二者的区别是： 当我们创建一个对象（new Object）时，就会调用对象的构造函数来开辟空间，将对象数据存储到堆内存中，与此同时在栈内存中生成对应的引用，当我们在后续代码中调用的时候用的都是栈内存中的引用。还需注意的一点，基本数据类型是存储在栈内存中。
JavaScript ArrayBuffer的读写与类型转换
白瑕 的博客
10-01 509
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
字符函数和字符串函数和内存函数
Java_fenxiang的博客
10-05 696
strtok函数原型与功能概述在 C 语言中，strtok函数的原型为char *strtok(char *str, const char *delim)。它的主要功能是将字符串str按照delim中指定的分隔符进行分割，返回被分割出来的子字符串。工作原理首次调用：当第一次调用strtok时，需要将待分割的字符串str作为...
MyBatis Dao接口详解：动态代理与延迟加载机制
例如，当你调用`a.getB().getName()`但`b`对象还未加载时，Mybatis会在拦截器中检查并执行一条查询语句来获取`b`，然后将其设置给`a`，实现了延迟加载的效果。 Mybatis的Mapper接口设计巧妙地结合了接口定义、XML...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值