【Spring 源码】 贯穿 Bean 生命周期的核心类之 AbstractAutowireCapableBeanFactory,中兴x500

文件名：【Spring 源码】 贯穿 Bean 生命周期的核心类之 AbstractAutowireCapableBeanFactory,中兴x500 【Spring 源码】 贯穿 Bean 生命周期的核心类之 AbstractAutowireCapableBeanFactory

🚀 作者主页： 有来技术 🔥 开源项目： youlai-mall 🍃 vue3-element-admin 🍃 youlai-boot 🌺 仓库主页： Gitee 💫 Github 💫 GitCode 💖 欢迎点赞 👍 收藏 ⭐留言 📝 如有错误敬请纠正！

目录 引言核心方法：doCreateBean1. 实例化 Bean2. 属性注入3. 初始化 Bean4. 代理处理 总结开源项目

引言

AbstractAutowireCapableBeanFactory 是 Spring 框架中至关重要的核心类之一，承担着整个 Bean 生命周期关键步骤的管理责任。其在 Bean 实例化、属性注入、初始化及代理处理等关键环节中发挥着关键作用，贯穿了整个 Bean 的声明周期。

核心方法：doCreateBean

深入研究 AbstractAutowireCapableBeanFactory 源码，将关注其中一个核心方法：doCreateBean。这个方法是贯穿 Bean 生命周期的纽带，涵盖了实例化、属性注入、初始化以及代理处理等关键任务。

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)throws BeanCreationException {// Instantiate the bean.BeanWrapper instanceWrapper = null;if (mbd.isSingleton()) {instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);}if (instanceWrapper == null) {instanceWrapper = createBeanInstance(beanName, mbd, args);}Object bean = instanceWrapper.getWrappedInstance();Class<?> beanType = instanceWrapper.getWrappedClass();if (beanType != NullBean.class) {mbd.resolvedTargetType = beanType;}// Allow post-processors to modify the merged bean definition.synchronized (mbd.postProcessingLock) {if (!mbd.postProcessed) {try {applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);}catch (Throwable ex) {throw new BeanCreationException(mbd.getResourceDescription(), beanName,"Post-processing of merged bean definition failed", ex);}mbd.markAsPostProcessed();}}// Eagerly cache singletons to be able to resolve circular references// even when triggered by lifecycle interfaces like BeanFactoryAware.boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&isSingletonCurrentlyInCreation(beanName));if (earlySingletonExposure) {if (logger.isTraceEnabled()) {logger.trace("Eagerly caching bean '" + beanName +"' to allow for resolving potential circular references");}addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));}// Initialize the bean instance.Object exposedObject = bean;try {populateBean(beanName, mbd, instanceWrapper);exposedObject = initializeBean(beanName, exposedObject, mbd);}catch (Throwable ex) {if (ex instanceof BeanCreationException bce && beanName.equals(bce.getBeanName())) {throw bce;}else {throw new BeanCreationException(mbd.getResourceDescription(), beanName, ex.getMessage(), ex);}}if (earlySingletonExposure) {Object earlySingletonReference = getSingleton(beanName, false);if (earlySingletonReference != null) {if (exposedObject == bean) {exposedObject = earlySingletonReference;}else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {String[] dependentBeans = getDependentBeans(beanName);Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);for (String dependentBean : dependentBeans) {if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {actualDependentBeans.add(dependentBean);}}if (!actualDependentBeans.isEmpty()) {throw new BeanCurrentlyInCreationException(beanName,"Bean with name '" + beanName + "' has been injected into other beans [" +StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +"] in its raw version as part of a circular reference, but has eventually been " +"wrapped. This means that said other beans do not use the final version of the " +"bean. This is often the result of over-eager type matching - consider using " +"'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");}}}}// Register bean as disposable.try {registerDisposableBeanIfNecessary(beanName, bean, mbd);}catch (BeanDefinitionValidationException ex) {throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);}return exposedObject;} 1. 实例化 Bean BeanWrapper instanceWrapper = null;if (mbd.isSingleton()) {instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);}if (instanceWrapper == null) {instanceWrapper = createBeanInstance(beanName, mbd, args);}

在这一步中，doCreateBean 方法首先尝试从单例缓存中获取 Bean 的包装实例，以支持单例模式。如果未找到，它将通过 createBeanInstance 方法进行实例化。

2. 属性注入 populateBean(beanName, mbd, instanceWrapper);

populateBean 方法负责将属性注入到 Bean 实例中，包括将依赖项注入到 Bean 中，以建立 Bean 之间的关系。

3. 初始化 Bean exposedObject = initializeBean(beanName, exposedObject, mbd);

在这一步，initializeBean 方法被调用，负责执行 Bean 的初始化。这包括调用任何与 Bean 生命周期相关的回调方法，以及应用任何与 Bean 相关的后处理器。

4. 代理处理 Object earlySingletonReference = getSingleton(beanName, false);if (earlySingletonReference != null) {// 处理代理，获取早期半成品对象exposedObject = earlySingletonReference;}

在初始化之后，如果存在代理，通过从二级缓存获取早期半成品对象，实现代理的替换。这对于 AOP 等方面的处理非常关键。

总结

AbstractAutowireCapableBeanFactory 类集中了 Bean 生命周期中的关键步骤，包括实例化、属性注入、初始化以及代理处理。通过深入理解这个类及其核心方法，我们能更好地把握 Spring 框架中 Bean 的创建和管理机制，从而更有效地进行应用程序开发。

开源项目 SpringCloud + Vue3 微服务商城 GithubGitee后端youlai-mall 🍃youlai-mall 🍃前端mall-admin🌺mall-admin 🌺移动端mall-app 🍌mall-app 🍌 SpringBoot 3+ Vue3 单体权限管理系统 GithubGitee后端youlai-boot 🍃youlai-boot 🍃前端vue3-element-admin 🌺vue3-element-admin 🌺