AbstractAutowireCapableBeanFactory

• 抽象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 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 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 createBean(Class 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