AbstractBeanFactory

org.springframework.beans.factory.support.AbstractBeanFactory抽象类，实现 ConfigurableBeanFactory接口， BeanFactory的基础实现类，提供依赖查找方法，可获取 Bean 对象，接下来我们来看看依赖查找的实现

源码解析

getBean 方法

getBean(String name)方法，根据名称获取 Bean，当然还有许多重载方法，如下：

@Override
public Object getBean(String name) throws BeansException {
    return doGetBean(name, null, null, false);
}

@Override
public <T> T getBean(String name, Class<T> requiredType) throws BeansException {
    return doGetBean(name, requiredType, null, false);
}

@Override
public Object getBean(String name, Object... args) throws BeansException {
    return doGetBean(name, null, args, false);
}

public <T> T getBean(String name, @Nullable Class<T> requiredType, @Nullable Object... args)
        throws BeansException {
    return doGetBean(name, requiredType, args, false);
}

最终都会调用doGetBean(...)这个方法

doGetBean 方法

doGetBean(final String name, @Nullable final Class<T> requiredType, @Nullable final Object[] args, boolean typeCheckOnly)方法，获取一个 Bean，方法如下：

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

    // <1> 获取 `beanName`
    // 因为入参 `name` 可能是别名，也可能是 FactoryBean 类型 Bean 的名称（`&` 开头，需要去除）
    // 所以需要获取真实的 beanName
    final String beanName = transformedBeanName(name);
    Object bean;

    // <2> 先从缓存（仅缓存单例 Bean ）中获取 Bean 对象，这里缓存指的是 `3` 个 Map
    // 缓存中也可能是正在初始化的 Bean，可以避免**循环依赖注入**引起的问题
    Object sharedInstance = getSingleton(beanName);
    // <3> 若从缓存中获取到对应的 Bean，且 `args` 参数为空
    if (sharedInstance != null && args == null) {
        if (logger.isTraceEnabled()) {
            if (isSingletonCurrentlyInCreation(beanName)) {
                logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
                        "' that is not fully initialized yet - a consequence of a circular reference");
            }
            else {
                logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
            }
        }
        // <3.1> 获取 Bean 的目标对象，`scopedInstance` 非 FactoryBean 类型直接返回
        // 否则，调用 FactoryBean#getObject() 获取目标对象
        bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    }
    // 缓存中没有对应的 Bean，则开启 Bean 的加载
    else {
        // <4> 如果非单例模式下的 Bean 正在创建，这里又开始创建，表明存在循环依赖，则直接抛出异常
        if (isPrototypeCurrentlyInCreation(beanName)) {
            throw new BeanCurrentlyInCreationException(beanName);
        }

        BeanFactory parentBeanFactory = getParentBeanFactory();
        // <5> 如果从当前容器中没有找到对应的 BeanDefinition，则从父容器中加载（如果存在父容器）
        if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
            // <5.1> 获取 `beanName`，因为可能是别名，则进行处理
            // 和第 `1` 步不同，不需要对 `&` 进行处理，因为进入父容器重新依赖查找
            String nameToLookup = originalBeanName(name);
            // <5.2> 若为 AbstractBeanFactory 类型，委托父容器的 doGetBean 方法进行处理
            // 否则，就是非 Spring IoC 容器，根据参数调用相应的 `getBean(...)`方法
            if (parentBeanFactory instanceof AbstractBeanFactory) {
                return ((AbstractBeanFactory) parentBeanFactory).doGetBean(nameToLookup, requiredType, args, typeCheckOnly);
            }
            else if (args != null) {
                return (T) parentBeanFactory.getBean(nameToLookup, args);
            }
            else if (requiredType != null) {
                return parentBeanFactory.getBean(nameToLookup, requiredType);
            }
            else {
                return (T) parentBeanFactory.getBean(nameToLookup);
            }
        }

        // <6> 如果不是仅仅做类型检查，则表示需要创建 Bean，将 `beanName` 标记为已创建过
        if (!typeCheckOnly) {
            markBeanAsCreated(beanName);
        }

        try {
            // <7> 从容器中获取 `beanName` 对应的的 RootBeanDefinition（合并后）
            final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
            // 检查是否为抽象类
            checkMergedBeanDefinition(mbd, beanName, args);

            // <8> 获取当前正在创建的 Bean 所依赖对象集合（`depends-on` 配置的依赖）
            String[] dependsOn = mbd.getDependsOn();
            if (dependsOn != null) {
                for (String dep : dependsOn) {
                    // <8.1> 检测是否存在循环依赖，存在则抛出异常
                    if (isDependent(beanName, dep)) {
                        throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
                    }
                    // <8.2> 将 `beanName` 与 `dep` 之间依赖的关系进行缓存
                    registerDependentBean(dep, beanName);
                    try {
                        // <8.3> 先创建好依赖的 Bean（重新调用 `getBean(...)` 方法）
                        getBean(dep);
                    }
                    catch (NoSuchBeanDefinitionException ex) {
                        throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
                    }
                }
            }

            // <9> 开始创建 Bean，不同模式创建方式不同
            if (mbd.isSingleton()) { // <9.1> 单例模式
                /*
                 * <9.1.1> 创建 Bean，成功创建则进行缓存，并移除缓存的早期对象
                 * 创建过程实际调用的下面这个 `createBean(...)` 方法
                 */
                sharedInstance = getSingleton(beanName,
                        // ObjectFactory 实现类
                        () -> {
                            try {
                                // **【核心】** 创建 Bean
                                return createBean(beanName, mbd, args);
                            } catch (BeansException ex) {
                                // Explicitly remove instance from singleton cache: It might have been put there
                                // eagerly by the creation process, to allow for circular reference resolution.
                                // Also remove any beans that received a temporary reference to the bean.
                                // 如果创建过程出现异常，则显式地从缓存中删除当前 Bean 相关信息
                                // 在单例模式下为了解决循环依赖，创建过程会缓存早期对象，这里需要进行删除
                                destroySingleton(beanName);
                                throw ex;
                            }
                });
                // <9.1.2> 获取 Bean 的目标对象，`scopedInstance` 非 FactoryBean 类型直接返回
                // 否则，调用 FactoryBean#getObject() 获取目标对象
                bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
            }
            // <9.2> 原型模式
            else if (mbd.isPrototype()) {
                // It's a prototype -> create a new instance.
                Object prototypeInstance = null;
                try {
                    // <9.2.1> 将 `beanName` 标记为原型模式正在创建
                    beforePrototypeCreation(beanName);
                    // <9.2.2> **【核心】** 创建 Bean
                    prototypeInstance = createBean(beanName, mbd, args);
                }
                finally {
                    // <9.2.3> 将 `beanName` 标记为不在创建中，照应第 `9.2.1` 步
                    afterPrototypeCreation(beanName);
                }
                // <9.2.4> 获取 Bean 的目标对象，`scopedInstance` 非 FactoryBean 类型直接返回
                // 否则，调用 FactoryBean#getObject() 获取目标对象
                bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
            }
            // <9.3> 其他模式
            else {
                // <9.3.1> 获取该模式的 Scope 对象 `scope`，不存在则抛出异常
                String scopeName = mbd.getScope();
                final Scope scope = this.scopes.get(scopeName);
                if (scope == null) {
                    throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
                }
                try {
                    // <9.3.1> 从 `scope` 中获取 `beanName` 对应的对象（看你的具体实现），不存在则执行**原型模式**的四个步骤进行创建
                    Object scopedInstance = scope.get(beanName, () -> {
                        // 将 `beanName` 标记为原型模式正在创建
                        beforePrototypeCreation(beanName);
                        try {
                            // **【核心】** 创建 Bean
                            return createBean(beanName, mbd, args);
                        }
                        finally {
                            // 将 `beanName` 标记为不在创建中，照应上一步
                            afterPrototypeCreation(beanName);
                        }
                    });
                    // 获取 Bean 的目标对象，`scopedInstance` 非 FactoryBean 类型直接返回
                    // 否则，调用 FactoryBean#getObject() 获取目标对象
                    bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
                }
                catch (IllegalStateException ex) {
                    throw new BeanCreationException(beanName,
                            "Scope '" + scopeName + "' is not active for the current thread; consider " +
                            "defining a scoped proxy for this bean if you intend to refer to it from a singleton",
                            ex);
                }
            }
        }
        catch (BeansException ex) {
            cleanupAfterBeanCreationFailure(beanName);
            throw ex;
        }
    }

    // Check if required type matches the type of the actual bean instance.
    // <10> 如果入参 `requiredType` 不为空，并且 Bean 不是该类型，则需要进行类型转换
    if (requiredType != null && !requiredType.isInstance(bean)) {
        try {
            // <10.1> 通过类型转换机制，将 Bean 转换成 `requiredType` 类型
            T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
            // <10.2> 转换后的 Bean 为空则抛出异常
            if (convertedBean == null) {
                // 转换失败，抛出 BeanNotOfRequiredTypeException 异常
                throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
            }
            // <10.3> 返回类型转换后的 Bean 对象
            return convertedBean;
        }
        catch (TypeMismatchException ex) {
            if (logger.isTraceEnabled()) {
                logger.trace("Failed to convert bean '" + name + "' to required type '" +
                        ClassUtils.getQualifiedName(requiredType) + "'", ex);
            }
            throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
        }
    }
    // <11> 返回获取到的 Bean
    return (T) bean;
}

