Spring源码解读（五）Bean创建过程之创建——AbstractAutowireCapableBeanFactory-CSDN博客

本文链接：https://blog.csdn.net/lishuzhen5678/article/details/123450010

前言

上文 Spring源码解读（四）Bean创建过程之加载——AbstractBeanFactory 中分析到创建bean时由各Scope负责创建，这篇博文以scope=singleton为例，分析单例对象的创建过程。其中主要设计到 AbstractActowireCapableBeanFactory 和 DefalutSingletonBeanRegistry两个类

程序入口

                // 开始创建bean实例
				if (mbd.isSingleton()) {
					// 调用DefaultSingletonBeanRegistry.getSingleton获取单例对象实例
					// 这个方法的参数时，beanName 和 ObjectFactory, 这里new一个匿名实现类
					sharedInstance = getSingleton(beanName, () -> {
						try {
							// 调用AbstractAutowireCapableBeanFactory.createBean
							return createBean(beanName, mbd, args);
						}
						catch (BeansException ex) {
		                    destroySingleton(beanName);
							throw ex;
						}
					});
					// 获取这个bean的实例对象
					bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
				}

准备创建Bean

AbstractAutowireCapableBeanFactory.createBean

createBean是AbstractBeanFactory定义的抽象方法，只有AbstractAutowireCapableBeanFactory实现了这个方法，所以所有的bean实例创建都会委托给它处理。

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

		if (logger.isTraceEnabled()) {
			logger.trace("Creating instance of bean '" + beanName + "'");
		}
		RootBeanDefinition mbdToUse = mbd;
		// 将 bean 类名称解析为 Class 引用
		Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
		if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
			// 确保此时实际解析了 bean 类
			// 并克隆 bean 定义以防动态解析的 Class 无法存储在共享的合并 bean 定义中。
			mbdToUse = new RootBeanDefinition(mbd);
			mbdToUse.setBeanClass(resolvedClass);
		}

		// Prepare method overrides.
		try {
			// 准备覆盖overrides方法，检查查找方法是否存在并确定它们的重载状态。
			mbdToUse.prepareMethodOverrides();
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
					beanName, "Validation of method overrides failed", ex);
		}
		try {
			// 应用实例化前后处理器, 如果由代理对象，返回一个代理对象代替这个bean
			// SpringAOP 就是由此实现
			// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
			Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
			if (bean != null) {
				// 存在代理对象，直接返回
				return bean;
			}
		}
		catch (Throwable ex) {
			throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
					"BeanPostProcessor before instantiation of bean failed", ex);
		}

		try {
			// 之前都是做一些检查工作，此处调用doCreateBean 才开始创建bean实例
			Object beanInstance = doCreateBean(beanName, mbdToUse, args);
			if (logger.isTraceEnabled()) {
				logger.trace("Finished creating instance of bean '" + beanName + "'");
			}
			return beanInstance;
		}
		catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
			throw ex;
		}
		catch (Throwable ex) {
			throw new BeanCreationException(
					mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
		}
	}

解析 beanClass

AbstractBeanFactory#resolveBeanClass

为指定的 beanBedifition 解析 beanClass，将 bean 类名称解析为 Class 引用（如果需要）并将解析的 Class 存储在 bean 定义中以供进一步使用。

    @Nullable
	protected Class<?> resolveBeanClass(RootBeanDefinition mbd, String beanName, Class<?>... typesToMatch)
			throws CannotLoadBeanClassException {

		try {
			if (mbd.hasBeanClass()) {
				return mbd.getBeanClass();
			}
			if (System.getSecurityManager() != null) {
				return AccessController.doPrivileged((PrivilegedExceptionAction<Class<?>>)
						() -> doResolveBeanClass(mbd, typesToMatch), getAccessControlContext());
			}
			else {
				return doResolveBeanClass(mbd, typesToMatch);
			}
		}
		catch (PrivilegedActionException pae) {
			ClassNotFoundException ex = (ClassNotFoundException) pae.getException();
			throw new CannotLoadBeanClassException(mbd.getResourceDescription(), beanName, mbd.getBeanClassName(), ex);
		}
		catch (ClassNotFoundException ex) {
			throw new CannotLoadBeanClassException(mbd.getResourceDescription(), beanName, mbd.getBeanClassName(), ex);
		}
		catch (LinkageError err) {
			throw new CannotLoadBeanClassException(mbd.getResourceDescription(), beanName, mbd.getBeanClassName(), err);
		}
	}

