BeanFactory / BeanDefinition 基础设施族
概述
Spring IoC 容器的基础设施围绕 BeanFactory 和 BeanDefinition 两大核心展开。BeanFactory 定义了容器的基本行为，BeanDefinition 承载了 Bean 的完整元数据。理解这些基础设施内部的工作机制，是深入理解 Spring IoC 的关键。
本文将深入拆解 BeanFactory / BeanDefinition 基础设施族的 10 个关键细节，涵盖接口层次结构、核心数据结构、BeanDefinition 类型体系、自动装配模式、Bean 扫描、名称生成、注册校验、单例注册、BeanPostProcessor 链等核心内容。
本文基于 Spring Framework 6.1.6 源码分析。
容器体系概览可参考 IoC 容器体系 - BeanFactory vs ApplicationContext 深度解析。
1. BeanFactory 接口层次结构
BeanFactory 及其子接口构成一个分层的继承体系，每层接口新增特定能力。
BeanFactory（顶层接口）
↓ 继承
ListableBeanFactory（可列举能力）
↓ 继承
HierarchicalBeanFactory（父子容器）
↓ 实现
ConfigurableBeanFactory（Bean 配置能力）
↓ 继承
ConfigurableListableBeanFactory（完整配置能力）
↓ 实现
DefaultListableBeanFactory（默认实现）每层新增的能力：
| 接口 | 新增方法 | 能力说明 |
|---|---|---|
BeanFactory | getBean()、isSingleton()、containsBean()、getType()、isPrototype() | 基础 IoC：按名称/类型获取 Bean，判断存在性 |
ListableBeanFactory | getBeanDefinitionNames()、getBeansOfType()、getBeansWithAnnotation() | 列举能力：遍历所有已注册的 BeanDefinition |
HierarchicalBeanFactory | getParentBeanFactory()、containsLocalBean() | 父子容器：支持容器层次结构 |
ConfigurableBeanFactory | addBeanPostProcessor()、setParentBeanFactory()、registerScope()、setConversionService() | Bean 配置：注册后置处理器、作用域、类型转换 |
ConfigurableListableBeanFactory | registerResolvableDependency()、preInstantiateSingletons() | 完整配置：预实例化单例、注册可解析依赖 |
DefaultListableBeanFactory 的继承链：
java
public class DefaultListableBeanFactory
extends AbstractAutowireCapableBeanFactory // Bean 创建和自动装配
implements ConfigurableListableBeanFactory, // 完整配置接口
BeanDefinitionRegistry, // BeanDefinition 注册
Serializable {
// 继承链：
// DefaultListableBeanFactory
// → AbstractAutowireCapableBeanFactory（Bean 创建核心）
// → AbstractBeanFactory（Bean 获取核心）
// → FactoryBeanRegistrySupport（FactoryBean 缓存）
// → DefaultSingletonBeanRegistry（单例注册表）
// → SimpleAliasRegistry（别名注册）
}核心方法在每层的归属：
| 方法 | 所属类/接口 | 说明 |
|---|---|---|
getBean() | AbstractBeanFactory | 获取 Bean 实例 |
getSingleton() | DefaultSingletonBeanRegistry | 从单例缓存获取 |
doCreateBean() | AbstractAutowireCapableBeanFactory | 创建 Bean 实例 |
populateBean() | AbstractAutowireCapableBeanFactory | 填充属性 |
initializeBean() | AbstractAutowireCapableBeanFactory | 初始化 Bean |
preInstantiateSingletons() | DefaultListableBeanFactory | 预实例化所有单例 |
2. DefaultListableBeanFactory 的 3 个核心 Map
DefaultListableBeanFactory 内部维护了 3 个核心的 ConcurrentHashMap，是 IoC 容器的数据基石。
java
public class DefaultListableBeanFactory
extends AbstractAutowireCapableBeanFactory
implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {
/** 核心 Map 1：BeanDefinition 存储（名称 → BeanDefinition） */
private final Map<String, BeanDefinition> beanDefinitionMap
= new ConcurrentHashMap<>(256);
/** 核心 Map 2：BeanDefinition 名称有序列表 */
private volatile List<String> beanDefinitionNames
= new ArrayList<>(256);
/** 核心 Map 3：手动注册的单例 Bean（非工厂创建） */
private final Map<String, Object> manuallyRegisteredSingletons
= new ConcurrentHashMap<>(16);
// 父类 DefaultSingletonBeanRegistry 中的核心 Map：
// singletonObjects → 一级缓存：完全初始化的单例 Bean
// earlySingletonObjects → 二级缓存：提前暴露的 Bean（未完全初始化）
// singletonFactories → 三级缓存：单例工厂
}3 个核心 Map 的职责：
| Map | 类型 | 说明 | 使用场景 |
|---|---|---|---|
beanDefinitionMap | ConcurrentHashMap<String, BeanDefinition> | Bean 定义缓存 | 注册/查找 BeanDefinition |
beanDefinitionNames | ArrayList<String>（配合 volatile） | 所有 Bean 名称的有序列表 | 遍历所有 Bean |
manuallyRegisteredSingletons | ConcurrentHashMap<String, Object> | 手动注册的 Bean 实例 | 通过 registerSingleton() 注册 |
getBeanDefinitionNames() 的遍历：
java
// 返回所有已注册的 BeanDefinition 名称
@Override
public String[] getBeanDefinitionNames() {
// 通过 beanDefinitionNames 的 toArray() 返回
String[] frozenNames = this.frozenBeanDefinitionNames;
if (frozenNames != null) {
return frozenNames.clone(); // 冻结模式：直接返回缓存数组
}
// 从 ArrayList 转数组返回
return StringUtils.toStringArray(this.beanDefinitionNames);
}getBeanNamesForType() 的类型查找：
java
@Override
public String[] getBeanNamesForType(ResolvableType type) {
// 遍历 beanDefinitionNames 列表
// 对每个 BeanDefinition 检查其类型是否匹配
// 支持泛型检查（通过 ResolvableType）
List<String> matches = new ArrayList<>();
for (String beanName : this.beanDefinitionNames) {
BeanDefinition bd = this.beanDefinitionMap.get(beanName);
if (bd != null && isTypeMatch(beanName, type)) {
matches.add(beanName);
}
}
return StringUtils.toStringArray(matches);
}3. BeanDefinition 的 6 种 scope
BeanDefinition 支持 6 种作用域，控制 Bean 的生命周期和可见性。
java
public interface BeanDefinition {
// 标准作用域常量
String SCOPE_SINGLETON = ConfigurableBeanFactory.SCOPE_SINGLETON; // "singleton"
String SCOPE_PROTOTYPE = ConfigurableBeanFactory.SCOPE_PROTOTYPE; // "prototype"
// 获取和设置作用域
void setScope(@Nullable String scope);
String getScope();
// 判断是否是单例/原型
boolean isSingleton();
boolean isPrototype();
}6 种作用域对比：
| 作用域 | 常量 | 生命周期 | 适用场景 |
|---|---|---|---|
singleton | SCOPE_SINGLETON | 容器启动创建，关闭时销毁 | 无状态 Service、Repository、DataSource |
prototype | SCOPE_PROTOTYPE | 每次获取创建，容器不管理销毁 | 有状态的 Model、Command 对象 |
request | — | 每次 HTTP 请求创建一个 | Web 控制器、请求上下文对象 |
session | — | 每个 HTTP Session 创建一个 | 用户会话、购物车 |
application | — | 每个 ServletContext 创建一个 | 应用级缓存、全局配置 |
websocket | — | 每个 WebSocket Session 创建一个 | WebSocket 会话状态 |
scope 的存储和解析：
java
// AbstractBeanDefinition 中的 scope 存储
public abstract class AbstractBeanDefinition implements BeanDefinition {
// scope 值（null 表示 singleton）
@Nullable
private volatile String scope = SCOPE_SINGLETON_DEFAULT; // 默认 singleton
@Override
public void setScope(@Nullable String scope) {
this.scope = scope;
}
@Override
public String getScope() {
return this.scope;
}
@Override
public boolean isSingleton() {
return SCOPE_SINGLETON.equals(this.scope) || this.scope == null;
}
@Override
public boolean isPrototype() {
return SCOPE_PROTOTYPE.equals(this.scope);
}
}自定义 scope 注册：
java
// ConfigurableBeanFactory 中注册自定义 scope
public interface ConfigurableBeanFactory {
// 注册自定义作用域
void registerScope(String scopeName, Scope scope);
}
// 自定义 scope 示例：ThreadLocalScope
public class ThreadLocalScope implements Scope {
private final ThreadLocal<Map<String, Object>> threadScope =
ThreadLocal.withInitial(HashMap::new);
@Override
public Object get(String name, ObjectFactory<?> objectFactory) {
return threadScope.get().computeIfAbsent(name, k -> objectFactory.getObject());
}
@Override
public void registerDestructionCallback(String name, Runnable callback) {
// 线程作用域无需销毁回调
}
// remove()、getConversationId() 等
}4. ScannedGenericBeanDefinition 的 @Component 扫描
ScannedGenericBeanDefinition 是组件扫描（@ComponentScan）产生的 BeanDefinition 类型。
java
// ClassPathScanningCandidateComponentProvider 扫描过程
public class ClassPathScanningCandidateComponentProvider {
public Set<BeanDefinition> findCandidateComponents(String basePackage) {
// 1. 将包名转换为 classpath 路径（com.example → classpath*:com/example/**/*.class）
String packageSearchPath = "classpath*:" +
basePackage.replace('.', '/') + "/**/*.class";
// 2. 使用资源模式解析器查找所有 .class 文件
Resource[] resources = resourcePatternResolver.getResources(packageSearchPath);
Set<BeanDefinition> candidates = new LinkedHashSet<>();
for (Resource resource : resources) {
if (resource.isReadable()) {
// 3. 使用 ASM 元数据读取器解析 .class 文件（不加载类）
MetadataReader metadataReader = metadataReaderFactory.getMetadataReader(resource);
// 4. 检查类型过滤器（@Component、@Service、@Repository 等）
if (isCandidateComponent(metadataReader)) {
// 5. 创建 ScannedGenericBeanDefinition
ScannedGenericBeanDefinition sbd =
new ScannedGenericBeanDefinition(metadataReader);
sbd.setResource(resource);
sbd.setSource(resource);
candidates.add(sbd);
}
}
}
return candidates;
}
}ScannedGenericBeanDefinition 的创建：
java
public class ScannedGenericBeanDefinition
extends GenericBeanDefinition
implements AnnotatedBeanDefinition {
private final AnnotationMetadata metadata; // ASM 解析的类元数据
public ScannedGenericBeanDefinition(MetadataReader metadataReader) {
// 从 ASM 元数据读取器构建 BeanDefinition
// 不通过 JVM 类加载，避免触发类初始化
Assert.notNull(metadataReader, "MetadataReader must not be null");
// 设置 Bean 类名（延迟加载时使用）
setBeanClassName(metadataReader.getClassMetadata().getClassName());
// 保存 ASM 元数据（用于后续 @Autowired、@Value 等注解解析）
this.metadata = metadataReader.getAnnotationMetadata();
}
}ClassPathBeanDefinitionScanner.doScan()：
java
public class ClassPathBeanDefinitionScanner {
protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
// 1. 扫描候选组件
Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
for (BeanDefinition candidate : candidates) {
// 2. 解析 scope（@Scope 注解）
ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
candidate.setScope(scopeMetadata.getScopeName());
// 3. 生成 Bean 名称（@Component("myBean") 或类名首字母小写）
String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
// 4. 设置其他默认属性（懒加载、primary、依赖等）
if (candidate instanceof AbstractBeanDefinition abd) {
postProcessBeanDefinition(abd, beanName);
}
// 5. 注册到容器
BeanDefinitionHolder holder = new BeanDefinitionHolder(candidate, beanName);
registerBeanDefinition(holder, this.registry);
}
}
}扫描流程：
@ComponentScan("com.example")
↓
ClassPathBeanDefinitionScanner.doScan()
↓
ClassPathScanningCandidateComponentProvider.findCandidateComponents()
↓
① 解析资源路径："classpath*:com/example/**/*.class"
↓
② ResourcePatternResolver 查找所有 .class 文件
↓
③ MetadataReader（ASM）解析字节码，不加载类
↓
④ TypeFilter 匹配 @Component / @Service / @Repository / @Controller
↓
⑤ 创建 ScannedGenericBeanDefinition
↓
⑥ AnnotationBeanNameGenerator 生成 Bean 名称
↓
⑦ 注册到 BeanDefinitionRegistry5. AbstractBeanDefinition.setAutowireMode() 的 4 种模式
AbstractBeanDefinition 支持 4 种自动装配模式，控制 Bean 属性的注入方式。
java
public abstract class AbstractBeanDefinition implements BeanDefinition {
public static final int AUTOWIRE_NO = 0; // 不自动装配
public static final int AUTOWIRE_BY_NAME = 1; // 按名称自动装配
public static final int AUTOWIRE_BY_TYPE = 2; // 按类型自动装配
public static final int AUTOWIRE_CONSTRUCTOR = 3; // 按构造器自动装配
// 自动装配模式（默认不自动装配）
private int autowireMode = AUTOWIRE_NO;
public void setAutowireMode(int autowireMode) {
this.autowireMode = autowireMode;
}
public int getAutowireMode() {
return this.autowireMode;
}
}4 种模式对比：
| 模式 | 常量值 | 说明 | 使用方式 |
|---|---|---|---|
AUTOWIRE_NO | 0 | 不自动装配，通过 <property> 或 @Autowired 显式指定 | 默认值 |
AUTOWIRE_BY_NAME | 1 | 按属性名匹配容器中的 Bean | XML <bean autowire="byName"> |
AUTOWIRE_BY_TYPE | 2 | 按属性类型匹配容器中的 Bean | XML <bean autowire="byType"> |
AUTOWIRE_CONSTRUCTOR | 3 | 按构造器参数类型匹配 | XML <bean autowire="constructor"> |
AbstractAutowireCapableBeanFactory 中的装配逻辑：
java
public abstract class AbstractAutowireCapableBeanFactory {
protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {
// 1. 检查 autowire 模式
if (mbd.getAutowireMode() == AbstractBeanDefinition.AUTOWIRE_BY_NAME) {
// 按名称自动装配
autowireByName(beanName, mbd, bw, newPvs);
}
if (mbd.getAutowireMode() == AbstractBeanDefinition.AUTOWIRE_BY_TYPE) {
// 按类型自动装配
autowireByType(beanName, mbd, bw, newPvs);
}
if (mbd.getAutowireMode() == AbstractBeanDefinition.AUTOWIRE_CONSTRUCTOR) {
// 构造器自动装配（在 Bean 创建时执行）
}
// 2. 应用后置处理器解析 @Autowired、@Resource、@Value 等注解
// 由 AutowiredAnnotationBeanPostProcessor 处理
}
}6. RootBeanDefinition vs ChildBeanDefinition
RootBeanDefinition 和 ChildBeanDefinition 是实现 BeanDefinition 继承关系的两种类型。
java
// RootBeanDefinition：完整的 BeanDefinition，可独立存在
public class RootBeanDefinition extends AbstractBeanDefinition {
// 目标类（可独立存在）
@Nullable
private volatile Class<?> targetType;
// Bean 的工厂方法名称（用于静态工厂方法创建）
@Nullable
private String factoryMethodName;
// 是否已注册 BeanPostProcessor
private boolean postProcessed = false;
}
// ChildBeanDefinition：继承父 BeanDefinition 的属性
public class ChildBeanDefinition extends AbstractBeanDefinition {
// 父 BeanDefinition 的名称
private final String parentName;
public ChildBeanDefinition(String parentName, BeanDefinition original) {
// 存储父 BeanDefinition 的名称
setParentName(parentName);
// 从原始 BeanDefinition 复制属性（非最终）
// 子 BeanDefinition 可以覆盖任何属性
setBeanClassName(original.getBeanClassName());
setScope(original.getScope());
setLazyInit(original.isLazyInit());
// ...
}
}XML 配置中的父子 Bean：
xml
<!-- 父 BeanDefinition：定义公共属性 -->
<bean id="baseDataSource" class="com.zaxxer.hikari.HikariDataSource"
abstract="true">
<property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
<property name="username" value="admin"/>
</bean>
<!-- 子 BeanDefinition：继承 + 覆盖 -->
<bean id="userDataSource" parent="baseDataSource">
<property name="url" value="jdbc:mysql://localhost:3306/users"/>
<property name="password" value="user123"/>
</bean>
<bean id="orderDataSource" parent="baseDataSource">
<property name="url" value="jdbc:mysql://localhost:3306/orders"/>
<property name="password" value="order456"/>
</bean>属性合并过程：
java
// AbstractBeanFactory.getMergedBeanDefinition() 中处理父子关系
protected RootBeanDefinition getMergedBeanDefinition(String beanName, BeanDefinition bd) {
if (bd instanceof ChildBeanDefinition child) {
// 1. 递归获取父 BeanDefinition 的合并结果
String parentName = child.getParentName();
RootBeanDefinition merged = getMergedBeanDefinition(parentName);
// 2. 子属性覆盖父属性（子优先）
merged.overrideFrom(bd);
return merged;
}
// RootBeanDefinition 直接返回
return (RootBeanDefinition) bd;
}三种 BeanDefinition 类型对比：
| 类型 | 说明 | 是否可独立 | 适用场景 |
|---|---|---|---|
RootBeanDefinition | 完整的 BeanDefinition | 是 | 大部分 Bean |
ChildBeanDefinition | 继承父 BeanDefinition | 否 | XML 父子 Bean |
GenericBeanDefinition | 通用 BeanDefinition | 是 | 注解扫描、@Bean 方法（Spring 2.5+ 推荐） |
现代 Spring（2.5+）推荐使用
GenericBeanDefinition，ChildBeanDefinition主要保留给 XML 配置兼容。
7. AnnotationBeanNameGenerator.generateBeanName() 生成逻辑
AnnotationBeanNameGenerator 负责为被 @Component 家族注解标注的类生成 Bean 名称。
java
public class AnnotationBeanNameGenerator implements BeanNameGenerator {
// @Component 及其派生注解的完全限定名
private static final String COMPONENT_ANNOTATION_CLASSNAME =
"org.springframework.stereotype.Component";
@Override
public String generateBeanName(BeanDefinition definition, BeanDefinitionRegistry registry) {
// 1. 尝试从 BeanDefinition 中获取注解元数据
if (definition instanceof AnnotatedBeanDefinition annotatedDef) {
// 2. 从 @Component("myBean") 或 @Service("myService") 获取 value
String beanName = determineBeanNameFromAnnotation(annotatedDef);
if (StringUtils.hasText(beanName)) {
// 注解中指定了名称 → 直接使用
return beanName;
}
}
// 3. 无注解值 → 使用类名首字母小写
return buildDefaultBeanName(definition, registry);
}
// 从注解中获取 Bean 名称
private String determineBeanNameFromAnnotation(AnnotatedBeanDefinition annotatedDef) {
AnnotationMetadata metadata = annotatedDef.getMetadata();
// 遍历所有注解
for (String annotationType : metadata.getAnnotationTypes()) {
// 检查是否是 @Component（或其派生注解）
if (isStereotypeWithNameValue(annotationType, metadata)) {
// 获取 value 属性值
Map<String, Object> attributes =
metadata.getAnnotationAttributes(annotationType, false);
if (attributes != null) {
Object value = attributes.get("value");
if (value instanceof String str && StringUtils.hasText(str)) {
return str; // 返回 @Component("xxx") 中的 xxx
}
}
}
}
return null;
}
// 默认名称生成：类名首字母小写
private String buildDefaultBeanName(BeanDefinition definition, BeanDefinitionRegistry registry) {
// 1. 获取完全限定类名
String beanClassName = definition.getBeanClassName();
// 2. 提取短类名（去掉包名）
String shortName = ClassUtils.getShortName(beanClassName);
// 3. 首字母小写
return Introspector.decapitalize(shortName);
// 示例：
// "com.example.UserService" → "UserService" → "userService"
// "com.example.ABCService" → "ABCService" → "ABCService"（首字母连续大写时不处理）
}
}名称生成示例：
| 类 | @Component value | 生成的 Bean 名 |
|---|---|---|
@Component("userService") | "userService" | "userService" |
@Service（无 value） | null | "userServiceImpl" |
@Controller("myCtrl") | "myCtrl" | "myCtrl" |
@Repository（无 value） | null | "userDao" |
com.example.ABCService | null | "ABCService"（首字母大写不变） |
8. BeanDefinitionRegistry 的 registerBeanDefinition() 校验
BeanDefinitionRegistry 定义了 BeanDefinition 的注册契约。
java
public interface BeanDefinitionRegistry extends AliasRegistry {
// 注册一个 BeanDefinition
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);
// 获取所有 BeanDefinition 名称
String[] getBeanDefinitionNames();
// 获取注册的 BeanDefinition 数量
int getBeanDefinitionCount();
}DefaultListableBeanFactory 中的注册实现：
java
public class DefaultListableBeanFactory {
@Override
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
throws BeanDefinitionStoreException {
// 1. 参数校验：beanName 不能为空
Assert.hasText(beanName, "Bean 名称不能为空");
// 2. 参数校验：BeanDefinition 不能为 null
Assert.notNull(beanDefinition, "BeanDefinition 不能为 null");
// 3. 校验：不允许覆盖冻结阶段的 BeanDefinition
if (beanDefinition instanceof AbstractBeanDefinition abd) {
try {
abd.validate();
} catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(),
beanName, "BeanDefinition 校验失败", ex);
}
}
// 4. 检查是否已存在同名的 BeanDefinition
BeanDefinition existing = this.beanDefinitionMap.get(beanName);
if (existing != null) {
// 检查是否允许覆盖
if (!isAllowBeanDefinitionOverriding()) {
throw new BeanDefinitionStoreException(...);
}
// 处理覆盖优先级
if (existing.getRole() < beanDefinition.getRole()) {
// 框架内部定义的 Bean 不能被应用 Bean 覆盖
// ...
}
}
// 5. 注册到核心 Map
this.beanDefinitionMap.put(beanName, beanDefinition);
// 6. 添加到名称列表
this.beanDefinitionNames.add(beanName);
// 7. 清除相关的旧缓存
removeSingleton(beanName); // 清除单例缓存
clearTypeCache(); // 清除类型缓存
}
}注册校验流程：
BeanDefinitionRegistry.registerBeanDefinition(name, bd)
↓
① name 不能为空（Assert.hasText）
② bd 不能为 null（Assert.notNull）
③ bd.validate()（属性校验）
↓
④ beanDefinitionMap 中是否存在同名？
├── 存在 → 是否允许覆盖？
│ ├── 允许 → 覆盖（打印日志）
│ └── 不允许 → 抛出异常
└── 不存在 → 继续
↓
⑤ beanDefinitionMap.put(name, bd)
⑥ beanDefinitionNames.add(name)
⑦ 清除缓存（singleton、type）9. SingletonBeanRegistry.getSingleton() 的双检锁
DefaultSingletonBeanRegistry 是 Spring 三级缓存和单例注册的核心实现。
java
public class DefaultSingletonBeanRegistry
extends SimpleAliasRegistry
implements SingletonBeanRegistry {
/** 一级缓存：完全创建好的单例 Bean */
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
/** 二级缓存：提前暴露的 Bean（未完全初始化，用于解决循环依赖） */
private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>(16);
/** 三级缓存：单例工厂（用于生成代理对象） */
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
/** 正在创建中的 Bean 集合 */
private final Set<String> singletonsCurrentlyInCreation =
Collections.newSetFromMap(new ConcurrentHashMap<>(16));
// 获取单例 Bean（核心方法）
@Override
public Object getSingleton(String beanName) {
return getSingleton(beanName, true);
}
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
// 第一步：从一级缓存获取（最快路径）
Object singletonObject = this.singletonObjects.get(beanName);
// 二级缓存 + 三级缓存（仅当 Bean 正在创建中时访问）
if (singletonObject == null
&& isSingletonCurrentlyInCreation(beanName)) {
// 使用 synchronized 保证线程安全
synchronized (this.singletonObjects) {
// 第二步：从二级缓存获取（提前暴露的 Bean）
singletonObject = this.earlySingletonObjects.get(beanName);
// 第三步：三级缓存 → 创建对象 → 移到二级缓存
if (singletonObject == null && allowEarlyReference) {
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
// 通过工厂创建 Bean（可能是代理对象）
singletonObject = singletonFactory.getObject();
// 移到二级缓存（提升后续访问速度）
this.earlySingletonObjects.put(beanName, singletonObject);
// 从三级缓存移除
this.singletonFactories.remove(beanName);
}
}
}
}
return singletonObject;
}
}双检锁（DCL）模式：
getSingleton("userService")
↓
① singletonObjects.get("userService") ← 不加锁（最快路径）
↓ null?
② synchronized(singletonObjects) ← 加锁
↓
③ earlySingletonObjects.get("userService") ← 二级缓存
↓ null?
④ singletonFactories.get("userService") ← 三级缓存
↓ 存在？
⑤ factory.getObject() ← 创建对象（或代理）
⑥ earlySingletonObjects.put(...) ← 移到二级缓存
⑦ singletonFactories.remove(...) ← 移出三级缓存
↓
返回 singletonObject三级缓存在各阶段的状态：
| 阶段 | singletonObjects | earlySingletonObjects | singletonFactories |
|---|---|---|---|
| doCreateBean 之前 | 空 | 空 | 空 |
实例化后（createBeanInstance） | 空 | 空 | 有值（添加工厂） |
| populateBean 中（遇到循环依赖） | 空 | 有值（工厂创建） | 移除 |
| initializeBean 后 | 有值 | 空（清理） | 空 |
10. ConfigurableBeanFactory 的 BeanPostProcessor 链
ConfigurableBeanFactory 管理 BeanPostProcessor 的注册链，在 Bean 初始化前后应用这些处理器。
java
public abstract class AbstractBeanFactory
extends FactoryBeanRegistrySupport
implements ConfigurableBeanFactory {
/** BeanPostProcessor 列表（按添加顺序排序） */
private final List<BeanPostProcessor> beanPostProcessors
= new CopyOnWriteArrayList<>();
@Override
public void addBeanPostProcessor(BeanPostProcessor beanPostProcessor) {
// 1. 移除已有的相同实例（防止重复注册）
this.beanPostProcessors.remove(beanPostProcessor);
// 2. 按 PriorityOrdered > Ordered > 其他 排序插入
int index = 0;
for (BeanPostProcessor existing : this.beanPostProcessors) {
// 计算插入位置
if (beanPostProcessor instanceof PriorityOrdered) {
// PriorityOrdered 放在 Ordered 之前
if (!(existing instanceof PriorityOrdered)) break;
} else if (beanPostProcessor instanceof Ordered) {
// Ordered 放在非排序之前
if (existing instanceof PriorityOrdered) continue;
if (!(existing instanceof Ordered)) break;
} else {
// 非排序 → 末尾
index = this.beanPostProcessors.size();
break;
}
index++;
}
// 3. 插入到计算的位置
this.beanPostProcessors.add(index, beanPostProcessor);
}
@Override
public int getBeanPostProcessorCount() {
return this.beanPostProcessors.size();
}
// 获取当前 BeanPostProcessor 列表的快照
public List<BeanPostProcessor> getBeanPostProcessors() {
return this.beanPostProcessors;
}
}BeanPostProcessor 在 Bean 生命周期中的调用：
java
// AbstractAutowireCapableBeanFactory.initializeBean()
protected Object initializeBean(String beanName, Object bean, RootBeanDefinition mbd) {
// 1. 调用 Aware 方法（BeanNameAware、BeanFactoryAware 等）
invokeAwareMethods(beanName, bean);
// 2. 前置处理：调用所有 BeanPostProcessor.postProcessBeforeInitialization()
Object wrappedBean = applyBeanPostProcessorsBeforeInitialization(bean, beanName);
// 3. 初始化（@PostConstruct + InitializingBean + init-method）
invokeInitMethods(beanName, wrappedBean, mbd);
// 4. 后置处理：调用所有 BeanPostProcessor.postProcessAfterInitialization()
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
return wrappedBean;
}常见的 BeanPostProcessor：
| BeanPostProcessor | 阶段 | 作用 |
|---|---|---|
AutowiredAnnotationBeanPostProcessor | postProcessBeforeInitialization | 处理 @Autowired、@Value、@Inject |
CommonAnnotationBeanPostProcessor | postProcessBeforeInitialization | 处理 @Resource、@PostConstruct、@PreDestroy |
ApplicationContextAwareProcessor | postProcessBeforeInitialization | 处理 ApplicationContextAware 等 Aware 接口 |
AnnotationAwareAspectJAutoProxyCreator | postProcessAfterInitialization | 创建 AOP 代理 |
AsyncAnnotationBeanPostProcessor | postProcessAfterInitialization | 创建 @Async 异步代理 |
排序规则：
处理顺序：
PostProcessorsRegisteredEvent → 以下排序：
PriorityOrdered BeanPostProcessors
↓ （按 PriorityOrdered.getOrder() 排序）
Ordered BeanPostProcessors
↓ （按 Ordered.getOrder() 排序）
没有排序接口的 BeanPostProcessors
↓ （按注册顺序）
启动完成总结
BeanFactory / BeanDefinition 基础设施族的 10 个细节点总结如下：
| # | 细节点 | 核心类/机制 |
|---|---|---|
| ① | BeanFactory 接口层次结构 | ListableBeanFactory → ConfigurableBeanFactory → ConfigurableListableBeanFactory → DefaultListableBeanFactory 每层新增能力 |
| ② | DefaultListableBeanFactory 的 3 个核心 Map | beanDefinitionMap（ConcurrentHashMap）、singletonObjects、beanDefinitionNames（ArrayList） |
| ③ | BeanDefinition 的 6 种 scope | singleton / prototype / request / session / application / websocket |
| ④ | ScannedGenericBeanDefinition 的 @Component 扫描 | ClassPathBeanDefinitionScanner.doScan() → ASM MetadataReader → 不加载类 |
| ⑤ | AbstractBeanDefinition.setAutowireMode() 的 4 种模式 | AUTOWIRE_NO / AUTOWIRE_BY_NAME / AUTOWIRE_BY_TYPE / AUTOWIRE_CONSTRUCTOR |
| ⑥ | RootBeanDefinition vs ChildBeanDefinition | ChildBeanDefinition 继承父 BeanDefinition 的属性，运行时合并 |
| ⑦ | AnnotationBeanNameGenerator.generateBeanName() | @Component("myBean") → myBean；无值 → 类名首字母小写 |
| ⑧ | BeanDefinitionRegistry 的 registerBeanDefinition() 校验 | name 非空 → bd 非 null → validate() → beanDefinitionMap.put() |
| ⑨ | SingletonBeanRegistry.getSingleton() 的双检锁 | singletonObjects.get() → earlySingletonObjects → singletonFactories → 创建 → 提升 |
| ⑩ | ConfigurableBeanFactory 的 BeanPostProcessor 链 | addBeanPostProcessor() → CopyOnWriteArrayList 排序插入 |