transformedBeanName方法

获取beanName对应代码段：

// AbstractBeanFactory.java
final String beanName = transformedBeanName(name);

因为入参name可能是别名，也可能是 FactoryBean 类型 Bean 的名称（&开头，需要去除），所以需要进行一番转换，如下：

// AbstractBeanFactory.java
protected String transformedBeanName(String name) {
    return canonicalName(BeanFactoryUtils.transformedBeanName(name));
}
// BeanFactoryUtils.java
public static String transformedBeanName(String name) {
    Assert.notNull(name, "'name' must not be null");
    if (!name.startsWith(BeanFactory.FACTORY_BEAN_PREFIX)) {
        return name;
    }
    // 获取 name 对应的 beanName
    // 不为 null 则返回 `transformedBeanNameCache` 缓存中对应的 beanName，为 null 则对 name 进行处理
    // 例如，如果原始名称是&&myBean，第一次去掉一个&变成&myBean，然后再次检查，仍然以&开头，继续去掉，得到myBean，循环结束。
    return transformedBeanNameCache.computeIfAbsent(name, beanName -> {
        do {
            beanName = beanName.substring(BeanFactory.FACTORY_BEAN_PREFIX.length());
        }
        while (beanName.startsWith(BeanFactory.FACTORY_BEAN_PREFIX));
        return beanName;
    });
}
// SimpleAliasRegistry.java
// 通过 aliasMap（别名映射表）解析名称的最终规范名称。处理逻辑如下：
public String canonicalName(String name) {
    String canonicalName = name;
    String resolvedName;
    // 不断检查 aliasMap 中是否存在当前名称的别名。例如：
    // 若 aliasMap 中存在 A -> B 和 B -> C，则输入 A 会被解析为 C。
    // 当 aliasMap 中找不到下一级别名时（resolvedName == null），返回最终的 canonicalName。
    do {
        resolvedName = this.aliasMap.get(canonicalName);
        if (resolvedName != null) {
            canonicalName = resolvedName;
        }
    }
    while (resolvedName != null);
    return canonicalName;
}

