八、懒加载

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

  第一种方法:我们直接关联查询出所有订单和用户的信息


1

select * from orders o ,user u where o.user_id = u.id;

  分析:

  ①、这里我们一次查询出所有的信息,需要什么信息的时候直接从查询的结果中筛选。但是如果订单和用户表都比较大的时候,这种关联查询肯定比较耗时。

  ②、我们的需求是有时候需要关联查询用户信息,这里不是一定需要用户信息的。即有时候不需要查询用户信息,我们也查了,程序进行了多余的耗时操作。

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


1

2

3

4

//查询所有的订单信息,包括用户id

select * from orders;

//如果需要用户信息,我们在根据上一步查询的用户id查询用户信息

select * from user where id=user_id

  分析:

  ①、这里两步都是单表查询,执行效率比关联查询要高很多

  ②、分为两步,如果我们不需要关联用户信息,那么我们就不必执行第二步,程序没有进行多余的操作。

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

回到顶部

2、什么是懒加载?

  通俗的讲就是按需加载,我们需要什么的时候再去进行什么操作。而且先从单表查询,需要时再从关联表去关联查询,能大大提高数据库性能,因为查询单表要比关联查询多张表速度要快。

  在mybatis中,resultMap可以实现高级映射(使用association、collection实现一对一及一对多映射),association、collection具备延迟加载功能。

回到顶部

3、具体实例

  ①、创建实体类

    User.java


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

package com.ys.lazyload;

import java.util.List;

public class User {

    //用户ID

    private int id;

    //用户姓名

    private String username;

    //用户性别

    private String sex;

    //一个用户能创建多个订单,用户和订单构成一对多的关系

    public List<Orders> orders;

    

    public List<Orders> getOrders() {

        return orders;

    }

    public void setOrders(List<Orders> orders) {

        this.orders = orders;

    }

    public int getId() {

        return id;

    }

    public void setId(int id) {

        this.id = id;

    }

    public String getUsername() {

        return username;

    }

    public void setUsername(String username) {

        this.username = username;

    }

    public String getSex() {

        return sex;

    }

    public void setSex(String sex) {

        this.sex = sex;

    }

    @Override

    public String toString() {

        return "User [id=" + id + ", username=" + username + ", sex=" + sex

                "]";

    }

}

    Orders.java


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

package com.ys.lazyload;

public class Orders {

    //订单ID

    private int id;

    //用户ID

    private int userId;

    //订单数量

    private String number;

    //和用户表构成一对一的关系,即一个订单只能由一个用户创建

    private User user;

    

    public int getId() {

        return id;

    }

    public void setId(int id) {

        this.id = id;

    }

    public int getUserId() {

        return userId;

    }

    public void setUserId(int userId) {

        this.userId = userId;

    }

    public String getNumber() {

        return number;

    }

    public void setNumber(String number) {

        this.number = number;

    }

    public User getUser() {

        return user;

    }

    public void setUser(User user) {

        this.user = user;

    }

    @Override

    public String toString() {

        return "Orders [id=" + id + ", userId=" + userId + ", number=" + number

                ", user=" + user + "]";

    }

}

  ②、创建 OrderMapper 接口和 OrderMapper.xml 文件

    

由于我们采用 Mapper 代理加载 xxxMapper.xml 文件,这里我们重复一下 Mapper 代理所需的条件,接口和xml文件必须满足以下几个条件:

  1、接口必须要和 xml 文件同名且在同一个包下,也就是说 xml 文件中的namespace是接口的全类名  

  2、接口中的方法名和xml 文件中定义的 id 一致

  3、接口输入参数类型要和xml 中定义的 parameterType 一致

  4、接口返回数据类型要和xml 中定义的 resultType 一致

  详细介绍参考上一篇博客:http://www.cnblogs.com/ysocean/p/7301548.html

  OrderMapper 接口


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

package com.ys.lazyload;

import java.util.List;

import com.ys.lazyload.Orders;

import com.ys.lazyload.User;

public interface OrdersMapper {

    /**

     * select * from order //得到user_id

     * select * from user WHERE id=1   //1 是上一个查询得到的user_id的值

     * @param userID

     * @return

     */

    //得到订单信息(包含user_id)

    public List<Orders> getOrderByOrderId();

    //根据用户ID查询用户信息