解析override方法

AbstractBeanDefinition#prepareMethodOverrides

准备方法覆盖，以xml方式为例，这里实际也就是解析<lookup-method /> <replace-method>，这两个配置在加载时会合并到BeanDefinition的methodOverrides属性里，在检查重载的过程中会遍历整个实例的方法，根据方法名字匹配，实际上在这一步spring已经完成了重载方法的调用。

如果不存在重载的情况，那么会直接标记false，减少再后续方法调用时，再根据参数匹配对应的方法。

public void prepareMethodOverrides() throws BeanDefinitionValidationException {
   // 检查查找方法是否存在并确定它们的重载状态。
   // methodOverrides 就是个map, 如果是空，就表示没有方法重载
   // 是在BeanDefinitionParserDelegate.parseBeanDefinitionElement(String, BeanDefinition)解析元素时
   // 调用 BeanDefinitionParserDelegate.parseLookupOverrideSubElements 和 BeanDefinitionParserDelegate.parseReplacedMethodSubElements 写进去的
   // 实际也就是 <bean>中的 <lookup-method /> 和  <replace-method />
   if (hasMethodOverrides()) {
      getMethodOverrides().getOverrides().forEach(this::prepareMethodOverride);
   }
}

protected void prepareMethodOverride(MethodOverride mo) throws BeanDefinitionValidationException {
		// 通过方法名 遍历类中的方法
		int count = ClassUtils.getMethodCountForName(getBeanClass(), mo.getMethodName());
		if (count == 0) {
			// 不存在这个方法，无法override 抛出异常
			throw new BeanDefinitionValidationException(
					"Invalid method override: no method with name '" + mo.getMethodName() +
					"' on class [" + getBeanClassName() + "]");
		}
		else if (count == 1) {
			// 有且仅有一个，不存在重载的情况。
			// 直接标记为overload=false, 减少后续方法调用时，再次判断方法参数的开销
			mo.setOverloaded(false);
		}
    }

实例化的前置处理

AbstractBeanDefinition#resolveBeforeInstantiation

执行实例化前/后处理器，返回代理对象，这部分和AOP的实现有关，这里不再细分。

	@Nullable
	protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
		Object bean = null;
		// 如果此时还没有被解析
		if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
			// Make sure bean class is actually resolved at this point.
			// 确保此时实际解析了 bean 类
			if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
				Class<?> targetType = determineTargetType(beanName, mbd);
				if (targetType != null) {
					// 执行后置处理器 在初始化前
					bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
					if (bean != null) {
						// 执行后置处理器 在初始化后
						bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
					}
				}
			}
			mbd.beforeInstantiationResolved = (bean != null);
		}
		return bean;
	}

开始创建Bean

AbstractAutowireCapableBeanFactory#doCreateBean

