SpringBoot源码系列文章
SpringBoot源码解析(一)：SpringApplication构造方法
SpringBoot源码解析(二)：引导上下文DefaultBootstrapContext
SpringBoot源码解析(三)：启动开始阶段
SpringBoot源码解析(四)：解析应用参数args
SpringBoot源码解析(五)：准备应用环境
SpringBoot源码解析(六)：打印Banner
SpringBoot源码解析(七)：应用上下文结构体系
SpringBoot源码解析(八)：Bean工厂接口体系
目录
- 前言
- 一、DefaultListableBeanFactory类图
- 二、DefaultListableBeanFactory组件功能解析
- 1、BeanFactory（Bean管理核心接口）
- 2、HierarchicalBeanFactory（支持父子容器）
- 3、ListableBeanFactory（批量获取Bean）
- 4、AutowireCapableBeanFactory（自动装配Bean工厂）
- 5、SingletonBeanRegistry（单例bean的注册与管理）
- 6、ConfigurableBeanFactory（可配置的Bean工厂）
- 7、ConfigurableListableBeanFactory（可配置可列举Bean工厂）
- 8、SimpleAliasRegistry（简单别名注册）
- 9、DefaultSingletonBeanRegistry（默认单例Bean注册）
- 10、FactoryBeanRegistrySupport（FactoryBean注册支持类）
- 11、AbstractBeanFactory（抽象Bean工厂）
- 12、AbstractAutowireCapableBeanFactory（抽象自动装配Bean工厂）
- 13、BeanDefinitionRegistry（Bean定义注册）
- 14、DefaultListableBeanFactory（默认可列举Bean工厂）
- 总结
前言
在前文中，我们详细概述了SpringBoot架构中应用上下文结构体系的各个组件。其中，通用应用上下文（GenericApplicationContext）通过创建 DefaultListableBeanFactory，负责注册、管理和创建Bean定义，同时支持依赖注入和动态Bean管理。DefaultListableBeanFactory结构相对复杂，接下来我们将对其组件逐一进行介绍。
一、DefaultListableBeanFactory类图
二、DefaultListableBeanFactory组件功能解析
1、BeanFactory（Bean管理核心接口）
BeanFactory是Spring框架中最基础的IOC（Inversion of Control，控制反转）容器接口，它负责创建、管理和配置应用中的Bean（对象），并处理Bean的依赖注入与生命周期管理。BeanFactory支持延迟加载（懒加载），即在首次请求时才实例化Bean，适用于轻量级应用或资源受限的环境。
public interface BeanFactory {
// bean名称前加&，返回的FactoryBean工厂实例，否则返回实际创建类型实例
String FACTORY_BEAN_PREFIX = "&";
// 根据指定的名称获取Bean实例
// 返回的实例可能是单例模式下的共享实例，也可能是每次请求都会创建的新实例，具体取决于 Bean 的配置
// 如果容器中不存在该名称的 Bean，则会抛出异常
Object getBean(String name) throws BeansException;
// 根据指定的名称和类型获取Bean实例
// 如果名称对应的 Bean 类型与指定的类型不匹配，则会抛出异常
<T> T getBean(String name, Class<T> requiredType) throws BeansException;
// 根据指定的名称和参数获取Bean实例
Object getBean(String name, Object... args) throws BeansException;
// 根据指定的类型获取唯一匹配的Bean实例
// 如果容器中不存在该类型的 Bean，或者存在多个该类型的 Bean，则会抛出异常
<T> T getBean(Class<T> requiredType) throws BeansException;
// 根据指定的类型和参数获取Bean实例
<T> T getBean(Class<T> requiredType, Object... args) throws BeansException;
// 返回一个可以提供指定类型Bean的ObjectProvider对象
// ObjectProvider不会立即实例化Bean，只有在调用其方法时才会加载或创建Bean
<T> ObjectProvider<T> getBeanProvider(Class<T> requiredType);
// 通过ResolvableType，可以获取复杂类型或泛型Bean
// 可以定义复杂的泛型结构，如 List<MyBean>、Map<String, MyBean> 等
<T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType);
// 检查容器中是否存在指定名称的 Bean
boolean containsBean(String name);
// 检查指定名称的Bean是否为单例（一个类只能有一个实例）
boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
// 检查指定名称的Bean是否为原型（每次获取返回一个新实例）
boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
// 检查指定名称的Bean是否匹配某个ResolvableType
// 例如，检查一个Bean是否是List<String>类型
boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;
// 检查指定名称的Bean是否匹配某个Class类型
// 这是基础的类型匹配检查，不支持泛型，但速度更快
boolean isTypeMatch(String name, Class<?> typeToMatch) throws NoSuchBeanDefinitionException;
// 返回Bean的Class类型（不考虑FactoryBean情况）
@Nullable
Class<?> getType(String name) throws NoSuchBeanDefinitionException;
// 返回Bean的Class类型
// allowFactoryBeanInit=true,初始化FactoryBean返回实际类型
@Nullable
Class<?> getType(String name, boolean allowFactoryBeanInit) throws NoSuchBeanDefinitionException;
// 获取Bean的所有别名
String[] getAliases(String name);
}
2、HierarchicalBeanFactory（支持父子容器）
HierarchicalBeanFactory是Spring框架中定义的一个接口，它扩展了BeanFactory，用于支持Bean工厂的层次化结构管理。它的设计目的是允许一个Bean工厂拥有父级Bean工厂，并能够在当前Bean工厂和父级工厂之间协调Bean的管理和查找。
public interface HierarchicalBeanFactory extends BeanFactory {
// 返回父级Bean工厂，如果没有父级，则返回null
@Nullable
BeanFactory getParentBeanFactory();
// 判断本地 Bean 工厂是否包含指定名称的 Bean，忽略父级上下文中定义的 Bean
boolean containsLocalBean(String name);
}
3、ListableBeanFactory（批量获取Bean）
ListableBeanFactory是Spring框架中的一个接口，它扩展了BeanFactory，提供了按照类型、名称等多种方式列出Bean的功能。它是Spring应用上下文中一个核心接口，用于管理和访问Bean。
// "只考虑当前工厂"：检查范围限定为当前工厂的直接定义部分
// "不考虑层次结构"：不会递归查询父工厂或祖先工厂中的定义
public interface ListableBeanFactory extends BeanFactory {
// 检查此 Bean 工厂是否包含具有给定名称的 Bean 定义
boolean containsBeanDefinition(String beanName);
// 返回工厂中定义的 Bean 数量
int getBeanDefinitionCount();
// 返回此工厂中定义的所有 Bean 的名称
String[] getBeanDefinitionNames();
// 返回一个可以提供指定类型Bean的ObjectProvider对象，可选择是否延迟初始化
<T> ObjectProvider<T> getBeanProvider(Class<T> requiredType, boolean allowEagerInit);
// 返回一个可以提供复杂指定类型Bean的ObjectProvider对象，可选择是否延迟初始化
<T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType, boolean allowEagerInit);
// 返回与给定类型（包括给定类型子类）匹配的 Bean 名称
String[] getBeanNamesForType(ResolvableType type);
// 返回与给定复杂类型（包括给定子类）匹配的 Bean 名称
// 并允许对非单例 Bean 和延迟加载 Bean 进行控制
String[] getBeanNamesForType(ResolvableType type, boolean includeNonSingletons, boolean allowEagerInit);
// 返回与给定类型（包括子类）匹配的 Bean 名称
String[] getBeanNamesForType(@Nullable Class<?> type);
// 返回与给定类型（包括子类）匹配的 Bean 名称
// 并允许对非单例 Bean 和延迟加载 Bean 进行控制
String[] getBeanNamesForType(@Nullable Class<?> type, boolean includeNonSingletons, boolean allowEagerInit);
// 返回一个 Map，包含匹配的 Bean 名称和对应的 Bean 实例
<T> Map<String, T> getBeansOfType(@Nullable Class<T> type) throws BeansException;
// 返回一个 Map，包含匹配的 Bean 名称和对应的 Bean 实例
// 并允许对非单例 Bean 和延迟加载 Bean 进行控制
<T> Map<String, T> getBeansOfType(@Nullable Class<T> type, boolean includeNonSingletons, boolean allowEagerInit)
throws BeansException;
// 查找带有指定注解的所有 Bean 名称
String[] getBeanNamesForAnnotation(Class<? extends Annotation> annotationType);
// 一个 Map，包含匹配的 Bean 名称和对应带指定注解的Bean实例
Map<String, Object> getBeansWithAnnotation(Class<? extends Annotation> annotationType) throws BeansException;
// 用于查找指定 Bean 上的特定类型注解，并返回该注解的实例
@Nullable
<A extends Annotation> A findAnnotationOnBean(String beanName, Class<A> annotationType)
throws NoSuchBeanDefinitionException;
// 用于查找指定 Bean 上的特定注解，并提供一个参数来控制是否允许初始化 FactoryBean
@Nullable
<A extends Annotation> A findAnnotationOnBean(
String beanName, Class<A> annotationType, boolean allowFactoryBeanInit)
throws NoSuchBeanDefinitionException;
}
4、AutowireCapableBeanFactory（自动装配Bean工厂）
AutowireCapableBeanFactory用于在Spring容器外手动管理和操作bean，包括实例化、依赖注入、初始化以及应用BeanPostProcessor等功能。
public interface AutowireCapableBeanFactory extends BeanFactory {
// 不进行自动装配
int AUTOWIRE_NO = 0;
// 根据属性名称自动装配
int AUTOWIRE_BY_NAME = 1;
// 根据属性类型自动装配
int AUTOWIRE_BY_TYPE = 2;
// 通过构造函数自动装配
int AUTOWIRE_CONSTRUCTOR = 3;
// 是一个后缀，用于获取Bean的原始实例（未被代理或增强的版本）
String ORIGINAL_INSTANCE_SUFFIX = ".ORIGINAL";
// 用于根据指定的 beanClass 创建一个新的 Bean 实例
<T> T createBean(Class<T> beanClass) throws BeansException;
// 用于对已存在对象（非由 Spring 容器创建的对象）执行自动装配@Autowired等
// 但不会将该对象纳入Spring容器管理
void autowireBean(Object existingBean) throws BeansException;
// 用于对已存在对象（非由 Spring 容器创建的对象）纳入Spring容器的管理中，beanName就是其名称
// 应用 Spring 的依赖注入、生命周期回调以及其他配置
Object configureBean(Object existingBean, String beanName) throws BeansException;
// 使用指定的自动装配策略创建一个新的Bean实例
// autowireMode：自动装配类型，上面的常量，不自动装配、根据名称类型、构造函数
// dependencyCheck：是否进行依赖检查，否验证所有必需的依赖是否已被正确注入
Object createBean(Class<?> beanClass, int autowireMode, boolean dependencyCheck) throws BeansException;
// 为某个spring管理的Bean自动装配
Object autowire(Class<?> beanClass, int autowireMode, boolean dependencyCheck) throws BeansException;
// 与上面说到的autowireBean方法一样
// 对已存在对象（非由 Spring 容器创建的对象）执行自动装配,只是添加一些策略
void autowireBeanProperties(Object existingBean, int autowireMode, boolean dependencyCheck)
throws BeansException;
// 应用Bean定义中的属性值到指定的 Bean 实例
void applyBeanPropertyValues(Object existingBean, String beanName) throws BeansException;
// 对已实例化和属性填充完成的bean执行初始化操作
// 包括调用生命周期回调方法和应用BeanPostProcessor的前后处理逻辑
Object initializeBean(Object existingBean, String beanName) throws BeansException;
// 初始化bean之前，调用所有注册的BeanPostProcessor的postProcessBeforeInitialization方法
// 以便对 bean 进行自定义自定义的增强或修改
Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
throws BeansException;
// 初始化bean之前，调用所有注册的BeanPostProcessor的postProcessAfterInitialization方法
// 用于在 bean 完成初始化后对其进行进一步的处理或增强
Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
throws BeansException;
// 销毁指定的 Bean 实例
void destroyBean(Object existingBean);
// 根据指定类型查找对应的bean，并返回一个bean实例和bean名称捆绑对象NamedBeanHolder
// 如果容器中有多个同类型的 bean，可以返回一个符合类型的bean和其名称
<T> NamedBeanHolder<T> resolveNamedBean(Class<T> requiredType) throws BeansException;
// 根据给定的bean名称和依赖描述符 查找并返回匹配的bean实例
// DependencyDescriptor：封装了关于依赖的元数据，如依赖的类型、作用域等
Object resolveBeanByName(String name, DependencyDescriptor descriptor) throws BeansException;
// 主要用于根据依赖描述符查找bean实例，名称可选
@Nullable
Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName) throws BeansException;
// 用于根据依赖描述符、请求bean名称、自动装配bean名称集合和类型转换器解析查询Bean实例
@Nullable
Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,
@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException;
}
5、SingletonBeanRegistry（单例bean的注册与管理）
SingletonBeanRegistry是Spring提供的一个接口，用于定义单例Bean的注册、获取、判断是否存在、获取单例名称等功能。
// 接口定义了一个共享单例bean的缓存。以统一的方式公开其单例管理功能
public interface SingletonBeanRegistry {
// 将指定的单例对象以给定的 Bean 名称注册到 Spring 容器的单例缓存中
void registerSingleton(String beanName, Object singletonObject);
// 根据给定的名称返回（原始的）已注册的单例对象
@Nullable
Object getSingleton(String beanName);
// 用于检查Spring容器中是否已注册了具有指定名称的单例对象
boolean containsSingleton(String beanName);
// 返回当前已注册的所有单例Bean名称的数组
String[] getSingletonNames();
// 返回当前容器中已注册的单例对象的数量
int getSingletonCount();
// 主要作用是提供一个全局的同步锁对象
// 用于确保在多线程环境中对单例对象的注册和访问操作是线程安全的
Object getSingletonMutex();
}
6、ConfigurableBeanFactory（可配置的Bean工厂）
ConfigurableBeanFactory是Spring中定义的一个可配置的Bean工厂接口，提供了对Bean定义的管理、生命周期控制、作用域注册和依赖关系处理的扩展功能。
// 用于大多数 Bean 工厂实现的配置接口。提供了额外的功能来配置 Bean 工厂
public interface ConfigurableBeanFactory extends HierarchicalBeanFactory, SingletonBeanRegistry {
// ==================== Scope 标识符 ====================
// 标准单例作用域的标识符
String SCOPE_SINGLETON = "singleton";
// 标准原型作用域的标识符
String SCOPE_PROTOTYPE = "prototype";
// ==================== 父工厂设置与获取 ====================
// 设置该 Bean 工厂的父工厂
void setParentBeanFactory(BeanFactory parentBeanFactory) throws IllegalStateException;
// 省略类加载器相关、Bean元数据缓存、表达式与转换、属性编辑器与类型转换、嵌入值解析...
// ==================== Bean 后置处理器 ====================
// 添加一个 BeanPostProcessor
void addBeanPostProcessor(BeanPostProcessor beanPostProcessor);
// 返回当前注册的 BeanPostProcessor 的数量
int getBeanPostProcessorCount();
// 省略自定义作用域...
// ==================== 工厂配置复制 ====================
// 从另一个 ConfigurableBeanFactory 中复制所有相关的配置设置到当前工厂
// 简化工厂的配置管理，支持配置共享和继承
void copyConfigurationFrom(ConfigurableBeanFactory otherFactory);
// ==================== Bean 别名相关 ====================
// 为指定的 Bean 注册别名
void registerAlias(String beanName, String alias) throws BeanDefinitionStoreException;
// 通过指定的解析器，解析并动态修改工厂中定义的别名
void resolveAliases(StringValueResolver valueResolver);
// ==================== 合并 Bean 定义 ====================
// 返回指定 beanName 的合并后 BeanDefinition
// 即父子结构中，将父BeanDefinition的属性与子BeanDefinition合并后的结果
BeanDefinition getMergedBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
// ==================== FactoryBean 检查 ====================
// 判断指定名称的 Bean 是否为 FactoryBean
boolean isFactoryBean(String name) throws NoSuchBeanDefinitionException;
// ==================== Bean 创建状态 ====================
// 显式设置指定 Bean 的当前创建状态
void setCurrentlyInCreation(String beanName, boolean inCreation);
// 检查指定 Bean 是否正在创建中
boolean isCurrentlyInCreation(String beanName);
// ==================== Bean 依赖管理 ====================
// 注册一个依赖关系，表明 dependentBeanName 依赖于 beanName
// 用于跟踪 Bean 之间的依赖关系，以便在销毁 beanName 时正确销毁其依赖的 Bean
void registerDependentBean(String beanName, String dependentBeanName);
// 返回所有依赖于指定 beanName 的 Bean 名称数组
String[] getDependentBeans(String beanName);
// 返回指定 beanName 所依赖的所有 Bean 名称数组
String[] getDependenciesForBean(String beanName);
// ==================== Bean 销毁 ====================
// 销毁指定的 Bean 实例
void destroyBean(String beanName, Object beanInstance);
// 销毁当前作用域中的指定 Scoped Bean
void destroyScopedBean(String beanName);
// 销毁工厂中所有的单例 Bean
void destroySingletons();
}
7、ConfigurableListableBeanFactory（可配置可列举Bean工厂）
ConfigurableListableBeanFactory是Spring中一个可配置且可列举的BeanFactory，提供对Bean定义的详细管理、修改以及单例Bean的预实例化功能。
// 在ConfigurableBeanFactory的基础上，提供了分析和修改 Bean 定义、以及预实例化单例 Bean 的功能
public interface ConfigurableListableBeanFactory
extends ListableBeanFactory, AutowireCapableBeanFactory, ConfigurableBeanFactory {
// 用于告诉依赖注入框架忽略指定类型，不对其进行自动注入解析
void ignoreDependencyType(Class<?> type);
// 用于告诉框架忽略某个接口类型的依赖注入
void ignoreDependencyInterface(Class<?> ifc);
// 注册一个依赖类型及其对应值，供自动注入时使用
void registerResolvableDependency(Class<?> dependencyType, @Nullable Object autowiredValue);
// 用于检查指定的 Bean 是否可以作为依赖注入的候选项，根据 Bean 的定义及依赖描述来确定
boolean isAutowireCandidate(String beanName, DependencyDescriptor descriptor)
throws NoSuchBeanDefinitionException;
// 返回指定 Bean 的定义对象 (BeanDefinition)，用于描述和管理 Bean 的配置信息
BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
// 返回一个迭代器，用于遍历所有已注册的 Bean 名称
Iterator<String> getBeanNamesIterator();
// 清空 Bean 元数据的缓存，通常用于调试或强制刷新配置状态
void clearMetadataCache();
// 冻结所有 Bean 定义，表明注册的 Bean 定义不再会被修改或后处理
void freezeConfiguration();
// 判断此工厂的 Bean 定义是否已冻结
boolean isConfigurationFrozen();
// 提前实例化所有定义为单例作用域的 Bean，以确保它们在容器启动时被创建并初始化
void preInstantiateSingletons() throws BeansException;
}
8、SimpleAliasRegistry（简单别名注册）
SimpleAliasRegistry是Spring框架中用于注册、管理和解析别名（alias）映射的简单工具类，提供别名的增删查功能并防止循环引用。
public class SimpleAliasRegistry implements AliasRegistry {
// Key：存储别名，Value：存储别名对应的实际名称
private final Map<String, String> aliasMap = new ConcurrentHashMap<>(16);
// ... 省略AliasRegistry接口的全部功能的实现方法
}
// 管理别名的通用接口（提供了注册、删除、查询别名的方法）
public interface AliasRegistry {
// 为给定的名称注册一个别名
void registerAlias(String name, String alias);
// 从注册表中删除指定的别名
void removeAlias(String alias);
// 确定给定的名称是否被定义为别名（而不是实际注册的组件名称）
boolean isAlias(String name);
// 返回给定名称的所有别名（如果定义了别名）
String[] getAliases(String name);
}
9、DefaultSingletonBeanRegistry（默认单例Bean注册）
DefaultSingletonBeanRegistry是Spring中用于管理单例Bean的基础类，支持单例Bean的注册、缓存、销毁及循环依赖处理，同时继承SimpleAliasRegistry以支持别名管理。
public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
// ==================== 核心属性 ====================
// 一级缓存：存储已经完成初始化的单例Bean（是单例 Bean 的主缓存）
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
// 二级缓存：存储早期暴露的单例对象，这些对象可能尚未完全初始化（用于解决循环依赖问题）
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);
// 三级缓存：存储创建单例对象的工厂，这些工厂可以在需要时生成对应的单例对象（延迟加载机制，将单例对象的创建延后到需要时再执行）
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
// 存储所有已经注册为单例的 Bean 名称
private final Set<String> registeredSingletons = new LinkedHashSet<>(256);
// ==================== 核心方法 ====================
// 注册单例对象
@Override
public void registerSingleton(String beanName, Object singletonObject) throws IllegalStateException {
...
}
// 获取单例对象
@Override
@Nullable
public Object getSingleton(String beanName) {
...
}
// 销毁指定名称的单例 Bean
public void destroySingleton(String beanName) {
...
}
}
10、FactoryBeanRegistrySupport（FactoryBean注册支持类）
FactoryBeanRegistrySupport是Spring容器中用于支持FactoryBean实例管理的基类，负责从FactoryBean获取对象、处理单例缓存以及提供扩展后的后处理能力。
public abstract class FactoryBeanRegistrySupport extends DefaultSingletonBeanRegistry {
// 缓存由 FactoryBean 创建的单例对象，映射为：FactoryBean名称 -> 对象
private final Map<String, Object> factoryBeanObjectCache = new ConcurrentHashMap<>(16);
// ==================== 核心方法 ====================
// 确定给定 FactoryBean 的类型
@Nullable
protected Class<?> getTypeForFactoryBean(FactoryBean<?> factoryBean) {
...
}
// 获取由给定 FactoryBean 创建的对象
protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
...
}
// 这是一个模板方法，默认实现直接返回从 FactoryBean 中获取的对象
// 子类可以通过重写这个方法，对获取到的对象进行自定义后处理(添加代理、应用额外的拦截器、动态修改对象的属性等)
protected Object postProcessObjectFromFactoryBean(Object object, String beanName) throws BeansException {
return object;
}
}
11、AbstractBeanFactory（抽象Bean工厂）
AbstractBeanFactory是Spring框架中BeanFactory接口的抽象实现，负责提供Bean的基础获取和管理功能，但不包含具体的Bean创建逻辑。
public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {
// 表示当前 BeanFactory 的父工厂（支持层级结构）,用于递归地从父工厂中查找 Bean
@Nullable
private BeanFactory parentBeanFactory;
// ==================== 核心方法 ====================
// 通过名称获取 Bean 的主入口，内部调用 doGetBean 方法
@Override
public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);
}
// 按类型获取 Bean，并进行类型检查
@Override
public <T> T getBean(String name, Class<T> requiredType) throws BeansException {
return doGetBean(name, requiredType, null, false);
}
// 核心实现方法(1.别名解析 2.缓存检查：先从单例缓存中获取 3.创建对象 4.依赖处理：递归解决依赖 Bean)
protected <T> T doGetBean(
String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
throws BeansException {
...
}
// 创建Bean的抽象方法，具体的实例化逻辑由子类
protected abstract Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException;
}
12、AbstractAutowireCapableBeanFactory（抽象自动装配Bean工厂）
AbstractAutowireCapableBeanFactory是Spring框架中AbstractBeanFactory的具体实现类，负责处理Bean的创建、属性注入和自动装配逻辑，提供Spring容器中Bean管理的核心功能。
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
implements AutowireCapableBeanFactory {
// 存储所有注册的 BeanPostProcessor，用于在 bean 初始化前后进行自定义逻辑处理
private final List<BeanPostProcessor> beanPostProcessors = new BeanPostProcessorCacheAwareList();
// ==================== 核心方法 ====================
// 创建一个完整的 bean 实例，处理了整个生命周期，包括依赖注入、初始化以及后处理
@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
...
}
// 内部调用，用于创建 bean 实例的核心方法，负责实例化、依赖注入和初始化
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
...
}
// 通过无参构造器实例化 bean
protected BeanWrapper instantiateBean(String beanName, RootBeanDefinition mbd) {
...
}
// 解析依赖关系，找到依赖的目标 bean
@Override
@Nullable
public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,
@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
...
}
// 填充 bean 的属性，支持自动装配
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
...
}
// 完成 bean 的初始化工作，调用 BeanPostProcessor 和初始化回调方法
protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
...
}
}
13、BeanDefinitionRegistry（Bean定义注册）
BeanDefinitionRegistry是Spring容器中管理和操作 BeanDefinition 的核心接口，提供动态注册、删除和查询Bean定义的方法。
public interface BeanDefinitionRegistry extends AliasRegistry {
// 注册一个新的 BeanDefinition 到当前注册表中。
// 必须支持 RootBeanDefinition 和 ChildBeanDefinition。
void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
throws BeanDefinitionStoreException;
// 根据给定的名称移除对应的 BeanDefinition
void removeBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
// 返回给定名称对应的 BeanDefinition
BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
// 检查注册表中是否包含给定名称的 BeanDefinition
boolean containsBeanDefinition(String beanName);
// 返回当前注册表中定义的所有 Bean 的名称
String[] getBeanDefinitionNames();
// 返回当前注册表中定义的 Bean 总数
int getBeanDefinitionCount();
// 判断给定的 bean 名称是否已被使用（包括本地 bean 或别名）
boolean isBeanNameInUse(String beanName);
}
14、DefaultListableBeanFactory（默认可列举Bean工厂）
DefaultListableBeanFactory是Spring框架中的一个核心类，负责管理和创建应用上下文中的所有Bean，提供了Bean定义的注册、查找和生命周期管理功能。
public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {
// ==================== 核心属性 ====================
// 存储所有注册的 BeanDefinition，键为 beanName，值为对应的 BeanDefinition
private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);
// 记录所有注册的beanName，保持注册顺序（通过配置文件、注解、或约定方式将 Bean 注册到容器中，由 Spring 自动完成）
private volatile List<String> beanDefinitionNames = new ArrayList<>(256);
// 存储手动注册的单例Bean名称（通过编程方式显式地将 Bean 注册到 Spring 容器中）
private volatile Set<String> manualSingletonNames = new LinkedHashSet<>(16);
// 存储直接可解析的依赖项（如环境变量或系统资源）
private final Map<Class<?>, Object> resolvableDependencies = new ConcurrentHashMap<>(16);
// 缓存按类型解析的所有 Bean 名称
private final Map<Class<?>, String[]> allBeanNamesByType = new ConcurrentHashMap<>(64);
// 缓存按类型解析的单例 Bean 名称
private final Map<Class<?>, String[]> singletonBeanNamesByType = new ConcurrentHashMap<>(64);
// ==================== 核心方法 ====================
// ...省略BeanDefinitionRegistry接口实现的功能
// 获取指定类型的所有 Bean 名称，可通过参数控制是否包含非单例和是否允许提前初始化
@Override
public String[] getBeanNamesForType(ResolvableType type, boolean includeNonSingletons, boolean allowEagerInit) {
...
}
// 获取指定类型的所有 Bean 实例
@Override
@SuppressWarnings("unchecked")
public <T> Map<String, T> getBeansOfType(
@Nullable Class<T> type, boolean includeNonSingletons, boolean allowEagerInit) throws BeansException {
...
}
// 获取带有指定注解的所有 Bean 名称
@Override
public String[] getBeanNamesForAnnotation(Class<? extends Annotation> annotationType) {
...
}
// 获取带有指定注解的所有 Bean 实例
@Override
public Map<String, Object> getBeansWithAnnotation(Class<? extends Annotation> annotationType) {
...
}
// 提前初始化所有非懒加载的单例 Bean
@Override
public void preInstantiateSingletons() throws BeansException {
...
}
}
总结
DefaultListableBeanFactory是Spring框架中核心的IOC容器实现，作为一个功能全面的Bean工厂，它同时实现了多个接口，集成了Bean的注册、管理、创建、检索和销毁等核心功能，支持按名称、类型、注解等多种方式获取 Bean。
它具备强大的依赖注入和自动装配能力，支持动态注册Bean定义、生命周期管理、作用域扩展，以及多级缓存（解决循环依赖），同时提供对单例和多实例Bean的高效管理，是Spring应用上下文的基础。