getSingleton方法

从缓存中获取单例 Bean，对应代码段：

// AbstractBeanFactory#doGetBean(...) 方法
Object sharedInstance = getSingleton(beanName);

单例模式的 Bean 被创建后会缓存，为了避免循环依赖注入，在创建过程会临时缓存正在创建的 Bean（早期 Bean），在后续文章会讲到，从缓存中获取对象过程如下：

// DefaultSingletonBeanRegistry.java

public Object getSingleton(String beanName) {
    return getSingleton(beanName, true);
}

// 首先，我需要明确这三个缓存的作用：
// 一级缓存（singletonObjects）​：存储已经完全初始化好的单例Bean。
// ​二级缓存（earlySingletonObjects）​：存储早期的Bean引用，这些Bean已经实例化但尚未完成初始化（如属性填充）。
​// 三级缓存（singletonFactories）​：存储Bean的ObjectFactory，用于创建早期的Bean实例。

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    // 尝试从一级缓存singletonObjects获取Bean：如果找到了就直接返回，否则进入后续处理。
    Object singletonObject = this.singletonObjects.get(beanName);
    // 如果一级缓存中不存在，且当前 beanName 正在创建
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        // 对 singletonObjects 加锁
        synchronized (this.singletonObjects) {
            // 从二级缓存earlySingletonObjects获取Bean：如果存在，则直接返回，避免重复创建。
            singletonObject = this.earlySingletonObjects.get(beanName);
            // 如果二级缓存earlySingletonObjects中不存在，且允许提前创建
            if (singletonObject == null && allowEarlyReference) {
                // 则从三级缓存singletonFactories获取ObjectFactory，并通过它创建Bean实例
                // 然后将该实例放入二级缓存，并从三级缓存移除对应的ObjectFactory。
                ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                // 如果从三级缓存singletonFactories中存在对应的对象，则进行下面的处理
                if (singletonFactory != null) {
                    // 调用 ObjectFactory#getOject() 方法，获取目标 Bean 对象（早期半成品）
                    singletonObject = singletonFactory.getObject();
                    // 将目标对象放入二级 Map
                    this.earlySingletonObjects.put(beanName, singletonObject);
                    // 从三级 Map移除 beanName
                    this.singletonFactories.remove(beanName);
                }
            }
        }
    }
    // 返回从缓存中获取的对象
    return singletonObject;
}

getObjectForBeanInstance 方法

对应代码段：

bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);

不管是从缓存中获取的还是新创建的，都会调用这个方法进行处理，如果是FactoryBean类型则调用其getObject()获取目标对象

// AbstractBeanFactory.java
protected Object getObjectForBeanInstance( Object beanInstance, String name, String beanName, 
                                          @Nullable RootBeanDefinition mbd) {

    // <1> 若 `name` 以 `&` 开头，说明想要获取 FactoryBean，则校验其正确性
    if (BeanFactoryUtils.isFactoryDereference(name)) {
        // <1.1> 如果是 NullBean 空对象，则直接返回
        if (beanInstance instanceof NullBean) {
            return beanInstance;
        }
        // <1.2> 如果不是 FactoryBean 类型，则抛出异常
        if (!(beanInstance instanceof FactoryBean)) {
            throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());
        }
    }

    // 到这里我们就有了一个 Bean，可能是一个正常的 Bean，也可能是一个 FactoryBean
    // 如果是 FactoryBean，则需要通过其 getObject() 方法获取目标对象

    // <2> 如果 `beanInstance` 不是 FactoryBean 类型，不需要再处理则直接返回
    // 或者（表示是 FactoryBean 类型） `name` 以 `&` 开头，表示你想要获取实际 FactoryBean 对象，则直接返回
    // 还不符合条件的话，表示是 FactoryBean，需要获取 getObject() 返回目标对象
    if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
        return beanInstance;
    }

    Object object = null;
    // <3> 如果入参没有传 BeanDefinition，则从 `factoryBeanObjectCache` 缓存中获取对应的 Bean 对象
	// 入参传了 BeanDefinition 表示这个 Bean 是刚创建的，不走缓存，需要调用其 getObject() 方法获取目标对象
	// `factoryBeanObjectCache`：FactoryBean#getObject() 调用一次后返回的目标对象缓存在这里
    if (mbd == null) {
        object = getCachedObjectForFactoryBean(beanName);
    }
    // <4> 若第 `3` 步获取的对象为空，则需要调用 FactoryBean#getObject() 获得对象
    if (object == null) {
        // <4.1> 将 `beanInstance` 转换成 FactoryBean 类型
        FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
        // <4.2> 如果入参没有传 BeanDefinition 并且当前容器存在对应的 BeanDefinition
        if (mbd == null && containsBeanDefinition(beanName)) {
            // 获取对应的 RootBeanDefinition（合并后）
            mbd = getMergedLocalBeanDefinition(beanName);
        }
        // 是否是用户定义的，synthetic 为 true 表示该 Bean 是 Spring 内部生成的（如 AOP 代理），可能不需要缓存或后处理。
        boolean synthetic = (mbd != null && mbd.isSynthetic());
        // <4.3>【核心】通过 FactoryBean 获得目标对象，单例模式会缓存在 `factoryBeanObjectCache` 中
        object = getObjectFromFactoryBean(factory, beanName, !synthetic);
    }
    return object;
}

