IoC 容器 refresh() 与 getBean() 源码精读
概述
本文逐行精读 Spring IoC 容器的核心启动方法 refresh() 和 Bean 创建方法 getBean()，理解从配置文件/注解到完整 Bean 的全过程。
一、refresh() 12 步全景
java
// org.springframework.context.support.AbstractApplicationContext.refresh()
@Override
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// 1. 准备刷新上下文：记录启动时间、设置激活状态、初始化属性源
prepareRefresh();
// 2. 获取 BeanFactory（核心步骤）
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// 3. 预处理 BeanFactory：设置类加载器、SPEL 解析器、注册 Aware 接口处理器等
prepareBeanFactory(beanFactory);
try {
// 4. 子类后置处理 BeanFactory
postProcessBeanFactory(beanFactory);
// 5. 调用 BeanFactoryPostProcessor
invokeBeanFactoryPostProcessors(beanFactory);
// 6. 注册 BeanPostProcessor
registerBeanPostProcessors(beanFactory);
// 7. 初始化 MessageSource（国际化）
initMessageSource();
// 8. 初始化 ApplicationEventMulticaster（事件广播器）
initApplicationEventMulticaster();
// 9. 子类刷新（如 Web 容器）
onRefresh();
// 10. 注册监听器
registerListeners();
// 11. 实例化所有非懒加载的单例 Bean
finishBeanFactoryInitialization(beanFactory);
// 12. 完成刷新：初始化 LifecycleProcessor、发布 ContextRefreshedEvent
finishRefresh();
}
catch (BeansException ex) {
// 失败：销毁已创建的 Bean
destroyBeans();
cancelRefresh(ex);
throw ex;
}
}
}1.1 prepareRefresh() — 准备刷新
java
protected void prepareRefresh() {
// 记录启动时间
this.startupDate = System.currentTimeMillis();
// 容器关闭标志置 false
this.closed.set(false);
// 容器激活标志置 true
this.active.set(true);
// 初始化属性源（子类可覆盖）
initPropertySources();
// 验证必需属性是否存在
getEnvironment().validateRequiredProperties();
}1.2 obtainFreshBeanFactory() — 获取 BeanFactory
java
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
// AbstractApplicationContext 中调用子类实现
refreshBeanFactory();
// 返回当前 BeanFactory
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
if (logger.isDebugEnabled()) {
logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
}
return beanFactory;
}
// AbstractRefreshableApplicationContext.refreshBeanFactory()
@Override
protected final void refreshBeanFactory() throws BeansException {
// 如果已有 BeanFactory，销毁并关闭
if (hasBeanFactory()) {
destroyBeans();
closeBeanFactory();
}
try {
// 创建新的 DefaultListableBeanFactory
DefaultListableBeanFactory beanFactory = createBeanFactory();
beanFactory.setSerializationId(getId());
// 设置是否允许 Bean 覆盖、是否允许循环引用
customizeBeanFactory(beanFactory);
// 加载 Bean 定义（核心！XmlBeanDefinitionReader / ClassPathBeanDefinitionScanner）
loadBeanDefinitions(beanFactory);
this.beanFactory = beanFactory;
} catch (IOException ex) {
throw new ApplicationContextException("I/O error parsing bean definition source", ex);
}
}1.3 prepareBeanFactory() — 预处理
java
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
// 设置类加载器
beanFactory.setBeanClassLoader(getClassLoader());
// 设置 SPEL 解析器（StandardBeanExpressionResolver）
beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
// 设置属性编辑器
beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
// 注册 ApplicationContextAwareProcessor（处理 Aware 接口回调）
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
// 忽略以下接口的自动装配（它们通过 Aware 回调注入）
beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
// 注册可解析的依赖类型
beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
beanFactory.registerResolvableDependency(ResourceLoader.class, this);
beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
beanFactory.registerResolvableDependency(ApplicationContext.class, this);
// 注册 ApplicationListenerDetector（检测 ApplicationListener 类型）
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
// 注册 LoadTimeWeaver（AOP 织入）
if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
}1.4 invokeBeanFactoryPostProcessors() — 调用 BeanFactoryPostProcessor
java
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
// 委托给 PostProcessorRegistrationDelegate
PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
// 检测 LoadTimeWeaver（AOP 需要）
if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
}1.5 finishBeanFactoryInitialization() — 实例化所有单例
java
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
// 初始化 ConversionService（类型转换服务）
if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
beanFactory.setConversionService(
beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
}
// 注册默认的 EmbeddedValueResolver
if (!beanFactory.hasEmbeddedValueResolver()) {
beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
}
// 初始化 LoadTimeWeaverAware Bean
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
for (String weaverAwareName : weaverAwareNames) {
getBean(weaverAwareName);
}
// 停止使用临时类加载器
beanFactory.setTempClassLoader(null);
// 冻结 BeanDefinition（不再允许修改）
beanFactory.freezeConfiguration();
// 实例化所有非懒加载的单例 Bean
beanFactory.preInstantiateSingletons();
}二、getBean() 源码精读
2.1 AbstractBeanFactory.getBean()
java
@Override
public Object getBean(String name) throws BeansException {
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 name（去除 & 前缀、别名转换）
String beanName = transformedBeanName(name);
// 2. 从三级缓存尝试获取（解决循环依赖）
Object sharedInstance = getSingleton(beanName);
Object beanInstance;
if (sharedInstance != null && args == null) {
// 缓存命中
beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);
} else {
// 3. 检查是否正在创建中（循环依赖检测）
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
// 4. 检查父 BeanFactory
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
return parentBeanFactory.getBean(name, requiredType);
}
// 5. 标记已创建（用于循环依赖检测）
if (!typeCheckOnly) {
markBeanAsCreated(beanName);
}
try {
// 6. 获取 RootBeanDefinition
RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
// 7. 检查 BeanDefinition 是否为抽象的
checkMergedBeanDefinition(mbd, beanName, args);
// 8. 处理 depends-on 依赖
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
for (String dep : dependsOn) {
if (isDependent(beanName, dep)) {
throw new BeanCreationException("Circular depends-on relationship");
}
registerDependentBean(dep, beanName);
getBean(dep);
}
}
// 9. 创建 Bean 实例（核心！）
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, () -> {
try {
return createBean(beanName, mbd, args);
} catch (BeansException ex) {
destroySingleton(beanName);
throw ex;
}
});
beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
} else if (mbd.isPrototype()) {
// Prototype 每次创建新实例
Object prototypeInstance = createBean(beanName, mbd, args);
beanInstance = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
} else {
// Session / Request 作用域
String scopeName = mbd.getScope();
Scope scope = this.scopes.get(scopeName);
Object scopedInstance = scope.get(beanName, () -> createBean(beanName, mbd, args));
beanInstance = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
}
} catch (BeansException ex) {
cleanupAfterBeanCreationFailure(beanName);
throw ex;
}
}
// 10. 类型转换
return adaptBeanInstance(name, beanInstance, requiredType);
}2.2 AbstractAutowireCapableBeanFactory.createBean()
java
@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
// 1. 解析 Bean Class
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbd.setBeanClass(resolvedClass);
}
// 2. 检查 MethodOverride（lookup-method / replace-method）
mbd.prepareMethodOverrides();
try {
// 3. 调用 BeanPostProcessor 中的 InstantiationAwareBeanPostProcessor
// 这里给 AOP 等代理提供机会（如果返回非空，则跳过后续创建流程）
Object bean = resolveBeforeInstantiation(beanName, mbd);
if (bean != null) {
return bean;
}
} catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, ex);
}
// 4. 真正的创建 Bean
return doCreateBean(beanName, mbd, args);
}2.3 doCreateBean() — 创建 Bean 全流程
java
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
// 1. 实例化 Bean（通过构造函数/工厂方法）
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
Object bean = instanceWrapper.getWrappedInstance();
Class<?> beanType = instanceWrapper.getWrappedClass();
// 2. 允许 MBD 的后置处理器修改
// 这里将 Bean 的 ObjectFactory 放入三级缓存 singletonFactories
// 解决循环依赖的关键！
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
// 3. 属性填充（依赖注入）
populateBean(beanName, mbd, instanceWrapper);
// 4. 初始化 Bean
// Aware → BeanPostProcessor(before) → init-method → BeanPostProcessor(after) → AOP 代理
exposedObject = initializeBean(beanName, exposedObject, mbd);
// 5. 注册 DisposableBean
registerDisposableBeanIfNecessary(beanName, bean, mbd);
return exposedObject;
}2.4 createBeanInstance() — 实例化
java
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
// 1. 检查 BeanDefinition 是否已定义工厂方法
if (mbd.getFactoryMethodName() != null) {
return instantiateUsingFactoryMethod(beanName, mbd, args);
}
// 2. 解析构造函数（Spring 4.0+ 自动推断）
Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR) {
return autowireConstructor(beanName, mbd, ctors, args);
}
// 3. 默认无参构造函数
return instantiateBean(beanName, mbd);
}2.5 populateBean() — 属性填充
java
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
// 1. 调用 InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation()
// 如果返回 false，跳过属性填充
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
if (!((InstantiationAwareBeanPostProcessor) bp)
.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
return;
}
}
}
}
// 2. 获取需要注入的属性值（@Autowired、@Value、XML 配置等）
PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
// 3. 按自动装配模式解析属性
if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME) {
autowireByName(beanName, mbd, bw, newPvs);
}
if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
autowireByType(beanName, mbd, bw, newPvs);
}
// 4. 调用 InstantiationAwareBeanPostProcessor.postProcessProperties()
// @Autowired、@Value、@Resource 等注解在这里处理
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
PropertyValues pvsToUse = ((InstantiationAwareBeanPostProcessor) bp)
.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
return;
}
pvs = pvsToUse;
}
}
// 5. 应用属性到 BeanWrapper
applyPropertyValues(beanName, mbd, bw, pvs);
}2.6 initializeBean() — 初始化
java
protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
// 1. 调用 Aware 接口方法
// BeanNameAware → BeanClassLoaderAware → BeanFactoryAware
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
invokeAwareMethods(beanName, bean);
return null;
}, getAccessControlContext());
} else {
invokeAwareMethods(beanName, bean);
}
// 2. BeanPostProcessor 前置处理
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
// 3. 调用初始化方法
// @PostConstruct → InitializingBean.afterPropertiesSet() → @Bean(initMethod)
try {
invokeInitMethods(beanName, wrappedBean, mbd);
} catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, ex);
}
// 4. BeanPostProcessor 后置处理（AOP 代理在此创建！）
if (mbd == null || !mbd.isSynthetic()) {
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}三、三级缓存与循环依赖
3.1 三级缓存结构
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 HashMap<>(16);
// 三级缓存：Bean 工厂（用于生成代理对象）
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
}3.2 getSingleton() — 从缓存获取
java
@Override
@Nullable
public Object getSingleton(String beanName) {
// 先从一级缓存获取
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
// Bean 正在创建中 → 从二级缓存获取
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null) {
synchronized (this.singletonObjects) {
singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null) {
// 从三级缓存获取 → 调用 ObjectFactory 生成早期引用
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
singletonObject = singletonFactory.getObject();
// 提升到二级缓存，删除三级缓存
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
}
}
return singletonObject;
}3.3 循环依赖解决流程
text
场景：A 依赖 B，B 依赖 A
1. A 开始创建 → doCreateBean(A)
├── createBeanInstance(A) → 实例化 A
├── addSingletonFactory(A, earlyBeanReference) → 放入三级缓存
└── populateBean(A) → 发现依赖 B
└── getBean(B) → doCreateBean(B)
├── createBeanInstance(B) → 实例化 B
├── addSingletonFactory(B, earlyBeanReference) → 放入三级缓存
└── populateBean(B) → 发现依赖 A
└── getSingleton(A) → 三级缓存中找到 A 的 ObjectFactory
→ 调用 getEarlyBeanReference(A) → 返回 A 的早期引用（未完成属性填充）
→ 放入二级缓存
└── B 完成创建 → 放入一级缓存
├── A 继续 populateBean() → 属性填充成功
├── initializeBean(A) → 初始化完成
└── A 放入一级缓存四、总结
| 步骤 | 方法 | 核心作用 |
|---|---|---|
| 1 | prepareRefresh | 初始化环境、属性源 |
| 2 | obtainFreshBeanFactory | 创建/刷新 BeanFactory |
| 3 | prepareBeanFactory | 设置类加载器、Aware 处理器 |
| 4 | postProcessBeanFactory | 子类扩展（如 Web） |
| 5 | invokeBeanFactoryPostProcessors | BeanFactory 后置处理 |
| 6 | registerBeanPostProcessors | 注册 Bean 后置处理器 |
| 7 | initMessageSource | 国际化配置 |
| 8 | initApplicationEventMulticaster | 事件广播器 |
| 9 | onRefresh | Web 容器初始化 |
| 10 | registerListeners | 注册监听器 |
| 11 | finishBeanFactoryInitialization | 实例化所有单例 |
| 12 | finishRefresh | 发布 ContextRefreshedEvent |
参考链接：