延迟加载

本文深入解析MyBatis中的懒加载技术,介绍其工作原理,如何在关联查询中节省资源,以及如何正确配置和使用懒加载及积极的懒加载。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

Mybatis的延迟加载(懒加载)

目录

1、什么是延迟加载(懒加载)?
2、需求:查询订单信息,有时候需要关联查出用户信息。
3、具体实例
4、测试
5、积极的懒加载
5、总结

什么是延迟加载(懒加载)

延迟加载的意思是说,在关联查询时,利用延迟加载,先加载主信息。需要关联信息时再去按需加载关联信息。这样会大大提高数据库性能,因为查询单表要比关联查询多张表速度要快。
延迟加载又叫懒加载,也叫按需加载。也就是说先加载主信息,在需要的时候,再去加载从信息。
在mybatis中,resultMap标签 的association标签和collection标签具有延迟加载的功能。

需求:查询订单信息,有时候需要关联查出用户信息

第一种方法:我们直接关联查询出所有订单和用户的信息
select * from orders o ,user u where o.user_id = u.id;

分析:
①、这里我们一次查询出所有的信息,需要什么信息的时候直接从查询的结果中筛选。但是如果订单和用户表都比较大的时候,这种关联查询肯定比较耗时。
②、我们的需求是有时候需要关联查询用户信息,这里不是一定需要用户信息的。即有时候不需要查询用户信息,我们也查了,程序进行了多余的耗时操作。

第二种方法:分步查询,首先查询出所有的订单信息,然后如果需要用户的信息,我们在根据查询的订单信息去关联用户信息

  1. select * from orders;
  2. select * from user where id=user_id

分析:
①、这里两步都是单表查询,执行效率比关联查询要高很多
②、分为两步,如果我们不需要关联用户信息,那么我们就不必执行第二步,程序没有进行多余的操作。

那么我们说,这第二种方法就是mybatis的懒加载。

具体实例

①、创建实体类(PO类)
User.java

  package com.xlj.po;

import java.util.Date;

public class User {
   // 用户id
    private Integer id;
   //用户名
    private String username;
   //用户的生日
    private Date birthday;
   // 用户的性别
    private String sex;
   //用户的地址
    private String address;
    
    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 == null ? null : username.trim();
    }
    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 == null ? null : sex.trim();
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address == null ? null : address.trim();
    } 
    @Override
    public String toString() {
        return "User{" + "id=" + id + ", username='" + username + '\'' + ", birthday=" + birthday + ", sex='" + sex + '\'' + ", address='" + address + '\'' + '}';
    }
}

Orders.java

package com.xlj.po;

import java.util.Date;

public class Orders {
    // 订单id
    private Integer id;
   // 下单用户id
    private Integer userId;
   // 订单号
    private String number;
   // 创建订单时间
    private Date createtime;
   //备注
    private String note;
    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 String getNumber() {
        return number;
    }
    public void setNumber(String number) {
        this.number = number == null ? null : number.trim();
    }
    public Date getCreatetime() {
        return createtime;
    }
    public void setCreatetime(Date createtime) {
        this.createtime = createtime;
    }
    public String getNote() {
        return note;
    }
    public void setNote(String note) {
        this.note = note == null ? null : note.trim();
    }
    @Override
    public String toString() {
        return "Orders{" + "id=" + id + ", userId=" + userId + ", number='" + number + '\'' + ", createtime=" + createtime + ", note='" + note + '\'' + '}';
    }
}

OrdersExample.java

package com.xlj.po;

public class OrdersExample extends Orders {

    // 以订单为主表,查询user,一对一查询,一个订单只能有一个User
    private User user;

    public User getUser() {
        return user;
    }
    public void setUser(User user) {
        this.user = user;
    }
    @Override
    public String toString() {
        return "OrdersExample{" + "user=" + user + '}';
    }
}

②、创建 OrderMapper 接口和 OrderMapper.xml 文件,UserMapper接口和UserMapper.xml文件,以及Service与Controller层,如下图:
在这里插入图片描述
由于我们采用 Mapper 代理加载 xxxMapper.xml 文件,这里我们重复一下 Mapper 代理所需的条件,接口和xml文件必须满足以下几个条件:
  1、接口必须要和 xml 文件同名且在同一个包下,也就是说 xml 文件中的namespace是接口的全类名  
  2、接口中的方法名和xml 文件中定义的 id 一致
  3、接口输入参数类型要和xml 中定义的 parameterType 一致
  4、接口返回数据类型要和xml 中定义的 resultType 一致
  
OrderMapper 接口

package com.xlj.mapper;