getObjectFromFactoryBean 方法

getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess)方法，获取FactoryBean的目标对象，方法如下：

// FactoryBeanRegistrySupport.java
protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
    // <1> `factory` 为单例模式，且单例 Bean 缓存中存在 `beanName` 对应的 FactoryBean 对象
    if (factory.isSingleton() && containsSingleton(beanName)) {
        // <1.1> 获取单例锁，保证安全
        synchronized (getSingletonMutex()) { 
            // <1.2> 从 `factoryBeanObjectCache` 缓存中获取 FactoryBean#getObject() 创建的目标对象
            Object object = this.factoryBeanObjectCache.get(beanName);
            if (object == null) {
                // <1.3> 则根据 `factory` 获取目标对象，调用 FactoryBean#getObject() 方法
                object = doGetObjectFromFactoryBean(factory, beanName);
                // <1.4> 这里再进行一次校验，看是否在缓存中存在 FactoryBean 创建的目标对象，如果有则优先从缓存中获取
                // 保证 FactoryBean#getObject() 只能被调用一次
                // 没有的话，则对刚获取到的目标对象进行接下来的处理
                Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
                if (alreadyThere != null) {
                    object = alreadyThere;
                } else {
                    // <1.5> 是否需要后续处理，这个 FactoryBean 的前身 BeanDefinition 是否由 Spring 解析出来的，通常情况下都是
                    if (shouldPostProcess) {
                        // <1.5.1> 若该 FactoryBean 处于创建中，则直接返回这个目标对象，不进行接下来的处理过程
                        if (isSingletonCurrentlyInCreation(beanName)) {
                            return object;
                        }
                        // <1.5.2> 前置处理，将 `beanName` 标志为正在创建
                        beforeSingletonCreation(beanName);
                        try {
                            // <1.5.3> 对通过 FactoryBean 获取的目标对象进行后置处理
                            // 遍历所有的 BeanPostProcessor 的 postProcessAfterInitialization 方法（初始化的处理）
                            object = postProcessObjectFromFactoryBean(object, beanName);
                        }
                        catch (Throwable ex) {
                            throw new BeanCreationException(beanName,
                                    "Post-processing of FactoryBean's singleton object failed", ex);
                        }
                        finally {
                            // <1.5.4> 后置处理，将 `beanName` 标志为不在创建中
                            afterSingletonCreation(beanName);
                        }
                    }
                    // <1.6> 如果缓存中存在 `beanName` 对应的 FactoryBean 对象
                    // 上面不是判断了吗？也可能在上面的处理过程会有所变化，所以这里在做一层判断
                    // 目的：缓存 FactoryBean 创建的目标对象，则需要保证 FactoryBean 本身这个对象存在缓存中
                    if (containsSingleton(beanName)) {
                        // <1.6.1> 将这个 FactoryBean 创建的目标对象保存至 `factoryBeanObjectCache`
                        this.factoryBeanObjectCache.put(beanName, object);
                    }
                }
            }
            // <1.7> 返回 FactoryBean 创建的目标对象
            return object;
        }
    }
    // <2> `factory` 非单例模式，或单例 Bean 缓存中不存在 `beanName` 对应的 FactoryBean 对象
    else {
        // <2.1> 则根据 `factory` 获取目标对象，调用 FactoryBean#getObject() 方法
        Object object = doGetObjectFromFactoryBean(factory, beanName);
        // <2.2> 是否需要后续处理，这个 FactoryBean 的前身 BeanDefinition 是否由 Spring 解析出来的，通常情况下都是
        if (shouldPostProcess) {
            try {
                // <2.2.1> 对通过 FactoryBean 获取的目标对象进行后置处理
                // 遍历所有的 BeanPostProcessor 的 postProcessAfterInitialization 方法（初始化的处理）
                object = postProcessObjectFromFactoryBean(object, beanName);
            }
            catch (Throwable ex) {
                throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);
            }
        }
        // <2.3> 返回 FactoryBean 创建的目标对象，非单例模式不会进行缓存
        return object;
    }
}

isPrototypeCurrentlyInCreation方法

对应代码段：

// AbstractBeanFactory#doGetBean(...) 方法
// Spring 对于非单例模式的 Bean 无法进行相关缓存，也就无法处理循环依赖的情况，选择了直接抛出异常
if (isPrototypeCurrentlyInCreation(beanName)) {
    throw new BeanCurrentlyInCreationException(beanName);
}
//prototypesCurrentlyInCreation 中保存非单例模式下正在创建的 Bean 的名称，这里又重新创建，表示出现循环依赖，则直接抛出异常
protected boolean isPrototypeCurrentlyInCreation(String beanName) {
    Object curVal = this.prototypesCurrentlyInCreation.get();
    return (curVal != null && (curVal.equals(beanName) // 相等
            || (curVal instanceof Set && ((Set<?>) curVal).contains(beanName)))); // 包含
}

