【Spring源码三千问】@Lazy延迟加载与延迟注入有什么区别？

最新推荐文章于 2024-08-02 15:15:00 发布
最新推荐文章于 2024-08-02 15:15:00 发布
阅读量2.6k 收藏 7
点赞数 3
分类专栏： # Spring 源码三千问 文章标签： spring 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wang489687009/article/details/122284171
版权

@Lazy延迟加载与延迟注入有什么区别？

前言

@Lazy 最常用的场景是，当我们遇到循环依赖报错的时候，将报错的 bean 使用 @Lazy 进行标记。
那么，为什么加上 @Lazy 之后就不会报错了呢？

我们还可以发现，@Lazy 标记在 @Autowired/@Resource 注入的属性上，或者对应的 bean 类上，都可以解决这种循环依赖报错的问题。
那么，不同的使用方式有什么区别呢？会带来什么样不同的效果呢？

带着这些疑问，我们开始源码之旅…

版本约定

Spring 5.3.9 (通过 SpringBoot 2.5.3 间接引入的依赖)

正文

为了了解 @Lazy 的原理，我们可以先看它的源码定义，站在一个高的层次来整体的认识一下 @Lazy。

@Lazy 的定义和使用范围

@Lazy 的定义如下：

@Target({ElementType.TYPE, ElementType.METHOD, ElementType.CONSTRUCTOR, ElementType.PARAMETER, ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Lazy {

	/**
	 * Whether lazy initialization should occur.
	 */
	boolean value() default true;
}

可以看出，@Lazy 可以使用在类、方法、构造函数、参数、属性上

@Lazy 的作用

通过源码的注释，我们可以先得出一部分@Lazy 作用的结论。
源码的注释如下：

Indicates whether a bean is to be lazily initialized.
May be used on any class directly or indirectly annotated with @Component or on methods annotated with @Bean.
If this annotation is not present on a @Component or @Bean definition, eager initialization will occur. If present and set to true, the @Bean or @Component will not be initialized until referenced by another bean or explicitly retrieved from the enclosing BeanFactory. If present and set to false, the bean will be instantiated on startup by bean factories that perform eager initialization of singletons.
If Lazy is present on a @Configuration class, this indicates that all @Bean methods within that @Configuration should be lazily initialized. If @Lazy is present and false on a @Bean method within a @Lazy-annotated @Configuration class, this indicates overriding the 'default lazy' behavior and that the bean should be eagerly initialized.
In addition to its role for component initialization, this annotation may also be placed on injection points marked with org.springframework.beans.factory.annotation.Autowired or javax.inject.Inject: In that context, it leads to the creation of a lazy-resolution proxy for all affected dependencies, as an alternative to using org.springframework.beans.factory.ObjectFactory or javax.inject.Provider.

通过源码的注释，我们可以了解到 @Lazy 在不同的场景下提供的功能有细微的差别：

使用范围起到的作用
标记在普通 bean 类上被标记的 bean 会延迟加载
标记在 @Configuration 类上被标记的 @Configuration 类及其内部的 @Bean 都会延迟加载
标记在 @Autowired/@Resource 的属性上被标记的属性会延迟注入（注意：属性对应的 bean 并不会延迟加载）
标记在参数上被标记的参数会解析成一个延迟解析代理（lazy-resolution proxy）。
这种情况，可以使用 org.springframework.beans.factory.ObjectFactory 或 javax.inject.Provider 来替代解决

从源码来分析延迟加载 与 延迟注入 的区别：
我们主要来分析一下最常用的两种方式: 标记在属性上；标记在普通的 bean 类上。

其他的使用场景，读者感兴趣的话，可以通过作者的思路自己去探索，这样可以让自己更好的理解源码

@Lazy 主要使用在循环依赖报错的场景，所以，我们先来解释一下循环依赖的概念。

循环依赖的概念

在分析之前，我们对循环依赖的概念做一下解析。

场景(–> 表示依赖)说明
A --> B --> A称做 A 被循环依赖了。（或者：A 产生了循环依赖）
B --> A --> B称做 B 被循环依赖了。（或者：B 产生了循环依赖）

可能有些同学觉得很奇怪， A --> B --> A 与 B --> A --> B 不是一样吗，将它还原成代码不是同一个场景吗？

还原成代码如下：

@Service
public class A {
    @Autowired
    private B b;
}

@Service
public class B {
    @Autowired
    private A a;
}

A --> B --> A 与 B --> A --> B 的确是两种不同的场景。
如果 bean A 先加载，那么产生循环依赖的顺序就是 A --> B --> A ，循环依赖的主体就是 A。
如果 bean B 先加载，那么产生循环依赖的顺序就是 B --> A --> B ，循环依赖的主体就是 B。

也就是说：A, B 加载顺序的不同，会导致产生循环依赖的主体不同。

我们分析一下，如果是 A --> B --> A 的场景，那么，A 加载时，在 populateBean() 时，会去注入 B，从而触发 B 的加载。
当 B 加载时，在 populateBean() 时，会去注入 A，此时会通过 A 对应的三级缓存获取到 bean A 的早期引用。
所以，当 A 产生循环依赖，被循环注入时，会通过 A 对应的三级缓存来获取 bean A 的早期引用。

也就是说：如果 beanX 产生了循环依赖的话，最后会使用 beanX 的三级缓存来获取 beanX 的早期引用。（这一点是很重要的，需要理解清楚）

@Lazy 标记在属性上

@Lazy 最常用的场景是当我们遇到循环依赖报错的时候，将它标记在 @Autowired/@Resource 注入的属性上。

例如：
A --> B --> A 的场景，bean A 是一个被 @Async 标记而生产的代理 bean

@Service
public class A {
    @Autowired
    @Lazy // 延迟注入 B
    private B b;

    @Async
    public void m1() {
    }
}

@Service
public class B {
    @Autowired
    private A a;
}

如果不添加 @Lazy，会得到如下的错误信息:

Exception in thread "main" org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name 'p1Service': 
Bean with name 'p1Service' has been injected into other beans [p2Service] in its raw version as part of a circular reference, but has eventually been wrapped. 
This means that said other beans do not use the final version of the bean. This is often the result of over-eager type matching - consider using 'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.

添加上 @Lazy 之后，起到了什么作用呢？

之前讲 IoC 依赖注入时，讲到 @Autowired 注入是通过 AutowiredFieldElement 来进行处理的。
最终，它会调用 DefaultListableBeanFactory#resolveDependency() 来进行依赖的解析
resolveDependency2

可以看到，解析依赖时，就有对 @Lazy 标记的属性进行处理。具体是通过 AutowireCandidateResolver#getLazyResolutionProxyIfNecessary() 来获取到依赖属性的代理。
也就是说被 @Lazy 标记的属性，最终注入的是一个代理类，在 Spring 文档中称之为：lazy-resolution proxy（延迟解析代理）

既然注入的是一个代理，那么，也就不会去触发依赖 bean 的解析和加载了，这样，循环依赖的链条到此就终止了。也就解决了循环依赖的报错问题了。

虽然 B 被 @Lazy 标记之后会延迟注入，但是并不表示 bean B 不会加载了。
由于 B 同时是一个单例 bean，所以，在 AbstractApplicationContext#finishBeanFactoryInitialization() 时，会触发 bean B 的加载。

所以，@Lazy 标记在依赖注入的属性上，最终会注入一个 lazy-resolution proxy（延迟解析代理）。

做为一个嗅觉敏锐的技术人，从上图我们还可以看出 Spring 对 ObjectFactory 和 ObjectProvider 类型的依赖进行了特殊处理，注入的是一个 new 出来的 DependencyObjectProvider 对象。
跟下源码，就可以发现，ObjectFactory 和 ObjectProvider 类型的依赖在注入时，不会马上去加载真正的 bean，而是在使用 DependencyObjectProvider#getObject() 才会触发 bean 的加载。
所以，在某种程度上来说，ObjectFactory 和 ObjectProvider 可以替代 @Lazy 的功能。

@Lazy 标记在类上

上面的例子中，也可以将 @Lazy 标记在 bean 类上，也能解决问题，如下：

@Lazy // 延迟加载 A
@Service
public class A {
    @Autowired
    private B b;

    @Async
    public void m1() {
    }
}

@Service
public class B {
    @Autowired
    private A a;
}

将 @Lazy 标记在 bean A 上之后，bean A 就会延迟加载。也就是说 B 会先于 A 进行 bean 的初始化流程。
这样的话，就变成了 B --> A --> B 的场景了，也就是 B 产生了循环依赖。

当 B 通过 @Autowired 注入 A 时，也就是 populateBean() 填充依赖时，会触发 A 的加载，走 getBean() 的流程。
当 A 通过 @Autowired 注入 B 时，可以通过三级缓存获取到 B 的早期引用。B 是普通的 bean，被循环依赖是没有问题的。

所以，@Lazy 标记在 bean A 类上，也解决了循环依赖的问题。

当 @Lazy 标记在类上之后，这个类的 lazy 延迟加载属性就为 true 了，即： BeanDefinition#isLazyInit() == true

如何做到 bean 在真正使用的时候才进行加载？

上面的例子中，@Lazy 不管是标记在依赖注入的属性上，还是标记在 bean 类上，最终 A, B 两个 bean 都在 Spring 容器启动完成之后完成了加载流程。

如果我们想让 bean A 在真正使用的时候才进行加载，该怎么去配置呢？
答：需要两个步骤：

  1. 将 @Lazy 标记在 bean A 类上，使得 bean A 不会被 Spring 容器主动加载
  2. 将依赖注入 bean A 的地方使用 @Lazy 将属性进行标记

沿用上面的例子，代码如下：

@Lazy // 延迟加载 A
@Service
public class A {
    @Autowired
    private B b;

    @Async
    public void m1() {
    }
}

@Service
public class B {
    @Autowired
    @Lazy // 延迟注入 A
    private A a;
}

也就是说，如果我们想让 bean A 在真正使用的时候才通过 Spring 容器进行加载的话，就需要使用 @Lazy 将 A 标记成 延迟加载 和 延迟注入。
这样的话，在 Spring 容器启动时，所有的地方都不会主动去加载 bean A 了。

如何验证 bean 是在使用的时候才进行加载的？

如何能快速的验证 bean A 是在使用的时候才进行加载的呢？
我们可以为 bean A 增加一个默认的构造函数：

@Lazy // 延迟加载 A
@Service
public class A {
    @Autowired
    private B b;

   public P1Service() {
      log.info("A创建实例...");
   }

    @Async
    public void m1() {
       log.info("异步执行--A中打印B:" + b + "--" + b.getClass());
    }
}

启动容器后，会发现构造函数中的日志并不会打印，而是在调用 A.m1() 方法时才会打印。
这样也就说明了 A 是在真正使用的时候才去创建的实例，完成 bean 的初始化流程的。

也可以通过源码调试的方式，可以更加直观的观察 A 的加载流程是什么时候进行的。
只需要将断点打在 bean 的创建流程中即可，即: AbstractAutowireCapableBeanFactory#createBeanInstance()
了解 bean 的创建流程请戳:bean 的创建过程

小结

本文分析了 @Lazy 延迟加载 和 延迟注入 的使用和区别:

  1. 延迟加载
    将 @Lazy 标记在 bean 类上，这样，Spring 容器就不会主动加载这个 bean。
    但当这个 bean 被依赖注入时，就会触发这个 bean 的加载。

  2. 延迟注入
    将 @Lazy 标记在依赖注入的属性上，这样，populateBean() 时就不会注入真正的依赖，而是注入一个延迟解析代理（lazy-resolution proxy），这样就不会触发这个 bean 的加载。
    当 Spring 容器进行 finishBeanFactoryInitialization() 时，就会挨个初始化所有的非懒加载 bean，此时就会触发这个依赖 bean 的加载了。

只使用 延迟加载 或者 延迟注入 的话，bean 通常都是在容器启动完成后就完成了加载过程。
如果想让一个 beanX 在真正使用的时候才进行加载的话，就需要使用 延迟加载 + 延迟注入

使用 ObjectFactory 和 ObjectProvider 同样也可以达到类似延迟注入的效果。

如果本文对你有所帮助，欢迎点赞收藏!

源码测试工程下载：
老王读Spring IoC源码分析&测试代码下载
老王读Spring AOP源码分析&测试代码下载

公众号后台回复：下载IoC 或者 下载AOP 可以免费下载源码测试工程…

阅读更多文章，请关注公众号: 老王学源码
gzh

系列博文：
【老王读Spring AOP-0】SpringAop引入&&AOP概念、术语介绍
【老王读Spring AOP-1】Pointcut如何匹配到 join point
【老王读Spring AOP-2】如何为 Pointcut 匹配的类生成动态代理类
【老王读Spring AOP-3】Spring AOP 执行 Pointcut 对应的 Advice 的过程
【老王读Spring AOP-4】Spring AOP 与Spring IoC 结合的过程 && ProxyFactory 解析
【老王读Spring AOP-5】@Transactional产生AOP代理的原理
【老王读Spring AOP-6】@Async产生AOP代理的原理
【Spring 源码阅读】Spring IoC、AOP 原理小总结

相关阅读：
【Spring源码三千问】Spring动态代理：什么时候使用的 cglib，什么时候使用的是 jdk proxy？
【Spring源码三千问】Advice、Advisor、Advised都是什么接口？
【Spring源码三千问】没有AspectJ，Spring中如何使用SpringAOP、@Transactional？
【Spring源码三千问】Spring AOP 中 AbstractAdvisorAutoProxyCreator、AbstractAdvisingBeanPostProcessor的区别
【Spring 源码三千问】同样是AOP代理bean，为什么@Async标记的bean循环依赖时会报错？

老王学源码
关注
专栏目录
Spring ： Bean延时加载注解(@Lazy)
九师兄
01-19 3783
1.美图 2.概述 @Lazy：用于标识Bean是否需要延迟加载，延时加载就是在第一次使用的时候才加载。@Lazy的主要作用就是用来减少Spring IOC容器启动的加载时间。 3.源码 @Target({ElementType.TYPE, ElementType.METHOD, ElementType.CONSTRUCTOR, ElementType.PARAMETER, ElementTyp...
《Spring》第十九篇 注解使用 - @Lazy
入坑太深起不来
03-04 655
目录 @Target({ElementType.TYPE, ElementType.METHOD, ElementType.CONSTRUCTOR, ElementType.PARAMETER, ElementType.FIELD}) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface Lazy { /** * Whether lazy initialization should occur. */ boolean
Spring IoC 延迟注入
qq_43578218的博客
01-17 522
定义两个实体类 public class UserRepository { private ObjectFactory<User> objectFactory; // Getter/Setter } public class User { private Long id; private String name; // Getter/Setter } 定义spring.xml，将两个对象注入，使用autowire="byType"将user注入
Spring 延迟注入
qq_41197578的博客
06-05 346
延迟注入
深入理解Spring中的@Lazy注解
最新发布
weixin_44976692的博客
08-02 1万+
Lazy注解是Spring框架中的一个标注，用于指定bean的延迟初始化。使用@Lazy注解的bean只有在第一次被实际需要的时候才会被创建和初始化，而不是在容器启动时立即创建。这样可以有效地节省系统资源，并且加快应用程序的启动时间。@Lazy注解可以应用于类级别或方法级别，用于控制bean的创建时机。
Spring Boot-延迟依赖注入
yygr的博客
03-22 869
Spring Boot-延迟依赖注入_绅士jiejie的博客-CSDN博客_延迟依赖注入 有一个接口类Animal，如下： public interface Animal { } 123 接口类Animal有一个实现类Cat，如下： import org.springframework.stereotype.Service; ​ @Service public class Cat implements Animal { public Cat() { Sy...
Spring框架中@Lazy延迟加载原理和使用细节
Armyyyyy丶的博客
07-14 2万+
目录 一、@Lazy延迟加载原理 1.延迟加载原理 1.1 @Lazy三种配置方法 1.2 @ComponentScan配置延迟加载 1.3 加载原理 2.延迟加载实现原理 2.1 AbstractApplicationContext 2.2 DefaultListableBeanFactory 二、使用细节 1.@Lazy失效实例 1.1 Controller非延迟加载类 1.2 Service延迟加载类 1.3 结果输出 2.@Lazy起效实例 2.1 修改的Control
延迟初始化Spring Bean：延迟初始化的Bean会影响依赖注入吗？
码农架构
08-29 345
前面提到过Bean的初始化方式，在Bean 的配置元信息时候我们知道Bean的元信息配置中有lazy-init 延迟初始化属性配置，延迟初始化Spring Bean 还有Java 注解API的方式实现 案例分析 这里已Java 注解方式案例讲解描述 @Target({ElementType.TYPE,ElementType.METHOD,ElementType.CONSTRUCTOR,ElementType.PARAMETER,ElementType.FIELD}) @Retention...
Spring中@Lazy注解的使用
m0_67393295的博客
08-02 1316
Lazy注解用于标识bean是否需要延迟加载./***/}查看注解源码可知,只有一个参数,默认为true,即添加该注解的bean对象就会延迟初始化.是项目没有将application.yml配置文件加载.点击maven中clean一下项目,重启项目即可.先自我介绍一下，小编13年上师交大毕业，曾经在小公司待过，去过华为OPPO等大厂，18年进入阿里，直到现在。深知大多数初中级java工程师，想要升技能，往往是需要自己摸索成长或是报班学习，但对于培训机构动则近万元的学费，着实压力不小。...
spring源码学习---@Autowired 注入源码分析和自定义依赖注入
qq_36697880的博客
07-08 1670
一、简介 众所周知，Spring的依赖注入（DI）对Spring IOC 有着举足轻重的作用，是Spring灵魂所在。本篇文章就从日常开发中最常用的注解@Autowired开始，着手分析Spring是如何通过它们将Bean所需的外部资源注入其中. 1.1、@Autowired 注入规则 @Autowired可以应用在非静态字段、非静态方法、构造器上面注入bean。 1.2、@Autowired 注入过程 元信息解析 依赖查找 依赖注入（字...
延迟加载：如何使用Spring的@Lazy注解提升应用性能
逆流的小鱼
04-20 990
Lazy，顾名思义，该注解背后的理念就是“惰性”。在Spring的默认行为中，所有的bean会在容器启动时创建。但是，如果我们将@Lazy注解应用在某个bean上，那么这个bean将被延迟创建，直到第一次被需要的时候。通过使用@Lazy注解，我们能更为灵活地管理bean的生命周期，优化应用启动时间，提高系统的响应能力。Spring框架的@Lazy注解是一个强大的工具，它可以帮助我们更灵活地管理bean的生命周期，优化应用性能，全面提升项目的质量和效率。
Spring中 静态成员变量的注入，以及其他静态成员变量的单例延迟加载--查漏补缺
tjlog的专栏
09-22 606
Spring中 静态成员变量的注入，以及其他静态成员变量的单例依赖静态变量的情形，通过延迟加载方式调用注入的静态变量
Spring 与组件注入相关的注解之 @Scope 和 @Lazy
demon_2018的博客
04-13 327
前言： 通过上一个demo，又进一步体会到了如何实现 spring 组件的注入。下面对注入到 IOC 容器中的组件的作用域作进一步说明。其实，这里还涉及到注入到容器中的 bean 的生命周期的问题，后面也会作相关介绍。 实验： 准备配置类，注入 Person 组件： package com.uestc.auto.xiaoxie.config; import org.springframewo...
万不得已不要使用ORM延迟加载(Lazy Loading)
黄刚的专栏
12-28 6574
       延迟加载(Lazy Loading)是啥玩意儿？估计地球人都知道，它的意义在于只在需要的时候才去加载必要的数据，这样可以避免即时加载所带来的不必要的系统开销(教科书是这么说的)。另外，教科书中还举了个例子。例如某个User对象在加载时会同时读取其所关联的多个地址（Address）对象，对于需要对Address进行操作的应用来说，关联数据的自动加载机制非常有效。不过呢如果我们只想要获得
Spring的实例化和依赖注入时机与延迟实例化
三毛村滴雪鱼粉的博客
01-07 2284
Spring的实例化 使用@Autowired可以注入一个bean进来 @Autowired private Diana diana; 那么如果在容器中没有Diana的对象被实例化的时候应用程序会报错吗？我们可以通过把Diana上面的@Component注释掉来看一下结果如何 //@Component public class Diana { public void r(){ ...
Spring 通过 @Lazy 注解解决构造方法循环依赖问题
龚小帅的博客
12-11 8517
像这种在 Apple 里面有一个属性 Orange、Orange 中有一个属性 Apple，你中有我，我中有你，这样可以称之为循环依赖。循环依赖问题不止在 Spring 中有，在 Mybatis 中也有，解决思想基本一样，都需要借助额外的缓存进行实现。Spring 对于这种属性注入的循环依赖是支持的，不会有任何问题，今天这里探讨一下 Spring 中构造方法的循环依赖问题，Spring 默认是不支持的，但是也提供了方法解决。
Spring注解@Lazy
大树
12-20 3912
Spring注解@Lazy 一、@Lazy注解 1、@Lazy注解作用 lazy 翻译过来是"懒惰的" @Lazy（懒加载）：该注解用于惰性加载初始化标注的类、方法和参数。 在Spring中常用于单实例Bean对象的创建和使用； 单实例Bean懒加载：容器启动后不创建对象，而是在第一次获取Bean创建对象时，初始化。 2、@Lazy 可标注在类、方法、构造方法、参数、字段上 @Target({ElementType.TYPE, ElementType.METHOD, ElementType.CONSTR
spring @lazy注解的使用
m0_69860228的博客
05-11 4191
spring @lazy注解的使用 在spring中@lazy注解表达延迟的含义，但在不同情况下，这里的延迟并不是同一层意思。下面将描述我发现的两层含义。 1. 延迟初始化bean ​ 首先我们知道，容器启动之前会扫描所有的class文件，并将需要加载到容器中的类，整理成BeanDefinition存储。容器启动时将依次将BeanDefinition构建成bean，构建过程中同时解决依赖注入和循环引用的问题。 ​ 但并不是所有的BeanDefinition都会被构建成bean，观察源码中下面方法o.
Spring中的 @Lazy注解简析
热门推荐
_夜渐凉
11-07 7万+
Spring IoC （ApplicationContext） 容器一般都会在启动的时候实例化所有单实例 bean 。如果我们想要 Spring 在启动的时候延迟加载 bean，即在调用某个 bean 的时候再去初始化，那么就可以使用 @Lazy 注解。 @Lazy 的属性 value 取值有 true 和 false 两个 默认值为 true true 表示使用 延迟加载， false 表...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

老王学源码

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值