AbstractAutowireCapableBeanFactory

忘是亡心i 2024-03-24 23:21 48阅读 0赞

*  抽象bean工厂是一个用于创建和管理bean的类。它提供了创建bean的标准功能，并按照RootBeanDefinition类的规范实现了完整的功能。此外，它还实现了AutowireCapableBeanFactory接口，该接口定义了用于自动装配bean的方法。
 *  抽象bean工厂提供了bean的创建（包括构造函数解析）、属性注入、装配（包括自动装配）和初始化等功能。它处理运行时的bean引用，解析管理的集合，调用初始化方法等操作。它支持通过构造函数进行自动装配、按名称进行属性注入以及按类型进行属性注入。
 *  抽象bean工厂中的关键模板方法是 `resolveDependency`，用于解析依赖关系并进行自动装配。子类需要根据具体的实现方式，实现这个方法以支持按类型进行自动装配。对于那些能够搜索其bean定义的工厂，通常会通过搜索匹配的bean。而对于其他类型的工厂，可以实现简化的匹配算法来找到合适的依赖对象。
 *  抽象bean工厂只提供了基本的bean创建、属性注入和初始化等功能，并没有具体实现bean定义的注册操作。如果需要在工厂中注册和管理bean定义，可以使用DefaultListableBeanFactory类来实现。

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
    		implements AutowireCapableBeanFactory {}

*  `factoryBeanInstanceCache`用于缓存未完成的 `FactoryBean`实例，其中键是 `FactoryBean`的名称，值是与该 `FactoryBean`相关联的 `BeanWrapper`对象。
 *  在Spring框架中，`FactoryBean`是一种特殊的Bean，它负责创建和管理其他Bean的实例。每当使用 `getBean`方法获取 `FactoryBean`的实例时，Spring容器会检查缓存中是否存在该 `FactoryBean`的实例，在缓存中找到对应的 `BeanWrapper`对象后，可以直接返回已经创建的实例，从而避免重复创建。
 *  需要注意的是，`factoryBeanInstanceCache`仅用于缓存未完成的 `FactoryBean`实例，即那些处于创建过程中但还未完成的实例。一旦 `FactoryBean`实例完成创建，它将不再存在于该缓存中。

/** Cache of unfinished FactoryBean instances: FactoryBean name to BeanWrapper. */
    	private final ConcurrentMap<String, BeanWrapper> factoryBeanInstanceCache = new ConcurrentHashMap<>();

*      AbstractAutowireCapableBeanFactory()
    
    这段代码是创建一个新的 `AbstractAutowireCapableBeanFactory`的构造函数。在构造函数中，做了一些初始化操作。
    
    首先，调用了父类的无参构造函数 `super()`进行初始化。
    
    然后，通过 `ignoreDependencyInterface`方法忽略了一些特定接口的依赖关系。在这个例子中，忽略了 `BeanNameAware`、`BeanFactoryAware`和 `BeanClassLoaderAware`接口的依赖关系。这意味着如果某个Bean实现了这些接口，Spring容器将不会自动处理这些接口的依赖注入。
    
    接下来，通过判断当前应用是否运行在Native Image环境下（通过调用 `NativeDetector.inNativeImage()`），来确定使用哪种实例化策略。
    
    如果当前应用运行在Native Image环境下，使用 `SimpleInstantiationStrategy`作为实例化策略。
    
    如果不是运行在Native Image环境下，则使用 `CglibSubclassingInstantiationStrategy`作为实例化策略。
    
    通过不同的实例化策略，可以选择使用不同的方式来创建Bean的实例。`SimpleInstantiationStrategy` 是一种简单的实例化策略，主要使用Java的反射机制来实现实例化，而 `CglibSubclassingInstantiationStrategy` 则是使用CGLIB库来创建Bean的子类来实现实例化。

public AbstractAutowireCapableBeanFactory() {
    		super();
    		ignoreDependencyInterface(BeanNameAware.class);
    		ignoreDependencyInterface(BeanFactoryAware.class);
    		ignoreDependencyInterface(BeanClassLoaderAware.class);
    		if (NativeDetector.inNativeImage()) {
    			this.instantiationStrategy = new SimpleInstantiationStrategy();
    		}
    		else {
    			this.instantiationStrategy = new CglibSubclassingInstantiationStrategy();
    		}
    	}

*  createBean(Class<T> beanClass)

在这个方法中，首先创建一个 `RootBeanDefinition`对象，并传入指定的 `beanClass`来定义一个原型（prototype）作用域的Bean定义。

然后，设置该Bean定义的作用域为原型作用域（`SCOPE_PROTOTYPE`），表示每次获取该Bean时都会创建一个新的实例。

接下来，根据 `beanClass`是否是缓存安全（cache-safe）的类型，设置Bean定义的 `allowCaching`属性。如果 `beanClass`是缓存安全的，则可以允许缓存Bean实例。否则，不允许缓存。

最后，调用重载的 `createBean`方法，传入 `beanClass.getName()`作为Bean的名称，创建Bean实例并返回。

@Override
    	@SuppressWarnings("unchecked")
    	public <T> T createBean(Class<T> beanClass) throws BeansException {
    		// Use prototype bean definition, to avoid registering bean as dependent bean.
    		RootBeanDefinition bd = new RootBeanDefinition(beanClass);
    		bd.setScope(SCOPE_PROTOTYPE);
    		bd.allowCaching = ClassUtils.isCacheSafe(beanClass, getBeanClassLoader());
    		return (T) createBean(beanClass.getName(), bd, null);
    	}

*  autowireBean(Object existingBean)

在这个方法中，首先创建一个 `RootBeanDefinition`对象，并使用 `ClassUtils.getUserClass(existingBean)`获取现有Bean实例的用户类。用户类是指具体类，而不是代理类或者CGLIB生成的子类。

然后，设置该Bean定义的作用域为原型作用域（`SCOPE_PROTOTYPE`），表示每次获取该Bean时都会创建一个新的实例。