之前的步骤都是在做检查，doCreateBean开始真正的创建Bean。

	protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
			throws BeanCreationException {
		// 开始实例化
		BeanWrapper instanceWrapper = null;
		if (mbd.isSingleton()) {
			// factoryBeanInstanceCache : 未完成的 FactoryBean 实例的缓存, Map<beanName, BeanWrapper>
			// 将这个bean从未完成的缓存中移除
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		}
		if (instanceWrapper == null) {
			// 创建bean实例化对象，根据不同的实例化策略实例化bean，如工厂方法、构造函数自动装配或简单实例化
			// 同时将 BeanDefinition 转化为 BeanWrapper
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
		Object bean = instanceWrapper.getWrappedInstance();
		Class<?> beanType = instanceWrapper.getWrappedClass();
		if (beanType != NullBean.class) {
			mbd.resolvedTargetType = beanType;
		}

		// 允许后处理器修改合并的 bean 定义。
		synchronized (mbd.postProcessingLock) {
			// 同步代码块，通知只能有一个线程对bean进行后置处理
			if (!mbd.postProcessed) {
				try {
					// 将后置处理器应用于这个bean
					// 如 @Autowire AutowiredAnnotationBeanPostProcessor 就在这个方法内遍历执行。
					applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
				}
				catch (Throwable ex) {
					throw new BeanCreationException(mbd.getResourceDescription(), beanName,
							"Post-processing of merged bean definition failed", ex);
				}
				// 标记后置处理完成
				mbd.postProcessed = true;
			}
		}

		// 优先解决循环依赖
		// 提前暴力ObjectFactory,这里可能会出现 BeanFactoryAware 等生命周期接口触发的情况，但是相比循环依赖，还是要先处理循环依赖
		// 必须满足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");
			}
			// 提前暴露给 SingletonFactory
			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
		}

		Object exposedObject = bean;
		try {
			// 填充属性，使用 beanDefinition中的属性值填充BeanWrapper 中的 bean 实例。
			populateBean(beanName, mbd, instanceWrapper);
			// 初始化bean，这个方法内处理Aware回调，调用init方法，执行初始化前后的bean处理器。
			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);
			}
		}

		// 提前暴露BeanFactory,
		if (earlySingletonExposure) {
			// 表示已经缓存了这个对象了，直接通过通过name获取bean
			Object earlySingletonReference = getSingleton(beanName, false);
			if (earlySingletonReference != null) {
				if (exposedObject == bean) {
					// 直接使用缓存重点bean
					exposedObject = earlySingletonReference;
				}
				else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
					// 如果不允许循环依赖，但是出现了所依赖的beanMap缓存中又出现了这个bean，那么此时就是出现了循环依赖
					// 通过beanName拿到这个bean的所有依赖对象
					String[] dependentBeans = getDependentBeans(beanName);
					Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
					for (String dependentBean : dependentBeans) {
						// 删除给定 bean 名称的单例实例（如果有），但前提是它没有用于类型检查以外的其他目的。
						if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
							// 删除失败了，添加到循环依赖的数组中
							actualDependentBeans.add(dependentBean);
						}
					}
					// 循环依赖的bean没有没完全删除，抛出异常
					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 {
			// 将给定的 bean 添加到该工厂的一次性 bean 列表中，仅适用于单例
			// spring 关闭时，如果满足下面的条件之一，就调用destroy()
			// 实现Disposable接口、自定义destroy()方法、实现AutoCloseable
			registerDisposableBeanIfNecessary(beanName, bean, mbd);
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanCreationException(
					mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
		}

		return exposedObject;
	}

实例化Bean

AbstractAutowireCapableBeanFactory#createBeanInstance

这里会将BeanDefinition转换为BeanWrapper，转换过程十分复杂，具体创建逻辑的实现以后再讲解，目前大概可以概况为三个点：

如果存在工厂方法则使用工厂方法创建
一个类存在多个构造方法，根据参数锁定对应的构造方法进行创建
排除以上两个场景后则使用默认的无参构造创建

	protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
		// createBean方法已经解析过了，为了确保此时实际解析了，再次解析这个bean  bean 类。
		Class<?> beanClass = resolveBeanClass(mbd, beanName);

		// 解析失败
		// 没有public修饰
		// 不允许访问非公共构造函数和方法
		// 出现以上三种情况，无法在外部实例化，抛出异常
		if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
			throw new BeanCreationException(mbd.getResourceDescription(), beanName,
					"Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
		}

		// 通过BeanDefinition中的supplier实例化这个bean
		Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
		if (instanceSupplier != null) {
			return obtainFromSupplier(instanceSupplier, beanName);
		}

		// 通过工厂方法实例化这个bean
		if (mbd.getFactoryMethodName() != null) {
			return instantiateUsingFactoryMethod(beanName, mbd, args);
		}

		// 通过构造方法创建这个bean
		boolean resolved = false;
		boolean autowireNecessary = false;
		if (args == null) {
			// constructorArgumentLock 构造参数锁，针对构造起作用
			synchronized (mbd.constructorArgumentLock) {
				// resolvedConstructorOrFactoryMethod : 缓存解析的构造函数或工厂方法
				if (mbd.resolvedConstructorOrFactoryMethod != null) {
					resolved = true;
					// constructorArgumentsResolved  构造函数参数解析状态
					autowireNecessary = mbd.constructorArgumentsResolved;
				}
			}
		}
		if (resolved) {
			if (autowireNecessary) {
				// 自动设配参数 使用有参构造实例化bean
				return autowireConstructor(beanName, mbd, null, null);
			}
			else {
				// 无参构造实例化bean
				return instantiateBean(beanName, mbd);
			}
		}

		// 自动装配的候选构造函数
		Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
		if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
				mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
			return autowireConstructor(beanName, mbd, ctors, args);
		}

		// 默认构造的首选构造函数
		ctors = mbd.getPreferredConstructors();
		if (ctors != null) {
			return autowireConstructor(beanName, mbd, ctors, null);
		}
		// 没有特殊处理：只需使用无参数构造函数。
		return instantiateBean(beanName, mbd);
	}

