/**
 * 返回指定bean的实例，该实例可能是共享的或独立的。
 * 此方法使Spring BeanFactory可以替代单例或原型设计模式。在单例bean的情况下，调用者可以保留返回对象的引用。
 * 将别名转换回相应的规范bean名称。
 * 如果在这个工厂实例中找不到bean，将询问父工厂。
 * 
 * @param name 要检索的bean的名称
 * @return bean的实例
 * @throws NoSuchBeanDefinitionException 如果没有指定名称的bean
 * @throws BeansException 如果无法获取bean
 */
Object getBean(String name) throws BeansException;

public class GetBeanApplication {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyConfiguration.class);
        System.out.println("myServiceA = " + context.getBean("myServiceA"));
        System.out.println("myServiceB = " + context.getBean("myServiceB"));
    }
}

@Configuration
@ComponentScan("com.xcs.spring.service")
public class MyConfiguration {
    
}

package com.xcs.spring.service;

@Component
public class MyServiceA {

}

@Component
public class MyServiceB {

}

myServiceA = com.xcs.spring.service.MyServiceA@23c30a20
myServiceB = com.xcs.spring.service.MyServiceB@1e1a0406

@Override
public Object getBean(String name) throws BeansException {
    // 调用doGetBean方法来真正的获取bean。
    // 参数说明：
    // 1. name: 要获取的bean的名称。
    // 2. null: bean的所需类型，这里为null表示没有指定具体类型。
    // 3. null: 构造函数或工厂方法的参数，这里为null表示默认构造方法或工厂方法。
    // 4. false: 指定是否仅进行类型检查，false表示需要实例化bean。
    return doGetBean(name, null, null, false);
}

protected <T> T doGetBean(
			String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
			throws BeansException {

    // 步骤1: 转换bean名称
    String beanName = transformedBeanName(name);

    // 步骤2: 尝试从缓存中检索单例bean
    Object sharedInstance = getSingleton(beanName);
    Object beanInstance;

    if (sharedInstance != null && args == null) {
        // 获取bean实例本身
        beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    }
    else {
        // 步骤3: 处理原型作用域的bean，并检查是否已在创建中
        if (isPrototypeCurrentlyInCreation(beanName)) {
            throw new BeanCurrentlyInCreationException(beanName);
        }

        // 步骤4: 尝试在父Bean工厂中检索bean定义
        BeanFactory parentBeanFactory = getParentBeanFactory();

        if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
            String nameToLookup = originalBeanName(name);
            // ... [代码部分省略以简化]
            return (T) parentBeanFactory.getBean(nameToLookup);
        }

        // 步骤5: 标记bean为已创建状态
        if (!typeCheckOnly) {
            markBeanAsCreated(beanName);
        }

        try {
            // 步骤6: 获取合并后的bean定义
            RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
            checkMergedBeanDefinition(mbd, beanName, args);

            // 步骤7: 确保bean的依赖已经初始化
            String[] dependsOn = mbd.getDependsOn();
            if (dependsOn != null) {
                for (String dep : dependsOn) {
                    // 步骤7.1: 是否存在循环依赖
                    if (isDependent(beanName, dep)) {
                       // ... [代码部分省略以简化]
                    }
                    // 步骤7.2: 注册Bean与Bean之间的依赖关系
                    registerDependentBean(dep, beanName);
                    // 步骤7.3: 获取被依赖的Bean对象
                    getBean(dep);
                }
            }

            // 步骤8: 根据bean的作用域，创建或检索bean实例
            if (mbd.isSingleton()) {
                // 步骤8.1: 处理单例作用域
                sharedInstance = getSingleton(beanName, () -> {
                    try {
                        // 步骤8.2: 创建Bean
                        return createBean(beanName, mbd, args);
                    }
                    catch (BeansException ex) {
                        // ... [代码部分省略以简化]
                    }
                });
                // 步骤8.3: 获取bean实例本身
                beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
            }
            else if (mbd.isPrototype()) {
                // 处理原型作用域
                // ... [代码部分省略以简化]
            }
            else {
                // 处理其他作用域
                // ... [代码部分省略以简化]
            }
        }
        catch (BeansException ex) {
            // 处理bean创建失败的情况
            // ... [代码部分省略以简化]
        }
        finally {
            // ... [代码部分省略以简化]
        }
    }

    // 步骤9: 适配bean实例
    return adaptBeanInstance(name, beanInstance, requiredType);
}