import com.xlj.po.OrdersExample;
import java.util.List;

/**
 * Created by 小林 on 2018/11/19.
 */

public interface OrdersMapper {

    // 查询订单或者查询订单及其订单拥有者user的信息
    List<OrdersExample> findOrdersAndUser();    
}

OrderMapper.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="com.xlj.mapper.OrdersMapper" >

  <!--懒加载-->
  <resultMap id="lazyLoadingOrdersUser" type="com.xlj.po.OrdersExample">
    <id column="id" property="id"></id>
    <result column="user_id" property="userId"></result>
    <result column="number" property="number"></result>
    <!-- 用户信息(一对一) -->
    <!-- select:指定关联查询的查询statement(即查询用户的statement的id),然后将查询结果,封装到property属性指定的变量中
    statement相当于虚拟机表对象
    -->
    <!-- column:通过column指定的列所查询出的结果,作为select指的statement的入参 -->
    <association property="user" select="com.xlj.mapper.UserMapper.findUserById" column="user_id"></association>
  </resultMap>

  <select id="findOrdersAndUser" resultMap="lazyLoadingOrdersUser">
         SELECT * FROM orders;
  </select>
  
  <select id="findOrdersById" parameterType="int" resultType="com.xlj.po.Orders">
    SELECT * FROM orders  WHERE user_id =#{id};
  </select>
  
</mapper>

UserMapper接口

package com.xlj.mapper;

import com.xlj.po.User;

public interface UserMapper {

    User findUserById(int id);
    
}

UserMapper.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="com.xlj.mapper.UserMapper" >

  <select id="findUserById" parameterType="int" resultType="com.xlj.po.User">
    SELECT * FROM USER  WHERE id =#{id};
  </select>
  </mapper>

测试

①、当我们不开启懒加载执行程序,查看查询过程
controller测试类中:

package com.xlj.controller;

import com.xlj.po.OrdersExample;
import com.xlj.service.OrdersService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

import java.util.List;

/**
 * Created by 小林 on 2018/11/19.
 */

@Controller
@RequestMapping("order")
public class OrdersController {

    @Autowired
    private OrdersService ordersService;

    @RequestMapping("test")
    public String test(){
          List<OrdersExample> ordersExampleList = ordersService.findOrdersAndUser();
        // 用.size验证懒加载是否有效 因为我们只需要查询订单的数量,不需要查询订单的拥有者User的信息,所以正常就不要进行对User的查询了,即用到就会被加载,用不到不会被执行
        //如果直接打印ordersExampleList,需要用到user,那么就会用到User信息,则后面的操作User的sql语句将会被执行,无法验证

        //打印订单数量
        System.out.println("订单的个数为:"+ordersExampleList.size());
        return "orders/list";
    }    
}

测试结果:
在这里插入图片描述分析:
如图,查询结果中,执行了三次查询,我们在测试类中只需要订单的数量(只能查询订单的数量,不能查订单的其他属性值,否则User也会被查出来,如果想查询订单的其他信息而不查user信息,就需要用到积极的懒加载,待会详细测试),跟User没有关系,但是程序将查询User信息的指令也执行了,耗费了资源,所以当我们想要只获取订单信息,而不要跟他关联的User信息时,就用到了懒加载,下面我们就用懒加载测试一遍.

②、开启懒加载执行程序,查看查询过程

开启懒加载要在SSM配置文件中的SqlMapConfig.xml文件中进行
在这里插入图片描述
在这里插入图片描述
controller测试类中:(执行上面同样的代码)

package com.xlj.controller;

import com.xlj.po.OrdersExample;
import com.xlj.service.OrdersService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

import java.util.List;

/**
 * Created by 小林 on 2018/11/19.
 */

@Controller
@RequestMapping("order")
public class OrdersController {

    @Autowired
    private OrdersService ordersService;

    @RequestMapping("test")
    public String test(){
          List<OrdersExample> ordersExampleList = ordersService.findOrdersAndUser();
        // 用.size验证懒加载是否有效 因为我们只需要查询订单的数量,不需要查询订单的拥有者User的信息,所以正常就不要进行对User的查询了,即用到就会被加载,用不到不会被执行
        //如果直接打印ordersExampleList,需要用到user,那么就会用到User信息,则后面的操作User的sql语句将会被执行,无法验证

        //打印订单数量
        System.out.println("订单的个数为:"+ordersExampleList.size());
        return "orders/list";
    }    
}

