Bean创建过程

从AbstractAutowireCapableBeanFactory说起、AbstractAutowireCapableBeanFactory顾明思议、是带有自动注入功能的BeanFactory、我们先看他的类继承结构

如上图所示、AbstractAutowireCapableBeanFactory实现了AbstractBeanFactory说明其本身实现了BeanFactory的功能、包括bean的创建。

其次AbstractAutowireCapableBeanFactory也实现了AutowireCapableBeanFactory扩展接口、表明其具有自动注入属性的功能。由于其是一个抽象的类、所以由此猜测AbstractAutowireCapableBeanFactory实现了bean创建的默认行为以及基础的属性注入功能，来看spring源码对AbstractAutowireCapableBeanFactory的注释:

/**
 * Abstract bean factory superclass that implements default bean creation,
 * with the full capabilities specified by the {@link RootBeanDefinition} class.
 * Implements the {@link org.springframework.beans.factory.config.AutowireCapableBeanFactory}
 * interface in addition to AbstractBeanFactory's {@link #createBean} method.
 *
 * <p>Provides bean creation (with constructor resolution), property population,
 * wiring (including autowiring), and initialization. Handles runtime bean
 * references, resolves managed collections, calls initialization methods, etc.
 * Supports autowiring constructors, properties by name, and properties by type.
 *
 * <p>The main template method to be implemented by subclasses is
 * {@link #resolveDependency(DependencyDescriptor, String, Set, TypeConverter)},
 * used for autowiring by type. In case of a factory which is capable of searching
 * its bean definitions, matching beans will typically be implemented through such
 * a search. For other factory styles, simplified matching algorithms can be implemented.
 *
 * <p>Note that this class does <i>not</i> assume or implement bean definition
 * registry capabilities. See {@link DefaultListableBeanFactory} for an implementation
 * of the {@link org.springframework.beans.factory.ListableBeanFactory} and
 * {@link BeanDefinitionRegistry} interfaces, which represent the API and SPI
 * view of such a factory, respectively.
 */

简单翻译以上意思是：

它是bean工厂的超类、此bean工厂实现了bean创建功能。创建的bean具有RootBeanDefinition指定的全部功能。并且实现了AbstractBeanFactory的createBean方法。同时它也实现了AutowireCapableBeanFactory接口

提供了bean的创建(带有构造器解析)，属性注入，和初始化。处理运行时bean引用。解析收管理的集合。调用初始化的方法等等功能，提供了构造器注入、通过名称注入属性、通过类型注入属性。

其中提供给子类覆盖的主要模板方法是resolveDependency(DependencyDescriptor, String, Set, TypeConverter)这个方法用于通过类型注入的时候、提供多态的机制。

注意一点是：

AbstractAutowireCapableBeanFactory没有bean定义注册的功能、因为他并没有实现BeanDefinitionRegistry接口、注意他和DefaultListableBeanFactory的区别、DefaultListableBeanFactory它即实现了ListableBeanFactory同时也实现了BeanDefinitionRegistry。看一个类图我们就明白了。

AbstractBeanFactory---->doCreateBean开始说起:

/**
	 * Create a bean instance for the given merged bean definition (and arguments).
	 * The bean definition will already have been merged with the parent definition
	 * in case of a child definition.
	 * <p>All bean retrieval methods delegate to this method for actual bean creation.
	 *
	 * @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
	 */
	protected abstract Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
			throws BeanCreationException;
此方法在AbstractBeanFactory是一个protected类型的方法、方法签名表明该方法是用于创建bean实例的方法、调用该方法的时候所有的bean定义已经准备好、如果是子类的bean定义已经完全和父bean定义合并。所有的获取bean实例的方法都会委托给此方法去做真正的创建工作。

AbstractAutowireCapableBeanFactory--->doCreateBean

//这里的beanName就是我们在xml中定义的bean定义名称。mbd是已经合并(如果是子类需要和父类合并属性)的bean定义对象。args表示如果是构造器注入需要传入的参数。
@Override
	protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
			throws BeanCreationException {
		RootBeanDefinition mbdToUse = mbd;
=================================(参考2.1)==============================
     // Make sure bean class is actually resolved at this point, and
		// clone the bean definition in case of a dynamically resolved Class
		// which cannot be stored in the shared merged bean definition.
		// 解析 bean 的类型  此处使用来解析bean的类型。因为RootBeanDefinition保存的只是bean的定义信息、
    // bean的定义信息中只是包含了	bean的名称、但是还没有利用反射解析出Bean的真正Class引用、故resolveBeanClass利用反射解析出
    //bean的Class<?>信息存入到RootBeanDefinition的beanClass属性当中去。
		Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
		if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
			mbdToUse = new RootBeanDefinition(mbd);
			mbdToUse.setBeanClass(resolvedClass);
		}

=================================(参考2.2)==============================
       // Prepare method overrides.
			// 处理 lookup-method 和 replace-method 配置，Spring 将这两个配置统称为 override method
			mbdToUse.prepareMethodOverrides();		