接下来，根据Bean定义的类是否是缓存安全的，设置Bean定义的 `allowCaching`属性。如果Bean定义的类是缓存安全的，则允许缓存Bean实例。否则，不允许缓存。

之后，创建一个 `BeanWrapperImpl`对象，将现有的Bean对象包装起来，以便进行属性的注入和赋值操作。

调用 `initBeanWrapper`方法对 `BeanWrapperImpl`进行初始化，以确保其内部状态正确设置，以便进行属性注入和赋值。

最后，调用 `populateBean`方法，传入Bean名称、Bean定义和 `BeanWrapper`对象，进行属性的自动注入。

@Override
    	public void autowireBean(Object existingBean) {
    		// Use non-singleton bean definition, to avoid registering bean as dependent bean.
    		RootBeanDefinition bd = new RootBeanDefinition(ClassUtils.getUserClass(existingBean));
    		bd.setScope(SCOPE_PROTOTYPE);
    		bd.allowCaching = ClassUtils.isCacheSafe(bd.getBeanClass(), getBeanClassLoader());
    		BeanWrapper bw = new BeanWrapperImpl(existingBean);
    		initBeanWrapper(bw);
    		populateBean(bd.getBeanClass().getName(), bd, bw);
    	}

*      configureBean(Object existingBean, String beanName)

`configureBean`方法的功能是对已存在的Bean对象进行配置，包括标记为已创建状态、获取合并的Bean定义、设置作用域和缓存属性、进行属性注入和初始化等操作，以确保现有Bean对象的正确配置和初始化。

@Override
    	public Object configureBean(Object existingBean, String beanName) throws BeansException {
    		markBeanAsCreated(beanName);
    		BeanDefinition mbd = getMergedBeanDefinition(beanName);
    		RootBeanDefinition bd = null;
    		if (mbd instanceof RootBeanDefinition) {
    			RootBeanDefinition rbd = (RootBeanDefinition) mbd;
    			bd = (rbd.isPrototype() ? rbd : rbd.cloneBeanDefinition());
    		}
    		if (bd == null) {
    			bd = new RootBeanDefinition(mbd);
    		}
    		if (!bd.isPrototype()) {
    			bd.setScope(SCOPE_PROTOTYPE);
    			bd.allowCaching = ClassUtils.isCacheSafe(ClassUtils.getUserClass(existingBean), getBeanClassLoader());
    		}
    		BeanWrapper bw = new BeanWrapperImpl(existingBean);
    		initBeanWrapper(bw);
    		populateBean(beanName, bd, bw);
    		return initializeBean(beanName, existingBean, bd);
    	}

*      autowire(Class<?> beanClass, int autowireMode, boolean dependencyCheck)

`autowire`方法用于自动装配指定类型的Bean对象，根据自动装配模式和依赖检查的设置，创建一个非单例、原型作用域的Bean定义，并通过适当的方式实例化Bean对象。然后，对该Bean对象进行属性的自动注入。最终返回创建的Bean对象或通过构造器注入后的实例对象。注意，该方法使用的是原型作用域的Bean定义，以避免将该Bean注册为其他Bean的依赖关系。

@Override
    	public Object autowire(Class<?> beanClass, int autowireMode, boolean dependencyCheck) throws BeansException {
    		// Use non-singleton bean definition, to avoid registering bean as dependent bean.
    		RootBeanDefinition bd = new RootBeanDefinition(beanClass, autowireMode, dependencyCheck);
    		bd.setScope(SCOPE_PROTOTYPE);
    		if (bd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR) {
    			return autowireConstructor(beanClass.getName(), bd, null, null).getWrappedInstance();
    		}
    		else {
    			Object bean;
    			if (System.getSecurityManager() != null) {
    				bean = AccessController.doPrivileged(
    						(PrivilegedAction<Object>) () -> getInstantiationStrategy().instantiate(bd, null, this),
    						getAccessControlContext());
    			}
    			else {
    				bean = getInstantiationStrategy().instantiate(bd, null, this);
    			}
    			populateBean(beanClass.getName(), bd, new BeanWrapperImpl(bean));
    			return bean;
    		}
    	}

*  applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)

这个方法的功能是在Bean对象初始化之前，依次应用注册的Bean后置处理器对Bean对象进行处理，并返回处理后的最终结果。可以在这里添加一些自定义的逻辑来对Bean对象进行进一步的处理。

@Override
    	public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
    			throws BeansException {
    
    		Object result = existingBean;
    		for (BeanPostProcessor processor : getBeanPostProcessors()) {
    			Object current = processor.postProcessBeforeInitialization(result, beanName);
    			if (current == null) {
    				return result;
    			}
    			result = current;
    		}
    		return result;
    	}

*  createBean(String beanName, RootBeanDefinition mbd, @Nullable Object\[\] args)

核心方法。该方法负责创建Bean实例、填充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;
    
    		// 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.
    		Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
    		if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
    			mbdToUse = new RootBeanDefinition(mbd);
    			mbdToUse.setBeanClass(resolvedClass);
    		}
    
    		// Prepare method overrides.
    		try {
    			mbdToUse.prepareMethodOverrides();
    		}
    		catch (BeanDefinitionValidationException ex) {
    			throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
    					beanName, "Validation of method overrides failed", ex);
    		}
    
    		try {
    			// 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 {
    			Object beanInstance = doCreateBean(beanName, mbdToUse, args);
    			if (logger.isTraceEnabled()) {
    				logger.trace("Finished creating instance of bean '" + beanName + "'");
    			}
    			return beanInstance;
    		}
    		catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
    			// A previously detected exception with proper bean creation context already,
    			// or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.
    			throw ex;
    		}
    		catch (Throwable ex) {
    			throw new BeanCreationException(
    					mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
    		}
    	}

*      doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)

这个核心方法的功能是实际上创建Bean实例，并在创建过程中进行属性填充、初始化和后置处理等操作。它还负责处理循环引用和Bean的销毁等相关逻辑。

