【Spring源码】doCreateBean()

简易版

    protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
		// 实例化bean
        BeanWrapper instanceWrapper = createBeanInstance(beanName, mbd, args);
        // 属性填充
        populateBean(beanName, mbd, instanceWrapper);
        // 调用初始化方法
        return initializeBean(beanName, instanceWrapper.getWrappedInstance(), mbd);
    }

中文注释版

1、如果是单例首先清除缓存
2、实例化bean
3、bean合并后的处理
4、依赖处理
5、属性填充
6、循环依赖检查
7、注册DisposableBean
8、完成创建并返回

    /**
     * 实际创建指定的bean。 预创建处理此时已经发生，例如 检查 postProcessBeforeInstantiation 回调。
     * 区分默认 bean 实例化、使用工厂方法和自动装配构造函数。
     * @param beanName bean 的名称
     * @param mbd bean 的合并 bean 定义
     * @param args 用于构造函数或工厂方法调用的显式参数
     * @return 一个新的 bean 实例
     * @throws BeanCreationException 如果无法创建 bean
     * @see #instantiateBean
     * @see #instantiateUsingFactoryMethod
     * @see #autowireConstructor
     */
	protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {

		// Instantiate the bean.
		BeanWrapper instanceWrapper = null;
		if (mbd.isSingleton()) {
		    // 	未完成的 FactoryBean 实例的缓存：FactoryBean 名称  BeanWrapper
            //  var factoryBeanInstanceCache = new ConcurrentHashMap<String, BeanWrapper>(16);
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		}
		if (instanceWrapper == null) {
			// 将bean转换为BeanWrapper，使用对应的策略创建新的实例，例如 工厂方法、构造函数自动注入、简单初始化
			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) {
				// @Autowired通过此方法实现诸如类型的预解析
				applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
				mbd.postProcessed = true;
			}
		}

		// 当创建B的时候，涉及自动注入A的步骤时，不是直接创建A，而是通过放入缓存中的ObjectFactory来创建实例
        // 是否需要提早曝光：单例&允许循环依赖&当前bean正在创建中，检测循环依赖
        // 急切地缓存单例，以便即使在由 BeanFactoryAware 等生命周期接口触发时也能解析循环引用。
		boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
				isSingletonCurrentlyInCreation(beanName));
		if (earlySingletonExposure) {
			// addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
			// 为避免后续循环依赖，可以在 bean 初始化完成前将创建实例的ObjectFactory加入工厂
            addSingletonFactory(beanName, new ObjectFactory() {
                public Object getObject() {
                    // 对bean 再一次依赖引用，主要应用 SmartInstantiationAware BeanPostProcessor
                    // 其中AOP就是在这里将advice动态织入bean中，若没有则直接返回bean，不作任何处理
                    return getEarlyBeanReference(beanName, mbd, bean);
                }
            });
		}

		// 对bean进行填充，将各个属性值注入，其中，可能存在依赖于其他bean的属性，则会递归初始依赖bean
		populateBean(beanName, mbd, instanceWrapper);
		// 调用初始化方法，比如init-method
		Object exposedObject = initializeBean(beanName, exposedObject, mbd);

		// 只对单例有效，prototype抛出异常。检测已经加载的bean是否已经出现了依赖循环，并判断是否要抛出异常
		if (earlySingletonExposure) {
			Object earlySingletonReference = getSingleton(beanName, false);
			// earlySingletonReference 只有在检测到有循环依赖的情况下才会不为空
			if (earlySingletonReference != null) {
				// 如果exposedObject没有在初始化方法中被改变，也就是没有被增强
				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);
						}
					}
					// 因为 bean 创建后其所依赖的bean 一定是创建的，actualDependentBeans 不为空则表示当前bean创建后其依赖的bean 却没有全部创建完，即存在循环依赖
                    if (!actualDependentBeans.isEmpty()) {
                    }
				}
			}
		}

		// 如果配置了destroy-method，这里需要注册以便于销毁时调用
        // 将 bean 注册为一次性,根据 scope 注册bean
		registerDisposableBeanIfNecessary(beanName, bean, mbd);
		return exposedObject;
	}

英文版

	/**
	 * Actually create the specified bean. Pre-creation processing has already happened
	 * at this point, e.g. checking {@code postProcessBeforeInstantiation} callbacks.
	 * <p>Differentiates between default bean instantiation, use of a
	 * factory method, and autowiring a constructor.
	 * @param beanName the name of the bean
	 * @param mbd the merged bean definition for the bean
	 * @param args explicit arguments to use for constructor or factory method invocation
	 * @return a new instance of the bean
	 * @throws BeanCreationException if the bean could not be created
	 * @see #instantiateBean
	 * @see #instantiateUsingFactoryMethod
	 * @see #autowireConstructor
	 */
	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.postProcessed = true;
			}
		}

		// 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.isDebugEnabled()) {
				logger.debug("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 && beanName.equals(((BeanCreationException) ex).getBeanName())) {
				throw (BeanCreationException) ex;
			}
			else {
				throw new BeanCreationException(
						mbd.getResourceDescription(), beanName, "Initialization of bean failed", 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;
	}