getParentBeanFactory方法

对应代码段：

// AbstractBeanFactory#doGetBean(...) 方法
BeanFactory parentBeanFactory = getParentBeanFactory();
// 如果当前 BeanFactory 没有对应的 BeanDefinition，也就无法创建 Bean
//但是如果存在父 BeanFactory，则将接下来的操作交由父 BeanFactory，找不到会层层找上去，如果所有 BeanFactory 都找不到对应的 BeanDefinition 最终会抛出异常。
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
    // Not found -> check parent.
    // <5.1> 获取 `beanName`，因为可能是别名，则进行处理
    // 和第 `1` 步不同，不需要对 `&` 进行处理，因为进入父容器重新依赖查找
    String nameToLookup = originalBeanName(name);
    // <5.2> 若为 AbstractBeanFactory 类型，委托父容器的 doGetBean 方法进行处理
    // 否则，就是非 Spring IoC 容器，根据参数调用相应的 `getBean(...)`方法
    if (parentBeanFactory instanceof AbstractBeanFactory) {
        return ((AbstractBeanFactory) parentBeanFactory).doGetBean(nameToLookup, requiredType, args, typeCheckOnly);
    }
    else if (args != null) {
        return (T) parentBeanFactory.getBean(nameToLookup, args);
    }
    else if (requiredType != null) {
        return parentBeanFactory.getBean(nameToLookup, requiredType);
    }
    else {
        return (T) parentBeanFactory.getBean(nameToLookup);
    }
}

在 Spring 框架中，parentBeanFactory表示 ​父级容器（父容器）​，它是 Spring 容器（ApplicationContext或BeanFactory）层次结构中的一个重要概念。通过父容器机制，Spring 支持多级容器的协作，允许子容器共享或继承父容器中的 Bean 定义和实例，同时保持自身的独立性。以下是详细解释：

parentBeanFactory的作用

• ​Bean 定义继承：子容器可以访问父容器中定义的 Bean，但父容器无法访问子容器的 Bean。
  ​隔离与复用：
• ​复用公共配置：将公共的 Bean（如数据源、事务管理器）定义在父容器中，供多个子容器复用。
• ​隔离模块配置：不同子容器可以定义同名但不同实现的 Bean，避免冲突。
• ​分层管理：适用于模块化应用，例如在 Web 应用中，父容器管理服务层 Bean，子容器（如每个DispatcherServlet的容器）管理控制器和视图相关 Bean。

为什么需要父容器？

(1) 应用场景

​ 场景	说明
多模块应用	多个子模块（子容器）共享父容器的公共 Bean（如数据库配置、工具类），避免重复定义。
Web 应用分层	父容器管理服务层和 DAO 层 Bean，每个 DispatcherServlet 子容器管理 MVC 相关 Bean。
​测试环境隔离	在测试中，父容器使用生产配置，子容器覆盖部分 Bean（如 Mock 数据源）。
​微服务配置共享	多个微服务子容器共享父容器中的全局配置（如认证中心、日志服务）。

实现机制
​(1) 核心接口与类

• ​HierarchicalBeanFactory：
  定义了getParentBeanFactory()方法，表示容器支持父级容器的层次结构。
• ​ApplicationContext继承关系：
  如ClassPathXmlApplicationContext、AnnotationConfigApplicationContext等均可通过setParent()方法设置父容器。

通过编程方式设置父容器：

// 创建父容器
AnnotationConfigApplicationContext parentContext = new AnnotationConfigApplicationContext();
parentContext.register(ParentConfig.class);
parentContext.refresh();

// 创建子容器并设置父容器
AnnotationConfigApplicationContext childContext = new AnnotationConfigApplicationContext();
childContext.setParent(parentContext);
childContext.register(ChildConfig.class);
childContext.refresh();

markBeanAsCreated方法

对应代码段：

// AbstractBeanFactory#doGetBean(...) 方法
// <6> 如果不是仅仅做类型检查，则表示需要创建 Bean，将 `beanName` 标记为已创建过
if (!typeCheckOnly) {
    markBeanAsCreated(beanName);
}

如果不是仅仅做类型检查，则调用markBeanAsCreated(String beanName)方法，如下：

// AbstractBeanFactory.java
protected void markBeanAsCreated(String beanName) {
    // 检查这个beanName是否不在alreadyCreated集合里。如果不在，说明这个Bean还未创建。
    if (!this.alreadyCreated.contains(beanName)) {
        // 加上全局锁
        synchronized (this.mergedBeanDefinitions) {
            // 再次检查一次：DCL 双检查模式
            if (!this.alreadyCreated.contains(beanName)) {
                // 从 mergedBeanDefinitions 中删除 beanName，并在下次访问时重新创建它
                clearMergedBeanDefinition(beanName);
                // 添加到已创建 bean 集合中
                this.alreadyCreated.add(beanName);
            }
        }
    }
}

将这个beanName保存在alreadyCreated集合中（SetFromMap），在后面的循环依赖检查中会使用到

getMergedLocalBeanDefinition方法

对应代码段：