1.  首先，根据Bean定义的作用域确定是否从工厂缓存中获取Bean实例的包装器（`instanceWrapper`）对象。如果Bean是单例作用域且缓存中存在，则从缓存中移除并将其赋值给 `instanceWrapper`，否则调用 `createBeanInstance`方法创建新的实例包装器。
2.  然后，通过实例包装器获取Bean实例和Bean类型，并将Bean类型设置到Bean定义中。这一步主要是为了记录解析后的目标类型。
3.  接下来，使用 `synchronized`关键字对 `mbd.postProcessingLock`进行加锁，确保在后续的处理中只有一个线程能够执行。在加锁的情况下，将会应用所有注册的Bean定义后置处理器，并在处理完成后将 `mbd.postProcessed`标志设置为 `true`，以避免重复处理。
4.  如果Bean是单例作用域且允许循环引用，并且当前正在创建的Bean是一个单例Bean，则会将该Bean提前暴露给其他Bean，以解决潜在的循环引用问题。如果启用了跟踪日志，则会记录相应的日志信息。
5.  接着，调用 `populateBean`方法填充Bean的属性值，这包括属性注入和依赖处理等操作。
6.  然后，调用 `initializeBean`方法对Bean进行初始化。这一步会应用所有注册的Bean后置处理器，并执行初始化回调方法（例如 `InitializingBean`接口的 `afterPropertiesSet`方法）。
7.  如果之前提前暴露了单例Bean，并且在初始化过程中创建了其他Bean的原始引用，并且配置禁止原始注入嵌套包装，则会抛出 `BeanCurrentlyInCreationException`异常，以防止原始引用的使用。
8.  接下来，根据需要将Bean注册为可销毁的Bean对象，以确保在容器关闭时能够正确地销毁Bean实例。
9.  最后，返回经过初始化处理后的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.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.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 && 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;
    	}

*  getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean)

这个方法的功能是在bean实例化过程中提前获取对特定bean的引用。通常用于解决循环依赖的问题。通过提前获取一个依赖bean的引用，可以将该引用注入到依赖它的其他bean中。

这个方法的主要作用是通过执行已注册的SmartInstantiationAwareBeanPostProcessor实现类的getEarlyBeanReference方法来处理实例化前的逻辑。

protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
    		Object exposedObject = bean;
    		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
    			for (SmartInstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().smartInstantiationAware) {
    				exposedObject = bp.getEarlyBeanReference(exposedObject, beanName);
    			}
    		}
    		return exposedObject;
    	}

*      getSingletonFactoryBeanForTypeCheck(String beanName, RootBeanDefinition mbd)

这个方法用于获取用于类型检查的单例FactoryBean实例。

首先，它在同步块中检查了factoryBeanInstanceCache（FactoryBean实例缓存）是否存在指定beanName对应的BeanWrapper（Bean包装器），如果存在，则获取并返回其中的FactoryBean实例。

如果factoryBeanInstanceCache中不存在指定beanName对应的BeanWrapper，则通过getSingleton方法获取该bean的实例。如果该实例是FactoryBean的实现类，则将其强制转换为FactoryBean实例并返回；否则，继续进行后续处理。

接下来，它检查了当前是否正在创建指定beanName或其工厂bean的实例，如果是，则直接返回null。

然后，它开始创建bean的实例。在创建之前，它调用了beforeSingletonCreation方法将该bean标记为正在创建中。然后，它尝试调用resolveBeforeInstantiation方法解析实例化前的逻辑，如果返回的实例为空，则调用createBeanInstance方法创建bean的实例。

在创建bean实例过程中，如果出现了UnsatisfiedDependencyException或BeanCreationException等异常，则会抛出这些异常，不会被捕获，以保证正常的异常处理。

最后，它通过getFactoryBean方法获取FactoryBean实例，并将其返回。如果在之前已经获取到了BeanWrapper，则将BeanWrapper存储到factoryBeanInstanceCache中。

@Nullable
    	private FactoryBean<?> getSingletonFactoryBeanForTypeCheck(String beanName, RootBeanDefinition mbd) {
    		synchronized (getSingletonMutex()) {
    			BeanWrapper bw = this.factoryBeanInstanceCache.get(beanName);
    			if (bw != null) {
    				return (FactoryBean<?>) bw.getWrappedInstance();
    			}
    			Object beanInstance = getSingleton(beanName, false);
    			if (beanInstance instanceof FactoryBean) {
    				return (FactoryBean<?>) beanInstance;
    			}
    			if (isSingletonCurrentlyInCreation(beanName) ||
    					(mbd.getFactoryBeanName() != null && isSingletonCurrentlyInCreation(mbd.getFactoryBeanName()))) {
    				return null;
    			}
    
    			Object instance;
    			try {
    				// Mark this bean as currently in creation, even if just partially.
    				beforeSingletonCreation(beanName);
    				// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
    				instance = resolveBeforeInstantiation(beanName, mbd);
    				if (instance == null) {
    					bw = createBeanInstance(beanName, mbd, null);
    					instance = bw.getWrappedInstance();
    				}
    			}
    			catch (UnsatisfiedDependencyException ex) {
    				// Don't swallow, probably misconfiguration...
    				throw ex;
    			}
    			catch (BeanCreationException ex) {
    				// Don't swallow a linkage error since it contains a full stacktrace on
    				// first occurrence... and just a plain NoClassDefFoundError afterwards.
    				if (ex.contains(LinkageError.class)) {
    					throw ex;
    				}
    				// Instantiation failure, maybe too early...
    				if (logger.isDebugEnabled()) {
    					logger.debug("Bean creation exception on singleton FactoryBean type check: " + ex);
    				}
    				onSuppressedException(ex);
    				return null;
    			}
    			finally {
    				// Finished partial creation of this bean.
    				afterSingletonCreation(beanName);
    			}
    
    			FactoryBean<?> fb = getFactoryBean(beanName, instance);
    			if (bw != null) {
    				this.factoryBeanInstanceCache.put(beanName, bw);
    			}
    			return fb;
    		}
    	}

*  resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd)