填充属性

AbstractAutowireCapableBeanFactory#populateBean

为实例化对象填充属性，使用 beanDefinition中的属性值填充BeanWrapper 中的 bean 实例

	protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
		if (bw == null) {
			// 如果beanWrapper是null，同时没有属性，也就无法填充，直接返回一个空实例
			// 如果有属性需要填充，又不能为null填充，抛出异常
			if (mbd.hasPropertyValues()) {
				throw new BeanCreationException(
						mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
			}
			else {
				// Skip property population phase for null instance.
				return;
			}
		}

		// Give any InstantiationAwareBeanPostProcessors the opportunity to modify the
		// state of the bean before properties are set. This can be used, for example,
		// to support styles of field injection.
		// 让任何 InstantiationAwareBeanPostProcessors 。例如，这可以用于支持字段注入的样式。
		// 非合成的bean
		// 同时存在有初始化意识的Bean后置处理器
		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
			// 此时，可以在在设置属性之前修改 bean 的状态
			for (BeanPostProcessor bp : getBeanPostProcessors()) {
				if (bp instanceof InstantiationAwareBeanPostProcessor) {
					InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
					// 在通过构造函数或工厂方法实例化 bean 之后，但在 Spring 属性填充（来自显式属性或自动装配）发生之前执行操作。 
					// 在 Spring 的自动装配开始之前，给定 bean 实例上执行自定义字段注入的理想回调，
					if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
						return;
					}
				}
			}
		}

		PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);

		// 自动注入@Autowire注解的属性
		int resolvedAutowireMode = mbd.getResolvedAutowireMode();
		if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
			MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
			// Add property values based on autowire by name if applicable.
			if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
				// 根据名称自动装配属性值
				autowireByName(beanName, mbd, bw, newPvs);
			}
			// Add property values based on autowire by type if applicable.
			if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
				// 根据类型添加基于自动装配的属性值。
				autowireByType(beanName, mbd, bw, newPvs);
			}
			pvs = newPvs;
		}

		// 存在实例化时适用的后置处理器
		boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
		// 需要依赖检查
		boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);

		PropertyDescriptor[] filteredPds = null;
		if (hasInstAwareBpps) {
			if (pvs == null) {
				pvs = mbd.getPropertyValues();
			}
			for (BeanPostProcessor bp : getBeanPostProcessors()) {
				if (bp instanceof InstantiationAwareBeanPostProcessor) {
					InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
					PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
					if (pvsToUse == null) {
						if (filteredPds == null) {
							filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
						}
						// 后置处理bean属性值
						// 在工厂将给定的属性值应用于给定的 bean 之前对其进行后处理。
						// 允许检查是否所有依赖项都已满足，例如基于 bean 属性设置器上的“必需”注释。 
						pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
						if (pvsToUse == null) {
							return;
						}
					}
					pvs = pvsToUse;
				}
			}
		}
		// 最后进行依赖检查
		if (needsDepCheck) {
			if (filteredPds == null) {
				// 从beanWrapper 中提取一组过滤的 PropertyDescriptor，
				// 不包括忽略的依赖类型或定义在忽略的依赖接口上的属性。
				filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
			}
			// 执行依赖项检查以确保所有公开的属性都已设置。
			// 依赖项检查可以是对象（协作 bean）、简单的（基元和字符串）或全部（两者）。
			checkDependencies(beanName, mbd, filteredPds, pvs);
		}

		if (pvs != null) {
			// 应用给定的属性值，解析对此 bean 工厂中其他 bean 的任何运行时引用。
			// 必须使用深拷贝，所以我们不会永久修改这个属性。
			applyPropertyValues(beanName, mbd, bw, pvs);
		}
	}