    public User getUserByUserId(int userID);

}

  OrderMapper.xml


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

<?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.ys.lazyload.OrdersMapper">

    <!--

         延迟加载:

         select user_id from order WHERE id=1;//得到user_id

         select * from user WHERE id=1   //1 是上一个查询得到的user_id的值

         property:别名(属性名)    column:列名 -->

    <select id="getOrderByOrderId" resultMap="getOrderMap">

        select * from orders

    </select>

    <resultMap type="com.ys.lazyload.Orders" id="getOrderMap">

        <id column="id" property="id"/>

        <result column="number" property="number"/>

        <!-- select:指定延迟加载需要执行的statement的id(根据user_id查询的statement)

                    如果不在本文件中,需要加上namespace

             property:resultMap中type指定类中的属性名

             column:和select查询关联的字段user_id

         -->

        <association property="user" javaType="com.ys.lazyload.User"  column="user_id" select="getUserByUserId">

        

        </association>

    </resultMap>

    <select id="getUserByUserId" resultType="com.ys.lazyload.User">

        select * from user where id=#{id}

    </select>

    

</mapper>

  

  ③、向 mybatis-configuration.xml 配置文件中注册 OrderMapper.xml 文件

   

  ④、开启懒加载配置


1

2

3

4

5

6

7

<!-- 开启懒加载配置 -->

<settings>

    <!-- 全局性设置懒加载。如果设为‘false‘,则所有相关联的都会被初始化加载。 -->

    <setting name="lazyLoadingEnabled" value="true"/>

    <!-- 当设置为‘true‘的时候,懒加载的对象可能被任何懒属性全部加载。否则,每个属性都按需加载。 -->

    <setting name="aggressiveLazyLoading" value="false"/>

</settings>

  ⑤、测试


1

2

3

4

5

6

7

8

9

10

11

@Test

public void testLazy(){

    String statement = "com.ys.lazyload.OrdersMapper.getOrderByOrderId";

    //创建OrdersMapper对象,mybatis自动生成mapepr代理对象

    OrdersMapper orderMapper = session.getMapper(OrdersMapper.class);

    List<Orders> orders = orderMapper.getOrderByOrderId();//第一步

    for(Orders order : orders){

        System.out.println(order.getUser());//第二步

    }

    session.close();

}

  我们在上面标识的第一步打一个断点,然后进行断点调试。

  第一次进入断点:注意看控制台Console现在是没有任何sql语句发出的

  

  下一步:这一步发出了第一次查询所有订单信息sql语句:select * from orders。注意只是查询订单信息,还没有进行关联查询

  

  下一步:下图已经执行了一次for循环,因为我们需要用户信息,故发出了根据用户id查询用户信息的sql语句

      注意:如果用户信息有多条,这里并不会发出多条sql语句,这是由于mybatis的一级缓存的原因,下一章会讲到。

  

回到顶部

4、总结

  ①、启动懒加载,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文件中配置好关联关系了,我们直接调用就好了。而自己实现的原理就是手动去建立关联关系。

原文地址:https://www.cnblogs.com/zhoanghua/p/9292203.html

时间: 2024-11-09 02:56:34

八、懒加载的相关文章

Hibernate学习笔记(八) — 懒加载与抓取策略

懒加载(Load On Demand)是一种独特而又强大的数据获取方法,它能够在用户滚动页面的时候自动获取更多的数据,而新得到的数据不会影响原有数据的显示,同时最大程度上减少服务器端的资源耗用.总结一句话:什么时候需要数据,什么时候加载. 一.懒加载 1.1 类的懒加载 由javassist产生的代理类与Classes类是继承关系, session.load()方法产生的是代理对象,该代理类是持久化类的子类 /** * 类的懒加载 */ @Test public void testClass_l

图片懒加载

一.什么是图片滚动加载? 通俗的将就是:当访问一个页面的时候,先把img元素或是其他元素的背景图片路径替换成一张大小为1*1px图片的路径(这样就只需请求一次),只有在图片出现在浏览器的可视区域内时,才设置图片真正的路径,让图片显示出来.这就是图片懒加载. 二.为什么要使用这个技术? 比如一个页面中有很多图片,如淘宝.京东首页等等,如果一上来就发送这么多请求,页面加载就会很漫长,如果js文件都放在了文档的底部,恰巧页面的头部又依赖这个js文件,那就不好办了.更为要命的是:一上来就发送百八十个请求