该方法接受bean的名称（beanName）和Bean定义（mbd）作为参数。

首先，它初始化了一个名为"bean"的null对象。然后，它检查mbd中的beforeInstantiationResolved属性是否为false或null。

如果beforeInstantiationResolved不等于false，则继续执行下面的逻辑。它首先确保此时Bean的类已经解析成功（非合成的，并且存在实例化Aware类型的BeanPostProcessor）。

随后，它调用determineTargetType方法确定Bean的目标类型。如果确定了目标类型，则调用applyBeanPostProcessorsBeforeInstantiation方法，在实例化之前应用BeanPostProcessor的前置处理器，并将目标类型和Bean名称作为参数传递进去。

如果通过前置处理器成功获取到了bean实例，则调用applyBeanPostProcessorsAfterInitialization方法，在初始化之后再次应用BeanPostProcessor的处理器，并将bean实例和bean名称作为参数传递进去。

最后，通过设置mbd的beforeInstantiationResolved属性，表示是否已解析出"实例化前快捷方式"。

最终，返回解析出的bean实例。

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

*  createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object\[\] args)

该方法接受bean的名称（beanName）、bean定义（mbd）和用于构造函数或工厂方法调用的显式参数（args）作为参数。

在方法内部，首先通过resolveBeanClass方法解析出bean的类。如果bean类不为null且不是public修饰的，并且bean定义中不允许使用非公开访问，则会抛出BeanCreationException异常。

接下来，它检查bean定义中是否指定了instanceSupplier，如果有，则通过obtainFromSupplier方法从supplier获取bean实例。

然后，它检查bean定义中是否指定了factoryMethodName，如果有，则调用instantiateUsingFactoryMethod方法使用工厂方法来实例化bean。

如果没有工厂方法，则进入下面的逻辑。根据提供的参数args是否为null，如果为null，则使用synchronized块来确保线程安全地获得已解析的构造函数或工厂方法。

如果已解析，则根据是否需要自动装配来返回相应的实例。如果需要自动装配，则调用autowireConstructor方法进行自动装配，否则调用instantiateBean方法来创建实例。

如果没有解析构造函数，则继续执行下面的逻辑。它尝试从BeanPostProcessor中确定自动装配的候选构造函数。如果存在候选构造函数，或者bean定义中指定了AUTOWIRE\_CONSTRUCTOR自动装配模式，或者bean定义中已经设置了构造函数参数值，或者提供了显式的args参数，则调用autowireConstructor方法进行自动装配。

如果没有候选构造函数，则继续执行下面的逻辑。它尝试从bean定义中获取优选的构造函数，并调用autowireConstructor方法进行自动装配。

最后，如果没有进行特殊处理，则使用无参构造函数来实例化bean并返回。

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
    		// Make sure bean class is actually resolved at this point.
    		Class<?> beanClass = resolveBeanClass(mbd, beanName);
    
    		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());
    		}
    
    		Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
    		if (instanceSupplier != null) {
    			return obtainFromSupplier(instanceSupplier, beanName);
    		}
    
    		if (mbd.getFactoryMethodName() != null) {
    			return instantiateUsingFactoryMethod(beanName, mbd, args);
    		}
    
    		// Shortcut when re-creating the same bean...
    		boolean resolved = false;
    		boolean autowireNecessary = false;
    		if (args == null) {
    			synchronized (mbd.constructorArgumentLock) {
    				if (mbd.resolvedConstructorOrFactoryMethod != null) {
    					resolved = true;
    					autowireNecessary = mbd.constructorArgumentsResolved;
    				}
    			}
    		}
    		if (resolved) {
    			if (autowireNecessary) {
    				return autowireConstructor(beanName, mbd, null, null);
    			}
    			else {
    				return instantiateBean(beanName, mbd);
    			}
    		}
    
    		// Candidate constructors for autowiring?
    		Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
    		if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
    				mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
    			return autowireConstructor(beanName, mbd, ctors, args);
    		}
    
    		// Preferred constructors for default construction?
    		ctors = mbd.getPreferredConstructors();
    		if (ctors != null) {
    			return autowireConstructor(beanName, mbd, ctors, null);
    		}
    
    		// No special handling: simply use no-arg constructor.
    		return instantiateBean(beanName, mbd);
    	}

*  instantiateBean(String beanName, RootBeanDefinition mbd)

该方法接受bean的名称（beanName）和bean定义（mbd）作为参数。

在方法内部，首先声明一个名为"beanInstance"的变量。

然后，它检查当前是否存在安全管理器（System.getSecurityManager() != null）。如果存在安全管理器，则使用AccessController.doPrivileged方法来执行获取实例化策略的实例化操作。这是为了确保在有安全管理器的情况下，可以以特权方式执行实例化操作。

接着，通过调用getInstantiationStrategy().instantiate(mbd, beanName, this)方法来实例化bean。getInstantiationStrategy()方法是从容器中获取相应的实例化策略对象。

接下来，使用实例化的bean创建一个BeanWrapper，并初始化BeanWrapper的相关属性。

最后，返回创建的BeanWrapper。

/**
    	 * Instantiate the given bean using its default constructor.
    	 * @param beanName the name of the bean
    	 * @param mbd the bean definition for the bean
    	 * @return a BeanWrapper for the new instance
    	 */
    	protected BeanWrapper instantiateBean(String beanName, RootBeanDefinition mbd) {
    		try {
    			Object beanInstance;
    			if (System.getSecurityManager() != null) {
    				beanInstance = AccessController.doPrivileged(
    						(PrivilegedAction<Object>) () -> getInstantiationStrategy().instantiate(mbd, beanName, this),
    						getAccessControlContext());
    			}
    			else {
    				beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, this);
    			}
    			BeanWrapper bw = new BeanWrapperImpl(beanInstance);
    			initBeanWrapper(bw);
    			return bw;
    		}
    		catch (Throwable ex) {
    			throw new BeanCreationException(
    					mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
    		}
    	}

*  populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw)