protected String transformedBeanName(String name) {
    // 首先，使用BeanFactoryUtils的transformedBeanName方法来处理传入的name。
    // 这通常用于移除bean名称前缀，例如"&"，这在工厂beans中使用。
    // 使用canonicalName方法来获取别名映射后的真实bean名称。
    return canonicalName(BeanFactoryUtils.transformedBeanName(name));
}

public String canonicalName(String name) {
    // 初始化canonicalName为传入的name
    String canonicalName = name; 

    // 循环处理别名映射
    String resolvedName;
    do {
        // 从别名映射中获取真实的bean名称
        resolvedName = this.aliasMap.get(canonicalName);
        
        // 如果找到了一个真实的bean名称（即resolvedName不为null），则更新canonicalName为这个新找到的名称
        if (resolvedName != null) {
            canonicalName = resolvedName;
        }
    } 
    // 如果还可以在aliasMap中找到resolvedName的别名，继续循环
    while (resolvedName != null);

    // 返回最终确定的bean名称
    return canonicalName;
}

@Override
@Nullable
public Object getSingleton(String beanName) {
    // 调用重载的getSingleton方法来获取单例bean。
    // 参数说明：
    // 1. beanName: 要获取的单例bean的名称。
    // 2. true: 表示如果当前bean正在创建中（例如处理循环引用的情况），则允许返回早期的单例bean引用。
    return getSingleton(beanName, true);
}

@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    // 尝试从缓存中快速检索已存在的bean实例，避免完全锁定单例
    Object singletonObject = this.singletonObjects.get(beanName);
    
    // 如果找不到实例，并且该bean当前正在创建中（例如，处理循环引用）
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        singletonObject = this.earlySingletonObjects.get(beanName);
        
        // 如果允许提前引用并且在早期单例对象中仍未找到
        if (singletonObject == null && allowEarlyReference) {
            synchronized (this.singletonObjects) {
                // 在完整的单例锁定范围内，确保早期引用的一致性创建
                singletonObject = this.singletonObjects.get(beanName);
                if (singletonObject == null) {
                    singletonObject = this.earlySingletonObjects.get(beanName);
                    
                    // 如果在早期的单例对象中仍然找不到，并且存在一个单例工厂来创建这个bean
                    if (singletonObject == null) {
                        ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                        if (singletonFactory != null) {
                            // 使用单例工厂创建bean
                            singletonObject = singletonFactory.getObject();
                            // 将新创建的bean存放到早期单例对象缓存中
                            this.earlySingletonObjects.put(beanName, singletonObject);
                            // 从单例工厂缓存中删除对应的工厂
                            this.singletonFactories.remove(beanName);
                        }
                    }
                }
            }
        }
    }
    // 返回找到的单例bean实例，如果没有找到则返回null
    return singletonObject;
}

protected boolean isPrototypeCurrentlyInCreation(String beanName) {
    // 获取当前正在创建的原型bean的值
    Object curVal = this.prototypesCurrentlyInCreation.get();

    // 检查当前值是否不为空，并且
    // 1) 当前值是否等于给定的bean名称，或者
    // 2) 当前值是否是一个Set并且该Set包含给定的bean名称
    return (curVal != null &&
            (curVal.equals(beanName) || (curVal instanceof Set && ((Set<?>) curVal).contains(beanName))));
}

