本文深入解析MyBatis中的懒加载技术，介绍其工作原理，如何在关联查询中节省资源，以及如何正确配置和使用懒加载及积极的懒加载。
Mybatis的延迟加载（懒加载）
目录
1、什么是延迟加载(懒加载)？
2、需求：查询订单信息，有时候需要关联查出用户信息。
3、具体实例
4、测试
5、积极的懒加载
5、总结
什么是延迟加载（懒加载）
延迟加载的意思是说，在关联查询时，利用延迟加载，先加载主信息。需要关联信息时再去按需加载关联信息。这样会大大提高数据库性能，因为查询单表要比关联查询多张表速度要快。
延迟加载又叫懒加载，也叫按需加载。也就是说先加载主信息，在需要的时候，再去加载从信息。
在mybatis中，resultMap标签 的association标签和collection标签具有延迟加载的功能。
需求：查询订单信息，有时候需要关联查出用户信息
第一种方法：我们直接关联查询出所有订单和用户的信息
select * from orders o ,user u where o.user_id = u.id;
分析：
①、这里我们一次查询出所有的信息，需要什么信息的时候直接从查询的结果中筛选。但是如果订单和用户表都比较大的时候，这种关联查询肯定比较耗时。
②、我们的需求是有时候需要关联查询用户信息，这里不是一定需要用户信息的。即有时候不需要查询用户信息，我们也查了，程序进行了多余的耗时操作。
第二种方法：分步查询，首先查询出所有的订单信息，然后如果需要用户的信息，我们在根据查询的订单信息去关联用户信息
select * from orders;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文件中配置好关联关系了，我们直接调用就好了。而自己实现的原理就是手动去建立关联关系。
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