这个方法是Spring框架中的一个核心方法，其主要功能是根据给定的bean定义，将属性值填充到BeanWrapper的bean实例中。

具体而言，它执行以下操作：

1.  首先，检查传入的BeanWrapper是否为null。如果为null，并且bean定义中有属性值需要设置，将抛出异常。否则，直接跳过对null实例的属性填充阶段。
2.  如果BeanWrapper不为null，将进行属性填充的逻辑。
3.  如果bean定义不是合成的（非代理对象），并且存在InstantiationAwareBeanPostProcessor的后处理器，在设置属性之前，会调用这些后处理器的postProcessAfterInstantiation()方法，给它们在属性设置之前修改bean状态的机会。
4.  获取bean定义中的属性值（PropertyValues）。如果bean定义没有属性值，那么会得到一个null。
5.  检查bean定义中是否已解析了自动装配模式。如果是按名称自动装配，将创建一个新的MutablePropertyValues对象，根据bean的名称进行属性自动装配；如果是按类型自动装配，也会创建一个新的MutablePropertyValues对象，根据bean的类型进行属性自动装配。最终得到更新后的PropertyValues。
6.  检查是否存在InstantiationAwareBeanPostProcessor的后处理器，然后依次调用它们的postProcessProperties()和postProcessPropertyValues()方法，对PropertyValues进行后处理。通过这些后处理器，可以对属性值进行修改或添加新的属性值。
7.  根据bean定义中的依赖检查模式，检查bean的属性和依赖是否匹配。如果需要进行依赖检查，会执行检查逻辑，确保所有依赖的属性都已设置。
8.  最后，将得到的PropertyValues应用于BeanWrapper的bean实例，完成属性的填充。

/**
    	 * Populate the bean instance in the given BeanWrapper with the property values
    	 * from the bean definition.
    	 * @param beanName the name of the bean
    	 * @param mbd the bean definition for the bean
    	 * @param bw the BeanWrapper with bean instance
    	 */
    	@SuppressWarnings("deprecation")  // for postProcessPropertyValues
    	protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
    		if (bw == 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.
    		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
    			for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
    				if (!bp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
    					return;
    				}
    			}
    		}
    
    		PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
    
    		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 (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);
    		}
    
    		if (pvs != null) {
    			applyPropertyValues(beanName, mbd, bw, pvs);
    		}
    	}

*  autowireByName(
    
        String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs)

这个方法的功能是根据bean定义中的属性依赖，查找容器中对应名称的其他bean，并将它们填充到目标bean的属性中。具体而言，它执行以下操作：

1.  首先，获取未满足依赖且非简单属性的名称列表。这些属性是需要进行自动装配的属性。
2.  遍历属性名称列表，对于每个属性名称，判断容器中是否存在对应名称的其他bean。
3.  如果存在对应名称的其他bean，则获取该bean，并将其添加到目标bean的PropertyValues中，完成属性的自动装配。
4.  同时，将当前属性作为依赖关系注册到容器中，以表明它依赖于其他bean。
5.  如果日志级别为跟踪（Trace），则打印相关的跟踪日志，记录完成了按名称自动装配的操作。

/**
    	 * Fill in any missing property values with references to
    	 * other beans in this factory if autowire is set to "byName".
    	 * @param beanName the name of the bean we're wiring up.
    	 * Useful for debugging messages; not used functionally.
    	 * @param mbd bean definition to update through autowiring
    	 * @param bw the BeanWrapper from which we can obtain information about the bean
    	 * @param pvs the PropertyValues to register wired objects with
    	 */
    	protected void autowireByName(
    			String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
    
    		String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
    		for (String propertyName : propertyNames) {
    			if (containsBean(propertyName)) {
    				Object bean = getBean(propertyName);
    				pvs.add(propertyName, bean);
    				registerDependentBean(propertyName, beanName);
    				if (logger.isTraceEnabled()) {
    					logger.trace("Added autowiring by name from bean name '" + beanName +
    							"' via property '" + propertyName + "' to bean named '" + propertyName + "'");
    				}
    			}
    			else {
    				if (logger.isTraceEnabled()) {
    					logger.trace("Not autowiring property '" + propertyName + "' of bean '" + beanName +
    							"' by name: no matching bean found");
    				}
    			}
    		}
    	}

*  autowireByType(
    
        String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs)

这个方法的功能是根据bean定义中的属性依赖，通过类型匹配的方式，查找容器中与属性类型匹配的其他bean，并将它们填充到目标bean的属性中。具体而言，它执行以下操作：

1.  首先，获取未满足依赖且非简单属性的名称列表。这些属性是需要进行自动装配的属性。
2.  遍历属性名称列表，对于每个属性名称，获取BeanWrapper中关联属性的PropertyDescriptor。
3.  判断属性类型是否为Object类。如果不是Object类，则创建一个描述依赖的DependencyDescriptor，并指定是否立即初始化相关bean。
4.  调用resolveDependency()方法，解决依赖并获取依赖的实例。该方法会根据属性的类型，匹配容器中对应的bean，并返回实例。
5.  如果获取到了依赖的实例，将其添加到目标bean的PropertyValues中，完成属性的自动装配。
6.  同时，将被自动装配的依赖的bean名称注册为当前bean的依赖关系。
7.  如果日志级别为跟踪（Trace），则打印相关的跟踪日志，记录完成了按类型自动装配的操作。