protected void markBeanAsCreated(String beanName) {
    // 1. 初步检查bean是否已被标记为已创建
    if (!this.alreadyCreated.contains(beanName)) {
        
        // 2. 为了确保在多线程环境下的线程安全，进行同步操作
        synchronized (this.mergedBeanDefinitions) {
            
            // 3. 双重检查锁定模式：再次确认bean是否已被标记为已创建
            if (!this.alreadyCreated.contains(beanName)) {
                
                // 4. 清除bean的合并定义，以便在后续访问时重新合并
                clearMergedBeanDefinition(beanName);
                
                // 5. 在集合中标记bean已被创建
                this.alreadyCreated.add(beanName);
            }
        }
    }
}

protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException {
    // 1. 快速从并发映射中检查bean定义，这样做可以最小化锁定。
    RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName);
    
    // 2. 如果合并的bean定义存在并且没有过期，直接返回它。
    if (mbd != null && !mbd.stale) {
        return mbd;
    }
    
    // 3. 如果上述检查失败，进一步获取并返回合并的bean定义。
    return getMergedBeanDefinition(beanName, getBeanDefinition(beanName));
}

@Override
public BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException {
    // 1. 从beanDefinitionMap中获取bean的定义
    BeanDefinition bd = this.beanDefinitionMap.get(beanName);
    
    // 2. 如果没有找到BeanDefinition，进行日志跟踪并抛出异常
    if (bd == null) {
        // 如果启用了trace级别的日志，记录一条日志
        if (logger.isTraceEnabled()) {
            logger.trace("No bean named '" + beanName + "' found in " + this);
        }
        // 抛出没有找到BeanDefinition的异常
        throw new NoSuchBeanDefinitionException(beanName);
    }
    
    // 3. 返回找到的BeanDefinition
    return bd;
}

protected RootBeanDefinition getMergedBeanDefinition(String beanName, BeanDefinition bd)
			throws BeanDefinitionStoreException {

    // 为给定的Bean名称和Bean定义获取一个合并的RootBeanDefinition，
    // 由于这个版本的方法没有提供一个父Bean定义，所以我们传递null作为第三个参数。
    return getMergedBeanDefinition(beanName, bd, null);
}

protected RootBeanDefinition getMergedBeanDefinition(
        String beanName, BeanDefinition bd, @Nullable BeanDefinition containingBd)
        throws BeanDefinitionStoreException {

    // 1. 对mergedBeanDefinitions进行同步以确保线程安全。
    synchronized (this.mergedBeanDefinitions) {
        RootBeanDefinition mbd = null;
        RootBeanDefinition previous = null;

        // 2. 在完整的锁定中检查，以确保使用相同的合并实例。
        if (containingBd == null) {
            mbd = this.mergedBeanDefinitions.get(beanName);
        }

        // 3. 如果bean定义未被合并或已过期，进行合并操作。
        if (mbd == null || mbd.stale) {
            previous = mbd;

            // 4. 处理没有父定义的情况。
            if (bd.getParentName() == null) {
                if (bd instanceof RootBeanDefinition) {
                    mbd = ((RootBeanDefinition) bd).cloneBeanDefinition();
                }
                else {
                    mbd = new RootBeanDefinition(bd);
                }
            }
            // 5. 处理有父定义的情况：需要与父定义合并。
            else {
                BeanDefinition pbd;
                try {
                    String parentBeanName = transformedBeanName(bd.getParentName());
                    if (!beanName.equals(parentBeanName)) {
                        pbd = getMergedBeanDefinition(parentBeanName);
                    }
                    else {
                        BeanFactory parent = getParentBeanFactory();
                        if (parent instanceof ConfigurableBeanFactory) {
                            pbd = ((ConfigurableBeanFactory) parent).getMergedBeanDefinition(parentBeanName);
                        }
                        else {
                            // ... [代码部分省略以简化]
                        }
                    }
                }
                catch (NoSuchBeanDefinitionException ex) {
                    // ... [代码部分省略以简化]
                }
                mbd = new RootBeanDefinition(pbd);
                mbd.overrideFrom(bd);
            }

            // 6. 如果bean定义的范围没有明确设置，将其默认为单例。
            if (!StringUtils.hasLength(mbd.getScope())) {
                mbd.setScope(SCOPE_SINGLETON);
            }

            // 7. 非单例bean中的bean不能是单例。在这里修复这种情况。
            if (containingBd != null && !containingBd.isSingleton() && mbd.isSingleton()) {
                mbd.setScope(containingBd.getScope());
            }

            // 8. 如果需要，缓存合并后的bean定义。
            if (containingBd == null && isCacheBeanMetadata()) {
                this.mergedBeanDefinitions.put(beanName, mbd);
            }
        }
        // 9. 如果之前存在一个bean定义，复制相关的缓存。
        if (previous != null) {
            copyRelevantMergedBeanDefinitionCaches(previous, mbd);
        }

        // 10. 返回合并后的bean定义。
        return mbd;
    }
}