// AbstractBeanFactory#doGetBean(...) 方法
// <7> 从容器中获取 `beanName` 对应的的 RootBeanDefinition（合并后）
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
// 检查是否为抽象类
checkMergedBeanDefinition(mbd, beanName, args);

因为我们定义的 Bean 大多数都被 Spring 解析成 GenericBeanDefinition类型，具有父子关系，则需要获取最终的 BeanDefinition；如果存在父子关系，则会进行一系列的合并，转换成RootBeanDefinition对象，调用getMergedLocalBeanDefinition(String beanName)方法，如下：

// AbstractBeanFactory.java
protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException {
    // 尝试从mergedBeanDefinitions缓存获取已合并的定义RootBeanDefinition，存在则直接返回
    RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName);
    if (mbd != null) {
        return mbd;
    }
    // 获取 BeanDefinition 并转换成，如果存在父子关系则进行合并
    return getMergedBeanDefinition(beanName, getBeanDefinition(beanName));
}

protected RootBeanDefinition getMergedBeanDefinition(String beanName, BeanDefinition bd)
        throws BeanDefinitionStoreException {
    return getMergedBeanDefinition(beanName, bd, null);
}

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

    // 加锁
    synchronized (this.mergedBeanDefinitions) {
        RootBeanDefinition mbd = null;

        // 再次检查缓存（双检锁模式）
        if (containingBd == null) {
            mbd = this.mergedBeanDefinitions.get(beanName);
        }

        if (mbd == null) {
            // 如果没有父类则直接转换成 RootBeanDefinition 对象
            if (bd.getParentName() == null) {
                if (bd instanceof RootBeanDefinition) {
                    // 需要克隆操作保证原始定义不被修改
                    mbd = ((RootBeanDefinition) bd).cloneBeanDefinition();
                }
                else {
                    mbd = new RootBeanDefinition(bd);
                }
            }
            // 有父类则进行合并
            else {
                // Child bean definition: needs to be merged with parent.
                BeanDefinition pbd;
                try {
                    // 获取父类的对应的 BeanDefinition 对象
                    // transformedBeanName：处理别名和工厂Bean前缀
                    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 {
                            throw new NoSuchBeanDefinitionException(parentBeanName,
                                    "Parent name '" + parentBeanName + "' is equal to bean name '" + beanName +
                                    "': cannot be resolved without an AbstractBeanFactory parent");
                        }
                    }
                }
                catch (NoSuchBeanDefinitionException ex) {
                    throw new BeanDefinitionStoreException(bd.getResourceDescription(), beanName,
                            "Could not resolve parent bean definition '" + bd.getParentName() + "'", ex);
                }
                // 创建合并后的定义
                mbd = new RootBeanDefinition(pbd);
                // 父子合并
                mbd.overrideFrom(bd);
            }

            // 如果没有设置scope，则默认设置单例作用域
            if (!StringUtils.hasLength(mbd.getScope())) {
                mbd.setScope(RootBeanDefinition.SCOPE_SINGLETON);
            }

            // 这段代码是 Spring 容器中处理作用域继承的核心逻辑，用于确保内部 Bean 的作用域与其容器 Bean 保持一致。
            //当内部 Bean 被声明在非单例（如原型）的容器 Bean 中时，若内部 Bean 保持单例状态，会导致以下问题：
            // PrototypeBean outer = ctx.getBean("outerPrototypeBean"); // 每次返回新实例
            // outer.getInnerBean().doSomething();
            // 若 innerBean 是单例，所有 outer 实例共享同一个 innerBean
            // 当 outer 是原型时，这会导致状态污染
            // 说白了就是强制将内部 Bean 的作用域设置为与容器 Bean 相同
            if (containingBd != null && !containingBd.isSingleton() && mbd.isSingleton()) {
                mbd.setScope(containingBd.getScope());
            }

            // Cache the merged bean definition for the time being
            // (it might still get re-merged later on in order to pick up metadata changes)
            if (containingBd == null && isCacheBeanMetadata()) {
                // 放入缓存中
                this.mergedBeanDefinitions.put(beanName, mbd);
            }
        }

        return mbd;
    }
}

getDependsOn方法

对应代码段：

// AbstractBeanFactory#doGetBean(...) 方法
// <8> 获取当前正在创建的 Bean 所依赖对象集合（`depends-on` 配置的依赖）
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
    for (String dep : dependsOn) {
        // <8.1> 检测是否存在循环依赖，存在则抛出异常
        if (isDependent(beanName, dep)) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                    "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
        }
        // <8.2> 将 `beanName` 与 `dep` 之间依赖的关系进行缓存
        registerDependentBean(dep, beanName);
        try {
            // <8.3> 先创建好依赖的 Bean（重新调用 `getBean(...)` 方法）
            getBean(dep);
        }
        catch (NoSuchBeanDefinitionException ex) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                    "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
        }
    }
}

isDependent 方法

DefaultSingletonBeanRegistry.java
protected boolean isDependent(String beanName, String dependentBeanName) {
    synchronized (this.dependentBeanMap) {
        return isDependent(beanName, dependentBeanName, null);
    }
}