/**
    	 * Abstract method defining "autowire by type" (bean properties by type) behavior.
    	 * <p>This is like PicoContainer default, in which there must be exactly one bean
    	 * of the property type in the bean factory. This makes bean factories simple to
    	 * configure for small namespaces, but doesn't work as well as standard Spring
    	 * behavior for bigger applications.
    	 * @param beanName the name of the bean to autowire by type
    	 * @param mbd the merged bean definition to update through autowiring
    	 * @param bw the BeanWrapper from which we can obtain information about the bean
    	 * @param pvs the PropertyValues to register wired objects with
    	 */
    	protected void autowireByType(
    			String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
    
    		TypeConverter converter = getCustomTypeConverter();
    		if (converter == null) {
    			converter = bw;
    		}
    
    		Set<String> autowiredBeanNames = new LinkedHashSet<>(4);
    		String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
    		for (String propertyName : propertyNames) {
    			try {
    				PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);
    				// Don't try autowiring by type for type Object: never makes sense,
    				// even if it technically is a unsatisfied, non-simple property.
    				if (Object.class != pd.getPropertyType()) {
    					MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);
    					// Do not allow eager init for type matching in case of a prioritized post-processor.
    					boolean eager = !(bw.getWrappedInstance() instanceof PriorityOrdered);
    					DependencyDescriptor desc = new AutowireByTypeDependencyDescriptor(methodParam, eager);
    					Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter);
    					if (autowiredArgument != null) {
    						pvs.add(propertyName, autowiredArgument);
    					}
    					for (String autowiredBeanName : autowiredBeanNames) {
    						registerDependentBean(autowiredBeanName, beanName);
    						if (logger.isTraceEnabled()) {
    							logger.trace("Autowiring by type from bean name '" + beanName + "' via property '" +
    									propertyName + "' to bean named '" + autowiredBeanName + "'");
    						}
    					}
    					autowiredBeanNames.clear();
    				}
    			}
    			catch (BeansException ex) {
    				throw new UnsatisfiedDependencyException(mbd.getResourceDescription(), beanName, propertyName, ex);
    			}
    		}
    	}

*  applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs)

这个方法的目的是在创建bean并将属性值应用于目标对象时，解析并应用属性值中对其他bean的引用。

该方法在Spring框架中的功能如下：

1.  首先，检查传入的属性值是否为空，如果为空，则直接返回。
2.  如果存在安全管理器，并且BeanWrapper是BeanWrapperImpl类型的，则设置安全上下文。
3.  检查属性值是否是MutablePropertyValues类型的实例。如果是，则转换为MutablePropertyValues，并检查是否已经转换过。
4.  如果存在自定义的TypeConverter，则使用自定义的TypeConverter；否则，使用BeanWrapper作为TypeConverter。
5.  创建一个BeanDefinitionValueResolver对象，用于解析属性值中对其他bean的引用。
6.  创建一个深拷贝的属性值列表，用于存储解析后的属性值。
7.  遍历原始的属性值列表，并对每个属性值进行处理：
    
     *  如果属性值已经转换过，则直接添加到深拷贝列表中。
     *  如果属性值是AutowiredPropertyMarker的实例，表示要进行自动装配，将其替换为对应属性的DependencyDescriptor对象。
     *  否则，使用BeanDefinitionValueResolver解析属性值中的引用，并进行相应的转换。如果属性可读写且不是嵌套或索引属性，则进行转换。
     *  如果转换后的值与原始值相同，则将转换后的值存储在属性值中，并将其添加到深拷贝列表中。
     *  否则，将解析后的属性值添加到深拷贝列表中，并标记需要进一步解析。
8.  如果原始的属性值是MutablePropertyValues类型的实例，并且不需要进一步解析，则将其标记为已转换。
9.  最后，使用深拷贝的属性值列表设置BeanWrapper的属性值。

/**
    	 * Apply the given property values, resolving any runtime references
    	 * to other beans in this bean factory. Must use deep copy, so we
    	 * don't permanently modify this property.
    	 * @param beanName the bean name passed for better exception information
    	 * @param mbd the merged bean definition
    	 * @param bw the BeanWrapper wrapping the target object
    	 * @param pvs the new property values
    	 */
    	protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
    		if (pvs.isEmpty()) {
    			return;
    		}
    
    		if (System.getSecurityManager() != null && bw instanceof BeanWrapperImpl) {
    			((BeanWrapperImpl) bw).setSecurityContext(getAccessControlContext());
    		}
    
    		MutablePropertyValues mpvs = null;
    		List<PropertyValue> original;
    
    		if (pvs instanceof MutablePropertyValues) {
    			mpvs = (MutablePropertyValues) pvs;
    			if (mpvs.isConverted()) {
    				// Shortcut: use the pre-converted values as-is.
    				try {
    					bw.setPropertyValues(mpvs);
    					return;
    				}
    				catch (BeansException ex) {
    					throw new BeanCreationException(
    							mbd.getResourceDescription(), beanName, "Error setting property values", ex);
    				}
    			}
    			original = mpvs.getPropertyValueList();
    		}
    		else {
    			original = Arrays.asList(pvs.getPropertyValues());
    		}
    
    		TypeConverter converter = getCustomTypeConverter();
    		if (converter == null) {
    			converter = bw;
    		}
    		BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);
    
    		// Create a deep copy, resolving any references for values.
    		List<PropertyValue> deepCopy = new ArrayList<>(original.size());
    		boolean resolveNecessary = false;
    		for (PropertyValue pv : original) {
    			if (pv.isConverted()) {
    				deepCopy.add(pv);
    			}
    			else {
    				String propertyName = pv.getName();
    				Object originalValue = pv.getValue();
    				if (originalValue == AutowiredPropertyMarker.INSTANCE) {
    					Method writeMethod = bw.getPropertyDescriptor(propertyName).getWriteMethod();
    					if (writeMethod == null) {
    						throw new IllegalArgumentException("Autowire marker for property without write method: " + pv);
    					}
    					originalValue = new DependencyDescriptor(new MethodParameter(writeMethod, 0), true);
    				}
    				Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);
    				Object convertedValue = resolvedValue;
    				boolean convertible = bw.isWritableProperty(propertyName) &&
    						!PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);
    				if (convertible) {
    					convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);
    				}
    				// Possibly store converted value in merged bean definition,
    				// in order to avoid re-conversion for every created bean instance.
    				if (resolvedValue == originalValue) {
    					if (convertible) {
    						pv.setConvertedValue(convertedValue);
    					}
    					deepCopy.add(pv);
    				}
    				else if (convertible && originalValue instanceof TypedStringValue &&
    						!((TypedStringValue) originalValue).isDynamic() &&
    						!(convertedValue instanceof Collection || ObjectUtils.isArray(convertedValue))) {
    					pv.setConvertedValue(convertedValue);
    					deepCopy.add(pv);
    				}
    				else {
    					resolveNecessary = true;
    					deepCopy.add(new PropertyValue(pv, convertedValue));
    				}
    			}
    		}
    		if (mpvs != null && !resolveNecessary) {
    			mpvs.setConverted();
    		}
    
    		// Set our (possibly massaged) deep copy.
    		try {
    			bw.setPropertyValues(new MutablePropertyValues(deepCopy));
    		}
    		catch (BeansException ex) {
    			throw new BeanCreationException(
    					mbd.getResourceDescription(), beanName, "Error setting property values", ex);
    		}
    	}

