From ff3faa04b6c4f037c45c4550c02b895710d4b8cd Mon Sep 17 00:00:00 2001 From: xuchengsheng Date: Tue, 24 Oct 2023 18:02:43 +0800 Subject: [PATCH] =?UTF-8?q?getBean=E6=96=B9=E6=B3=95=E6=BA=90=E7=A0=81?= =?UTF-8?q?=E5=88=86=E6=9E=90?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- spring-core/spring-core-getBean/README.md | 1478 +++++++---------- .../com/xcs/spring/GetBeanApplication.java | 7 +- 2 files changed, 559 insertions(+), 926 deletions(-) diff --git a/spring-core/spring-core-getBean/README.md b/spring-core/spring-core-getBean/README.md index e7c7e8d..9152333 100644 --- a/spring-core/spring-core-getBean/README.md +++ b/spring-core/spring-core-getBean/README.md @@ -1,57 +1,62 @@ -## `IOC` +## getBean -- [`IOC`](#ioc) - - [一、接口描述](#一接口描述) - - [二、IOC源码](#二ioc源码) - - [三、主要功能](#三主要功能) - - [四、最佳实践](#四最佳实践) - - [五、时序图](#五时序图) - - [5.1、Bean定义注册过程时序图](#51bean定义注册过程时序图) - - [5.2、Bean初始化过程时序图](#52bean初始化过程时序图) - - [5.3、Bean销毁过程时序图](#53bean销毁过程时序图) - - [六、源码分析](#六源码分析) - - [6.1、Bean定义注册过程源码分析](#61bean定义注册过程源码分析) - - [6.2、Bean初始化过程源码分析](#62bean初始化过程源码分析) - - [6.3、Bean销毁过程源码分析](#63bean销毁过程源码分析) - - [七、注意事项](#七注意事项) - - [八、总结](#八总结) - - [8.1、最佳实践总结](#81最佳实践总结) - - [8.2、源码分析总结](#82源码分析总结) +### 一、基本信息 +✒️ **作者** - Lex 📝 **博客** - [我的CSDN]() 📚 **文章目录** - [所有文章](https://github.com/xuchengsheng/spring-reading) 🔗 **源码地址** - [getBean源码](https://github.com/xuchengsheng/spring-reading/tree/master/spring-core/spring-core-getBean) -### 一、接口描述 +### 二、方法描述 -Spring IOC（Inversion of Control）容器是Spring框架的核心部分。它负责创建、配置、装配和管理应用中的对象及其生命周期。 +在 Spring 框架中，`getBean` 方法是 `ApplicationContext` 接口中的一个核心方法，用于从 Spring 容器中检索 bean。Spring 的核心是控制反转（Inversion of Control, IoC）和依赖注入（Dependency Injection, DI），`getBean` 方法正是实现这两个核心概念的重要方法。 -### 二、IOC源码 +### 三、方法源码 -由于IOC是框架的核心部分，其源码是非常庞大和复杂的。在这里，可以为大家提供一个关于IOC部分源码的概述，但要理解每个细节，你可能需要花费相当的时间去阅读和理解。Spring框架的源码是开源的，你可以在其GitHub仓库中找到。 - -### 三、主要功能 - -+ **依赖管理**：Spring IOC容器负责自动注入对象的依赖。这意味着我们不需要手动地在对象内部创建或查找其依赖项；相反，Spring容器会为我们注入它们。这有助于实现解耦和更好的模块化。提供多种注入方式，例如构造器注入、Setter方法注入和字段注入。 - -+ **Bean生命周期管理**：从bean的创建、初始化到销毁，Spring IOC容器都会管理其整个生命周期。可以使用初始化方法、销毁方法、`InitializingBean`和`DisposableBean`接口等方式来控制bean的生命周期。 - -+ **作用域管理**：Spring IOC容器支持多种bean的作用域，如单例（singleton）、原型（prototype）、会话（session）和请求（request）等。 - -+ **AOP与IOC的集成**：Spring的AOP（面向切面编程）功能与IOC容器紧密集成，允许你为bean定义切面、通知和切点，实现横切关注点的模块化。 - -+ **提供扩展点**：通过`BeanPostProcessor`、`BeanFactoryPostProcessor`等扩展点，可以在bean初始化前后插入自定义逻辑 - -### 四、最佳实践 - -首先来看看启动类入口，上下文环境使用`AnnotationConfigApplicationContext`（此类是使用Java注解来配置Spring容器的方式），构造参数我们给定了一个`MyConfiguration`组件类。通过`getBeanDefinitionNames`方法，可以获得容器中所有bean的名称，使用`getBean`方法获取其实例，并打印该Bean，最后关闭了容器来触发单例bean的销毁方法。 +这个方法的定义和说明表明了 Spring IoC 容器的一些核心概念和工作机制。当你请求一个 bean 时，Spring 会查找该 bean、处理任何别名、检查其作用域（例如，单例或原型），并最终返回适当的 bean 实例给调用者。 ```java -public class IOCApplication { +/** + * 返回指定bean的实例，该实例可能是共享的或独立的。 + * 此方法使Spring BeanFactory可以替代单例或原型设计模式。在单例bean的情况下，调用者可以保留返回对象的引用。 + * 将别名转换回相应的规范bean名称。 + * 如果在这个工厂实例中找不到bean，将询问父工厂。 + * + * @param name 要检索的bean的名称 + * @return bean的实例 + * @throws NoSuchBeanDefinitionException 如果没有指定名称的bean + * @throws BeansException 如果无法获取bean + */ +Object getBean(String name) throws BeansException; +``` + +### 四、主要功能 + +1. **检索 Bean** + + 从 Spring 容器中检索并返回指定名称或类型的 bean 的实例。 +2. **作用域处理** + + 根据 bean 的配置和作用域（例如 "singleton" 或 "prototype"），`getBean` 可以返回单例的 bean 实例或每次都创建一个新的实例。 +3. **别名处理** + + 如果 bean 有别名，`getBean` 可以根据这些别名解析并返回相应的 bean 实例。 +4. **考虑父容器** + + 如果在当前容器中找不到 bean，但容器有父容器，则 `getBean` 会在父容器中查找该 bean。 +5. **类型转换** + + `getBean` 还有一个重载版本，允许用户指定返回 bean 的类型，这样可以避免在后续使用中进行显式的类型转换。 +6. **异常处理** + + 如果容器中不存在指定的 bean，它会抛出 `NoSuchBeanDefinitionException`。如果在尝试创建或检索 bean 时出现其他问题，它会抛出 `BeansException`。 +7. **支持依赖查找** + + 尽管 Spring 的主要目标是通过依赖注入提供依赖关系，但 `getBean` 方法提供了一种手动查找依赖的方式。 +8. **初始化 Bean** + + 如果 bean 尚未初始化（例如，对于单例 bean 在首次请求时），`getBean` 方法会触发其初始化。 + +### 五、最佳实践 + +首先来看看启动类入口，上下文环境使用`AnnotationConfigApplicationContext`（此类是使用Java注解来配置Spring容器的方式），构造参数我们给定了一个`MyConfiguration`组件类，然后从Spring上下文中获取两个Bean对象`myServiceA`，`myServiceB`类型的bean。 + +```java +public class GetBeanApplication { public static void main(String[] args) { AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyConfiguration.class); - for (String beanDefinitionName : context.getBeanDefinitionNames()) { - System.out.println("Bean = " + context.getBean(beanDefinitionName)); - } - context.close(); + System.out.println("myServiceA = " + context.getBean("myServiceA")); + System.out.println("myServiceB = " + context.getBean("myServiceB")); } } ``` @@ -62,7 +67,7 @@ public class IOCApplication { @Configuration @ComponentScan("com.xcs.spring.service") public class MyConfiguration { - + } ``` @@ -72,7 +77,7 @@ public class MyConfiguration { package com.xcs.spring.service; @Component -public class MyServiceB { +public class MyServiceA { } @@ -82,288 +87,177 @@ public class MyServiceB { } ``` -运行结果发现，这是我们自己定义的两个服务类。它们都被标记为`@Component`，因此Spring容器会为每个类创建一个bean实例（其他的Bean是Spring内部Bean）。 +运行结果发现，这是我们自己定义的两个服务类。它们都被标记为`@Component`，因此Spring容器会为每个类创建一个bean实例。 ```java -Bean = org.springframework.context.annotation.ConfigurationClassPostProcessor@23c30a20 -Bean = org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor@1e1a0406 -Bean = org.springframework.context.event.EventListenerMethodProcessor@3cebbb30 -Bean = org.springframework.context.event.DefaultEventListenerFactory@12aba8be -Bean = com.xcs.spring.config.MyConfiguration$$EnhancerBySpringCGLIB$$7a35e03c@290222c1 -Bean = com.xcs.spring.service.MyServiceA@67f639d3 -Bean = com.xcs.spring.service.MyServiceB@6253c26 +myServiceA = com.xcs.spring.service.MyServiceA@23c30a20 +myServiceB = com.xcs.spring.service.MyServiceB@1e1a0406 ``` -### 五、时序图 - -#### 5.1、Bean定义注册过程时序图 +### 六、时序图 ~~~mermaid sequenceDiagram - Title: Bean注册过程时序图 - participant IOCApplication - participant AnnotationConfigApplicationContext - participant AbstractApplicationContext - participant PostProcessorRegistrationDelegate - participant ConfigurationClassPostProcessor - participant ConfigurationClassParser - participant ComponentScanAnnotationParser - participant ClassPathBeanDefinitionScanner - participant BeanDefinitionReaderUtils - participant DefaultListableBeanFactory - - IOCApplication->>AnnotationConfigApplicationContext:AnnotationConfigApplicationContext(componentClasses)
创建应用上下文 - AnnotationConfigApplicationContext->>AbstractApplicationContext:refresh()
刷新应用上下文 - AbstractApplicationContext->>AbstractApplicationContext:invokeBeanFactoryPostProcessors(beanFactory)
调用BFPP方法 - AbstractApplicationContext->>PostProcessorRegistrationDelegate:invokeBeanFactoryPostProcessors(beanFactory,beanFactoryPostProcessors)
委托BFPP处理 - PostProcessorRegistrationDelegate->>PostProcessorRegistrationDelegate:invokeBeanDefinitionRegistryPostProcessors(postProcessors,registry,applicationStartup)
调用BDRPP方法 - PostProcessorRegistrationDelegate->>ConfigurationClassPostProcessor:postProcessBeanDefinitionRegistry(registry)
处理Bean定义 - ConfigurationClassPostProcessor->>ConfigurationClassPostProcessor:processConfigBeanDefinitions(registry)
处理配置类Bean - ConfigurationClassPostProcessor->>ConfigurationClassParser:parse(configCandidates)
解析配置类 - ConfigurationClassParser->>ConfigurationClassParser:parse(metadata,beanName)
解析指定类 - ConfigurationClassParser->>ConfigurationClassParser:processConfigurationClass(configClass,filter)
处理配置注解 - ConfigurationClassParser->>+ConfigurationClassParser: doProcessConfigurationClass(configClass, sourceClass, filter)
进一步处理配置 - ConfigurationClassParser-->>-ConfigurationClassParser: 返回SourceClass - ConfigurationClassParser->>ComponentScanAnnotationParser:parse(componentScan,declaringClass)
解析@ComponentScan - ComponentScanAnnotationParser->>ClassPathBeanDefinitionScanner:doScan(basePackages)
扫描指定包路径 - ClassPathBeanDefinitionScanner->>+ClassPathBeanDefinitionScanner:findCandidateComponents(basePackage)
找到Bean候选者 - ClassPathBeanDefinitionScanner-->>-ClassPathBeanDefinitionScanner:返回Set - ClassPathBeanDefinitionScanner->>ClassPathBeanDefinitionScanner:registerBeanDefinition(definitionHolder,registry)
注册Bean定义 - ClassPathBeanDefinitionScanner->>BeanDefinitionReaderUtils:registerBeanDefinition(definitionHolder,registry)
工具类注册Bean - BeanDefinitionReaderUtils->>DefaultListableBeanFactory:registerBeanDefinition(beanName,beanDefinition)
最终注册Bean - ComponentScanAnnotationParser-->>ConfigurationClassParser:返回Set +DefaultListableBeanFactory->>AbstractBeanFactory:getBean(name) +note over AbstractBeanFactory: 请求一个Bean +AbstractBeanFactory->>AbstractBeanFactory:doGetBean(name,requiredType,args,typeCheckOnly) +note over AbstractBeanFactory: 执行实际的获取Bean逻辑 + +AbstractBeanFactory->>AbstractBeanFactory:transformedBeanName(name) +note over AbstractBeanFactory: 获取真正的bean名称 + +AbstractBeanFactory->>DefaultSingletonBeanRegistry:getSingleton(beanName) +note over DefaultSingletonBeanRegistry: 检查Bean是否为单例 + +DefaultSingletonBeanRegistry->>DefaultSingletonBeanRegistry:getSingleton(beanName,allowEarlyReference) +note over DefaultSingletonBeanRegistry: 如果允许，检查早期引用的单例Bean + +DefaultSingletonBeanRegistry->>AbstractBeanFactory:返回已注册的singleton对象 +note over AbstractBeanFactory: 如果已注册，则返回这个单例Bean + +AbstractBeanFactory->>DefaultListableBeanFactory:返回Bean对象 +note over DefaultListableBeanFactory: 返回到原始的请求源 + +note over AbstractBeanFactory: Bean不在缓存中，需要创建 + +AbstractBeanFactory->>AbstractBeanFactory:getParentBeanFactory() +note over AbstractBeanFactory: 检查是否有父Bean工厂 + +AbstractBeanFactory->>DefaultListableBeanFactory:parentBeanFactory.getBean(name) +note over DefaultListableBeanFactory: 在父工厂中请求Bean + +AbstractBeanFactory->>AbstractBeanFactory:markBeanAsCreated(beanName) +note over AbstractBeanFactory: 标记该Bean为已创建 + +AbstractBeanFactory->>AbstractBeanFactory:getMergedLocalBeanDefinition(beanName) +note over AbstractBeanFactory: 获取合并后的Bean定义 + +AbstractBeanFactory->>AbstractBeanFactory:checkMergedBeanDefinition(mbd, beanName, args) +note over AbstractBeanFactory: 检查合并后的Bean定义是否有效 + +AbstractBeanFactory->>AbstractBeanDefinition:getDependsOn() +note over AbstractBeanFactory: 获取该Bean的依赖 + +AbstractBeanFactory->>DefaultSingletonBeanRegistry:isDependent(beanName, dep) +note over DefaultSingletonBeanRegistry: 检查是否存在依赖 + +DefaultSingletonBeanRegistry->>DefaultSingletonBeanRegistry:isDependent(beanName, dependentBeanName, null) +note over DefaultSingletonBeanRegistry: 检查依赖 + +DefaultSingletonBeanRegistry->>DefaultSingletonBeanRegistry:canonicalName(beanName) +note over DefaultSingletonBeanRegistry: 获取Bean的规范名称 + +DefaultSingletonBeanRegistry->>AbstractBeanFactory:返回是否存在循环依赖的情况 +note over AbstractBeanFactory: 返回循环依赖的检查结果 + +note over AbstractBeanFactory: 如果存在循环依赖，则抛出异常 throw new BeanCreationException(""Circular depends-on relationship between") + +AbstractBeanFactory->>DefaultSingletonBeanRegistry:registerDependentBean(dep, beanName) +note over DefaultSingletonBeanRegistry: 注册依赖关系 + +AbstractBeanFactory->>DefaultListableBeanFactory:getBean(name) +note over DefaultListableBeanFactory: 获取被依赖的bean对象 + +AbstractBeanFactory->>DefaultSingletonBeanRegistry:getSingleton(beanName,singletonFactory) +note over DefaultSingletonBeanRegistry: 获取或创建单例Bean + +DefaultSingletonBeanRegistry->>DefaultSingletonBeanRegistry:beforeSingletonCreation(beanName) +note over DefaultSingletonBeanRegistry: 在创建单例之前的准备工作 + +DefaultSingletonBeanRegistry->>AbstractBeanFactory:singletonFactory.getObject() +note over AbstractBeanFactory: 使用单例工厂创建Bean + +AbstractBeanFactory->>AbstractAutowireCapableBeanFactory:createBean(beanName, mbd, args) +note over AbstractAutowireCapableBeanFactory: 创建新的Bean实例 + +AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:resolveBeanClass(mbd, beanName) +note over AbstractAutowireCapableBeanFactory: 解析Bean的类 + +AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:resolveBeforeInstantiation(beanName, mbdToUse) +note over AbstractAutowireCapableBeanFactory: 在实例化前尝试解析Bean + +AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:doCreateBean(beanName,mbd,args) +note over AbstractAutowireCapableBeanFactory: 执行实际的Bean创建 + +AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:createBeanInstance(beanName, mbd, args) +note over AbstractAutowireCapableBeanFactory: 创建Bean实例 + +AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:determineConstructorsFromBeanPostProcessors(beanClass, beanName) +note over AbstractAutowireCapableBeanFactory: 从SmartInstantiationAwareBeanPostProcessor确定构造器 + +AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:instantiateBean(beanName, mbd) +note over AbstractAutowireCapableBeanFactory: 实例化Bean + +AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName) +note over AbstractAutowireCapableBeanFactory: 应用合并后的Bean定义后处理器 + +AbstractAutowireCapableBeanFactory->>DefaultSingletonBeanRegistry:addSingletonFactory(beanName,singletonFactory) +note over DefaultSingletonBeanRegistry: 添加单例工厂 + +AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:populateBean(beanName, mbd, instanceWrapper) +note over AbstractAutowireCapableBeanFactory: 填充Bean的属性 + +AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:postProcessAfterInstantiation(bean,beanName) +note over AbstractAutowireCapableBeanFactory: 实例化后的后处理 + +AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:postProcessProperties(pvs,bean,beanName) +note over AbstractAutowireCapableBeanFactory: 属性后处理 + +AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:postProcessPropertyValues(pvs,pds,bean,beanName) +note over AbstractAutowireCapableBeanFactory: 属性后处理 + +AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:applyPropertyValues(beanName,mbd,bw,pvs) +note over AbstractAutowireCapableBeanFactory: 应用属性值 + +AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:initializeBean(beanName, exposedObject, mbd) +note over AbstractAutowireCapableBeanFactory: 初始化Bean + +AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:invokeAwareMethods(beanName, bean) +note over AbstractAutowireCapableBeanFactory: 调用Aware接口方法 + +AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName) +note over AbstractAutowireCapableBeanFactory: 在初始化前应用BeanPostProcessors + +AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:invokeInitMethods(beanName, wrappedBean, mbd) +note over AbstractAutowireCapableBeanFactory: 调用初始化方法 + +AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName) +note over AbstractAutowireCapableBeanFactory: 在初始化后应用BeanPostProcessors + +AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:registerDisposableBeanIfNecessary(beanName, bean, mbd) +note over AbstractAutowireCapableBeanFactory: 如果需要，注册可销毁的Bean + +AbstractAutowireCapableBeanFactory->>AbstractBeanFactory:返回创建的单例Bean +AbstractBeanFactory->>DefaultSingletonBeanRegistry:返回创建的单例Bean + +DefaultSingletonBeanRegistry->>DefaultSingletonBeanRegistry:afterSingletonCreation(beanName) +note over DefaultSingletonBeanRegistry: 单例创建后的后续处理 + +DefaultSingletonBeanRegistry->>DefaultSingletonBeanRegistry:addSingleton(beanName, singletonObject) +note over DefaultSingletonBeanRegistry: 向注册表中添加新的单例Bean + +DefaultSingletonBeanRegistry->>AbstractBeanFactory:返回创建的单例Bean + +AbstractBeanFactory->>AbstractAutowireCapableBeanFactory:getObjectForBeanInstance(sharedInstance, name, beanName, mbd) +note over AbstractAutowireCapableBeanFactory: 获取Bean实例的对象 + +AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:处理FactoryBean +note over AbstractAutowireCapableBeanFactory: 如果是FactoryBean，则处理 + +AbstractAutowireCapableBeanFactory->>AbstractBeanFactory:返回真正的Bean对象 +note over AbstractBeanFactory: 返回真实的Bean对象，而不是FactoryBean + +AbstractBeanFactory->>AbstractBeanFactory:adaptBeanInstance(name, beanInstance, requiredType) +note over AbstractBeanFactory: 适配Bean实例的类型 + +AbstractBeanFactory->>DefaultListableBeanFactory:返回真正的Bean对象 +note over DefaultListableBeanFactory: 返回到原始的请求源 ~~~ -#### 5.2、Bean初始化过程时序图 +### 七、源码分析 -~~~mermaid -sequenceDiagram - Title: Bean初始化过程时序图 - participant IOCApplication - participant AnnotationConfigApplicationContext - participant AbstractApplicationContext - participant DefaultListableBeanFactory - participant AbstractBeanFactory - participant DefaultSingletonBeanRegistry - participant AbstractAutowireCapableBeanFactory - participant InstantiationAwareBeanPostProcessor - participant SmartInstantiationAwareBeanPostProcessor - participant MergedBeanDefinitionPostProcessor - participant BeanPostProcessor - participant InitializingBean - participant Bean对象 - - IOCApplication->>AnnotationConfigApplicationContext:AnnotationConfigApplicationContext(componentClasses)
创建应用上下文 - AnnotationConfigApplicationContext->>AbstractApplicationContext:refresh()
刷新应用上下文 - AbstractApplicationContext->>AbstractApplicationContext:finishBeanFactoryInitialization(beanFactory)
完成bean工厂初始化 - AbstractApplicationContext->>DefaultListableBeanFactory:preInstantiateSingletons()
预实例化单例beans - DefaultListableBeanFactory->>AbstractBeanFactory:getBean(name)
获取bean实例 - AbstractBeanFactory->>AbstractBeanFactory:doGetBean(name,requiredType,args,typeCheckOnly)
具体获取bean逻辑 - AbstractBeanFactory->>DefaultSingletonBeanRegistry:getSingleton(beanName,singletonFactory)
从注册表获取单例bean - DefaultSingletonBeanRegistry-->>AbstractBeanFactory:getObject()
从工厂获取bean对象 - AbstractBeanFactory->>AbstractAutowireCapableBeanFactory:createBean(beanName,mbd,args)
创建bean实例 - AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:resolveBeforeInstantiation(beanName, mbdToUse)
解析实例化前的bean - AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:applyBeanPostProcessorsBeforeInstantiation(targetType, beanName)
应用BP前实例化 - AbstractAutowireCapableBeanFactory->>InstantiationAwareBeanPostProcessor:postProcessBeforeInstantiation(beanClass, beanName)
实例化前处理bean - InstantiationAwareBeanPostProcessor-->>AbstractAutowireCapableBeanFactory:返回要使用的bean对象 - AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:doCreateBean(beanName,mbd,args)
执行创建bean逻辑 - AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:createBeanInstance(beanName, mbd, args)
创建bean实例 - AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:determineConstructorsFromBeanPostProcessors(beanClass, beanName)
确定构造器 - AbstractAutowireCapableBeanFactory->>SmartInstantiationAwareBeanPostProcessor:determineCandidateConstructors(beanClass, beanName)
确定候选构造器 - SmartInstantiationAwareBeanPostProcessor-->>AbstractAutowireCapableBeanFactory:返回构造器 - AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:applyMergedBeanDefinitionPostProcessors(mbd,beanType,beanName)
应用合并的BDPP - AbstractAutowireCapableBeanFactory->>MergedBeanDefinitionPostProcessor:postProcessMergedBeanDefinition(mbd,beanType,beanName)
处理合并的bean定义 - AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:addSingletonFactory(beanName,singletonFactory)
添加单例工厂 - AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:getEarlyBeanReference(beanName,mbd,bean)
获取早期bean引用 - AbstractAutowireCapableBeanFactory->>SmartInstantiationAwareBeanPostProcessor:getEarlyBeanReference(exposedObject, beanName)
获取早期bean引用 - SmartInstantiationAwareBeanPostProcessor-->>AbstractAutowireCapableBeanFactory:返回bean引用公开的对象 - AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:populateBean(beanName,mbd,instanceWrapper)
填充bean属性 - AbstractAutowireCapableBeanFactory->>InstantiationAwareBeanPostProcessor:postProcessAfterInstantiation(bean,beanName)
实例化后处理bean - InstantiationAwareBeanPostProcessor->>AbstractAutowireCapableBeanFactory:返回是否属性填充 - AbstractAutowireCapableBeanFactory->>InstantiationAwareBeanPostProcessor:postProcessProperties(pvs,bean,beanName)
处理bean属性 - InstantiationAwareBeanPostProcessor->>AbstractAutowireCapableBeanFactory:返回属性值 - AbstractAutowireCapableBeanFactory->>InstantiationAwareBeanPostProcessor:postProcessPropertyValues(pds,bean,beanName)
处理bean属性 - InstantiationAwareBeanPostProcessor->>AbstractAutowireCapableBeanFactory:返回属性值 - AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:initializeBean(beanName,bean,mbd)
开始初始化bean - AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
- AbstractAutowireCapableBeanFactory->>BeanPostProcessor:postProcessBeforeInitialization(bean,beanName)
应用初始化前的BPP - BeanPostProcessor-->>AbstractAutowireCapableBeanFactory:返回Bean对象 - AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:invokeInitMethods(beanName,bean,mbd)
调用初始化方法 - AbstractAutowireCapableBeanFactory->>InitializingBean:afterPropertiesSet()
设置bean属性后 - AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:invokeCustomInitMethod(beanName,bean,mbd)
调用自定义初始化 - AbstractAutowireCapableBeanFactory->>Bean对象:init-method
执行bean的初始化方法 - AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:applyBeanPostProcessorsAfterInitialization(existingBean,beanName)
应用初始化后的BPP - AbstractAutowireCapableBeanFactory->>BeanPostProcessor:postProcessAfterInitialization(bean,beanName)
处理初始化后的bean - BeanPostProcessor-->>AbstractAutowireCapableBeanFactory:返回Bean对象 - AbstractAutowireCapableBeanFactory-->>AbstractBeanFactory:返回Bean对象 - AbstractBeanFactory-->>DefaultListableBeanFactory:返回Bean对象 -~~~ - -#### 5.3、Bean销毁过程时序图 - -~~~mermaid -sequenceDiagram - Title: Bean销毁过程时序图 - participant IOCApplication - participant AnnotationConfigApplicationContext - participant AbstractApplicationContext - participant DefaultListableBeanFactory - participant DefaultSingletonBeanRegistry - participant DisposableBeanAdapter - participant DestructionAwareBeanPostProcessor - participant DisposableBean - participant Bean对象 - - IOCApplication->>AnnotationConfigApplicationContext: AnnotationConfigApplicationContext(componentClasses )
应用开始初始化上下文 - AnnotationConfigApplicationContext-->>IOCApplication:初始化完成 - IOCApplication->>AbstractApplicationContext:close()
请求关闭上下文 - AbstractApplicationContext->>AbstractApplicationContext:doClose()
执行关闭逻辑 - AbstractApplicationContext->>AbstractApplicationContext:destroyBeans()
开始销毁beans - AbstractApplicationContext->>DefaultListableBeanFactory:destroySingletons()
销毁单例beans - DefaultListableBeanFactory->>DefaultSingletonBeanRegistry:super.destroySingletons()
调父类销毁方法 - DefaultSingletonBeanRegistry-->>DefaultListableBeanFactory:destroySingleton(beanName)
销毁单个bean - DefaultListableBeanFactory->>DefaultSingletonBeanRegistry:super.destroySingleton(beanName)
调父类销毁bean方法 - DefaultSingletonBeanRegistry->>DefaultSingletonBeanRegistry:destroyBean(beanName,bean)
执行销毁bean操作 - DefaultSingletonBeanRegistry->>DisposableBeanAdapter:destroy()
适配器执行销毁 - DisposableBeanAdapter->>DestructionAwareBeanPostProcessor:postProcessBeforeDestruction(bean,beanName)
执行自定义销毁逻辑 - DisposableBeanAdapter->>DisposableBean:destroy()
执行自定义销毁逻辑 - DisposableBeanAdapter->>DisposableBeanAdapter:invokeCustomDestroyMethod(destroyMethod)
调用自定义销毁方法 - DisposableBeanAdapter->>Bean对象:destroy-method
执行bean的销毁方法 - AbstractApplicationContext-->>IOCApplication:请求关闭上下文结束 -~~~ - -### 六、源码分析 - -#### 6.1、Bean定义注册过程源码分析 - -+ 关于@ComponentScan源码分析 - -#### 6.2、Bean初始化过程源码分析 - -首先来看看启动类入口，上下文环境使用`AnnotationConfigApplicationContext`（此类是使用Java注解来配置Spring容器的方式），构造参数我们给定了一个`MyConfiguration`组件类。通过`getBeanDefinitionNames`方法，可以获得容器中所有bean的名称，使用`getBean`方法获取其实例，并打印该Bean，最后关闭了容器来触发单例bean的销毁方法。 - -```java -public class IOCApplication { - - public static void main(String[] args) { - AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyConfiguration.class); - for (String beanDefinitionName : context.getBeanDefinitionNames()) { - System.out.println("Bean = " + context.getBean(beanDefinitionName)); - } - context.close(); - } -} -``` - -在`org.springframework.context.annotation.AnnotationConfigApplicationContext#AnnotationConfigApplicationContext`构造函数中，执行了三个步骤，我们重点关注`refresh()`方法 - -```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 -/** - * 完成此工厂的bean初始化，实例化所有剩余的非延迟初始化单例bean。 - * - * @param beanFactory 要初始化的bean工厂 - */ -protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) { - // ... [代码部分省略以简化] - // 完成所有剩余非懒加载的单列Bean对象。 - beanFactory.preInstantiateSingletons(); -} -``` - -在`org.springframework.beans.factory.support.DefaultListableBeanFactory#preInstantiateSingletons`方法中，对于每个bean，它检查bean是否应该被初始化，即它不是抽象的、是单例的，并且不是延迟加载的，如果bean是一个`FactoryBean`，则检查该`FactoryBean`是否应该提前初始化。如果是，它会执行提前初始化。如果bean不是`FactoryBean`，则直接进行初始化。在所有的beans被初始化之后，方法查找那些实现了`SmartInitializingSingleton`接口的beans。对于每一个这样的bean，它会调用`afterSingletonsInstantiated`方法，允许beans在所有其他的beans被实例化之后执行某些操作。 - -```java -/** - * 提前实例化所有非懒加载的单例bean，确保所有的单例bean都被初始化。 - * 1. 该方法首先遍历所有已注册的bean定义的名称。 - * 2. 对于每个bean名称，它获取合并的本地bean定义，并检查bean是否是抽象的、单例的以及非懒加载的。 - * 3. 如果满足上述条件，该方法将根据bean定义是不是一个工厂bean（FactoryBean）来决定如何获取bean实例。 - * 4. 之后，对于所有已创建的单例bean，如果它们实现了SmartInitializingSingleton接口，它们的afterSingletonsInstantiated方法将被调用。 - * - * 此方法在应用上下文的刷新过程中被调用，确保所有非懒加载的单例bean在上下文被刷新后都被创建和初始化。 - * - * @throws BeansException 如果任何bean不能被实例化或初始化。 - */ -@Override -public void preInstantiateSingletons() throws BeansException { - // 当TRACE日志级别被启用时，记录方法的开始日志。 - if (logger.isTraceEnabled()) { - logger.trace("Pre-instantiating singletons in " + this); - } - - // 获取beanDefinitionNames的副本。这样做是为了防止在迭代期间对其进行修改。 - List beanNames = new ArrayList<>(this.beanDefinitionNames); - - // 第一步：初始化所有的非延迟加载的单例beans。 - for (String beanName : beanNames) { - RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName); - - // 检查bean是否满足初始化条件：它不应该是抽象的，应该是一个单例，并且不是延迟加载。 - if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) { - - // 检查bean是否是一个FactoryBean。 - if (isFactoryBean(beanName)) { - Object bean = getBean(FACTORY_BEAN_PREFIX + beanName); - - // 如果bean是FactoryBean的实例，进一步检查它是否应该被提前初始化。 - if (bean instanceof FactoryBean) { - FactoryBean factory = (FactoryBean) bean; - boolean isEagerInit; - - // ... [代码部分省略以简化] - - // 如果工厂bean被标记为“eagerInit”，则立即初始化它。 - if (isEagerInit) { - getBean(beanName); - } - } - } else { - // 如果bean不是FactoryBean，则直接初始化它。 - getBean(beanName); - } - } - } - - // 第二步：对所有的单例beans执行后初始化回调。 - for (String beanName : beanNames) { - Object singletonInstance = getSingleton(beanName); - - // 如果bean实现了SmartInitializingSingleton接口，则调用afterSingletonsInstantiated方法。 - if (singletonInstance instanceof SmartInitializingSingleton) { - - // ... [代码部分省略以简化] - - // 调用afterSingletonsInstantiated方法 - smartSingleton.afterSingletonsInstantiated(); - } - } -} -``` - -在`org.springframework.beans.factory.support.AbstractBeanFactory#getBean`方法中，又调用了`doGetBean`方法来实际执行创建Bean的过程，传递给它bean的名称和一些其他默认的参数值。此处，`doGetBean`负责大部分工作，如查找bean定义、创建bean（如果尚未创建）、处理依赖关系等。 +在`org.springframework.beans.factory.support.AbstractBeanFactory#getBean(name)`方法中，这个方法内部调用了`doGetBean`，并且传递了四个参数。 ```java @Override @@ -372,105 +266,131 @@ public Object getBean(String name) throws BeansException { } ``` -在`org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean`方法中，首先尝试从单例缓存中获取已存在的bean。如果不存在，考虑原型循环引用并在必要时检查父容器。方法然后根据bean的作用域和定义合并其属性，处理其依赖关系，根据bean的作用域创建bean实例。若在创建过程中遇到错误，它执行清理并抛出异常。最终，返回适当的bean实例或其代理。 +在`org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean`方法中，是Spring框架中`AbstractBeanFactory`类的核心方法，用于获取bean实例。它考虑了单例、原型、特定作用域bean的创建，还处理了bean定义、循环引用、依赖等各种情况。 ```java -/** - * 根据给定的bean名称，尝试获取或创建bean。这是bean获取过程的核心方法。 - * 1. 如果bean存在于单例缓存中并且没有构造函数参数，它将直接返回该单例。 - * 2. 对于原型bean，此方法将创建一个新实例。 - * 3. 对于其他作用域的bean，它会根据作用域特定的策略创建或检索bean。 - * 4. 如果在父bean工厂中找到bean定义，它将在父工厂中尝试获取bean。 - * 5. 在创建bean之前，此方法还会处理bean的依赖关系，确保所有依赖关系首先被解析和创建。 - * - * @param name 要检索的bean的名称。 - * @param requiredType 返回对象必须匹配的类型；可以为null以获取任何类型的bean。 - * @param args 创建bean实例时使用的参数；如果为null，则使用默认构造函数。 - * @param typeCheckOnly 是否只进行类型检查，而不是创建bean。 - * @return 返回创建或检索的bean对象。 - * @throws BeansException 如果bean不能被创建或检索。 - */ protected T doGetBean( - String name, @Nullable Class requiredType, @Nullable Object[] args, boolean typeCheckOnly) - throws BeansException { + String name, @Nullable Class requiredType, @Nullable Object[] args, boolean typeCheckOnly) + throws BeansException { - // 1. 获取标准化的bean名称。 + // 步骤1: 转换bean名称 String beanName = transformedBeanName(name); + + // 步骤2: 尝试从缓存中检索单例bean + Object sharedInstance = getSingleton(beanName); Object beanInstance; - // 2. 尝试从单例缓存中获取bean。 - Object sharedInstance = getSingleton(beanName); if (sharedInstance != null && args == null) { - // ... [代码部分省略以简化] + // 获取bean实例本身 beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null); } - else { - // 3. 检查原型作用域bean的循环引用。 + // 步骤3: 处理原型作用域的bean，并检查是否已在创建中 if (isPrototypeCurrentlyInCreation(beanName)) { throw new BeanCurrentlyInCreationException(beanName); } - // 4. 检查当前工厂或父工厂中是否存在bean定义。 + // 步骤4: 尝试在父Bean工厂中检索bean定义 BeanFactory parentBeanFactory = getParentBeanFactory(); + if (parentBeanFactory != null && !containsBeanDefinition(beanName)) { + String nameToLookup = originalBeanName(name); // ... [代码部分省略以简化] + return (T) parentBeanFactory.getBean(nameToLookup); } - // 5. 标记bean为已创建。 + // 步骤5: 标记bean为已创建状态 if (!typeCheckOnly) { markBeanAsCreated(beanName); } try { - // 6. 获取合并的bean定义。 + // 步骤6: 获取合并后的bean定义 RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName); checkMergedBeanDefinition(mbd, beanName, args); - // 7. 保证当前bean所依赖的beans先被初始化。 + // 步骤7: 确保bean的依赖已经初始化 String[] dependsOn = mbd.getDependsOn(); if (dependsOn != null) { - // ... [代码部分省略以简化] + for (String dep : dependsOn) { + // 步骤7.1: 是否存在循环依赖 + if (isDependent(beanName, dep)) { + throw new BeanCreationException(mbd.getResourceDescription(), beanName, + "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'"); + } + // 步骤7.2: 注册Bean与Bean之间的依赖关系 + registerDependentBean(dep, beanName); + // 步骤7.3: 获取被依赖的Bean对象 + getBean(dep); + } } - // 8. 根据bean的作用域创建bean实例。 + // 步骤8: 根据bean的作用域，创建或检索bean实例 if (mbd.isSingleton()) { - // 为单例作用域创建或检索实例。 - sharedInstance = getSingleton(beanName, () -> createBean(beanName, mbd, args)); + // 步骤8.1: 处理单例作用域 + sharedInstance = getSingleton(beanName, () -> { + try { + return createBean(beanName, mbd, args); + } + catch (BeansException ex) { + // ... [代码部分省略以简化] + } + }); + // 步骤8.2: 获取bean实例本身 beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd); } else if (mbd.isPrototype()) { - // 为原型作用域创建新实例。 - beanInstance = getObjectForBeanInstance(createBean(beanName, mbd, args), name, beanName, mbd); + // 处理原型作用域 + // ... [代码部分省略以简化] } else { - // 为其他自定义作用域创建实例。 - String scopeName = mbd.getScope(); - Scope scope = this.scopes.get(scopeName); - beanInstance = getObjectForBeanInstance(scope.get(beanName, () -> createBean(beanName, mbd, args)), name, beanName, mbd); + // 处理其他作用域 + // ... [代码部分省略以简化] } } catch (BeansException ex) { - // 9. 如果创建bean失败，进行清理并重新抛出异常。 - cleanupAfterBeanCreationFailure(beanName); - throw ex; + // 处理bean创建失败的情况 + // ... [代码部分省略以简化] + } + finally { + // ... [代码部分省略以简化] } } - // 10. 返回适应的bean实例或其代理。 + // 步骤9: 适配bean实例 return adaptBeanInstance(name, beanInstance, requiredType); } ``` -在`org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton`方法中，方法将请求转发给另一个重载版本的 `getSingleton` 方法。 +首先来到在`org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean`方法中的步骤1。在`org.springframework.beans.factory.support.AbstractBeanFactory#transformedBeanName`方法中，主要是用来转换bean名称的。Spring允许在引用bean时使用特定的前缀，例如`&`前缀用于表示一个bean是`FactoryBean`，这样我们可以通过`&beanName`来获取`FactoryBean`对象本身，而不是它生产的对象。 + +```java +protected String transformedBeanName(String name) { + return canonicalName(BeanFactoryUtils.transformedBeanName(name)); +} +``` + +在`org.springframework.core.SimpleAliasRegistry#canonicalName`方法中，主要是用来获取bean的规范名称的。在Spring中，bean可以有多个别名，这个方法的目的是从别名链中找到最终的规范名称。 + +```java +public String canonicalName(String name) { + String canonicalName = name; + // Handle aliasing... + String resolvedName; + do { + resolvedName = this.aliasMap.get(canonicalName); + if (resolvedName != null) { + canonicalName = resolvedName; + } + } + while (resolvedName != null); + return canonicalName; +} +``` + +然后来到在`org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean`方法中的步骤2。在`org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton(beanName)`方法中，又调用了另外一个重载版本，还接受一个`boolean`参数，表示当bean正在被创建但尚未完成时，是否允许提前暴露这个bean的引用。传递`true`作为这个参数意味着是允许的。 ```java -/** - * 根据提供的bean名称从单例缓存中检索bean实例。 - * - * @param beanName 要检索的bean的名称 - * @return bean的实例，如果找不到或不是单例，则返回null - */ @Override @Nullable public Object getSingleton(String beanName) { @@ -478,38 +398,38 @@ public Object getSingleton(String beanName) { } ``` -在`org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton(beanName, allowEarlyReference)`方法中，先从单例缓存中检索指定名称的bean实例。当bean处于创建过程中，可能因为循环依赖而没有完成初始化。为了处理这样的场景，方法首先尝试从常规的单例缓存中获取bean，如果没有找到且该bean当前正在创建中，它会尝试从“早期单例缓存”中获取。如果还是没有找到并且允许提前引用，方法会使用单例工厂创建一个新的bean实例。这种机制允许Spring容器在bean完全初始化之前解决循环依赖的问题。 +在`org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton(beanName,allowEarlyReference)`方法中，首先，它从单例缓存中尝试获取bean。如果bean正在创建中，方法会从提前暴露的缓存中获取它以处理循环引用。为确保线程安全性，在同步块内进行进一步的检查和bean的创建。如果bean仍未被创建，但存在一个工厂，那么它会用这个工厂创建bean。最后，方法返回找到或新创建的bean，或者在没有找到bean时返回`null`。 ```java -/** - * 根据给定的 bean 名称从单例缓存中检索 bean 实例。 - * - * @param beanName 要检索的 bean 的名称 - * @param allowEarlyReference 如果为 true, 该方法会尝试在完整初始化之前提前解析单例bean，这主要用于处理循环引用 - * @return 返回该名称对应的单例bean对象，如果没有找到则返回 null - */ @Nullable protected Object getSingleton(String beanName, boolean allowEarlyReference) { - // 从缓存中快速获取单例对象，这是一个常见的检索操作，避免了不必要的同步 + // 1. 从已完成的单例缓存中初步检查bean Object singletonObject = this.singletonObjects.get(beanName); - - // 如果单例对象为 null 且当前bean正在创建中，则可能存在循环引用 + + // 2. 检查bean是否正在创建中，以处理可能的循环引用 if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) { + // 3. 尝试从提前暴露的单例缓存中获取bean singletonObject = this.earlySingletonObjects.get(beanName); + + // 4. 如果仍然没有获取到bean，且允许提前引用，则进一步处理 if (singletonObject == null && allowEarlyReference) { - // 使用完整的单例锁来确保单例的一致性创建和缓存 + // 5. 为了确保线程安全，使用同步块 synchronized (this.singletonObjects) { + // 6. 在同步块内再次检查缓存，以确保线程安全 singletonObject = this.singletonObjects.get(beanName); + if (singletonObject == null) { - // 再次尝试从早期单例缓存中获取 singletonObject = this.earlySingletonObjects.get(beanName); + + // 7. 如果仍然没有找到，尝试使用singletonFactory创建bean if (singletonObject == null) { - // 使用单例工厂创建对象。这是为了处理循环引用。 ObjectFactory singletonFactory = this.singletonFactories.get(beanName); if (singletonFactory != null) { + // 8. 使用singletonFactory创建bean singletonObject = singletonFactory.getObject(); - // 存储到早期单例缓存中并从工厂缓存中移除 + // 9. 将新创建的bean添加到提前暴露的单例缓存中 this.earlySingletonObjects.put(beanName, singletonObject); + // 10. 从singletonFactories缓存中移除beanName，因为它已经被使用 this.singletonFactories.remove(beanName); } } @@ -517,219 +437,260 @@ protected Object getSingleton(String beanName, boolean allowEarlyReference) { } } } - + + // 11. 返回找到或创建的单例bean return singletonObject; } ``` -我们回到`doGetBean`方法的第二步中，在尝试从单例缓存中成功获取到Bean后，会调用`beanorg.springframework.beans.factory.support.AbstractBeanFactory#getObjectForBeanInstance`方法，此方法主要用于从给定的bean实例中获取相应的对象。这可能涉及处理`FactoryBean`的逻辑，返回由`FactoryBean`创建的对象，或者直接返回传入的普通bean实例。PS：如果第二步中没有获取到Bean，此方法在`doGetBean`方法中的第八步会再次调用，确保能处理`FactoryBean`的逻辑。 +然后来到在`org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean`方法中的步骤3。在`org.springframework.beans.factory.support.AbstractBeanFactory#isPrototypeCurrentlyInCreation`方法中，用于确定指定名称的原型bean是否当前正在创建中。 ```java -/** - * 获取给定bean实例的相应对象。此方法处理可能的FactoryBean场景，并返回要使用的实际bean实例。 - * - * @param beanInstance 实际的bean实例，可以是常规bean或FactoryBean - * @param name 要查询的bean的名称 - * @param beanName bean的实际名称 - * @param mbd 可以为null的合并bean定义 - * @return 从FactoryBean或普通bean实例获取的对象 - * - * @throws BeanIsNotAFactoryException 如果给定名称的bean不是工厂，但尝试解引用 - */ -protected Object getObjectForBeanInstance( - Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) { - - // 如果调用者尝试解引用工厂并且bean实例不是工厂，抛出异常。 - if (BeanFactoryUtils.isFactoryDereference(name)) { - if (beanInstance instanceof NullBean) { - return beanInstance; - } - if (!(beanInstance instanceof FactoryBean)) { - throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass()); - } - if (mbd != null) { - mbd.isFactoryBean = true; - } - return beanInstance; - } - - // 如果bean实例不是FactoryBean，直接返回。 - if (!(beanInstance instanceof FactoryBean)) { - return beanInstance; - } - - // 如果FactoryBean的结果在缓存中，直接返回。 - Object object = null; - if (mbd != null) { - mbd.isFactoryBean = true; - } - else { - object = getCachedObjectForFactoryBean(beanName); - } - - // 如果缓存中没有，从FactoryBean获取对象。 - if (object == null) { - FactoryBean factory = (FactoryBean) beanInstance; - if (mbd == null && containsBeanDefinition(beanName)) { - mbd = getMergedLocalBeanDefinition(beanName); - } - boolean synthetic = (mbd != null && mbd.isSynthetic()); - object = getObjectFromFactoryBean(factory, beanName, !synthetic); - } - - return object; +protected boolean isPrototypeCurrentlyInCreation(String beanName) { + Object curVal = this.prototypesCurrentlyInCreation.get(); + return (curVal != null && + (curVal.equals(beanName) || (curVal instanceof Set && ((Set) curVal).contains(beanName)))); } ``` -我们回到`doGetBean`方法中的第八步。在`org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton`方法中，首先从单例缓存中检索指定的bean，如果该bean不存在并且提供了一个`singletonFactory`，该方法会尝试使用该工厂创建bean。如果在此过程中发生任何异常或在创建期间bean被其他线程提前创建，该方法都有相应的处理策略。特别地，方法还考虑到了循环引用的情况，并在出现循环引用时提供了有关错误信息。简而言之，`getSingleton`确保了单例bean的创建、缓存和提取，同时处理了与并发和循环引用相关的各种潜在问题。 +然后来到在`org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean`方法中的步骤5。在`org.springframework.beans.factory.support.AbstractBeanFactory#markBeanAsCreated`方法中，主要目的是标记指定的bean已经被创建或正在被创建。它在Spring的bean生命周期中起到关键作用，特别是当需要确保bean只被创建一次或者对其进行某些状态检查时。 + +```java +protected void markBeanAsCreated(String beanName) { + // 1. 初步检查bean是否已被标记为已创建 + if (!this.alreadyCreated.contains(beanName)) { + + // 2. 为了确保在多线程环境下的线程安全，进行同步操作 + synchronized (this.mergedBeanDefinitions) { + + // 3. 双重检查锁定模式：再次确认bean是否已被标记为已创建 + if (!this.alreadyCreated.contains(beanName)) { + + // 4. 清除bean的合并定义，以便在后续访问时重新合并 + clearMergedBeanDefinition(beanName); + + // 5. 在集合中标记bean已被创建 + this.alreadyCreated.add(beanName); + } + } + } +} +``` + +然后来到在`org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean`方法中的步骤6。在`org.springframework.beans.factory.support.AbstractBeanFactory#getMergedLocalBeanDefinition`方法中，主要是用于获取给定bean名称的合并bean定义。合并的bean定义是从父bean和子bean（如果有的话）定义中合并的结果。 + +```java +protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException { + // 1. 快速从并发映射中检查bean定义，这样做可以最小化锁定。 + RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName); + + // 2. 如果合并的bean定义存在并且没有过期，直接返回它。 + if (mbd != null && !mbd.stale) { + return mbd; + } + + // 3. 如果上述检查失败，进一步获取并返回合并的bean定义。 + return getMergedBeanDefinition(beanName, getBeanDefinition(beanName)); +} +``` + +在`org.springframework.beans.factory.support.DefaultListableBeanFactory#getBeanDefinition`方法中，主要用于查找bean定义。 + +```java +@Override +public BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException { + // 1. 从beanDefinitionMap中获取bean的定义 + BeanDefinition bd = this.beanDefinitionMap.get(beanName); + + // 2. 如果没有找到BeanDefinition，进行日志跟踪并抛出异常 + if (bd == null) { + // 如果启用了trace级别的日志，记录一条日志 + if (logger.isTraceEnabled()) { + logger.trace("No bean named '" + beanName + "' found in " + this); + } + // 抛出没有找到BeanDefinition的异常 + throw new NoSuchBeanDefinitionException(beanName); + } + + // 3. 返回找到的BeanDefinition + return bd; +} +``` + +在`org.springframework.beans.factory.support.AbstractBeanFactory#getMergedBeanDefinition(beanName, bd)`方法中，我们传递了`null`作为父bean定义，表示不需要合并父bean定义。 + +```java +protected RootBeanDefinition getMergedBeanDefinition(String beanName, BeanDefinition bd) + throws BeanDefinitionStoreException { + + return getMergedBeanDefinition(beanName, bd, null); +} +``` + +在`org.springframework.beans.factory.support.AbstractBeanFactory#getMergedBeanDefinition(beanName,bd,containingBd)`方法中，主要目的是获取指定bean名称的合并bean定义。它的主要工作是处理bean定义的父子关系和其他相关设置，然后返回一个合并后的bean定义。 + +```java +protected RootBeanDefinition getMergedBeanDefinition( + String beanName, BeanDefinition bd, @Nullable BeanDefinition containingBd) + throws BeanDefinitionStoreException { + + // 1. 对mergedBeanDefinitions进行同步以确保线程安全。 + synchronized (this.mergedBeanDefinitions) { + RootBeanDefinition mbd = null; + RootBeanDefinition previous = null; + + // 2. 在完整的锁定中检查，以确保使用相同的合并实例。 + if (containingBd == null) { + mbd = this.mergedBeanDefinitions.get(beanName); + } + + // 3. 如果bean定义未被合并或已过期，进行合并操作。 + if (mbd == null || mbd.stale) { + previous = mbd; + + // 4. 处理没有父定义的情况。 + if (bd.getParentName() == null) { + if (bd instanceof RootBeanDefinition) { + mbd = ((RootBeanDefinition) bd).cloneBeanDefinition(); + } + else { + mbd = new RootBeanDefinition(bd); + } + } + // 5. 处理有父定义的情况：需要与父定义合并。 + else { + BeanDefinition pbd; + try { + String parentBeanName = transformedBeanName(bd.getParentName()); + if (!beanName.equals(parentBeanName)) { + pbd = getMergedBeanDefinition(parentBeanName); + } + else { + BeanFactory parent = getParentBeanFactory(); + if (parent instanceof ConfigurableBeanFactory) { + pbd = ((ConfigurableBeanFactory) parent).getMergedBeanDefinition(parentBeanName); + } + else { + // ... [代码部分省略以简化] + } + } + } + catch (NoSuchBeanDefinitionException ex) { + // ... [代码部分省略以简化] + } + mbd = new RootBeanDefinition(pbd); + mbd.overrideFrom(bd); + } + + // 6. 如果bean定义的范围没有明确设置，将其默认为单例。 + if (!StringUtils.hasLength(mbd.getScope())) { + mbd.setScope(SCOPE_SINGLETON); + } + + // 7. 非单例bean中的bean不能是单例。在这里修复这种情况。 + if (containingBd != null && !containingBd.isSingleton() && mbd.isSingleton()) { + mbd.setScope(containingBd.getScope()); + } + + // 8. 如果需要，缓存合并后的bean定义。 + if (containingBd == null && isCacheBeanMetadata()) { + this.mergedBeanDefinitions.put(beanName, mbd); + } + } + // 9. 如果之前存在一个bean定义，复制相关的缓存。 + if (previous != null) { + copyRelevantMergedBeanDefinitionCaches(previous, mbd); + } + + // 10. 返回合并后的bean定义。 + return mbd; + } +} +``` + +然后来到在`org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean`方法中的步骤7.1。Spring处理了`@DependsOn`注解。这个注解允许开发者定义bean初始化之间的依赖关系，确保一个bean在另一个bean之前被初始化和销毁。为了深入了解`@DependsOn`注解的工作机制及其在Spring中的实现，您可以查阅已经准备好的专门分析该注解的博客文章。 + +[@DependsOn注解详解](https://github.com/xuchengsheng/spring-reading/blob/master/spring-annotation/spring-annotation-dependsOn) + +```java +String[] dependsOn = mbd.getDependsOn(); +if (dependsOn != null) { + for (String dep : dependsOn) { + // 步骤7.1: 是否存在循环依赖 + if (isDependent(beanName, dep)) { + throw new BeanCreationException(mbd.getResourceDescription(), beanName, + "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'"); + } + // 步骤7.2: 注册Bean与Bean之间的依赖关系 + registerDependentBean(dep, beanName); + // 步骤7.3: 获取被依赖的Bean对象 + getBean(dep); + } +} +``` + +然后来到在`org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean`方法中的步骤8.1。在`org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton(beanName, singletonFactory)`方法中，首先尝试从缓存中检索该bean。如果没有找到，它会使用提供的`singletonFactory`来创建这个bean，并在创建过程中进行前置和后置处理，以确保处理诸如循环引用等问题。创建的bean会被添加到缓存中。此外，该方法还处理了在创建过程中可能出现的各种异常，并确保在多线程环境中的线程安全。最后，返回所需的单例bean。 ```java -/** - * 根据给定的bean名称获取单例对象。如果在单例缓存中不存在该对象，使用传入的单例工厂创建它。 - * 该方法确保线程安全地创建和检索单例，并处理与bean创建失败相关的任何异常。 - * - * @param beanName 要检索的单例bean的名称。 - * @param singletonFactory 创建新单例时使用的工厂。 - * @return 返回创建或检索的单例对象。 - * @throws BeanCreationNotAllowedException 当单例处于销毁状态时，不允许创建单例。 - * @throws BeanCreationException 如果创建bean时出现问题。 - * @throws IllegalStateException 如果出现状态异常，如并发问题。 - */ public Object getSingleton(String beanName, ObjectFactory singletonFactory) { - // 1. 断言bean名称不为空 - Assert.notNull(beanName, "Bean name must not be null"); - - // 2. 通过同步块确保线程安全 synchronized (this.singletonObjects) { - - // 3. 尝试从缓存中获取单例对象 + // 首先尝试从缓存中获取单例 Object singletonObject = this.singletonObjects.get(beanName); - - // 4. 如果缓存中不存在 if (singletonObject == null) { - - // 5. 如果当前处于销毁其他单例的状态，则抛出异常 - if (this.singletonsCurrentlyInDestruction) { - // ... [代码部分省略以简化] - } - - // 6. 记录开始创建单例的日志 - if (logger.isDebugEnabled()) { - logger.debug("Creating shared instance of singleton bean '" + beanName + "'"); - } - - // 7. 将单例注册为当前正在创建中 + // ... [代码部分省略以简化] + + // 前置处理，例如标记这个bean正在创建，以处理循环引用等问题。 beforeSingletonCreation(beanName); - - // 8. 设置标识，默认为未创建新的单例 - boolean newSingleton = false; - - // 9. 准备记录与bean创建失败相关的任何异常 - boolean recordSuppressedExceptions = (this.suppressedExceptions == null); - if (recordSuppressedExceptions) { - this.suppressedExceptions = new LinkedHashSet<>(); - } - + + // ... [代码部分省略以简化] try { - // 10. 使用传递的singletonFactory创建单例 + // 使用singletonFactory创建单例对象 singletonObject = singletonFactory.getObject(); newSingleton = true; - } + } catch (IllegalStateException ex) { // ... [代码部分省略以简化] - } + } catch (BeanCreationException ex) { // ... [代码部分省略以简化] - } + } finally { // ... [代码部分省略以简化] - // 11. 将singleton标记为不再处于创建中 afterSingletonCreation(beanName); } - - // 12. 如果成功创建新的单例，将其加入缓存 + // 如果成功创建了新的单例bean，将其添加到缓存中 if (newSingleton) { addSingleton(beanName, singletonObject); } } - // 13. 返回创建或检索到的单例 + // 返回现有或新创建的单例bean return singletonObject; } } ``` -我们来到`getSingleton(beanName,singletonFactory)`方法中的第七步中。调用`org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#beforeSingletonCreation`方法，将单例注册为当前正在创建中。 +在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBean(beanName,mbd,args)`方法中，首先尝试进行前置处理，可能返回一个由BeanPostProcessors提供的代理bean。如果没有代理bean，它会进行真正的bean创建。 + +`resolveBeforeInstantiation` 方法主要在实际的 bean 实例化之前尝试解析 bean。这允许`InstantiationAwareBeanPostProcessor`在 bean 的实际实例化过程开始之前对其进行操作。 + +在Spring中，`InstantiationAwareBeanPostProcessor` 是一个特殊类型的`BeanPostProcessor`，它提供了更多的回调方法，特别是允许在实例化bean之前以及属性填充之前对bean进行处理。例如，它可以在 bean 实例化之前返回一个代理对象，从而避免默认的 bean 实例化过程。 + +要深入了解这两个接口以及它们在 Spring 框架中的工作方式，您可以参考以下两篇博客文章： + +1. [InstantiationAwareBeanPostProcessor 接口详解](https://github.com/xuchengsheng/spring-reading/blob/master/spring-interface/spring-interface-instantiationAwareBeanPostProcessor) +2. [BeanPostProcessor 接口详解](https://github.com/xuchengsheng/spring-reading/blob/master/spring-interface/spring-interface-beanPostProcessor) ```java -protected void beforeSingletonCreation(String beanName) { - if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) { - throw new BeanCurrentlyInCreationException(beanName); - } -} -``` - -我们来到`getSingleton(beanName,singletonFactory)`方法中的第十步中，调用`singletonFactory.getObject()`，这是在`doGetBean`方法中传递过来的lambda表达式的一个方法引用。 - -```java -() -> { - try { - return createBean(beanName, mbd, args); - } - catch (BeansException ex) { - // ... [代码部分省略以简化] - } -} -``` - -我们来到`getSingleton(beanName,singletonFactory)`方法中的第十一步中。调用`org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#afterSingletonCreation`方法，将singleton标记为不再处于创建中。 - -```java -protected void afterSingletonCreation(String beanName) { - if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.remove(beanName)) { - throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation"); - } -} -``` - -我们回到`getSingleton(beanName,singletonFactory)`方法中的第十步中。当我们调用`singletonFactory.getObject()`方法会调用到`createBean(beanName,mbd,args)`方法上来，在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBean`方法中，首先，确保了bean的类已经被正确解析并设置。接着，它会准备并验证方法重写，确保没有配置错误。然后，方法尝试使用`BeanPostProcessors`在实际实例化bean之前返回一个代理对象。如果没有代理返回，方法将继续实际的bean创建和初始化过程。整个过程中，任何发生的异常都会被捕获并转化为`BeanCreationException`，确保调用者可以从异常中获取明确的上下文信息。 - -```java -/** - * 创建一个新的bean实例。此过程涉及解析bean的类，处理方法重写，可能的代理创建以及最终bean的实际实例化和初始化。 - * - * @param beanName 要创建的bean的名称。 - * @param mbd 要创建的bean的合并bean定义。 - * @param args 用于构造函数或工厂方法的参数；可以为null。 - * @return 新创建的bean实例。 - * @throws BeanCreationException 如果创建bean失败。 - */ @Override protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) - throws BeanCreationException { - // 1.记录日志：开始创建bean - if (logger.isTraceEnabled()) { - logger.trace("Creating instance of bean '" + beanName + "'"); - } + throws BeanCreationException { + + // ... [代码部分省略以简化] RootBeanDefinition mbdToUse = mbd; - // 2.解析bean的类，以确保其已经被加载 - Class resolvedClass = resolveBeanClass(mbd, beanName); - if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) { - // 如果bean类已经被解析，并且原始bean定义没有设置bean类，则复制bean定义并设置bean类。 - mbdToUse = new RootBeanDefinition(mbd); - mbdToUse.setBeanClass(resolvedClass); - } + // ... [代码部分省略以简化] - // 3.准备方法重写，并对它们进行验证 try { - mbdToUse.prepareMethodOverrides(); - } - catch (BeanDefinitionValidationException ex) { - // ... [代码部分省略以简化] - } - - try { - // 4.允许BeanPostProcessors在bean实例化之前返回代理 Object bean = resolveBeforeInstantiation(beanName, mbdToUse); if (bean != null) { return bean; @@ -739,12 +700,9 @@ protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable O // ... [代码部分省略以简化] } - // 5.实际bean实例化。如果此过程中出现异常，异常将被捕获并适当处理。 try { Object beanInstance = doCreateBean(beanName, mbdToUse, args); - if (logger.isTraceEnabled()) { - logger.trace("Finished creating instance of bean '" + beanName + "'"); - } + // ... [代码部分省略以简化] return beanInstance; } catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) { @@ -756,69 +714,24 @@ protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable O } ``` -我们来到`createBean(beanName,mbd,args)`方法中的第四步中。在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#resolveBeforeInstantiation` 方法中，首先尝试在bean实际实例化之前提前完成bean的实例化。这通常是为了返回一个代理对象。`applyBeanPostProcessorsBeforeInstantiation` 方法，尝试使用 `InstantiationAwareBeanPostProcessor` 的 `postProcessBeforeInstantiation` 方法来预先实例化bean。如果上一步成功创建了bean（例如，返回了一个代理对象），那么这个bean还会经过所有注册的 `BeanPostProcessor` 的 `postProcessAfterInitialization` 方法，这是对bean进行初始化后的最后处理。 +在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean`方法中，主要处理了bean生命周期中的多个关键阶段，从bean的实例化、属性注入、初始化，到bean的清理注册。 ```java -protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) { - Object bean = null; - // 检查是否已尝试在实例化之前解析此bean - if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) { - // 如果bean不是合成的，并且存在InstantiationAwareBeanPostProcessors - if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) { - // 确定目标bean的类型 - Class targetType = determineTargetType(beanName, mbd); - // 如果目标类型不为空 - if (targetType != null) { - // 尝试在实际实例化之前，通过BeanPostProcessors提前创建bean实例 - bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName); - // 如果bean实例创建成功 - if (bean != null) { - // 对bean实例应用postProcessAfterInitialization方法 - bean = applyBeanPostProcessorsAfterInitialization(bean, beanName); - } - } - } - // 标记bean在实例化之前是否已被解析 - mbd.beforeInstantiationResolved = (bean != null); - } - // 返回创建的bean实例或null - return bean; -} -``` - -我们来到`createBean(beanName,mbd,args)`方法中的第五步中。在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean`方法中，首先负责bean的实例化，然后进行类型的解析和方法覆盖的准备。在实例化bean后，该方法允许`BeanPostProcessors`介入，为bean提供代理或进行其他改变。接下来，为解决可能出现的循环引用问题，bean会被尽早地放入缓存。之后，该方法进行bean的属性注入，并执行其初始化方法。在处理完成bean的循环引用后，如果bean定义了销毁方法或实现了相关接口，它将被注册为可销毁的。最后，方法返回完全初始化的bean实例。 - -```java -/** - * 实际创建指定的bean。先实例化，然后暴露为对象引用。 - * - * @param beanName bean的名称 - * @param mbd bean的合并bean定义 - * @param args 用于构造函数或工厂方法调用的显式参数 - * @return 创建的bean实例(可能是原始的或其创建的代理) - * @throws BeanCreationException 如果bean不能被创建 - */ protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException { - // 1. Bean实例化 + // Step 1: 尝试实例化bean BeanWrapper instanceWrapper = null; - // 如果是单例并且缓存中有，则从缓存中获取BeanWrapper if (mbd.isSingleton()) { instanceWrapper = this.factoryBeanInstanceCache.remove(beanName); } - // 如果BeanWrapper为空，则创建一个新的实例 if (instanceWrapper == null) { instanceWrapper = createBeanInstance(beanName, mbd, args); } - // 获取bean的实例和类型 - Object bean = instanceWrapper.getWrappedInstance(); - Class beanType = instanceWrapper.getWrappedClass(); - if (beanType != NullBean.class) { - mbd.resolvedTargetType = beanType; - } + + // ... [代码部分省略以简化] - // 2. 合并Bean定义后的后处理 + // Step 2: 合并bean定义的后置处理 synchronized (mbd.postProcessingLock) { if (!mbd.postProcessed) { try { @@ -830,33 +743,26 @@ protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable } } - // 3. 为了处理循环引用，提前将创建的实例放入缓存 + // Step 3: 处理可能的循环引用，通过提前暴露bean的引用 boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName)); if (earlySingletonExposure) { + // ... [代码部分省略以简化] addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean)); } + // Step 4: 初始化bean实例，填充bean属性并应用后处理器 Object exposedObject = bean; try { - // 4. Bean属性的注入 + // 属性填充 populateBean(beanName, mbd, instanceWrapper); - // 5. Bean初始化 - exposedObject = initializeBean(beanName, exposedObject, mbd); + // 初始化bean + exposedObject = initializeBean(beanName, exposedObject, mbd); } catch (Throwable ex) { // ... [代码部分省略以简化] } - // 6. 循环引用处理 - if (earlySingletonExposure) { - Object earlySingletonReference = getSingleton(beanName, false); - if (earlySingletonReference != null && exposedObject == bean) { - exposedObject = earlySingletonReference; - } - // ... [代码部分省略以简化] - } - - // 7. 如果需要，为bean注册销毁方法 + // Step 5: 如果需要，注册bean以便在容器关闭时进行清理 try { registerDisposableBeanIfNecessary(beanName, bean, mbd); } catch (BeanDefinitionValidationException ex) { @@ -867,326 +773,54 @@ protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable } ``` -我们来到`doCreateBean(beanName,mbd,args)`方法中的第二步中。在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#applyMergedBeanDefinitionPostProcessors`方法中，遍历每一个 `MergedBeanDefinitionPostProcessor` 的 `postProcessMergedBeanDefinition` 方法，提供了一个自定义或查询合并的 bean 定义的机会。 +在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBeanInstance`方法中，首先尝试从后处理器获取构造函数，然后检查是否有首选构造函数，最后如果没有其他选项，它会使用无参数构造函数。 ```java -protected void applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd, Class beanType, String beanName) { - for (MergedBeanDefinitionPostProcessor processor : getBeanPostProcessorCache().mergedDefinition) { - processor.postProcessMergedBeanDefinition(mbd, beanType, beanName); +protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) { + // ... [代码部分省略以简化] + + // Step 1: 首先尝试从BeanPostProcessors确定构造函数，这主要是为了处理例如@Autowired注解的情况 + Constructor[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName); + // 如果确定了构造函数或者bean定义中有相关的自动装配模式和构造函数参数，则使用自动装配构造函数创建bean实例 + if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR || + mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) { + return autowireConstructor(beanName, mbd, ctors, args); } + + // Step 2: 如果BeanDefinition中存在首选构造函数，使用这些构造函数 + ctors = mbd.getPreferredConstructors(); + if (ctors != null) { + return autowireConstructor(beanName, mbd, ctors, null); + } + + // Step 3: 如果前面的步骤都没有返回bean实例，那么使用无参数构造函数实例化bean + return instantiateBean(beanName, mbd); } ``` -我们来到`doCreateBean(beanName,mbd,args)`方法中的第四步中。在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#populateBean`方法中，首先确定bean实例是否存在。如果bean存在，该方法会根据bean的自动装配模式（例如`byName`或`byType`）来进行属性的自动装配。此外，对于任何显式定义的属性值，该方法也会确保它们被正确地设置到bean中。在整个属性填充过程中，方法为`InstantiationAwareBeanPostProcessors`提供了在不同阶段介入、修改bean属性或中断属性填充的机会。简而言之，这个方法确保bean的所有属性都被正确地配置和填充。 +在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#determineConstructorsFromBeanPostProcessors`方法中，在`determineConstructorsFromBeanPostProcessors`方法中，Spring查询所有注册的`SmartInstantiationAwareBeanPostProcessor`来确定bean的构造函数。这允许开发者或Spring内部组件对bean的实例化过程有更大的控制权。特别地，`SmartInstantiationAwareBeanPostProcessor`接口扩展了Spring的标准`BeanPostProcessor`，为bean的实例化提供更为智能的预测和干预能力。例如，它可以在bean实例化之前尝试猜测最合适的构造函数，或者提供代理类来代替实际的bean实例。对于想要深入了解`SmartInstantiationAwareBeanPostProcessor`的工作原理和如何使用它的开发者来说，我推荐阅读这篇详细的博客[SmartInstantiationAwareBeanPostProcessor源码分析](https://github.com/xuchengsheng/spring-reading/blob/master/spring-interface/spring-interface-smartInstantiationAwareBeanPostProcessor)。在这篇博客中，您将获得关于该接口及其与Spring框架交互的详尽解释。 ```java -/** - * 用于填充给定bean名称的bean实例的属性。此方法负责属性的自动装配以及应用显式属性值。 - * - * @param beanName bean的名称 - * @param mbd bean的合并BeanDefinition - * @param bw bean的BeanWrapper - */ -protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) { - - // 如果BeanWrapper为空并且存在属性值，则抛出BeanCreationException异常。 - if (bw == null) { - if (mbd.hasPropertyValues()) { - throw new BeanCreationException( - mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance"); - } else { - // 若实例为null且没有属性需要设置，则直接返回。 - return; - } - } - - // 在设置bean属性之前，给任何InstantiationAwareBeanPostProcessors一个机会来修改bean的状态。 - // 这可以用来支持字段注入的风格。 - if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) { - for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) { - if (!bp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) { - return; - } - } - } - - // 获取bean定义中的属性值。 - PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null); - - // 根据bean定义的自动装配模式进行处理。 - int resolvedAutowireMode = mbd.getResolvedAutowireMode(); - if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) { - MutablePropertyValues newPvs = new MutablePropertyValues(pvs); - - // 如果是按名称自动装配，将对应的属性值加入属性集。 - if (resolvedAutowireMode == AUTOWIRE_BY_NAME) { - autowireByName(beanName, mbd, bw, newPvs); - } - // 如果是按类型自动装配，将对应的属性值加入属性集。 - if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) { - autowireByType(beanName, mbd, bw, newPvs); - } - - pvs = newPvs; - } - - // 检查是否有InstantiationAwareBeanPostProcessors，并对属性值进行后处理。 - boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors(); - boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE); - - PropertyDescriptor[] filteredPds = null; - if (hasInstAwareBpps) { - if (pvs == null) { - pvs = mbd.getPropertyValues(); - } - for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) { - PropertyValues pvsToUse = bp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName); - if (pvsToUse == null) { - if (filteredPds == null) { - filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching); - } - pvsToUse = bp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName); - if (pvsToUse == null) { - return; - } - } - pvs = pvsToUse; - } - } - - // 如果需要进行依赖性检查，则进行检查。 - if (needsDepCheck) { - if (filteredPds == null) { - filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching); - } - checkDependencies(beanName, mbd, filteredPds, pvs); - } - - // 最后，将属性值应用到bean。 - if (pvs != null) { - applyPropertyValues(beanName, mbd, bw, pvs); - } -} -``` - -我们来到`doCreateBean(beanName,mbd,args)`方法中的第五步中。在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#initializeBean`方法中，首先如果Bean实现了特定的Aware接口（如`BeanNameAware`, `BeanFactoryAware`等），Spring容器会先调用相关的方法。在实际执行初始化方法前，Spring会先通过注册的`BeanPostProcessors`的`postProcessBeforeInitialization`方法进行预处理，允许修改Bean或执行其他自定义操作。接着，Spring会调用Bean的初始化方法。这可以是Bean定义中通过`init-method`属性指定的方法，也可以是Bean实现的`InitializingBean`接口的`afterPropertiesSet`方法。Bean的初始化方法调用后，再次通过注册的`BeanPostProcessors`的`postProcessAfterInitialization`方法进行后处理。这为开发者提供了一个在Bean初始化完成后再次修改Bean或执行其他自定义操作的机会。 - -```java -/** - * 初始化指定的bean。 - * - * @param beanName bean的名称 - * @param bean 实际的bean实例 - * @param mbd bean的合并bean定义；可以为{@code null}，例如对手动注册的单例。 - * @return 处理过后的bean实例 (可能是原始的或新的代理) - * @throws BeansException 如果初始化失败 - */ -protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) { - - // 1.调用bean的Aware回调方法 - invokeAwareMethods(beanName, bean); - - // 初始时bean的引用 - Object wrappedBean = bean; - - // 2.在真正的初始化之前，应用BeanPostProcessors的前置处理 - if (mbd == null || !mbd.isSynthetic()) { - wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName); - } - - // 3.调用bean的初始化方法（例如afterPropertiesSet或自定义的init方法） - try { - invokeInitMethods(beanName, wrappedBean, mbd); - } catch (Throwable ex) { - // ... [代码部分省略以简化] - } - - // 4.在初始化之后，应用BeanPostProcessors的后置处理 - if (mbd == null || !mbd.isSynthetic()) { - wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName); - } - - // 返回处理后的bean实例 - return wrappedBean; -} -``` - -我们来到`initializeBean(beanName,bean,mbd)`方法中的第一步中。在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#invokeAwareMethods`方法中，专门用于处理那些实现了Spring的Aware接口的bean，实现了`BeanNameAware`的bean，Spring容器会设置bean的名称，实现了`BeanClassLoaderAware`的bean，Spring容器会提供当前使用的类加载器，实现了`BeanFactoryAware`的bean，Spring容器会将自身的引用传递给bean。 - -```java -/** - * 调用bean的Aware接口方法。 - * 如果bean实现了Spring的Aware接口之一，那么Spring容器将会在bean初始化时通知bean关于某些容器的状态或信息。 - * - * @param beanName 该bean在Spring容器中的名称 - * @param bean 实际的bean实例 - */ -private void invokeAwareMethods(String beanName, Object bean) { - // 检查bean是否实现了Aware接口 - if (bean instanceof Aware) { - - // 如果bean实现了BeanNameAware接口，容器会通知bean关于其bean名称 - if (bean instanceof BeanNameAware) { - ((BeanNameAware) bean).setBeanName(beanName); - } - - // 如果bean实现了BeanClassLoaderAware接口，容器会通知bean关于它正在使用的类加载器 - if (bean instanceof BeanClassLoaderAware) { - ClassLoader bcl = getBeanClassLoader(); - // 检查类加载器是否为null，然后将其传递给bean - if (bcl != null) { - ((BeanClassLoaderAware) bean).setBeanClassLoader(bcl); - } - } - - // 如果bean实现了BeanFactoryAware接口，容器会通知bean关于其自身的引用 - if (bean instanceof BeanFactoryAware) { - ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this); - } - } -} -``` - -我们来到`initializeBean(beanName,bean,mbd)`方法中的第二步中。在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsBeforeInitialization`方法中，遍历每一个 `BeanPostProcessor` 的 `postProcessBeforeInitialization` 方法都有机会对bean进行修改或增强 - -```java -@Override -public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName) +@Nullable +protected Constructor[] determineConstructorsFromBeanPostProcessors(@Nullable Class beanClass, String beanName) throws BeansException { - Object result = existingBean; - for (BeanPostProcessor processor : getBeanPostProcessors()) { - Object current = processor.postProcessBeforeInitialization(result, beanName); - if (current == null) { - return result; + if (beanClass != null && hasInstantiationAwareBeanPostProcessors()) { + for (SmartInstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().smartInstantiationAware) { + Constructor[] ctors = bp.determineCandidateConstructors(beanClass, beanName); + if (ctors != null) { + return ctors; + } } - result = current; } - return result; + return null; } ``` -我们来到`initializeBean(beanName,bean,mbd)`方法中的第三步中。在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#invokeInitMethods`方法中，首先检查bean是否实现了`InitializingBean`接口，并调用其`afterPropertiesSet`方法，为bean执行任何必要的初始化逻辑。此外，如果bean定义中指定了一个自定义的初始化方法，该方法也会被执行，除非这个自定义的方法就是`afterPropertiesSet`，因为它已经在前面调用过了。总之，该方法确保了在bean的所有属性都被设置之后，可以按预期的顺序执行任何初始化逻辑。 +### 八、注意事项 -```java -/** - * 执行指定bean的初始化方法。这可能包括执行`InitializingBean`接口的`afterPropertiesSet`方法， - * 以及在bean定义中指定的任何自定义初始化方法。 - * - * @param beanName bean的名称 - * @param bean 实际的bean实例 - * @param mbd bean的定义，可能为null - * @throws Throwable 如果初始化方法抛出异常 - */ -protected void invokeInitMethods(String beanName, Object bean, @Nullable RootBeanDefinition mbd) - throws Throwable { +### 九、总结 - // 检查bean是否实现了InitializingBean接口 - boolean isInitializingBean = (bean instanceof InitializingBean); - // 如果是，并且afterPropertiesSet不是外部管理的（例如，通过AspectJ） - if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) { - if (logger.isTraceEnabled()) { - logger.trace("Invoking afterPropertiesSet() on bean with name '" + beanName + "'"); - } - if (System.getSecurityManager() != null) { - // ... [代码部分省略以简化] - } else { - // 调用afterPropertiesSet方法 - ((InitializingBean) bean).afterPropertiesSet(); - } - } +#### 最佳实践总结 - // 检查是否存在自定义的初始化方法，并且这个方法不是afterPropertiesSet（因为它已经在上面调用过了） - if (mbd != null && bean.getClass() != NullBean.class) { - String initMethodName = mbd.getInitMethodName(); - if (StringUtils.hasLength(initMethodName) && - !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) && - !mbd.isExternallyManagedInitMethod(initMethodName)) { - // 调用自定义的初始化方法 - invokeCustomInitMethod(beanName, bean, mbd); - } - } -} -``` - -我们来到`initializeBean(beanName,bean,mbd)`方法中的第四步中。在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsAfterInitialization`方法中，遍历每一个 `BeanPostProcessor` 的 `postProcessAfterInitialization` 方法都有机会对bean进行修改或增强。 - -```java -@Override -public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName) - throws BeansException { - - Object result = existingBean; - for (BeanPostProcessor processor : getBeanPostProcessors()) { - Object current = processor.postProcessAfterInitialization(result, beanName); - if (current == null) { - return result; - } - result = current; - } - return result; -} -``` - -#### 6.3、Bean销毁过程源码分析 - -+ [关于DestructionAwareBeanPostProcessor源码分析](../spring-interface-destructionAwareBeanPostProcessor/README.md) -+ [关于DisposableBean源码分析](../spring-interface-disposableBean/README.md) - -### 七、注意事项 - -**选择合适的生命周期**：默认情况下，Spring中的beans是单例的。如果bean需要在每次请求时都有一个新的实例，应该将其作用域设置为`prototype`。 - -**慎用原型作用域与单例作用域的组合**：注入原型作用域的bean到单例作用域的bean可能不会像预期的那样工作。每次对单例bean的请求都会返回相同的原型实例。 - -**避免循环依赖**：Spring可以解决构造器和setter方法的循环依赖，但推荐避免这种设计，因为它可能使代码更难理解和维护。 - -**避免多重bean定义**：确保应用程序上下文中没有多个相同名字或类型的bean，否则可能导致出现一些奇奇怪怪的问题。 - -**懒加载**：如果我们不希望容器启动时立即初始化某个bean，可以使用`@Lazy`注解或在XML中设置`lazy-init`属性。 - -**避免使用`depends-on`**：虽然`depends-on`可以指定bean的启动顺序，但在可能的情况下，避免使用它，因为它可能会导致配置更加复杂。 - -**使用`@PostConstruct`和`@PreDestroy`注解**：为bean的初始化和销毁提供方法，而不是使用Spring特定的`init-method`和`destroy-method`属性。 - -**谨慎使用Bean后处理器**：Bean后处理器（`BeanPostProcessor`）是一个强大的机制，但如果不当使用，可能会导致性能问题，因为它们会在每个bean的初始化阶段都被调用。 - -**避免在bean的初始化方法中使用其他bean**：在bean的生命周期中，避免在构造函数或初始化方法中调用其他bean，因为这些bean可能尚未完全初始化。 - -### 八、总结 - -#### 8.1、最佳实践总结 - -**应用程序入口**：在`IOCApplication`类中，首先创建了一个`AnnotationConfigApplicationContext`的实例，该实例是基于Java的Spring容器配置。作为构造参数，传递了`MyConfiguration`类，这意味着Spring将根据`MyConfiguration`类来配置IoC容器。 - -**配置类**：`MyConfiguration`类被注解为`@Configuration`，这意味着它是一个Spring配置类。它使用了`@ComponentScan`注解来告诉Spring去哪里查找beans。在这个示例中，它会扫描`com.xcs.spring.service`包及其子包。 - -**服务类**：`MyServiceA`和`MyServiceB`类都在指定的包路径下，并且都被注解为`@Component`。这意味着Spring将为它们创建bean实例并管理它们的生命周期。 - -**输出结果**：当`IOCApplication`运行时，它会打印出容器中所有bean的名称和实例。除了自定义的两个服务类之外，还有其他的Spring内部bean，例如`ConfigurationClassPostProcessor`、`AutowiredAnnotationBeanPostProcessor`等。 - -#### 8.2、源码分析总结 - -**启动类与上下文环境**：应用启动时，创建了一个`AnnotationConfigApplicationContext`，并注册了配置类`MyConfiguration`。随后，通过遍历并获取所有容器中的Bean实例，并打印其信息。在上下文关闭时，触发了单例bean的销毁方法。 - -**上下文刷新**：在`AnnotationConfigApplicationContext`构造函数中，主要关注了`refresh()`方法，这个方法里再继续调用了`finishBeanFactoryInitialization(beanFactory)`，它主要负责实例化所有剩余的非懒加载单例Bean对象。 - -**实例化所有非懒加载的单例Bean**：在`finishBeanFactoryInitialization`方法里，调用了`DefaultListableBeanFactory`类中的`preInstantiateSingletons`方法，这个方法会对每个非懒加载的单例bean进行实例化。当这些beans被初始化后，方法还会查找那些实现了`SmartInitializingSingleton`接口的beans，并执行它们的`afterSingletonsInstantiated`方法。 - -**Bean获取与创建**：`AbstractBeanFactory`类中的`getBean`方法负责获取bean。如果bean尚未创建，则会进一步调用`doGetBean`方法进行创建。这个方法处理了从缓存获取单例bean的逻辑，循环引用的问题，以及根据bean的作用域创建bean实例的逻辑。 - -**单例Bean的获取与创建**：`DefaultSingletonBeanRegistry`类中的`getSingleton`方法负责从单例缓存中获取bean，或者通过提供的`singletonFactory`进行创建。这个方法确保了线程安全地创建单例，并处理了与创建失败、并发和循环引用相关的问题。 - -**Bean创建前后的处理**：在创建单例bean之前和之后，系统通过`beforeSingletonCreation`和`afterSingletonCreation`方法进行相应的处理，如标记bean正在创建，以及后续的清理工作。 - -**Bean的创建**：`createBean(beanName,mbd,args)`是一个核心方法，它负责创建Bean。此过程包括：确保Bean的类已正确解析并设置。验证方法重写，确保没有配置错误。在实际实例化Bean之前，尝试使用`BeanPostProcessors`返回一个代理对象。实际创建和初始化Bean。 - -**早期解析与代理**：在`resolveBeforeInstantiation`方法中，尝试在Bean实际实例化之前完成Bean的实例化，这通常是为了返回一个代理对象。 - -**Bean实例化与属性注入**：`doCreateBean`方法首先负责Bean的实例化，然后进行类型的解析和方法覆盖的准备。在实例化Bean后，该方法允许`BeanPostProcessors`为Bean提供代理或进行其他更改。之后，该方法为解决可能的循环引用问题，提前将Bean放入缓存。接着，进行属性注入，并执行初始化方法。最后，如果Bean定义了销毁方法或实现了相关接口，它将被注册为可销毁的。 - -**Bean属性的填充**：`populateBean`方法确保Bean的所有属性都被正确地配置和填充。它负责按名字或类型进行自动装配，并处理显式定义的属性值。 - -**Bean的初始化**：`initializeBean`方法负责执行Bean的初始化逻辑。这包括调用Aware接口的方法，通过`BeanPostProcessors`进行预处理，执行初始化方法（例如`afterPropertiesSet`或自定义的init方法），最后通过`BeanPostProcessors`进行后处理。 - -**Aware接口的处理**：`invokeAwareMethods`方法是专门为那些实现了Spring的Aware接口的bean设计的，它负责通知Bean关于容器的某些状态或信息。 \ No newline at end of file +#### 源码分析总结 diff --git a/spring-core/spring-core-getBean/src/main/java/com/xcs/spring/GetBeanApplication.java b/spring-core/spring-core-getBean/src/main/java/com/xcs/spring/GetBeanApplication.java index 83d526b..c485731 100644 --- a/spring-core/spring-core-getBean/src/main/java/com/xcs/spring/GetBeanApplication.java +++ b/spring-core/spring-core-getBean/src/main/java/com/xcs/spring/GetBeanApplication.java @@ -1,6 +1,7 @@ package com.xcs.spring; import com.xcs.spring.config.MyConfiguration; +import com.xcs.spring.service.MyServiceA; import org.springframework.context.annotation.AnnotationConfigApplicationContext; /** @@ -11,9 +12,7 @@ public class GetBeanApplication { public static void main(String[] args) { AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyConfiguration.class); - for (String beanDefinitionName : context.getBeanDefinitionNames()) { - System.out.println("Bean = " + context.getBean(beanDefinitionName)); - } - context.close(); + System.out.println("myServiceA = " + context.getBean("myServiceA")); + System.out.println("myServiceB = " + context.getBean("myServiceB")); } }