private boolean isDependent(String beanName, String dependentBeanName, @Nullable Set<String> alreadySeen) {
    // 若当前 Bean（beanName）已被记录在 alreadySeen 集合中，直接返回 false，避免无限递归。
    if (alreadySeen != null && alreadySeen.contains(beanName)) {
        return false;
    }
    // <2> 获取最终的 `beanName`，因为可能是别名，需要进行相关处理
    String canonicalName = canonicalName(beanName);
    // <3> 从 dependentBeanMap（存储 Bean 的依赖关系）中获取所有直接依赖当前 Bean的其他 Bean（dependentBeans）。
    Set<String> dependentBeans = this.dependentBeanMap.get(canonicalName);
    // <4> 若当前 Bean 没有被其他 Bean 依赖（dependentBeans为空），返回 false，无循环依赖。
    if (dependentBeans == null) {
        return false;
    }
    // <5> 若 dependentBeans 包含目标 Bean（dependentBeanName），说明二者直接相互依赖，返回 true。
    if (dependentBeans.contains(dependentBeanName)) {
        // `beanName` 与 `dependentBeanName` 相互依赖
        return true;
    }
    // <6> 遍历所有直接依赖当前 Bean 的其他 Bean，递归检查它们是否间接依赖目标 Bean。
    // 通过 alreadySeen 记录已检测的 Bean，防止环路。
    for (String transitiveDependency : dependentBeans) {
        if (alreadySeen == null) {
            alreadySeen = new HashSet<>();
        }
        alreadySeen.add(beanName);
        if (isDependent(transitiveDependency, dependentBeanName, alreadySeen)) {
            return true;
        }
    }
    return false;
}

主要存在两种依赖场景：

• ​直接循环依赖
  Bean A 依赖 Bean B，Bean B 也依赖 Bean A。当检测 A 是否依赖 B 时，发现 B 直接依赖 A（步骤5），返回 true。
• ​间接循环依赖
  Bean A → Bean B → Bean C → Bean A。检测 A 是否依赖 C 时，递归发现 B 依赖 C，C 又依赖 A（步骤6），返回 true。

registerDependentBean 方法

DefaultSingletonBeanRegistry.java
public void registerDependentBean(String beanName, String dependentBeanName) {
    String canonicalName = canonicalName(beanName);

    // 对应关系：beanName -> 依赖 beanName 的集合
    synchronized (this.dependentBeanMap) {
        Set<String> dependentBeans = this.dependentBeanMap.computeIfAbsent(canonicalName, 
                                                                           k -> new LinkedHashSet<>(8));
        if (!dependentBeans.add(dependentBeanName)) {
            return;
        }
    }

    // 对应关系：beanName - > beanName 的依赖的集合
    synchronized (this.dependenciesForBeanMap) {
        Set<String> dependenciesForBean = this.dependenciesForBeanMap.computeIfAbsent(dependentBeanName, 
                                                                                      k -> new LinkedHashSet<>(8));
        dependenciesForBean.add(canonicalName);
    }
}

应用场景

1. ​循环依赖检测
   通过dependentBeanMap递归检查依赖链，判断是否存在环路（如isDependent方法）。
2. ​依赖注入
   当创建 Bean A 时，通过dependenciesForBeanMap找到其依赖的 Bean B，确保 B 已初始化。
3. ​Bean 销毁
   当销毁 Bean B 时，通过dependentBeanMap找到依赖它的 Bean A，级联销毁以避免悬空引用。

isSingleton方法

Spring 的作用域划分为三种：单例模式、原型模式、其他模式，会依次进行判断，然后进行创建，创建过程都是一样的，主要是存储范围不一样

• 单例模式：一个 BeanFactory 有且仅有一个实例
• 原型模式：每次依赖查找和依赖注入生成新 Bean 对象
• 其他模式，例如request作用域会将 Bean 存储在ServletRequest上下文中；session作用域会将 Bean 存储在HttpSession中；application作用域会将 Bean 存储在ServletContext中

对应代码段：

// AbstractBeanFactory#doGetBean(...) 方法
if (mbd.isSingleton()) { // <9.1> 单例模式
    /*
     * <9.1.1> 创建 Bean，成功创建则进行缓存，并移除缓存的早期对象
     * 创建过程实际调用的下面这个 `createBean(...)` 方法
     */
    sharedInstance = getSingleton(beanName,
            // ObjectFactory 实现类
            () -> {
                try {
                    // **【核心】** 创建 Bean
                    return createBean(beanName, mbd, args);
                } catch (BeansException ex) {
                    // 如果创建过程出现异常，则显式地从缓存中删除当前 Bean 相关信息
                    // 在单例模式下为了解决循环依赖，创建过程会缓存早期对象，这里需要进行删除
                    destroySingleton(beanName);
                    throw ex;
                }
    });
    // <9.1.2> 获取 Bean 的目标对象，`scopedInstance` 非 FactoryBean 类型直接返回
    // 否则，调用 FactoryBean#getObject() 获取目标对象
    bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}

getSingleton 方法

DefaultSingletonBeanRegistry#getSingleton(String beanName, ObjectFactory<?> singletonFactory)方法，单例模式下获取单例 Bean，如下：