初始化Bean

AbstractAutowireCapableBeanFactory#initializeBean

初始化给定的 bean 实例，应用工厂回调以及 init 方法和 bean 后处理器。这个方法内主要做四件事
1 - Aware 接口方法回调
2 - 初始化之前调用 Bean 后处理器
3 - 调用指定的init方法
4 - 初始化之后调用 Bean 后处理器

	protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
		// 如果bean有实现Aware接口，在这里执行接口的回调方法
		// 这里的invokeAwareMethods只处理 BeanNameAware BeanClassLoadAware BeanFactoryAware  三个子接口
		if (System.getSecurityManager() != null) {
			AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
				invokeAwareMethods(beanName, bean);
				return null;
			}, getAccessControlContext());
		}
		else {
			invokeAwareMethods(beanName, bean);
		}

		Object wrappedBean = bean;
		// RootBeanDefinition.isSynthetic : 此 bean 定义是否是“合成的”，即不是由应用程序本身定义的。
		if (mbd == null || !mbd.isSynthetic()) {
			// 如果不是合并的bean，在初始化之前执行 Bean 后处理器，调用其 postProcessBeforeInitialization 方法
			wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
		}

		try {
			// 调用初始化方法
			invokeInitMethods(beanName, wrappedBean, mbd);
		}
		catch (Throwable ex) {
			throw new BeanCreationException(
					(mbd != null ? mbd.getResourceDescription() : null),
					beanName, "Invocation of init method failed", ex);
		}
		if (mbd == null || !mbd.isSynthetic()) {
			// 如果不是合并的bean，在初始化之前执行 Bean 后处理器，调用其 postProcessAfterInitialization 方法
			wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
		}

		return wrappedBean;
	}

处理三个基础Aware的回调

invokeAwareMethods()