*      initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd)

这个方法的目的是初始化给定的bean实例，包括应用工厂回调函数、初始化方法和bean后置处理器。

该方法在Spring框架中的功能如下：

1.  首先，检查是否存在安全管理器。如果存在，则使用特权访问方式调用invokeAwareMethods方法，应用感知接口回调方法（比如BeanNameAware、BeanClassLoaderAware、BeanFactoryAware）。否则，直接调用invokeAwareMethods方法。
2.  调用applyBeanPostProcessorsBeforeInitialization方法，对bean进行初始化之前的处理。该方法会依次调用注册的所有BeanPostProcessor的postProcessBeforeInitialization方法，并返回处理后的bean实例。
3.  调用invokeInitMethods方法，执行bean的初始化方法。该方法会根据给定的bean名称、bean实例以及对应的RootBeanDefinition，调用bean的初始化方法。如果初始化方法抛出异常，则将其封装为BeanCreationException并抛出。
4.  如果存在RootBeanDefinition，并且不是合成定义的bean，则调用applyBeanPostProcessorsAfterInitialization方法，对bean进行初始化之后的处理。该方法会依次调用注册的所有BeanPostProcessor的postProcessAfterInitialization方法，并返回处理后的bean实例。
5.  返回经过初始化处理后的bean实例。

/**
    	 * Initialize the given bean instance, applying factory callbacks
    	 * as well as init methods and bean post processors.
    	 * <p>Called from {@link #createBean} for traditionally defined beans,
    	 * and from {@link #initializeBean} for existing bean instances.
    	 * @param beanName the bean name in the factory (for debugging purposes)
    	 * @param bean the new bean instance we may need to initialize
    	 * @param mbd the bean definition that the bean was created with
    	 * (can also be {@code null}, if given an existing bean instance)
    	 * @return the initialized bean instance (potentially wrapped)
    	 * @see BeanNameAware
    	 * @see BeanClassLoaderAware
    	 * @see BeanFactoryAware
    	 * @see #applyBeanPostProcessorsBeforeInitialization
    	 * @see #invokeInitMethods
    	 * @see #applyBeanPostProcessorsAfterInitialization
    	 */
    	protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
    		if (System.getSecurityManager() != null) {
    			AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
    				invokeAwareMethods(beanName, bean);
    				return null;
    			}, getAccessControlContext());
    		}
    		else {
    			invokeAwareMethods(beanName, bean);
    		}
    
    		Object wrappedBean = bean;
    		if (mbd == null || !mbd.isSynthetic()) {
    			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()) {
    			wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
    		}
    
    		return wrappedBean;
    	}

*  invokeAwareMethods(String beanName, Object bean)

这个方法的功能是在bean初始化过程中，检查并调用可能存在的Aware接口回调方法。通过这些回调方法，bean可以感知并获取与容器相关的信息，比如自己的名称、类加载器和所属的BeanFactory。这样设计的目的是为了给bean提供更多的自定义和扩展能力，在初始化阶段可以灵活地与容器进行交互。

该方法在Spring框架中的功能如下：

1.  首先，判断bean是否实现了Aware接口。Aware接口是一组特殊的接口，用于提供对容器或其他资源的感知能力。
2.  如果bean实现了BeanNameAware接口，表示它需要被通知自己在容器中的名字。在这种情况下，将bean的名称作为参数，调用setBeanName方法，将bean的名称传递给它。
3.  如果bean实现了BeanClassLoaderAware接口，表示它需要被通知所使用的类加载器。在这种情况下，获取当前容器的类加载器，并调用setBeanClassLoader方法，将类加载器传递给它。
4.  如果bean实现了BeanFactoryAware接口，表示它需要被通知所属的BeanFactory（即AbstractAutowireCapableBeanFactory）。在这种情况下，调用setBeanFactory方法，将当前的BeanFactory实例传递给它。

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

*  invokeInitMethods(String beanName, Object bean, @Nullable RootBeanDefinition mbd)

这个方法的功能是在bean初始化过程中，检查并调用可能存在的初始化回调方法。首先检查bean是否实现了InitializingBean接口，并执行其中的初始化逻辑。然后检查是否有自定义的初始化方法，并执行该方法。通过这些回调方法，bean可以在初始化时执行特定的操作，以确保它们处于正确的状态。这样设计的目的是为了扩展bean的初始化能力，并提供一种统一的初始化机制。

该方法在Spring框架中的功能如下：

1.  首先，判断bean是否实现了InitializingBean接口，该接口定义了一个方法afterPropertiesSet()，用于在属性设置完成后执行任意的初始化逻辑。如果bean实现了InitializingBean接口，并且没有自定义的外部管理的初始化方法（即在bean定义中指定了其他init方法），则调用afterPropertiesSet()方法来执行初始化逻辑。
2.  如果bean定义中指定了自定义的初始化方法，并且不是因为继承InitializingBean而导致的默认的afterPropertiesSet()方法，则调用invokeCustomInitMethod方法来执行自定义的初始化方法。