=================================(参考2.3)==============================
		// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
		// 在 bean 初始化前应用后置处理，如果后置处理返回的 bean 不为空，则直接返回
		Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
		if (bean != null) {
			return bean;
		}
		
=================================(参考2.4)===============================
		// 调用 doCreateBean 创建 bean
   Object beanInstance = doCreateBean(beanName, mbdToUse, args);   
   return beanInstance;
}

2.1. doCreateBean过程

2.2. doCreateBean过程

2.3. doCreateBean过程

2.4. doCreateBean过程

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
			throws BeanCreationException {

		// Instantiate the bean.
		/*
		 * BeanWrapper 是一个基础接口，由接口名可看出这个接口的实现类用于包裹 bean 实例。
		 * 通过 BeanWrapper 的实现类可以方便的设置/获取 bean 实例的属性
		 */
		BeanWrapper instanceWrapper = null;
		if (mbd.isSingleton()) {
			// 从缓存中获取 BeanWrapper，并清理相关记录
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		}
		if (instanceWrapper == null) {
			/*
			 * 创建 bean 实例，并将实例包裹在 BeanWrapper 实现类对象中返回。createBeanInstance
			 * 中包含三种创建 bean 实例的方式：
			 *   1. 通过工厂方法创建 bean 实例
			 *   2. 通过构造方法自动注入（autowire by constructor）的方式创建 bean 实例
			 *   3. 通过无参构造方法方法创建 bean 实例
			 *
			 * 若 bean 的配置信息中配置了 lookup-method 和 replace-method，则会使用 CGLIB
			 * 增强 bean 实例。关于这个方法，后面会专门写一篇文章介绍，这里先说这么多。
			 */
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
		// 此处的 bean 可以认为是一个原始的 bean 实例，暂未填充属性
		final Object bean = instanceWrapper.getWrappedInstance();
		Class<?> beanType = instanceWrapper.getWrappedClass();
		if (beanType != NullBean.class) {
			mbd.resolvedTargetType = beanType;
		}

		// Allow post-processors to modify the merged bean definition.
		// 这里又遇到后置处理了，此处的后置处理是用于处理已“合并的 BeanDefinition”。
		synchronized (mbd.postProcessingLock) {
			if (!mbd.postProcessed) {

				applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
				mbd.postProcessed = true;
			}
		}

		// Eagerly cache singletons to be able to resolve circular references
		// even when triggered by lifecycle interfaces like BeanFactoryAware.
		/*
		 * earlySingletonExposure 是一个重要的变量，这里要说明一下。该变量用于表示是否提前暴露
		 * 单例 bean，用于解决循环依赖。earlySingletonExposure 由三个条件综合而成，如下：
		 *   条件1：mbd.isSingleton() - 表示 bean 是否是单例类型
		 *   条件2：allowCircularReferences - 是否允许循环依赖
		 *   条件3：isSingletonCurrentlyInCreation(beanName) - 当前 bean 是否处于创建的状态中
		 *
		 * earlySingletonExposure = 条件1 && 条件2 && 条件3
		 *                        = 单例 && 是否允许循环依赖 && 是否存于创建状态中。
		 */
		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");
			}
			// 添加工厂对象到 singletonFactories 缓存中
			addSingletonFactory(beanName, () ->
					// 获取早期 bean 的引用，如果 bean 中的方法被 AOP 切点所匹配到，此时 AOP 相关逻辑会介入
					getEarlyBeanReference(beanName, mbd, bean));
		}

		// Initialize the bean instance.
		Object exposedObject = bean;

			// 向 bean 实例中填充属性，populateBean 所谓的属性注入都是发生在这个方法里面、详细解析
			populateBean(beanName, mbd, instanceWrapper);
			/*
			 * 进行余下的初始化工作，详细如下：
			 * 1. 判断 bean 是否实现了 BeanNameAware、BeanFactoryAware、
			 *    BeanClassLoaderAware 等接口，并执行接口方法
			 * 2. 应用 bean 初始化前置操作
			 * 3. 如果 bean 实现了 InitializingBean 接口，则执行 afterPropertiesSet
			 *    方法。如果用户配置了 init-method，则调用相关方法执行自定义初始化逻辑
			 * 4. 应用 bean 初始化后置操作
			 *
			 * 另外，AOP 相关逻辑也会在该方法中织入切面逻辑，此时的 exposedObject 就变成了
			 * 一个代理对象了
			 */
			exposedObject = initializeBean(beanName, exposedObject, mbd);

		if (earlySingletonExposure) {
			Object earlySingletonReference = getSingleton(beanName, false);
			if (earlySingletonReference != null) {
				// 若 initializeBean 方法未改变 exposedObject 的引用，则此处的条件为 true。
				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);
						}
					}
				}
			}
		}

		// Register bean as disposable.
			// 注册销毁逻辑
      registerDisposableBeanIfNecessary(beanName, bean, mbd);
		return exposedObject;
	}

文章作者: 书中人

文章连结: /archives/bean创建过程

微信扫一扫