// DefaultSingletonBeanRegistry.java
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
    Assert.notNull(beanName, "Bean name must not be null");
    // 全局加锁
    synchronized (this.singletonObjects) {
        // <1> 从 `singletonObjects` 单例 Bean 的缓存中获取 Bean（再检查一遍），存在则直接返回，否则开始创建
        Object singletonObject = this.singletonObjects.get(beanName);
        if (singletonObject == null) {
            if (this.singletonsCurrentlyInDestruction) {
                throw new BeanCreationNotAllowedException(beanName,
                        "Singleton bean creation not allowed while singletons of this factory are in destruction " +
                        "(Do not request a bean from a BeanFactory in a destroy method implementation!)");
            }
            if (logger.isDebugEnabled()) {
                logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
            }
            // <2> 将 `beanName` 标记为单例模式正在创建
            beforeSingletonCreation(beanName);
            boolean newSingleton = false;
            boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
            if (recordSuppressedExceptions) {
                this.suppressedExceptions = new LinkedHashSet<>();
            }
            try {
                /**
                 * <3> 创建 Bean，实际调用 
                 * {@link AbstractAutowireCapableBeanFactory#createBean(String, RootBeanDefinition, Object[])} 方法
                 */
                singletonObject = singletonFactory.getObject();
                newSingleton = true;
            }
            catch (IllegalStateException ex) {
                // Has the singleton object implicitly appeared in the meantime ->
                // if yes, proceed with it since the exception indicates that state.
                singletonObject = this.singletonObjects.get(beanName);
                if (singletonObject == null) {
                    throw ex;
                }
            }
            catch (BeanCreationException ex) {
                if (recordSuppressedExceptions) {
                    for (Exception suppressedException : this.suppressedExceptions) {
                        ex.addRelatedCause(suppressedException);
                    }
                }
                throw ex;
            }
            finally {
                if (recordSuppressedExceptions) {
                    this.suppressedExceptions = null;
                }
                // <4> 将 `beanName` 标记为不在创建中，照应第 `2` 步
                afterSingletonCreation(beanName);
            }
            // <5> 如果这里是新创建的单例模式 Bean，则在 `singletonObjects` 中进行缓存（无序），移除缓存的早期对象
            // 并在 `registeredSingletons` 中保存 `beanName`，保证注册顺序
            if (newSingleton) {
                addSingleton(beanName, singletonObject);
            }
        }
        return singletonObject;
    }
}

createBean 方法
AbstractAutowireCapableBeanFactory#createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) 方法，创建 Bean，整个过程大致如下：

1. Bean 的实例化
2. 属性赋值（包括依赖注入）
3. Aware 接口回调
4. 调用初始化方法

具体实现逻辑参考源码解析
AbstractAutowireCapableBeanFactory

isPrototype方法

对应代码段：

// AbstractBeanFactory.java
// <9.2> 原型模式
else if (mbd.isPrototype()) {
    // It's a prototype -> create a new instance.
    Object prototypeInstance = null;
    try {
        // <9.2.1> 将 `beanName` 标记为**非单例模式**正在创建
        beforePrototypeCreation(beanName);
        // <9.2.2> **【核心】** 创建 Bean
        prototypeInstance = createBean(beanName, mbd, args);
    }
    finally {
        // <9.2.3> 将 `beanName` 标记为不在创建中，照应第 `9.2.1` 步
        afterPrototypeCreation(beanName);
    }
    // <9.2.4> 获取 Bean 的目标对象，`scopedInstance` 非 FactoryBean 类型直接返回
    // 否则，调用 FactoryBean#getObject() 获取目标对象
    bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}

其他模式方法

对应代码段：

// AbstractBeanFactory.java
// <9.3> 其他模式
else {
    // <9.3.1> 获取该模式的 Scope 对象 `scope`，不存在则抛出异常
    String scopeName = mbd.getScope();
    final Scope scope = this.scopes.get(scopeName);
    if (scope == null) {
        throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
    }
    try {
        // <9.3.2> 从 `scope` 中获取 `beanName` 对应的对象（看你的具体实现），不存在则执行**原型模式**的四个步骤进行创建
        Object scopedInstance = scope.get(beanName, () -> {
            // 将 `beanName` 标记为**非单例模式**式正在创建
            beforePrototypeCreation(beanName);
            try {
                // **【核心】** 创建 Bean
                return createBean(beanName, mbd, args);
            }
            finally {
                // 将 `beanName` 标记为不在创建中，照应上一步
                afterPrototypeCreation(beanName);
            }
        });
        // 获取 Bean 的目标对象，`scopedInstance` 非 FactoryBean 类型直接返回
        // 否则，调用 FactoryBean#getObject() 获取目标对象
        bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
    }
    catch (IllegalStateException ex) {
        throw new BeanCreationException(beanName,
                "Scope '" + scopeName + "' is not active for the current thread; consider " +
                "defining a scoped proxy for this bean if you intend to refer to it from a singleton",
                ex);
    }
}

requiredType

对应代码段：

// AbstractBeanFactory#doGetBean(...) 方法
// <10> 如果入参 `requiredType` 不为空，并且 Bean 不是该类型，则需要进行类型转换
if (requiredType != null && !requiredType.isInstance(bean)) {
    try {
        // <10.1> 通过类型转换机制，将 Bean 转换成 `requiredType` 类型
        T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
        // <10.2> 转换后的 Bean 为空则抛出异常
        if (convertedBean == null) {
            throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
        }
        // <10.3> 返回类型转换后的 Bean 对象
        return convertedBean;
    }
    catch (TypeMismatchException ex) {
        if (logger.isTraceEnabled()) {
            logger.trace("Failed to convert bean '" + name + "' to required type '" +
                    ClassUtils.getQualifiedName(requiredType) + "'", ex);
        }
        throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
    }
}