前端优化-图片懒加载

一.什么是懒加载 懒加载技术(简称lazyload)是对网页性能优化的一种方案.lazyload的核心是按需加载,避免网页打开时加载过多资源,让用户等待太久,在适当的时候加载用户需要的资源(这里用户需要的资源指该资源呈现在浏览器可视区域).这里我们主要是对img标签使用懒加载技术,使用jquery的query.lazyload.js库实现. 通俗的讲就是:当访问一个页面的时候,先把img元素或是其他元素的背景图片路径替换成一张大小为1*1px图片的路径(这样就只需请求一次),只有当图片出现在浏览

关于解决懒加载的问题

今天被一个懒加载问题困扰了近八个钟头,现在将这些新的总结下,刚开始我使用的是struts2-Json的方式不让,目标列序列化,代码如下: @JSON(serialize = false) public Set<FixedArea> getFixedAreas() { return fixedAreas; } 但是这种方法在我这并不是太如意,时灵时不灵.对了不要有那个小伙伴去尝试把serialize换成,desrialize=true来代替,效果是一样的.然后我又换成了使用web.xml文件中配

懒加载——实现原理

本文主要通过以下几方面来说明懒加载技术的原理,个人前端小菜,有错误请多多指出 一.什么是图片滚动加载? 通俗的讲就是:当访问一个页面的时候,先把img元素或是其他元素的背景图片路径替换成一张大小为1*1px图片的路径(这样就只需请求一次),只有当图片出现在浏览器的可视区域内时,才设置图片正真的路径,让图片显示出来.这就是图片懒加载. 二.为什要使用这个技术? 比如一个页面中有很多图片,如淘宝.京东首页等等,如果一上来就发送这么多请求,页面加载就会很漫长,如果js文件都放在了文档的底部,恰巧页面的

关于Hibernate中立即加载和懒加载的区别

当1表与2表之间有OneToMany(类似)关系时候, 对于1表的实体类,设置FetchType=EAGER时(也就是立即加载),取1表数据,对应2表的数据都会跟着一起加载,优点不用进行二次查询. 缺点是严重影响数据查询时间,查询速度慢. FetchType=LAZY(也就是懒加载),此时查询时间大大缩短,缺点是查询表1的数据时,查询不到2表的数据. 不会主动取查询2表的数据.

深入懒加载

[javascript] view plain copy 懒加载(LazyLoad)一直是前端的优化方案之一.它的核心思想是:当用户想看页面某个区域时,再加载该区域的数据.这在一定程度上减轻了服务器端的压力,也加快了页面的呈现速度. 懒加载多用于图片,因为它属于流量的大头.最典型的懒加载实现方案是先将需要懒加载的图片的src隐藏掉,这样图片就不会下载,然后在图片需要呈现给用户时再加上src属性. 公司内部库的懒加载正是采用这种方案.它会遍历页面中所有的图片,将其src缓存起来后删除图片的src属

页面图片懒加载

一.页面滚动加载图片的理解 当一个网页含有大量的图片的时候,往往在打开页面的加载的很慢,如现在的大型电商.新闻.微博等,如果一下加载整个网页的所有图片,那会是一个缓慢的过程,要想快速的浏览网页,我们这时候就需要用到了在滚动或滑动页面的时候加载图片的方法.即图片懒加载!!! 二.实现懒加载的思路 当打开页面的时候,刚开始不给显示图片的位置放图片,等滚动或滑动到哪里的时候在获取图片.当然如果我们不给图片src中放图片,就会出现先找不到图片的提示,这样肯定是不行的. 所以我们在放图片的位置刚开始让一张

懒加载 lazy loading

懒加载:延迟加载,当程序启动时不加载资源,当程序需要这些资源时再去加载.需要的时候再加载的一种方式,能够减少内存的占用,效率高.其本质是重写get方法. 背景:由于ios内存有限,如果我们一次性将所有资源加载完毕将极大的消耗内存,降低程序运行效率.所以就要将一些比较大的资源,如音频,数据,图片等大资源进行懒加载,就需要                                             先判断是否存在,如果不存在再创建实例化. 1 @property (nonatomic,