/**
    	 * Give a bean a chance to react now all its properties are set,
    	 * and a chance to know about its owning bean factory (this object).
    	 * This means checking whether the bean implements InitializingBean or defines
    	 * a custom init method, and invoking the necessary callback(s) if it does.
    	 * @param beanName the bean name in the factory (for debugging purposes)
    	 * @param bean the new bean instance we may need to initialize
    	 * @param mbd the merged bean definition that the bean was created with
    	 * (can also be {@code null}, if given an existing bean instance)
    	 * @throws Throwable if thrown by init methods or by the invocation process
    	 * @see #invokeCustomInitMethod
    	 */
    	protected void invokeInitMethods(String beanName, Object bean, @Nullable RootBeanDefinition mbd)
    			throws Throwable {
    
    		boolean isInitializingBean = (bean instanceof InitializingBean);
    		if (isInitializingBean && (mbd == null || !mbd.hasAnyExternallyManagedInitMethod("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();
    			if (StringUtils.hasLength(initMethodName) &&
    					!(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
    					!mbd.hasAnyExternallyManagedInitMethod(initMethodName)) {
    				invokeCustomInitMethod(beanName, bean, mbd);
    			}
    		}
    	}

*      invokeCustomInitMethod(String beanName, Object bean, RootBeanDefinition mbd)

这个方法的功能是在给定的bean上调用指定的自定义初始化方法。它通过反射查找并调用初始化方法，以确保bean在初始化过程中执行特定的自定义逻辑。

该方法在Spring框架中的功能如下：

1.  首先，获取bean定义中指定的初始化方法的名称。
2.  如果找不到指定名称的初始化方法，则根据是否强制要求存在初始化方法进行相应的处理。如果强制要求存在初始化方法，则抛出BeanDefinitionValidationException异常；否则，忽略不存在的初始化方法，并返回。
3.  如果找到了指定名称的初始化方法，则根据非公共访问被允许的标志以及bean的类型，通过反射查找方法对象。
4.  如果找到了方法对象，则执行相应的初始化方法。
5.  在执行方法前，通过ReflectionUtils.makeAccessible方法设置方法的可访问性，并调用methodToInvoke.invoke(bean)来执行初始化方法。

/**
    	 * Invoke the specified custom init method on the given bean.
    	 * Called by invokeInitMethods.
    	 * <p>Can be overridden in subclasses for custom resolution of init
    	 * methods with arguments.
    	 * @see #invokeInitMethods
    	 */
    	protected void invokeCustomInitMethod(String beanName, Object bean, RootBeanDefinition mbd)
    			throws Throwable {
    
    		String initMethodName = mbd.getInitMethodName();
    		Assert.state(initMethodName != null, "No init method set");
    		Method initMethod = (mbd.isNonPublicAccessAllowed() ?
    				BeanUtils.findMethod(bean.getClass(), initMethodName) :
    				ClassUtils.getMethodIfAvailable(bean.getClass(), initMethodName));
    
    		if (initMethod == null) {
    			if (mbd.isEnforceInitMethod()) {
    				throw new BeanDefinitionValidationException("Could not find an init method named '" +
    						initMethodName + "' on bean with name '" + beanName + "'");
    			}
    			else {
    				if (logger.isTraceEnabled()) {
    					logger.trace("No default init method named '" + initMethodName +
    							"' found on bean with name '" + beanName + "'");
    				}
    				// Ignore non-existent default lifecycle methods.
    				return;
    			}
    		}
    
    		if (logger.isTraceEnabled()) {
    			logger.trace("Invoking init method  '" + initMethodName + "' on bean with name '" + beanName + "'");
    		}
    		Method methodToInvoke = ClassUtils.getInterfaceMethodIfPossible(initMethod, bean.getClass());
    
    		if (System.getSecurityManager() != null) {
    			AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
    				ReflectionUtils.makeAccessible(methodToInvoke);
    				return null;
    			});
    			try {
    				AccessController.doPrivileged((PrivilegedExceptionAction<Object>)
    						() -> methodToInvoke.invoke(bean), getAccessControlContext());
    			}
    			catch (PrivilegedActionException pae) {
    				InvocationTargetException ex = (InvocationTargetException) pae.getException();
    				throw ex.getTargetException();
    			}
    		}
    		else {
    			try {
    				ReflectionUtils.makeAccessible(methodToInvoke);
    				methodToInvoke.invoke(bean);
    			}
    			catch (InvocationTargetException ex) {
    				throw ex.getTargetException();
    			}
    		}
    	}

*      postProcessObjectFromFactoryBean(Object object, String beanName)

这个方法的功能是应用所有注册的BeanPostProcessor的postProcessAfterInitialization回调方法，以实现对从FactoryBean获取的对象进行后处理的能力。通过这些回调方法，可以对bean做进一步的定制化处理，以满足特定的业务需求。

该方法在Spring框架中的功能如下：

1.  首先，获取从FactoryBean获取到的对象和bean的名称。
2.  在容器启动过程中，Spring会扫描并实例化所有的BeanPostProcessor。BeanPostProcessor是一个特殊的接口，它定义了两个回调方法：postProcessBeforeInitialization和postProcessAfterInitialization。通过实现BeanPostProcessor接口，可以在bean初始化前后对其进行自定义的操作。
3.  applyBeanPostProcessorsAfterInitialization方法调用所有注册的BeanPostProcessor的postProcessAfterInitialization回调方法，这样它们就有机会对从FactoryBean获取的对象进行后处理操作。
4.  postProcessAfterInitialization方法允许BeanPostProcessor在bean的所有初始化工作完成之后对bean进行定制化的处理。这个回调方法可以被用来对bean进行增强，例如自动代理、修改属性值等。
5.  最后，返回经过所有BeanPostProcessor后处理后的对象。

/**
    	 * Applies the {@code postProcessAfterInitialization} callback of all
    	 * registered BeanPostProcessors, giving them a chance to post-process the
    	 * object obtained from FactoryBeans (for example, to auto-proxy them).
    	 * @see #applyBeanPostProcessorsAfterInitialization
    	 */
    	@Override
    	protected Object postProcessObjectFromFactoryBean(Object object, String beanName) {
    		return applyBeanPostProcessorsAfterInitialization(object, beanName);
    	}