String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
    for (String dep : dependsOn) {
        // 步骤7.1: 是否存在循环依赖
        // 它首先检查是否存在循环依赖，这意味着Bean A依赖Bean B，而Bean B又依赖Bean A。
        // 如果存在这样的情况它会抛出一个BeanCreationException异常。
        if (isDependent(beanName, dep)) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                            "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
        }
        // 步骤7.2: 注册Bean与Bean之间的依赖关系
        // 当前的Bean工厂中注册bean之间的依赖关系。这样，当获取或销毁bean时，Spring可以保持正确的顺序。
        registerDependentBean(dep, beanName);
        // 步骤7.3: 获取被依赖的Bean对象
        // 确保每个被依赖的bean都已经被创建。这是通过直接调用getBean方法完成的，该方法负责初始化并返回指定的bean。
        getBean(dep);
    }
}

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
    synchronized (this.singletonObjects) {
        // 首先尝试从缓存中获取单例
        Object singletonObject = this.singletonObjects.get(beanName);
        if (singletonObject == null) {
            // ... [代码部分省略以简化]
            
            // 步骤1: 前置处理，例如标记这个bean正在创建，以处理循环引用等问题。
            beforeSingletonCreation(beanName);
            
            // ... [代码部分省略以简化]
            try {
                // 步骤2: 使用singletonFactory创建单例对象
                singletonObject = singletonFactory.getObject();
                newSingleton = true;
            }
            catch (IllegalStateException ex) {
                // ... [代码部分省略以简化]
            }
            catch (BeanCreationException ex) {
                // ... [代码部分省略以简化]
            }
            finally {
                // ... [代码部分省略以简化]
                // 步骤3: 创建单例之后的回调
                afterSingletonCreation(beanName);
            }
            // 步骤4: 如果成功创建了新的单例bean，将其添加到缓存中
            if (newSingleton) {
                addSingleton(beanName, singletonObject);
            }
        }
        // 返回现有或新创建的单例bean
        return singletonObject;
    }
}

protected void beforeSingletonCreation(String beanName) {
    // 检查beanName是否在排除列表中或已经在创建中的集合中。
    // 如果bean不在排除列表中并且也不能添加到创建中的集合中，意味着bean已经在创建中。
    if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
        throw new BeanCurrentlyInCreationException(beanName);
    }
}

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

    // 对mbd进行一些预处理，这可能包括克隆bean定义，如果mbd是非共享的原型。
    RootBeanDefinition mbdToUse = mbd;

    // 步骤1: 尝试使用InstantiationAwareBeanPostProcessors来实例化bean。
    // 如果后处理器产生bean实例（例如通过AOP代理），则直接返回该实例。
    try {
        Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
        if (bean != null) {
            return bean;
        }
    }
    catch (Throwable ex) {
        // 如果解析失败，记录异常并继续常规的bean创建。
        // ... [代码部分省略以简化]
    }

    // 如果前置处理没有返回bean实例，进入常规的bean创建过程。
    try {
        // 步骤2: 创建bean实例。这可能是通过工厂方法、构造函数注入等完成的。
        Object beanInstance = doCreateBean(beanName, mbdToUse, args);
        return beanInstance;
    }
    // 捕获创建过程中可能出现的异常，并处理它们。
    catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
        // ... [代码部分省略以简化]
    }
    catch (Throwable ex) {
        // ... [代码部分省略以简化]
    }
}