测试结果:
在这里插入图片描述
分析:
当用了懒加载之后,当我们只需要orders的个数时,就不会再去查询跟它有关的User的信息了,节省了一大部分资源。可能有人会问,当用懒加载只查询orders的个数时就不去查询user信息了,那么当我用了懒加载之后还想查user的信息,还能查到吗?下面我们就测试一下。

测试运用懒加载之后还能不能查询User的信息
controller测试类中:

package com.xlj.controller;

import com.xlj.po.OrdersExample;
import com.xlj.service.OrdersService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

import java.util.List;

/**
 * Created by 小林 on 2018/11/19.
 */

@Controller
@RequestMapping("order")
public class OrdersController {

    @Autowired
    private OrdersService ordersService;


    @RequestMapping("test")
    public String test(){

          List<OrdersExample> ordersExampleList = ordersService.findOrdersAndUser();
        // 用.size验证懒加载是否有效 因为我们只需要查询订单的数量,不需要查询订单的拥有者User的信息,所以正常就不要进行对User的查询了,即用到就会被加载,用不到不会被执行
        //如果直接打印ordersExampleList,需要用到user,那么就会用到User信息,则后面的操作User的sql语句将会被执行,无法验证

        //打印订单数量
//        System.out.println("订单的个数为:"+ordersExampleList.size());
        for (OrdersExample ordersExample:ordersExampleList) {
            // 打印查询订单的拥有者user的信息
            System.out.println("========="+ordersExample.getUser());
        }
        return "orders/list";
    }
}

测试结果:
在这里插入图片描述
分析:
根据测试结果,说明用懒加载当需要查询跟orders关联的用户信息时,一样是可以查到的。所以说,懒加载是Mybatis中节省资源的一个非常实用而又有效的方法。

小总结:
当我们只查询所有的订单个数时,不用懒加载会将user信息一并查出来,用了懒加载之后,就不会执行查询user信息的语句,节省了资源。但是当我们不查询当单的个数,而是查询订单的其他属性时,就会发现user一样被查询来,这就用到了下面的积极的懒加载,下面我们就来验证一下:

积极的懒加载

①、当我们开启懒加载,而不开启积极懒加载执行程序,查看查询过程
controller测试类中:

package com.xlj.controller;

import com.xlj.po.OrdersExample;
import com.xlj.service.OrdersService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

import java.util.List;

/**
 * Created by 小林 on 2018/11/19.
 */

@Controller
@RequestMapping("order")
public class OrdersController {

    @Autowired
    private OrdersService ordersService;
    
    @RequestMapping("test")
    public String test(){
          List<OrdersExample> ordersExampleList = ordersService.findOrdersAndUser();
        // 用.size验证懒加载是否有效 因为我们只需要查询订单的数量,不需要查询订单的拥有者User的信息,所以正常就不要进行对User的查询了,即用到就会被加载,用不到不会被执行
        //如果直接打印ordersExampleList,需要用到user,那么就会用到User信息,则后面的操作User的sql语句将会被执行,无法验证

        //打印订单数量
//        System.out.println("订单的个数为:"+ordersExampleList.size());
        for (OrdersExample ordersExample:ordersExampleList) {
            //查询订单号
            System.out.println("========="+ordersExample.getNumber());
            // 打印查询订单的拥有者user的信息
           // System.out.println("========="+ordersExample.getUser());
        }
        return "orders/list";
    }
}

测试结果:
在这里插入图片描述
分析:
根据查询结果验证了我的说法,当不查询订单的个数时,而是去查询订单的订单号,那么同样user的信息会被查出来,同样耗费资源,解决这种问题就要用到积极的懒加载,下面进行测试。

②、开启懒加载与积极的懒加载执行程序,查看查询过程
开启积极的懒加载要在SSM配置文件中的SqlMapConfig.xml文件中进行
在这里插入图片描述
在这里插入图片描述
controller中(执行上面同样的代码):

package com.xlj.controller;

import com.xlj.po.OrdersExample;
import com.xlj.service.OrdersService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

import java.util.List;

/**
 * Created by 小林 on 2018/11/19.
 */

@Controller
@RequestMapping("order")
public class OrdersController {

    @Autowired
    private OrdersService ordersService;
    
    @RequestMapping("test")
    public String test(){
          List<OrdersExample> ordersExampleList = ordersService.findOrdersAndUser();
        // 用.size验证懒加载是否有效 因为我们只需要查询订单的数量,不需要查询订单的拥有者User的信息,所以正常就不要进行对User的查询了,即用到就会被加载,用不到不会被执行
        //如果直接打印ordersExampleList,需要用到user,那么就会用到User信息,则后面的操作User的sql语句将会被执行,无法验证

        //打印订单数量
//        System.out.println("订单的个数为:"+ordersExampleList.size());
        for (OrdersExample ordersExample:ordersExampleList) {
            //查询订单号
            System.out.println("========="+ordersExample.getNumber());
            // 打印查询订单的拥有者user的信息
           // System.out.println("========="+ordersExample.getUser());
        }
        return "orders/list";
    }
}

