zcy
/
spring-reading.
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

@Lazy源码分析

master
xuchengsheng 2023-10-11 17:44:40 +08:00
parent 9c885eb9b6
commit b925d19284
5 changed files with 736 additions and 8 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
README.md
View File

@ -73,11 +73,12 @@
*了解 Spring 如何通过注解驱动开发，简化和加强代码。* *了解 Spring 如何通过注解驱动开发，简化和加强代码。*
- [**解析@Configuration的力量**](spring-annotation/spring-annotation-configuration/README.md) - 揭露如何使用 Java 配置定义 beans。 - [**解析@Configuration的力量**](spring-annotation/spring-annotation-configuration/README.md) - 揭露如何使用 Java 配置定义 beans。
- [**组件扫描的魅力: @ComponentScan**](spring-annotation/spring-annotation-componentScan/README.md) - 探索如何自动检测和注册 beans。 - [**组件扫描的魅力@ComponentScan**](spring-annotation/spring-annotation-componentScan/README.md) - 探索如何自动检测和注册 beans。
- [**深入@Bean的秘密**](spring-annotation/spring-annotation-bean/README.md) - 理解如何通过 Java 方法定义 beans。 - [**深入@Bean的秘密**](spring-annotation/spring-annotation-bean/README.md) - 理解如何通过 Java 方法定义 beans。
- [**@Import的高级策略**](spring-annotation/spring-annotation-import/README.md) - 揭示如何导入其他配置类或组件。 - [**@Import的高级策略**](spring-annotation/spring-annotation-import/README.md) - 揭示如何导入其他配置类或组件。
- [**属性源探查: @PropertySource**](spring-annotation/spring-annotation-propertySource/README.md) - 深入了解如何为应用上下文添加属性源。 - [**属性源探查@PropertySource**](spring-annotation/spring-annotation-propertySource/README.md) - 深入了解如何为应用上下文添加属性源。
- [**掌控顺序: @DependsOn**](spring-annotation/spring-annotation-dependsOn/README.md) - 精确控制 Spring Beans 的加载顺序。 - [**掌控顺序@DependsOn**](spring-annotation/spring-annotation-dependsOn/README.md) - 精确控制 Spring Beans 的加载顺序。
- [**深入探究@Lazy注解**](spring-annotation/spring-annotation-lazy/README.md) - 如何优雅地实现 Spring Beans 的延迟加载。
## 🔄持续更新中 ## 🔄持续更新中

728
spring-annotation/spring-annotation-lazy/README.md Normal file
View File