@Nullable
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
    // 初始化一个bean变量，它可能会被后续的处理过程赋值
    Object bean = null;
    
    // 检查'beforeInstantiationResolved'属性是否为FALSE。如果是FALSE，则跳过后续的处理
    if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
        
        // 首先，确保此时的bean类已经被解析。
        // 然后，对于非合成的bean，并且如果有任何InstantiationAwareBeanPostProcessors，尝试进行前置处理。
        if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
            
            // 确定目标类型。这可能涉及到类的解析和其他初始化操作。
            Class<?> targetType = determineTargetType(beanName, mbd);
            
            if (targetType != null) {
                // 如果确定了目标类型，首先应用BeanPostProcessors的前置处理。这可能会返回一个bean实例，
                // 这样我们就可以避免标准的实例化过程。
                bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
                
                // 如果bean实例在上述步骤中被创建，则还需要进行初始化后的BeanPostProcessors处理。
                if (bean != null) {
                    bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
                }
            }
        }
        
        // 更新'mbd.beforeInstantiationResolved'的值，如果bean在上述步骤中被创建，则为true，否则为false。
        mbd.beforeInstantiationResolved = (bean != null);
    }
    
    // 返回可能已经在上述过程中创建的bean实例，或者如果没有创建bean，则返回null。
    return bean;
}

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

    BeanWrapper instanceWrapper = null;
    
    // ... [代码部分省略以简化]
    
    // 步骤1: 尝试实例化bean
    if (instanceWrapper == null) {
        instanceWrapper = createBeanInstance(beanName, mbd, args);
    }
    
    // ... [代码部分省略以简化]

    // 步骤2: 合并bean定义的后置处理
    synchronized (mbd.postProcessingLock) {
        if (!mbd.postProcessed) {
            try {
                applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
            } catch (Throwable ex) {
                // ... [代码部分省略以简化]
            }
            mbd.postProcessed = true;
        }
    }

    // 步骤3: 处理可能的循环引用，通过提前暴露bean的引用
    boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
            isSingletonCurrentlyInCreation(beanName));
    if (earlySingletonExposure) {
        // ... [代码部分省略以简化]
        // 步骤3.1: 注册一个`ObjectFactory`
        addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
    }

    // 步骤4: 初始化bean实例，填充bean属性并应用后处理器
    Object exposedObject = bean;
    try {
        // 步骤4.1: 属性填充
        populateBean(beanName, mbd, instanceWrapper);
        // 步骤4.2: 初始化bean
        exposedObject = initializeBean(beanName, exposedObject, mbd);  
    } catch (Throwable ex) {
        // ... [代码部分省略以简化]
    }

    // Step 5: 如果需要，注册bean以便在容器关闭时进行清理
    try {
        registerDisposableBeanIfNecessary(beanName, bean, mbd);
    } catch (BeanDefinitionValidationException ex) {
        // ... [代码部分省略以简化]
    }

    return exposedObject;
}

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
    // ... [代码部分省略以简化]

    // 步骤1: 首先尝试从BeanPostProcessors确定构造函数，这主要是为了处理例如@Autowired注解的情况
    Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
    // 如果确定了构造函数或者bean定义中有相关的自动装配模式和构造函数参数，则使用自动装配构造函数创建bean实例
    if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
        mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
        return autowireConstructor(beanName, mbd, ctors, args);
    }

    // 步骤2: 如果BeanDefinition中存在首选构造函数，使用这些构造函数
    ctors = mbd.getPreferredConstructors();
    if (ctors != null) {
        return autowireConstructor(beanName, mbd, ctors, null);
    }

    // 步骤3: 如果前面的步骤都没有返回bean实例，那么使用无参数构造函数实例化bean
    return instantiateBean(beanName, mbd);
}