测试结果:
在这里插入图片描述

分析:
根据测试结果可以看出,当我们用了懒加载与积极的懒加载之后,不论我们是查询订单的数量,还是订单的其他信息,只要与user无关,就不会查询user的信息,为数据库的运行节省了资源。

总结:

①、通常懒加载都要与积极懒加载配合使用才能达到最好的效果。

②、启动懒加载,Mybatis初始化返回类型的时候,会返回一个cglib代理对象,该对象的关联对象(例如一对多,多对一)相关信息就会在loadpair里边,并且添加到loadmap中,cglib对象会过滤get,set ,is,“equals”, “clone”, “hashCode”, "toString"触发方法,然后才会调用loadpair来加载关联对象的值。所以我们必须在进行懒加载的时候必须要导入相应的jar包,不然会报错。
  
在这里插入图片描述

③、其实通过上面的例子,我们很好理解懒加载的原理,就是按需加载。我们需要什么信息的时候再去查。而不是一次性查询所有的。将复杂的关联查询分解成单表查询,然后通过单表查询的结果去关联查询。

那么不用mybatis的懒加载我们也可是实现上面的例子:

一、定义两个mapper方法

1、查询订单列表

2、根据用户 id 查询用户信息

二、先去查询第一个mapper方法,获取订单信息列表,然后放入到一个集合中

三、如果需要用户信息,那么在程序中,我们可以遍历订单信息,得到用户id,然后通过id去查询用户信息。

这与mybatis懒加载的区别就是,mybatis是在mapper.xml文件中配置好关联关系了,我们直接调用就好了。而自己实现的原理就是手动去建立关联关系。