@ -0,0 +1,728 @@
## @Lazy
- [@Lazy](#lazy)
- [一、注解描述](#一注解描述)
- [二、注解源码](#二注解源码)
- [三、主要功能](#三主要功能)
- [四、最佳实践](#四最佳实践)
- [五、时序图](#五时序图)
- [5.1、Bean注册时序图](#51bean注册时序图)
- [5.2、Bean延迟创建时序图](#52bean延迟创建时序图)
- [5.3、Bean延迟注入时序图](#53bean延迟注入时序图)
- [六、源码分析](#六源码分析)
- [6.1、延迟初始化](#61延迟初始化)
- [6.2、延迟注入](#62延迟注入)
- [七、注意事项](#七注意事项)
- [八、总结](#八总结)
- [8.1、最佳实践总结](#81最佳实践总结)
- [8.2、源码分析总结](#82源码分析总结)
### 一、注解描述
`@Lazy`注解，它的主要用途是延迟依赖注入的初始化。通常情况下，当 ApplicationContext 被启动和刷新时，所有的单例 bean 会被立即初始化。但有时，可能希望某些 bean 在首次使用时才被初始化。
### 二、注解源码
`@Lazy`注解是 Spring 框架自 3.0 版本开始引入的一个核心注解，用于控制 bean 的懒加载行为。默认情况下，当 `@Lazy` 被应用，bean 不会在 Spring 容器启动时立即初始化，而是在首次被引用或请求时。这适用于通过 `@Component` 或 `@Bean` 定义的 bean。此外，`@Lazy` 还可以用于注入点，如 `@Autowired`，创建一个懒解析代理，从而实现延迟注入。当用在 `@Configuration` 类上时，它影响该配置中所有的 `@Bean` 定义。
```java
/**
* 指示一个bean是否应懒加载初始化。
*
* 可直接或间接地用于带 org.springframework.stereotype.Component @Component 注解的类，
* 或者用于带有 Bean @Bean 注解的方法。
*
* 如果此注解不在 @Component 或 @Bean 定义上，将会立即初始化。
* 如果存在并且设置为 true，除非被另一个bean引用或从包围的 org.springframework.beans.factory.BeanFactory BeanFactory 中显式检索，
* 否则 @Bean 或 @Component 不会初始化。如果存在并设置为 false，那么执行积极初始化单例的bean工厂将在启动时实例化bean。
*
* 如果Lazy存在于 Configuration @Configuration 类上，表示该 @Configuration 中的所有 @Bean 方法都应懒加载。
* 如果在一个带有 @Lazy 注解的 @Configuration 类的 @Bean 方法上 @Lazy 设置为false，则表示覆盖了“默认懒惰”行为，该bean应立即初始化。
*
* 除了其在组件初始化中的作用外，此注解也可用于带有 org.springframework.beans.factory.annotation.Autowired 或 javax.inject.Inject 的注入点：
* 在这种情况下，它会导致为所有受影响的依赖关系创建一个懒解析代理，作为使用 org.springframework.beans.factory.ObjectFactory 或 javax.inject.Provider 的替代方法。
*
* @author Chris Beams
* @author Juergen Hoeller
* @since 3.0
* @see Primary
* @see Bean
* @see Configuration
* @see org.springframework.stereotype.Component
*/
@Target({ElementType.TYPE, ElementType.METHOD, ElementType.CONSTRUCTOR, ElementType.PARAMETER, ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Lazy {
/**
* 是否应进行懒加载初始化。
*/
boolean value() default true;
}
```
### 三、主要功能
1. **延迟初始化**
+ 当 `@Lazy` 注解应用于一个 `@Bean` 或 `@Component` 上时，该 bean 不会在 Spring 容器启动时立即初始化。而是直到首次被引用或请求时才进行初始化。
2. **延迟注入**
+ 当 `@Lazy` 注解应用于 `@Autowired` 或其他注入点上时，它导致为所注入的依赖关系创建一个懒解析代理，实现首次访问时的延迟注入。
### 四、最佳实践
首先来看看启动类入口，上下文环境使用`AnnotationConfigApplicationContext`（此类是使用Java注解来配置Spring容器的方式），构造参数我们给定了一个`MyConfiguration`组件类，然后从中获取一个 `MyService` bean 并调用其 `show` 方法。
```java
public class LazyApplication {
public static void main(String[] args) {
System.out.println("启动 Spring ApplicationContext...");
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyConfiguration.class);
System.out.println("启动完成 Spring ApplicationContext...");
System.out.println("获取MyService...");
MyService myService = context.getBean(MyService.class);
System.out.println("调用show方法...");
myService.show();
}
}
```
这里使用`@Bean`注解，`MyBean` 被标注了 `@Lazy`，这意味着它只会在首次被请求时才会初始化。`MyService` 没有 `@Lazy` 注解，所以它会被立即初始化。
```java
@Configuration
public class MyConfiguration {
@Bean
@Lazy
public MyBean myBean(){
System.out.println("MyBean 初始化了!");
return new MyBean();
}
@Bean
public MyService myService(){
return new MyService();
}
}
```
`MyBean` 类定义很简单。它有一个构造函数，在构造函数中打印了 "MyBean 的构造函数被调用了!"，并有一个 `show` 方法，该方法打印 "hello world!"。
```java
public class MyBean {
public MyBean() {
System.out.println("MyBean 的构造函数被调用了!");
}
public void show() {
System.out.println("hello world!");
}
}
```
`MyService` 类有一个对 `MyBean` 的引用，而该引用通过 `@Autowired` 进行依赖注入。由于我们还在这个注入点上添加了 `@Lazy` 注解，这意味着 `myBean` 的实际注入将被延迟，直到我们首次尝试访问它时。
```java
public class MyService {
@Autowired
@Lazy
private MyBean myBean;
public void show() {
System.out.println("MyBean Class = " + myBean.getClass());
myBean.show();
}
}
```
运行结果发现
1. **延迟初始化**:
- 尽管 `MyService` 在应用上下文启动后可用，但由于 `MyBean` 上的 `@Lazy` 注解，`MyBean` 在启动时并未被初始化。
- 只有在首次访问或使用 `MyBean` 时，它才真正被初始化。这在 "MyBean 初始化了!" 和 "MyBean 的构造函数被调用了!" 的输出中得到了体现。
2. **延迟注入**:
- 在 `MyService` 的 `show` 方法首次被调用时，由于 `@Autowired` 和 `@Lazy` 注解的组合，Spring 不是直接注入原始的 `MyBean` 实例，而是注入一个代理对象。
- 这个代理对象的类名为 `com.xcs.spring.bean.MyBean$$EnhancerBySpringCGLIB$$2a517c55`，表明它是由 Spring 的 CGLIB 动态生成的。
- 当尝试访问该代理对象上的方法（如 `show` 方法）时，代理会确保真正的 `MyBean` 被初始化并代理该方法调用。
```java
启动 Spring ApplicationContext...
启动完成 Spring ApplicationContext...
获取MyService...
调用show方法...
MyBean Class = class com.xcs.spring.bean.MyBean$$EnhancerBySpringCGLIB$$2a517c55
MyBean 初始化了!
MyBean 的构造函数被调用了!
hello world!
```
### 五、时序图
#### 5.1、Bean注册时序图
~~~mermaid
sequenceDiagram
LazyApplication->>AnnotationConfigApplicationContext:AnnotationConfigApplicationContext(componentClasses)<br>创建应用上下文
AnnotationConfigApplicationContext->>AbstractApplicationContext:refresh()<br>刷新应用上下文
AbstractApplicationContext->>AbstractApplicationContext:invokeBeanFactoryPostProcessors(beanFactory)<br>调用BFPP方法
AbstractApplicationContext->>PostProcessorRegistrationDelegate:invokeBeanFactoryPostProcessors(beanFactory,beanFactoryPostProcessors)<br>委托BFPP处理
PostProcessorRegistrationDelegate->>PostProcessorRegistrationDelegate:invokeBeanDefinitionRegistryPostProcessors(postProcessors,registry,applicationStartup)<br>调用BDRPP方法
PostProcessorRegistrationDelegate->>ConfigurationClassPostProcessor:postProcessBeanDefinitionRegistry(registry)<br>处理Bean定义
ConfigurationClassPostProcessor->>ConfigurationClassPostProcessor:processConfigBeanDefinitions(registry)<br>处理配置类Bean
ConfigurationClassPostProcessor->>ConfigurationClassBeanDefinitionReader:loadBeanDefinitions(configurationModel)<br>加载Bean定义
ConfigurationClassBeanDefinitionReader->>ConfigurationClassBeanDefinitionReader:loadBeanDefinitionsForConfigurationClass(configClass,trackedConditionEvaluator)<br>为配置类加载
ConfigurationClassBeanDefinitionReader->>ConfigurationClassBeanDefinitionReader:loadBeanDefinitionsForBeanMethod(beanMethod)<br>为@Bean方法加载
ConfigurationClassBeanDefinitionReader->>AnnotationConfigUtils:processCommonDefinitionAnnotations(abd,metadata)<br>处理注解定义
AnnotationConfigUtils->>AnnotationConfigUtils:attributesFor(metadata, Lazy.class)<br>获取注解属性
AnnotationConfigUtils->>AbstractBeanDefinition:setLazyInit(lazyInit)<br>设置懒加载属性
~~~
#### 5.2、Bean延迟创建时序图
~~~mermaid
sequenceDiagram
DependsOnApplication->>AnnotationConfigApplicationContext:AnnotationConfigApplicationContext(componentClasses)<br>创建应用上下文
AnnotationConfigApplicationContext->>AbstractApplicationContext:refresh()<br>刷新应用上下文
AbstractApplicationContext->>AbstractApplicationContext:finishBeanFactoryInitialization(beanFactory)<br>完成bean工厂初始化
AbstractApplicationContext->>DefaultListableBeanFactory:preInstantiateSingletons()<br>预实例化单例beans
DefaultListableBeanFactory->>AbstractBeanDefinition:isLazyInit()
AbstractBeanDefinition->>DefaultListableBeanFactory:返回Bean是否懒加载
DefaultListableBeanFactory->>AbstractBeanFactory:getBean(beanName)
alt Bean是懒加载
AbstractBeanFactory->>DefaultListableBeanFactory: 执行初始化Bean对象
else Bean不是懒加载
AbstractBeanFactory->>DefaultListableBeanFactory: 跳过Bean初始化，等待真正使用时在初始化
end
~~~
#### 5.3、Bean延迟注入时序图
~~~mermaid
sequenceDiagram
Title: InstantiationAwareBeanPostProcessor时序图
InstantiationAwareBeanPostProcessorApplication->>AnnotationConfigApplicationContext:AnnotationConfigApplicationContext<br>开始初始化
AnnotationConfigApplicationContext->>AbstractApplicationContext:refresh<br>刷新上下文
AbstractApplicationContext->>AbstractApplicationContext:finishBeanFactoryInitialization<br>实例化非懒加载的单列Bean
AbstractApplicationContext->>DefaultListableBeanFactory:preInstantiateSingletons<br>预实例化Singleton
DefaultListableBeanFactory->>AbstractBeanFactory:getBean<br>根据beanName获取对象
AbstractBeanFactory->>AbstractBeanFactory:doGetBean<br>返回指定bean的实例
AbstractBeanFactory->>DefaultSingletonBeanRegistry:getSingleton<br>获取单例对象
DefaultSingletonBeanRegistry->>AbstractBeanFactory:getObject<br>ObjectFactory接口的工厂方法
AbstractBeanFactory->>AbstractAutowireCapableBeanFactory:createBean<br>创建一个bean实例，填充bean实例，应用后处理器
AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:doCreateBean(beanName,mbd,args)
AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:populateBean(beanName,mbd,bw)
AbstractAutowireCapableBeanFactory->>AutowiredAnnotationBeanPostProcessor:postProcessProperties(pvs,bean,beanName)
AutowiredAnnotationBeanPostProcessor->>AutowiredAnnotationBeanPostProcessor:findAutowiringMetadata(beanName,clazz,pvs)
AutowiredAnnotationBeanPostProcessor->>InjectionMetadata:inject(target,beanName,pvs)
InjectionMetadata->>AutowiredFieldElement:inject(bean,beanName,pvs)
AutowiredFieldElement->>AutowiredFieldElement:resolveFieldValue(field,bean,beanName)
AutowiredFieldElement->>DefaultListableBeanFactory:resolveDependency(descriptor,requestingBeanName,autowiredBeanNames,typeConverter)
DefaultListableBeanFactory->>DefaultListableBeanFactory:getAutowireCandidateResolver()
DefaultListableBeanFactory->>ContextAnnotationAutowireCandidateResolver:getLazyResolutionProxyIfNecessary(descriptor,beanName)
ContextAnnotationAutowireCandidateResolver->>ContextAnnotationAutowireCandidateResolver:isLazy(descriptor)
ContextAnnotationAutowireCandidateResolver->>ContextAnnotationAutowireCandidateResolver:buildLazyResolutionProxy(descriptor, beanName)
ContextAnnotationAutowireCandidateResolver->>ProxyFactory:getProxy(classLoader)
ProxyFactory->>ContextAnnotationAutowireCandidateResolver:返回被代理的对象
ContextAnnotationAutowireCandidateResolver->>DefaultListableBeanFactory:返回被代理的对象
DefaultListableBeanFactory->>AutowiredFieldElement:返回被代理的对象
AutowiredFieldElement->>Field:field.set(bean, value)注入被代理的对象
~~~
### 六、源码分析
首先来看看启动类入口，上下文环境使用`AnnotationConfigApplicationContext`（此类是使用Java注解来配置Spring容器的方式），构造参数我们给定了一个`MyConfiguration`组件类，然后从中获取一个 `MyService` bean 并调用其 `show` 方法。
```java
public class LazyApplication {
public static void main(String[] args) {
System.out.println("启动 Spring ApplicationContext...");
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyConfiguration.class);
System.out.println("启动完成 Spring ApplicationContext...");
System.out.println("获取MyService...");
MyService myService = context.getBean(MyService.class);
System.out.println("调用show方法...");
myService.show();
}
}
```
在`org.springframework.context.annotation.AnnotationConfigApplicationContext#AnnotationConfigApplicationContext`构造函数中，执行了三个步骤。
```java
public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
this();
register(componentClasses);
refresh();
}
```
在`org.springframework.context.support.AbstractApplicationContext#refresh`方法中，我们重点关注一下`finishBeanFactoryInitialization(beanFactory)`这方法会对实例化所有剩余非懒加载的单列Bean对象，其他方法不是本次源码阅读的重点暂时忽略。
```java
@Override
public void refresh() throws BeansException, IllegalStateException {
// ... [代码部分省略以简化]
// 实例化所有剩余非懒加载的单列Bean对象
finishBeanFactoryInitialization(beanFactory);
// ... [代码部分省略以简化]
}
```
在`org.springframework.context.support.AbstractApplicationContext#finishBeanFactoryInitialization`方法中，会继续调用`DefaultListableBeanFactory`类中的`preInstantiateSingletons`方法来完成所有剩余非懒加载的单列Bean对象。
```java
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
// ... [代码部分省略以简化]
// 完成所有剩余非懒加载的单列Bean对象。
beanFactory.preInstantiateSingletons();
}
```
#### 6.1、延迟初始化
在`org.springframework.beans.factory.support.DefaultListableBeanFactory#preInstantiateSingletons`方法中，确保所有非懒加载的单例 beans 在容器启动时都被初始化，除非它们显式地标记为懒加载。这也是为什么 `@Lazy` 注解对于那些想要推迟 bean 初始化的场景非常有用。
```java
public void preInstantiateSingletons() throws BeansException {
// ... [代码部分省略以简化]
// 复制Bean名称列表
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
// 初始化非懒加载单例
for (String beanName : beanNames) {
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
// Bean属性检查
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
// 是否为工厂Bean
if (isFactoryBean(beanName)) {
Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
// 是否为FactoryBean实例
if (bean instanceof FactoryBean) {
FactoryBean<?> factory = (FactoryBean<?>) bean;
boolean isEagerInit;
// 安全权限检查
if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
isEagerInit = AccessController.doPrivileged(
(PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit,
getAccessControlContext());
}
else {
// 是否立即初始化
isEagerInit = (factory instanceof SmartFactoryBean &&
((SmartFactoryBean<?>) factory).isEagerInit());
}
// 立即初始化Bean
if (isEagerInit) {
getBean(beanName);
}
}
}
else {
// 获取/创建Bean
getBean(beanName);
}
}
}
// ... [代码部分省略以简化]
}
```
#### 6.2、延迟注入
在`org.springframework.beans.factory.support.AbstractBeanFactory#getBean()`方法中，又调用了`doGetBean`方法来实际执行创建Bean的过程，传递给它bean的名称和一些其他默认的参数值。此处，`doGetBean`负责大部分工作，如查找bean定义、创建bean（如果尚未创建）、处理依赖关系等。
```java
@Override
public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);
}
```
在`org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean`方法中，首先检查所请求的bean是否是一个单例并且已经创建。如果尚未创建，它将创建一个新的实例。在这个过程中，它处理可能的异常情况，如循环引用，并确保返回的bean是正确的类型。这是Spring容器bean生命周期管理的核心部分。
```java
protected <T> T doGetBean(
String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
throws BeansException {
// ... [代码部分省略以简化]
// 开始创建bean实例
if (mbd.isSingleton()) {
// 如果bean是单例的，我们会尝试从单例缓存中获取它
// 如果不存在，则使用lambda创建一个新的实例
sharedInstance = getSingleton(beanName, () -> {
try {
// 尝试创建bean实例
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
// ... [代码部分省略以简化]
}
});
// 对于某些bean（例如FactoryBeans），可能需要进一步处理以获取真正的bean实例
beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
// ... [代码部分省略以简化]
// 确保返回的bean实例与请求的类型匹配
return adaptBeanInstance(name, beanInstance, requiredType);
}
```
在`org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton()`方法中，主要负责从单例缓存中获取一个已存在的bean实例，或者使用提供的`ObjectFactory`创建一个新的实例。这是确保bean在Spring容器中作为单例存在的关键部分。
```java
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
// ... [代码部分省略以简化]
// 同步访问单例对象缓存，确保线程安全
synchronized (this.singletonObjects) {
// 从缓存中获取单例对象
Object singletonObject = this.singletonObjects.get(beanName);
// 如果缓存中没有找到
if (singletonObject == null) {
// ... [代码部分省略以简化]
try {
// 使用工厂创建新的单例实例
singletonObject = singletonFactory.getObject();
newSingleton = true;
}
catch (IllegalStateException ex) {
// ... [代码部分省略以简化]
}
catch (BeanCreationException ex) {
// ... [代码部分省略以简化]
}
finally {
// ... [代码部分省略以简化]
}
// ... [代码部分省略以简化]
}
// 返回单例对象
return singletonObject;
}
}
```
在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBean()`方法中，主要的逻辑是调用 `doCreateBean`，这是真正进行 bean 实例化、属性填充和初始化的地方。这个方法会返回新创建的 bean 实例。
```java
@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
// ... [代码部分省略以简化]
try {
// 正常的bean实例化、属性注入和初始化。
// 这里是真正进行bean创建的部分。
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
// 记录bean成功创建的日志
if (logger.isTraceEnabled()) {
logger.trace("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}
catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
// ... [代码部分省略以简化]
}
catch (Throwable ex) {
// ... [代码部分省略以简化]
}
}
```
在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean`方法中，对 bean 的属性进行注入。
```java
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
// ... [代码部分省略以简化]
try {
// 属性注入：这一步将配置中的属性值注入到bean实例中。例如，XML中定义的属性或使用@Autowired和@Value注解的属性都会在这里被注入
populateBean(beanName, mbd, instanceWrapper);
// ... [代码部分省略以简化]
}
catch (Throwable ex) {
// ... [代码部分省略以简化]
}
// ... [代码部分省略以简化]
}
```
在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#populateBean`方法中，如果一个属性被标记为 `@Autowired`，并且与 `@Lazy` 结合使用，那么实际的懒加载逻辑会在这个步骤中的其他部分被处理（特别是通过 `AutowiredAnnotationBeanPostProcessor`）。
```java
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
// ... [代码部分省略以简化]
// 对每一个InstantiationAwareBeanPostProcessor进行处理，这些处理器可能会修改Bean的属性值。
for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
// 尝试使用新版本的方法 postProcessProperties
PropertyValues pvsToUse = bp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
// ... [代码部分省略以简化]
}
// ... [代码部分省略以简化]
}
```
在`org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor#postProcessProperties`方法中，用于处理 `@Autowired` 注解的依赖注入。
```java
@Override
public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
// 根据bean的名称和类查找@Autowired注解元数据
InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
try {
// 执行实际的依赖注入
metadata.inject(bean, beanName, pvs);
}
catch (BeanCreationException ex) {
// 抛出bean创建异常
throw ex;
}
catch (Throwable ex) {
// 处理其他类型的异常，转换为Bean创建异常
throw new BeanCreationException(beanName, "依赖自动注入失败", ex);
}
// 返回属性值
return pvs;
}
```
在`org.springframework.beans.factory.annotation.InjectionMetadata#inject`方法中，遍历所有这些元素并调用其 `inject` 方法，这样实现了对带有注解的字段或方法的实际注入。
```java
public void inject(Object target, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
// 获取已校验的注入元素
Collection<InjectedElement> checkedElements = this.checkedElements;
// 如果没有已校验的元素，则使用所有注入元素
Collection<InjectedElement> elementsToIterate =
(checkedElements != null ? checkedElements : this.injectedElements);
if (!elementsToIterate.isEmpty()) {
// 遍历所有待注入的元素（字段或方法）
for (InjectedElement element : elementsToIterate) {
// 执行实际的注入操作
element.inject(target, beanName, pvs);
}
}
}
```
在`org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor.AutowiredFieldElement#inject`方法中，这个 `inject` 方法的核心逻辑是解析 `@Autowired` 字段的值（即找到匹配的 bean 依赖）并注入到目标 bean 中。在这个过程中，使用缓存以提高性能。
```java
@Override
protected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
// 获取带有@Autowired注解的字段
Field field = (Field) this.member;
Object value;
// 如果字段的值已经被缓存，则直接从缓存中获取
if (this.cached) {
try {
value = resolvedCachedArgument(beanName, this.cachedFieldValue);
}
catch (NoSuchBeanDefinitionException ex) {
// 如果缓存中的bean意外被移除 -> 重新解析
value = resolveFieldValue(field, bean, beanName);
}
}
else {
// 解析字段的值（即找到要注入的bean）
value = resolveFieldValue(field, bean, beanName);
}
if (value != null) {
// 使字段可访问（例如，如果它是私有的）
ReflectionUtils.makeAccessible(field);
// 将解析出的值（bean）注入到目标bean的字段中
field.set(bean, value);
}
}
```
在`org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor.AutowiredFieldElement#resolveFieldValue`方法中，主要用于解析 `@Autowired` 注解的字段值。它确定了应该为目标字段注入哪个 bean。
```java
@Nullable
private Object resolveFieldValue(Field field, Object bean, @Nullable String beanName) {
// ... [代码部分省略以简化]
Object value;
try {
// 解析依赖：这里的核心逻辑是使用bean工厂去解析字段的依赖。它会查找合适的bean来注入到此字段。
value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);
}
catch (BeansException ex) {
// 当无法解析依赖时，抛出异常
throw new UnsatisfiedDependencyException(null, beanName, new InjectionPoint(field), ex);
}
// ... [代码部分省略以简化]
// 返回解析到的值（bean）
return value;
}
```
在`org.springframework.beans.factory.support.DefaultListableBeanFactory#resolveDependency`方法中，这里的关键逻辑是 `getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary`，该方法尝试为描述的依赖关系获取一个懒加载代理。如果该依赖关系标记为懒加载 (`@Lazy`)，并且被 `@Autowired` 引用，那么它将返回一个懒加载代理，而不是实际的 bean。这样，只有当应用程序真正访问该依赖关系时，实际的 bean 才会被初始化。
```java
@Override
@Nullable
public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,
@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
// ... [代码部分省略以简化]
// 尝试为描述的依赖关系获取一个懒加载代理。如果依赖是懒加载的，这将返回一个代理对象。
Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(
descriptor, requestingBeanName);
// 如果没有为懒加载的依赖关系获取到代理，则尝试直接解析依赖关系
if (result == null) {
result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);
}
return result; // 返回解析得到的bean或者懒加载代理
}
```
在`org.springframework.context.annotation.ContextAnnotationAutowireCandidateResolver#getLazyResolutionProxyIfNecessary`方法中，如果是懒加载，会调用 `buildLazyResolutionProxy` 来创建一个代理，当首次访问该代理时，代理会触发实际的 bean 初始化。
```java
@Override
@Nullable
public Object getLazyResolutionProxyIfNecessary(DependencyDescriptor descriptor, @Nullable String beanName) {
// 判断依赖描述是否被标记为懒加载
// 如果是懒加载，为其构建一个懒加载代理
// 如果不是懒加载，则返回null
return (isLazy(descriptor) ? buildLazyResolutionProxy(descriptor, beanName) : null);
}
```
在`org.springframework.context.annotation.ContextAnnotationAutowireCandidateResolver#buildLazyResolutionProxy`方法中，核心部分是 `TargetSource` 和 `ProxyFactory`。当我们访问这个懒加载代理时，`TargetSource` 的 `getTarget` 方法会被调用，它会解析和返回真正的 bean（或其他依赖项）。使用 `ProxyFactory`，可以为给定的 `TargetSource` 创建一个新的代理。这是 `@Lazy` 注解在字段注入时的实际实现，确保在首次访问字段时才触发依赖的解析和bean的初始化。
```java
protected Object buildLazyResolutionProxy(final DependencyDescriptor descriptor, final @Nullable String beanName) {
// 获取当前的BeanFactory
BeanFactory beanFactory = getBeanFactory();
// 确认BeanFactory是DefaultListableBeanFactory的实例
Assert.state(beanFactory instanceof DefaultListableBeanFactory,
"BeanFactory needs to be a DefaultListableBeanFactory");
final DefaultListableBeanFactory dlbf = (DefaultListableBeanFactory) beanFactory;
// 创建一个目标源(TargetSource)用于懒加载代理
TargetSource ts = new TargetSource() {
// 获取依赖的类型
@Override
public Class<?> getTargetClass() {
return descriptor.getDependencyType();
}
@Override
public boolean isStatic() {
return false;
}
// 当访问代理时，该方法被调用来解析实际的依赖关系
@Override
public Object getTarget() {
// ... [代码部分省略以简化]
return target; // 返回解析得到的bean
}
@Override
public void releaseTarget(Object target) {
}
};
// 使用Spring的ProxyFactory创建一个新的代理
ProxyFactory pf = new ProxyFactory();
pf.setTargetSource(ts);
Class<?> dependencyType = descriptor.getDependencyType();
if (dependencyType.isInterface()) {
pf.addInterface(dependencyType);
}
// 返回懒加载代理
return pf.getProxy(dlbf.getBeanClassLoader());
}
```
### 七、注意事项
1. **默认行为**
+ 如果没有使用 `@Lazy` 注解，Spring 容器会在启动时立即实例化单例 bean。通过使用 `@Lazy`，我们可以改变这个行为，使得 bean 只在首次请求时被初始化。
2. **构造函数注入**
+ 如果一个懒加载的 bean 依赖于另一个非懒加载的 bean，那么该懒加载的 bean 会在容器启动时被初始化，因为它的依赖需要它。这种情况常常在构造函数注入时出现。
3. **上下文的生命周期**
+ `@Lazy` 对于应用上下文的启动速度可能有益，因为少了一些即时初始化的工作。但请注意，延迟初始化可能会导致我们在首次访问 bean 时遇到延迟。
4. **与 `@Autowired` 结合使用**
+ 如果我们在一个字段或 setter 方法上同时使用 `@Autowired` 和 `@Lazy`，Spring 会注入一个代理对象。这个代理对象会在我们首次访问它时触发真正的 bean 初始化。
5. **懒加载的代理**
+ 当与 `@Autowired` 结合使用时，要确保 bean 的类型与代理类型兼容。如果注入的 bean 类型是一个接口，Spring 会创建一个基于接口的代理。如果是一个类，Spring 会创建一个基于类的代理。
6. **错误处理**
+ 延迟初始化意味着某些错误可能在应用启动时不会被立即发现，例如 bean 配置错误。这样的错误只有在实际尝试初始化 bean 时才会被抛出。
7. **在组件类上使用**
+ 对于直接或间接使用 `@Component`、`@Service`、`@Repository` 或 `@Controller` 注解的类，可以使用 `@Lazy` 注解来使这些组件在首次被注入或查找时才被初始化。
### 八、总结
#### 8.1、最佳实践总结
1. **上下文初始化**:
- 使用 `AnnotationConfigApplicationContext` 初始化应用上下文是针对基于Java的配置的推荐做法。
- 提供一个配置类（如 `MyConfiguration`）作为参数可以帮助上下文知道如何加载和配置beans。
2. **懒加载配置**:
- 通过在配置类的 `@Bean` 方法上添加 `@Lazy` 注解，可以确保特定的bean只在首次请求时被初始化，而不是在应用上下文启动时。
- 这可以提高应用启动速度，特别是对于资源密集型的beans或需要长时间初始化的beans。
3. **依赖注入**:
- 使用 `@Autowired` 注解是Spring的核心特性，它可以自动注入bean的依赖关系。
- 当与 `@Lazy` 注解组合使用时，Spring会注入一个代理对象而不是实际的bean实例。这个代理对象在首次访问时会触发真正的bean初始化。
4. **理解代理**:
- 由于延迟注入，通过 `@Autowired` 和 `@Lazy` 注解注入的对象是一个由CGLIB生成的代理对象。
- 这个代理对象负责在首次访问时初始化真正的bean。
5. **输出与验证**:
- 通过在bean的初始化和方法调用中添加日志或打印语句，可以验证和观察懒加载和代理的行为。
- 这对于确保应用的预期行为和性能调优非常有用。
#### 8.2、源码分析总结
1. **启动及初始化**:
- 使用`AnnotationConfigApplicationContext`初始化应用上下文。
- 在`AnnotationConfigApplicationContext`的构造函数中，执行了注册(`register`)和刷新(`refresh`)方法。
2. **Bean的实例化**:
- 在上下文刷新过程中，`finishBeanFactoryInitialization(beanFactory)`方法确保所有非懒加载的单例Beans被实例化。
- `DefaultListableBeanFactory#preInstantiateSingletons`方法确保所有非懒加载的单例Beans在容器启动时被初始化。
3. **延迟初始化**:
- 如果Bean被标记为`@Lazy`，它将不会在容器启动时被初始化，但只在首次请求时。
- `DefaultListableBeanFactory#preInstantiateSingletons`方法中，对于`isLazyInit`返回`true`的Beans，不会进行预初始化。
4. **Bean的获取与依赖注入**:
- 使用`AbstractBeanFactory#getBean`方法获取Bean实例。
- 如果Bean尚未创建，`doGetBean`方法将执行Bean的实际创建，包括解析依赖关系、处理循环引用等。
- 对于单例Beans，它们将被缓存，确保每次都返回相同的实例。
- 通过`AbstractAutowireCapableBeanFactory#createBean`来进行实际的Bean创建，并且将其属性通过`populateBean`方法注入。
5. **延迟注入**:
- 如果一个字段或属性被`@Autowired`注解，并与`@Lazy`结合使用，实际的懒加载逻辑会在属性填充阶段被处理。
- 使用`AutowiredAnnotationBeanPostProcessor`来处理带有`@Autowired`注解的属性的注入。
- 在`AutowiredFieldElement#inject`方法中，如果字段被标记为`@Lazy`，Spring不会直接注入真实的Bean，而是注入一个懒加载代理。
- 这个懒加载代理的实际行为是在首次访问时触发真正的Bean初始化。
6. **懒加载代理的创建**:
- 使用`ContextAnnotationAutowireCandidateResolver`来检查依赖关系是否需要懒加载。
- 如果需要懒加载，它将使用`buildLazyResolutionProxy`方法来为该依赖关系创建一个代理。
- 这个代理的行为是：在首次访问时，它会解析和返回真正的Bean或其他依赖项。
- 使用Spring的`ProxyFactory`来为给定的目标源创建新的代理。

5
spring-annotation/spring-annotation-lazy/src/main/java/com/xcs/spring/LazyApplication.java
View File

@ -13,11 +13,10 @@ public class LazyApplication {
public static void main(String[] args) { public static void main(String[] args) {
System.out.println("启动 Spring ApplicationContext..."); System.out.println("启动 Spring ApplicationContext...");
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyConfiguration.class); AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyConfiguration.class);
System.out.println("完成启动 Spring ApplicationContext..."); System.out.println("启动完成 Spring ApplicationContext...");
System.out.println("准备获取MyService..."); System.out.println("获取MyService...");
MyService myService = context.getBean(MyService.class); MyService myService = context.getBean(MyService.class);
System.out.println("成功获取MyService...-->" + myService);
System.out.println("调用show方法..."); System.out.println("调用show方法...");
myService.show(); myService.show();

2
spring-annotation/spring-annotation-lazy/src/main/java/com/xcs/spring/bean/MyBean.java
View File

@ -7,6 +7,6 @@ public class MyBean {
} }
public void show() { public void show() {
System.out.println("hello world"); System.out.println("hello world!");
} }
} }

2
spring-annotation/spring-annotation-lazy/src/main/java/com/xcs/spring/service/MyService.java
View File

@ -11,7 +11,7 @@ public class MyService {
private MyBean myBean; private MyBean myBean;
public void show() { public void show() {
System.out.println("@Lazy MyBean = " + myBean.getClass()); System.out.println("MyBean Class = " + myBean.getClass());
myBean.show(); myBean.show();
} }
} }