这里暂时只处理 BeanNameAware、BeanClassLoadAware、BeanFactoryAware三个子接口

	private void invokeAwareMethods(String beanName, Object bean) {
		if (bean instanceof Aware) {
			if (bean instanceof BeanNameAware) {
				((BeanNameAware) bean).setBeanName(beanName);
			}
			if (bean instanceof BeanClassLoaderAware) {
				ClassLoader bcl = getBeanClassLoader();
				if (bcl != null) {
					((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
				}
			}
			if (bean instanceof BeanFactoryAware) {
				((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
			}
		}
	}

执行初始化方法

invokInitMethos

调用初始化方法，初始化方法分为两种

1 - 实现InitializingBean接口，重写其afterPropertiesSet方法，

2 - init-mothod 指定的方法

注意这里两个选项互相排斥，只能同时存在一种，否则都不会被执行。

	protected void invokeInitMethods(String beanName, Object bean, @Nullable RootBeanDefinition mbd)
			throws Throwable {
		// 如果实现了InitializingBean，调用其实现的afterPropertiesSet()方法
		// 同时要注意如果实现了InitializingBean的afterPropertiesSet的方法，
		// 那么就指定初始化方法名（init-method）不能和 afterPropertiesSet重名，
		boolean isInitializingBean = (bean instanceof InitializingBean);
		if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
			if (logger.isTraceEnabled()) {
				logger.trace("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
			}
			if (System.getSecurityManager() != null) {
				try {
					AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
						((InitializingBean) bean).afterPropertiesSet();
						return null;
					}, getAccessControlContext());
				}
				catch (PrivilegedActionException pae) {
					throw pae.getException();
				}
			}
			else {
				((InitializingBean) bean).afterPropertiesSet();
			}
		}

		if (mbd != null && bean.getClass() != NullBean.class) {
			// 调用其指定的初始化方法
			String initMethodName = mbd.getInitMethodName();
			// 执行初始化方法的前提条件是
			// 1 - 不能实现InitializingBean
			// 2 - 指定的初始化方法名不能是afterPropertiesSet
			if (StringUtils.hasLength(initMethodName) &&
					!(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
					!mbd.isExternallyManagedInitMethod(initMethodName)) {
				invokeCustomInitMethod(beanName, bean, mbd);
			}
		}
	}

执行BeanPostProcessor后处理器

applyBeanPostProcessorsBeforeInitialization 和 applyBeanPostProcessorsAfterInitialization

BeanPostProcessor接口，这是spring为开发者提供的一个底层接口，会在bean初始化方法执行前后依次调用postProcessBeforeInitialization和postProcessAfterInitialization方法，就是通过拿到当前的BeanPostProcessord集合遍历调用其postProcessBeforeInitialization和postProcessAfterInitialization方法。如果我们相对bean初始化进行增强处理，可通过实现接口的这两个方法来完成。

上文中提到处理了三个Aware的子接口，这里遍历执行的过程中会调用到 ApplicationContextAwareProcessor#postProcessBeforeInitialization方法，这里会完成其他的Aware接口的回调处理。

	@Override
	public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
			throws BeansException {

		Object result = existingBean;
		for (BeanPostProcessor processor : getBeanPostProcessors()) {
			// 如ApplicationContextAwareProcessor.postProcessBeforeInitialization这个处理器就实现各种Aware方法的回调操作。
			Object current = processor.postProcessBeforeInitialization(result, beanName);
			if (current == null) {
				return result;
			}
			result = current;
		}
		return result;
	}

	@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;
	}

注册DisposableBean

AbstractBeanFactory#registerDisposableBeanIfNecessary

上文中说到了初始化方法的扩展接口，同样这里也有销毁方法的扩展接口。

可通过DestructionAwareBeanPostProcessors、DisposableBean接口、和自定义销毁方法来完成。

	protected void registerDisposableBeanIfNecessary(String beanName, Object bean, RootBeanDefinition mbd) {
		AccessControlContext acc = (System.getSecurityManager() != null ? getAccessControlContext() : null);
		if (!mbd.isPrototype() && requiresDestruction(bean, mbd)) {
			if (mbd.isSingleton()) {
				// Register a DisposableBean implementation that performs all destruction
				// work for the given bean: DestructionAwareBeanPostProcessors,
				// DisposableBean interface, custom destroy method.
				// 单例模式下注册需要销毁的Bean
				// 注册一个为给定 bean 执行所有销毁工作的 DisposableBean 实现：DestructionAwareBeanPostProcessors、DisposableBean 接口、自定义销毁方法。
				registerDisposableBean(beanName,
						new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
			}
			else {
				// A bean with a custom scope...
				// 非单例模式 交给各自的score处理
				Scope scope = this.scopes.get(mbd.getScope());
				if (scope == null) {
					throw new IllegalStateException("No Scope registered for scope name '" + mbd.getScope() + "'");
				}
				scope.registerDestructionCallback(beanName,
						new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
			}
		}
	}

至此，SpringBean整个创建过程已经分析完毕，后续会对这其中的细节进行具体分析。