<think>好的,用户现在想了解在RESTAPI中如何实现或优化延时加载。首先,我需要回顾一下之前提供的关于RESTAPI的最佳实践,以及用户提供的引用内容。用户提到的引用中,有关于延迟加载的触发条件和实现原理,比如在Java中通过调用集合方法触发加载,还有在ListView中延迟加载项目以减少初始加载时间。另外,引用[3]和[4]提到了批量处理数据时的大小优化和基准测试的重要性,这可能和API的分页或部分响应有关。引用[5]则提到了性能优化的各种技巧,比如使用合适的算法和数据结构。用户的问题是将延迟加载应用到RESTAPI的设计或优化中。我需要将延迟加载的概念RESTAPI的设计原则结合起来。首先,延迟加载在ORM中常见,比如Hibernate的延迟加载,避免一次性加载所有关联数据。那么在REST API中,如何实现类似的机制呢?可能的思路包括分页、部分响应、按需加载关联资源等。接下来,我需要考虑RESTful的最佳实践,比如使用HATEOAS,分页参数,字段过滤等。例如,当客户端请求一个资源时,不需要一次性返回所有关联数据,而是提供链接让客户端按需请求。这样可以减少初始响应的大小,提高性能。另外,用户提到的引用中有关于批量处理的数据大小优化,这可能涉及到在API设计中如何分批获取数据,比如使用分页参数,或者允许客户端指定需要哪些字段,避免传输不必要的数据。例如,使用GraphQL的查询语言,但用户的问题是关于REST API,所以可能需要使用fields参数来过滤返回的字段。 还需要考虑性能优化,比如缓存策略,使用ETag和Last-Modified头来减少重复传输,同时结合延迟加载,只在数据变更时触发加载。此外,异步处理可能也是一个方向,比如对于耗时操作,返回202 Accepted,让客户端轮询结果,但这可能不属于延迟加载的范畴。 然后,考虑到用户提供的Java代码示例,延迟加载是通过访问集合的方法触发的,那么在API中,可能需要设计不同的端点来访问关联资源。例如,主资源只返回基本信息和关联资源的链接,客户端可以按需请求关联资源的数据。此外,错误处理和标准化响应也很重要,比如当客户端请求未加载的数据时,返回适当的错误码或提示。同时,安全性方面,需要确保按需加载的端点有正确的权限控制,防止未授权访问。 总结起来,实现或优化延时加载的方法可能包括:分页处理、部分响应(字段过滤)、关联资源的按需加载(通过链接或单独端点)、缓存策略、异步处理,以及合理的API版本控制。同时,需要参考用户之前提到的批量处理优化,进行基准测试,确定合适的分批大小,避免性能问题。 现在需要将这些思路整理成结构化的回答,分点说明,结合引用中的内容,比如部分响应可以参考引用[3]和[4]中的批量处理建议,分页和字段过滤可以引用之前的REST最佳实践。同时,需要确保数学公式正确使用LaTeX格式,如分页的参数可以用数学表达式表示,比如每页数量$n$,页码$p$等。 可能还需要考虑HATEOAS的实现,在响应中包含相关资源的链接,这样客户端可以按需访问,减少初始负载。例如,用户资源返回时,包含订单的链接,而不是内嵌订单数据,这样只有当客户端访问订单链接时才会触发加载,类似于延迟加载的效果。 最后,生成相关问题,比如如何设计支持字段过滤的API,或者如何实现HATEOAS,这些都能帮助用户进一步探索相关主题。</think>### REST API 中延时加载的实现优化方法 --- #### 一、延时加载的核心思想 延时加载(Lazy Loading)是一种资源按需加载的优化策略,其数学描述为: $$ L(d) = \begin{cases} \text{加载数据} & \text{当} \ d \in D_{\text{required}} \\ \text{保持未加载} & \text{其他情况} \end{cases} $$ 其中 $D_{\text{required}}$ 表示客户端实际需要的数据子集。该技术可显著降低网络传输负载和服务器计算开销[^1]。 --- #### 二、实现延时加载的 4 种核心方法 ##### 1. 分页分段加载 - **基础分页**:通过 `page` 和 `size` 参数控制数据量 ```http GET /api/v1/products?page=2&size=20 ``` - **游标分页**:使用 `cursor` 标记分页位置,适用于大数据量场景 $$ \text{响应体} = \{ "data": [...], "next_cursor": "xYz123" \} $$ ##### 2. 部分响应(Partial Response) - 字段过滤参数:允许客户端指定需要的字段 ```http GET /api/v1/users?fields=id,name,email ``` - 嵌套资源延迟加载:关联资源通过独立端点访问 ```json { "user": { "id": 123, "links": { "orders": "/api/v1/users/123/orders" // 关联资源需单独请求[^1] } } } ``` ##### 3. 条件请求优化 - 缓存验证:通过 `ETag` 和 `If-None-Match` 避免重复传输 ```http GET /api/v1/articles/5 If-None-Match: "686897696a7c876b7e" ``` - 增量更新:使用 `Last-Modified` 配合 `If-Modified-Since` ##### 4. 异步资源加载 - 长期任务处理:返回 `202 Accepted` 状态码并异步处理 ```json { "status": "processing", "monitor_url": "/api/v1/tasks/5x8g9" } ``` --- #### 三、性能优化实践 1. **批量处理优化** 采用 Redis 批量操作模式,设置最佳批量大小 $n$: $$ \text{最佳批量大小} \ n = \arg\min_{k} \left( \frac{T_{\text{total}}}{k} + T_{\text{overhead}} \times k \right) $$ 建议通过基准测试确定具体值(参考 50-100 个 Key 的经验值)[^3][^4] 2. **缓存策略组合** ```mermaid graph LR A[客户端请求] --> B{缓存命中?} B -->|是| C[返回304 Not Modified] B -->|否| D[生成部分响应] D --> E[设置Cache-Control头] ``` 3. **智能预加载算法** 使用 Fisher-Yates 算法优化资源加载顺序: $$ \text{资源加载顺序} = \text{shuffle}(R, \text{seed}=t_{\text{access}}) $$ 其中 $R$ 为资源集合,$t_{\text{access}}$ 为访问时间戳[^5] --- #### 四、安全监控 1. **访问控制** - 速率限制:`X-RateLimit-Limit: 1000` - 权限验证:JWT Token 的细粒度权限控制 ```http GET /api/v1/users/orders Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9... ``` 2. **监控指标** 需监控的关键性能指标集合: $$ M = \{ \text{延迟}(ms), \text{缓存命中率}(\%), \text{分页深度}(p) \} $$ --- #### 五、代码实现示例(Python/Flask) ```python from flask import request, jsonify @app.route('/api/v1/products') def get_products(): # 实现字段过滤 fields = request.args.get('fields', 'id,name').split(',') # 实现分页 page = int(request.args.get('page', 1)) per_page = int(request.args.get('size', 20)) # 生成部分响应 data = Product.query.paginate(page, per_page).items return jsonify({ "data": [{f: getattr(p, f) for f in fields} for p in data], "next_page": f"/api/v1/products?page={page+1}&size={per_page}" }) ``` ---
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值