本文不满足于表面使用，将直击Spring框架的核心——IoC容器，通过源码逐层剖析，揭示其背后的设计精妙与实现原理。
一、Spring IoC容器总体架构：设计蓝图
在深入代码之前，必须先理解Spring IoC容器的顶层设计。整个容器体系围绕BeanFactory这一核心接口构建，其核心继承体系如下：
// 核心接口继承链
BeanFactory → ListableBeanFactory → ConfigurableBeanFactory
→ HierarchicalBeanFactory → ApplicationContext
1.1 核心接口职责分离
public interface BeanFactory {
// 1. 基础Bean获取能力
Object getBean(String name) throws BeansException;
<T> T getBean(String name, Class<T> requiredType) throws BeansException;
// 2. 类型检查与作用域判断
boolean isTypeMatch(String name, Class<?> typeToMatch) throws NoSuchBeanDefinitionException;
boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
}
public interface ListableBeanFactory extends BeanFactory {
// 3. 批量Bean查询能力
String[] getBeanDefinitionNames();
<T> Map<String, T> getBeansOfType(Class<T> type) throws BeansException;
}
public interface ConfigurableBeanFactory extends HierarchicalBeanFactory, SingletonBeanRegistry {
// 4. 容器配置能力
void addBeanPostProcessor(BeanPostProcessor beanPostProcessor);
void registerScope(String scopeName, Scope scope);
void destroySingletons();
}
设计哲学：通过精细的接口拆分，实现了"单一职责原则"，每个接口只关注特定方面的功能，使得整个架构高度可扩展。
二、BeanDefinition：Bean的"蓝图"
在Spring中，Bean并不是直接创建的，而是先通过BeanDefinition来描述Bean的元数据。
2.1 BeanDefinition核心结构
public interface BeanDefinition extends AttributeAccessor, BeanMetadataElement {
// 作用域常量
String SCOPE_SINGLETON = ConfigurableBeanFactory.SCOPE_SINGLETON;
String SCOPE_PROTOTYPE = ConfigurableBeanFactory.SCOPE_PROTOTYPE;
// Bean类信息
void setBeanClassName(String beanClassName);
String getBeanClassName();
// 作用域控制
void setScope(String scope);
String getScope();
// 生命周期配置
void setLazyInit(boolean lazyInit);
boolean isLazyInit();
void setInitMethodName(String initMethodName);
String getInitMethodName();
// 依赖关系
void setDependsOn(String... dependsOn);
String[] getDependsOn();
// 是否是主要候选者（@Primary）
void setPrimary(boolean primary);
boolean isPrimary();
}
2.2 BeanDefinition的注册过程
让我们跟踪ClassPathXmlApplicationContext的启动过程：
public class ClassPathXmlApplicationContext extends AbstractXmlApplicationContext {
public ClassPathXmlApplicationContext(String[] configLocations) {
// 核心启动流程
this(configLocations, true, null);
}
public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh,
ApplicationContext parent) {
super(parent);
setConfigLocations(configLocations);
if (refresh) {
// 这是整个Spring容器启动的核心入口！
refresh();
}
}
}
三、refresh()方法：容器启动的生命线
AbstractApplicationContext.refresh()是Spring容器启动的核心流程，理解它就理解了Spring的整个生命周期。
3.1 refresh()方法完整流程
@Override
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// 1. 准备刷新上下文
prepareRefresh();
// 2. 初始化BeanFactory并加载BeanDefinitions（关键步骤！）
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// 3. 配置BeanFactory（设置类加载器、SPEL解析器等）
prepareBeanFactory(beanFactory);
try {
// 4. 后处理BeanFactory（留给子类扩展）
postProcessBeanFactory(beanFactory);
// 5. 调用BeanFactoryPostProcessors（关键扩展点！）
invokeBeanFactoryPostProcessors(beanFactory);
// 6. 注册BeanPostProcessors（Bean后处理器）
registerBeanPostProcessors(beanFactory);
// 7. 初始化消息源（国际化）
initMessageSource();
// 8. 初始化应用事件广播器
initApplicationEventMulticaster();
// 9. 留给子类扩展的onRefresh方法
onRefresh();
// 10. 注册监听器
registerListeners();
// 11. 完成BeanFactory初始化，实例化所有非懒加载单例（关键步骤！）
finishBeanFactoryInitialization(beanFactory);
// 12. 完成刷新，发布相应事件
finishRefresh();
} catch (BeansException ex) {
// 13. 销毁已创建的Bean
destroyBeans();
// 14. 重置激活标志
cancelRefresh(ex);
throw ex;
} finally {
// 15. 重置Spring核心中的公共内省缓存
resetCommonCaches();
}
}
}
3.2 关键步骤深度解析：BeanDefinition加载
让我们深入第2步obtainFreshBeanFactory()：
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
// 1. 刷新BeanFactory
refreshBeanFactory();
// 2. 返回刷新后的BeanFactory
return getBeanFactory();
}
// 在AbstractRefreshableApplicationContext中的实现
@Override
protected final void refreshBeanFactory() throws BeansException {
if (hasBeanFactory()) {
destroyBeans();
closeBeanFactory();
}
try {
// 创建新的BeanFactory（默认是DefaultListableBeanFactory）
DefaultListableBeanFactory beanFactory = createBeanFactory();
beanFactory.setSerializationId(getId());
// 定制BeanFactory（设置是否允许覆盖、循环依赖等）
customizeBeanFactory(beanFactory);
// 加载BeanDefinitions（这是模板方法，由子类实现）
loadBeanDefinitions(beanFactory);
this.beanFactory = beanFactory;
} catch (IOException ex) {
throw new ApplicationContextException("I/O error parsing bean definition source", ex);
}
}
四、Bean创建过程：从定义到实例的涅槃
第11步finishBeanFactoryInitialization(beanFactory)是Bean实例化的核心：
4.1 Bean创建时序图
getBean() → doGetBean() → createBean() → doCreateBean()
↓
resolveBeanClass() → instantiateBean() → populateBean() → initializeBean()
4.2 核心源码解析
// AbstractBeanFactory
protected <T> T doGetBean(String name, Class<T> requiredType,
Object[] args, boolean typeCheckOnly) {
// 1. 转换Bean名称（处理FactoryBean、别名等）
String beanName = transformedBeanName(name);
// 2. 尝试从缓存中获取单例
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
return getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
// 3. 检查BeanDefinition是否存在
BeanDefinition bd = getMergedBeanDefinition(beanName);
// 4. 处理依赖的Bean（depends-on）
String[] dependsOn = bd.getDependsOn();
if (dependsOn != null) {
for (String dep : dependsOn) {
// 递归初始化依赖的Bean
getBean(dep);
registerDependentBean(dep, beanName);
}
}
// 5. 根据作用域创建Bean实例
if (bd.isSingleton()) {
sharedInstance = getSingleton(beanName, () -> {
try {
return createBean(beanName, bd, args);
} catch (BeansException ex) {
destroySingleton(beanName);
throw ex;
}
});
return getObjectForBeanInstance(sharedInstance, name, beanName, bd);
} else if (bd.isPrototype()) {
// 原型模式每次都创建新实例
Object prototypeInstance = createBean(beanName, bd, args);
return getObjectForBeanInstance(prototypeInstance, name, beanName, bd);
} else {
// 其他作用域（request、session等）
String scopeName = bd.getScope();
Scope scope = this.scopes.get(scopeName);
Object scopedInstance = scope.get(beanName, () -> {
return createBean(beanName, bd, args);
});
return getObjectForBeanInstance(scopedInstance, name, beanName, bd);
}
}
4.3 createBean的真正实现
// AbstractAutowireCapableBeanFactory
@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) {
// 1. 解析Bean类
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
// 2. 准备方法覆盖（lookup-method, replace-method）
mbdToUse.prepareMethodOverrides();
// 3. 给BeanPostProcessors机会返回代理而不是目标Bean（AOP的关键！）
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
return bean;
}
// 4. 真正的创建Bean实例
return doCreateBean(beanName, mbdToUse, args);
}
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, Object[] args) {
BeanWrapper instanceWrapper = null;
// 4.1 实例化Bean（调用构造方法）
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
// 4.2 应用MergedBeanDefinitionPostProcessors（@Autowired注解在这里处理）
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
// 4.3 属性填充（依赖注入！）
populateBean(beanName, mbd, instanceWrapper);
// 4.4 初始化Bean
Object exposedObject = initializeBean(beanName, exposedObject, mbd);
return exposedObject;
}
五、依赖注入：@Autowired的实现原理
让我们深入populateBean方法，看看Spring是如何实现依赖注入的：
5.1 自动装配的核心逻辑
protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {
// 1. 如果有属性值，先设置属性值
PropertyValues pvs = mbd.getPropertyValues();
// 2. 调用InstantiationAwareBeanPostProcessors（在设置属性之前）
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
return;
}
}
}
}
// 3. 自动装配ByName和ByType
if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME ||
mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
// 根据名称自动装配
if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME) {
autowireByName(beanName, mbd, bw, newPvs);
}
// 根据类型自动装配
if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
autowireByType(beanName, mbd, bw, newPvs);
}
pvs = newPvs;
}
// 4. 调用InstantiationAwareBeanPostProcessors的postProcessProperties方法
// 这里就是@Autowired注解处理的地方！
if (hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
// 兼容老版本
pvsToUse = ibp.postProcessPropertyValues(pvs,
filteredPds, bw.getWrappedInstance(), beanName);
}
if (pvsToUse != null) {
pvs = pvsToUse;
}
}
}
}
// 5. 应用属性值
applyPropertyValues(beanName, mbd, bw, pvs);
}
5.2 @Autowired注解处理器
AutowiredAnnotationBeanPostProcessor是处理@Autowired注解的核心类：
public class AutowiredAnnotationBeanPostProcessor implements
InstantiationAwareBeanPostProcessor, MergedBeanDefinitionPostProcessor {
// 1. 后处理合并的BeanDefinition，查找所有需要自动装配的元数据
@Override
public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition,
Class<?> beanType, String beanName) {
// 查找被@Autowired注解的字段和方法
InjectionMetadata metadata = findAutowiringMetadata(beanName, beanType, null);
metadata.checkConfigMembers(beanDefinition);
}
// 2. 属性填充阶段进行依赖注入
@Override
public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
// 获取注入元数据
InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
try {
// 进行注入！
metadata.inject(bean, beanName, pvs);
} catch (Throwable ex) {
throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", ex);
}
return pvs;
}
// 3. 构建注入元数据
private InjectionMetadata findAutowiringMetadata(String beanName, Class<?> clazz,
PropertyValues pvs) {
String cacheKey = (StringUtils.hasLength(beanName) ? beanName : clazz.getName());
return this.injectionMetadataCache.computeIfAbsent(cacheKey, k -> {
// 反射查找被@Autowired注解的字段和方法
List<InjectionMetadata.InjectedElement> elements = new ArrayList<>();
Class<?> targetClass = clazz;
do {
List<InjectionMetadata.InjectedElement> currElements = new ArrayList<>();
// 处理字段
ReflectionUtils.doWithLocalFields(targetClass, field -> {
AnnotationAttributes ann = findAutowiredAnnotation(field);
if (ann != null) {
if (Modifier.isStatic(field.getModifiers())) {
return; // 静态字段不注入
}
boolean required = determineRequiredStatus(ann);
currElements.add(new AutowiredFieldElement(field, required));
}
});
// 处理方法
ReflectionUtils.doWithLocalMethods(targetClass, method -> {
Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
AnnotationAttributes ann = findAutowiredAnnotation(bridgedMethod);
if (ann != null && method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {
if (Modifier.isStatic(method.getModifiers())) {
return; // 静态方法不注入
}
if (method.getParameterCount() == 0) {
return; // 无参数方法不处理
}
boolean required = determineRequiredStatus(ann);
PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
currElements.add(new AutowiredMethodElement(method, required, pd));
}
});
elements.addAll(0, currElements);
targetClass = targetClass.getSuperclass();
} while (targetClass != null && targetClass != Object.class);
return new InjectionMetadata(clazz, elements);
});
}
}
六、循环依赖：Spring的三级缓存解决方案
Spring通过三级缓存巧妙地解决了单例Bean的循环依赖问题：
6.1 三级缓存定义
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);
// 三级缓存：存放Bean工厂，用于生成早期引用
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
// 正在创建中的Bean
private final Set<String> singletonsCurrentlyInCreation =
Collections.newSetFromMap(new ConcurrentHashMap<>(16));
}
6.2 循环依赖解决流程
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
// 1. 从一级缓存查找
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
synchronized (this.singletonObjects) {
// 2. 从二级缓存查找
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null && allowEarlyReference) {
// 3. 从三级缓存获取ObjectFactory
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
// 4. 调用getObject方法获取早期引用（可能经过AOP代理）
singletonObject = singletonFactory.getObject();
// 5. 放入二级缓存，清除三级缓存
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
return singletonObject;
}
七、设计模式在Spring源码中的应用
Spring源码是设计模式应用的典范：
7.1 模板方法模式
AbstractApplicationContext.refresh()方法定义了容器启动的整体流程，具体步骤由子类实现。
7.2 工厂模式
BeanFactory是典型的工厂模式，隐藏了Bean创建的复杂细节。
7.3 策略模式
InstantiationStrategy定义了Bean实例化的策略，SimpleInstantiationStrategy和CglibSubclassingInstantiationStrategy是不同的实现。
7.4 观察者模式
Spring的事件机制ApplicationEvent和ApplicationListener是观察者模式的典型应用。
总结
通过深度剖析Spring IoC容器的源码，我们可以得出以下核心理解：
- BeanDefinition是基石：所有的Bean创建都基于BeanDefinition的元数据。
- refresh()是生命线：理解这个方法就理解了Spring容器的完整生命周期。
- BeanPostProcessor是扩展点：Spring的AOP、事务、异步等特性都通过BeanPostProcessor实现。
- 三级缓存解决循环依赖：这是Spring框架设计精妙的集中体现。
- 接口驱动设计：精细的接口划分使得Spring框架高度可扩展。
理解Spring源码不仅能够帮助我们更好地使用Spring，更重要的是能够学习到优秀框架的设计思想和架构模式，这对于提升我们的系统设计能力有着不可估量的价值。
希望这篇深度源码解析能够帮助您真正理解Spring框架的精髓！