@Nullable
protected Constructor<?>[] determineConstructorsFromBeanPostProcessors(@Nullable Class<?> beanClass, String beanName)
    throws BeansException {

    // 检查提供的beanClass是否不为null，以及是否存在任何InstantiationAwareBeanPostProcessor
    if (beanClass != null && hasInstantiationAwareBeanPostProcessors()) {

        // 遍历所有的SmartInstantiationAwareBeanPostProcessor
        for (SmartInstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().smartInstantiationAware) {
            
            // 使用当前的BeanPostProcessor获取候选的构造函数
            Constructor<?>[] ctors = bp.determineCandidateConstructors(beanClass, beanName);
            
            // 如果找到了合适的构造函数，直接返回它们
            if (ctors != null) {
                return ctors;
            }
        }
    }
    
    // 如果没有找到合适的构造函数，或beanClass为null，或没有相应的BeanPostProcessor，返回null
    return null;
}

protected BeanWrapper instantiateBean(String beanName, RootBeanDefinition mbd) {
    try {
        Object beanInstance;

        if (System.getSecurityManager() != null) {
            // ... [代码部分省略以简化]
        }
        else {
            // 如果不存在，使用实例化策略来创建bean实例
            beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, this);
        }

        // 使用创建的bean实例初始化BeanWrapper
        BeanWrapper bw = new BeanWrapperImpl(beanInstance);
        // 初始化BeanWrapper，可以设置一些自定义的属性编辑器等
        initBeanWrapper(bw);

        // 返回包装了bean实例的BeanWrapper
        return bw;
    }
    catch (Throwable ex) {
        // 处理创建bean实例过程中可能发生的异常
        // ... [代码部分省略以简化]
    }
}

protected void applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd, Class<?> beanType, String beanName) {
    // 遍历已缓存的所有MergedBeanDefinitionPostProcessor类型的后处理器
    for (MergedBeanDefinitionPostProcessor processor : getBeanPostProcessorCache().mergedDefinition) {
        // 调用每个后处理器的postProcessMergedBeanDefinition方法，对合并后的bean定义进行处理
        processor.postProcessMergedBeanDefinition(mbd, beanType, beanName);
    }
}

protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
    // 确保传入的singletonFactory不为null
    Assert.notNull(singletonFactory, "Singleton factory must not be null");
    synchronized (this.singletonObjects) {
        // 如果指定名称的bean尚未在singletonObjects缓存中
        if (!this.singletonObjects.containsKey(beanName)) {
            // 将传入的singletonFactory添加到singletonFactories缓存中
            this.singletonFactories.put(beanName, singletonFactory);
            // 从earlySingletonObjects缓存中移除指定bean名称，因为它现在已有一个完整的ObjectFactory
            this.earlySingletonObjects.remove(beanName);
            // 将bean名称添加到registeredSingletons集合中，标记它已被注册
            this.registeredSingletons.add(beanName);
        }
    }
}

protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
    // ... [代码部分省略以简化]

    // 如果当前的bean不是合成的，并且存在InstantiationAwareBeanPostProcessors
    if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
        // 遍历所有的InstantiationAwareBeanPostProcessors
        for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
            // 调用postProcessAfterInstantiation方法
            if (!bp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
                // 如果返回false，则提前结束bean属性的设置
                return;
            }
        }
    }

    // 获取bean定义中的属性值
    PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);

    // ... [代码部分省略以简化]

    // 检查是否有InstantiationAwareBeanPostProcessors
    boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
    // 确定是否需要进行依赖性检查
    boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);

    PropertyDescriptor[] filteredPds = null;
    if (hasInstAwareBpps) {
        // 如果没有属性值，则从bean定义中获取
        if (pvs == null) {
            pvs = mbd.getPropertyValues();
        }
        // 遍历所有的InstantiationAwareBeanPostProcessors
        for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
            // 调用postProcessProperties方法处理属性值
            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);
    }

    // 最后，将处理后的属性值应用到bean实例上
    if (pvs != null) {
        applyPropertyValues(beanName, mbd, bw, pvs);
    }
}

protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
    // 如果存在SecurityManager，执行相应的安全代码（省略部分）
    if (System.getSecurityManager() != null) {
        // ... [代码部分省略以简化]
    }
    else {
        // 如果bean实现了特定的Aware接口（如BeanNameAware, BeanFactoryAware等），则调用相应的方法
        invokeAwareMethods(beanName, bean);
    }

    // 初始化前的预处理
    // 如果bean不是合成的，调用所有BeanPostProcessors的postProcessBeforeInitialization方法
    Object wrappedBean = bean;
    if (mbd == null || !mbd.isSynthetic()) {
        wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
    }

    try {
        // 调用bean的初始化方法，例如afterPropertiesSet和custom init-method
        invokeInitMethods(beanName, wrappedBean, mbd);
    }
    catch (Throwable ex) {
        // ... [代码部分省略以简化]
    }

    // 初始化后的后处理
    // 如果bean不是合成的，调用所有BeanPostProcessors的postProcessAfterInitialization方法
    if (mbd == null || !mbd.isSynthetic()) {
        wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
    }

    // 返回最终的bean实例，可能被AOP代理等包装
    return wrappedBean;
}

private void invokeAwareMethods(String beanName, Object bean) {
    // 检查bean是否实现了Aware接口
    if (bean instanceof Aware) {
        // 如果bean实现了BeanNameAware接口，设置bean的名字
        if (bean instanceof BeanNameAware) {
            ((BeanNameAware) bean).setBeanName(beanName);
        }
        // 如果bean实现了BeanClassLoaderAware接口，设置bean的类加载器
        if (bean instanceof BeanClassLoaderAware) {
            ClassLoader bcl = getBeanClassLoader();
            if (bcl != null) {
                ((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
            }
        }
        // 如果bean实现了BeanFactoryAware接口，设置bean的工厂
        if (bean instanceof BeanFactoryAware) {
            ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
        }
    }
}

@Override
public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
    throws BeansException {
	// 设置当前bean为传入的bean
    Object result = existingBean;  

    // 遍历容器中所有的BeanPostProcessors
    for (BeanPostProcessor processor : getBeanPostProcessors()) {
        // 调用每个BeanPostProcessor的postProcessBeforeInitialization方法
        Object current = processor.postProcessBeforeInitialization(result, beanName);

        // 如果postProcessBeforeInitialization返回null，则直接返回原bean
        if (current == null) {
            return result;
        }
        
        result = current;  // 更新result为postProcessBeforeInitialization处理后的bean
    }

    // 返回所有BeanPostProcessors处理后的bean
    return result;
}

protected void registerDisposableBeanIfNecessary(String beanName, Object bean, RootBeanDefinition mbd) {
    // ... [代码部分省略以简化]
    registerDisposableBean(beanName, new DisposableBeanAdapter(
                bean, beanName, mbd, getBeanPostProcessorCache().destructionAware, acc));
    // ... [代码部分省略以简化]
}

public void registerDisposableBean(String beanName, DisposableBean bean) {
    synchronized (this.disposableBeans) {
        this.disposableBeans.put(beanName, bean);
    }
}

protected void afterSingletonCreation(String beanName) {
    // 检查给定的bean名称是否在排除列表中，如果不是，继续检查该bean是否正在创建
    if (!this.inCreationCheckExclusions.contains(beanName) 
        // 尝试从表示“当前正在创建的单例bean”集合中移除给定的bean名称
        && !this.singletonsCurrentlyInCreation.remove(beanName)) {
        // 如果给定的bean名称无法从集合中移除，说明在此时该bean不应该在创建中。
        // 这可能表示bean的创建有问题或被错误地标记为“当前正在创建”，因此抛出异常。
        throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation");
    }
}

protected void addSingleton(String beanName, Object singletonObject) {
    // 使用`synchronized`块确保多线程环境中对单例对象的线程安全操作
    synchronized (this.singletonObjects) {
        // 将新创建的单例对象添加到`singletonObjects`缓存中
        this.singletonObjects.put(beanName, singletonObject);
        
        // 从`singletonFactories`中移除bean名称，因为现在我们已经完成了该bean的完整实例化
        this.singletonFactories.remove(beanName);
        
        // 从`earlySingletonObjects`中移除bean名称，因为该bean现在已经完全初始化并存储在`singletonObjects`中
        this.earlySingletonObjects.remove(beanName);
        
        // 将bean名称添加到`registeredSingletons`集合中，以表示该bean已经被注册为一个单例
        this.registeredSingletons.add(beanName);
    }
}

protected Object getObjectForBeanInstance(
        Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {

    // 检查名称是否有工厂的解引用前缀（例如'&'）并且bean实例不是工厂
    if (BeanFactoryUtils.isFactoryDereference(name)) {
        // 当bean实例是NullBean时，直接返回bean实例
        if (beanInstance instanceof NullBean) {
            return beanInstance;
        }
        // 如果bean实例不是一个FactoryBean，抛出异常
        if (!(beanInstance instanceof FactoryBean)) {
            throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());
        }
        // 如果bean定义不为null，标记它为一个FactoryBean
        if (mbd != null) {
            mbd.isFactoryBean = true;
        }
        return beanInstance;
    }

    // 如果bean实例不是一个FactoryBean，则直接返回bean实例
    if (!(beanInstance instanceof FactoryBean)) {
        return beanInstance;
    }

    Object object = null;
    // 如果bean定义不为null，标记它为一个FactoryBean
    if (mbd != null) {
        mbd.isFactoryBean = true;
    }
    // 如果没有提供bean定义，则尝试从缓存中获取工厂bean生成的对象
    else {
        object = getCachedObjectForFactoryBean(beanName);
    }
    // 如果缓存中没有对象，则需要从FactoryBean中获取
    if (object == null) {
        FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
        // 如果存在bean定义并且没有为给定的beanName缓存对象，则获取合并的bean定义
        if (mbd == null && containsBeanDefinition(beanName)) {
            mbd = getMergedLocalBeanDefinition(beanName);
        }
        // 检查bean定义是否为合成的（例如，由基础设施代码创建的）
        boolean synthetic = (mbd != null && mbd.isSynthetic());
        // 从FactoryBean获取对象
        object = getObjectFromFactoryBean(factory, beanName, !synthetic);
    }
    return object;
}

<T> T adaptBeanInstance(String name, Object bean, @Nullable Class<?> requiredType) {
    // 检查所需的类型是否与实际bean实例的类型匹配
    if (requiredType != null && !requiredType.isInstance(bean)) {
        try {
            // 如果不匹配，尝试转换bean实例为所需的类型
            Object convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
            // 如果转换后的bean为null，抛出异常
            if (convertedBean == null) {
                throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
            }
            return (T) convertedBean;
        }
        catch (TypeMismatchException ex) {
            // 如果类型转换失败，记录trace日志并抛出异常
            if (logger.isTraceEnabled()) {
                logger.trace("Failed to convert bean '" + name + "' to required type '" +
                             ClassUtils.getQualifiedName(requiredType) + "'", ex);
            }
            throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
        }
    }
    // 如果bean实例的类型与所需的类型匹配，直接返回bean实例
    return (T) bean;
}