Spring IOC 源码深挖
IOC 是 Spring 的根基,掌握「容器体系 + refresh 流程 + Bean 生命周期」三层,就能把 IOC 讲透。本文带你逐层看源码。
一、什么是 IOC / DI
考察点:概念 + 能举例。
- IOC(控制反转):把「对象创建和依赖管理」的控制权从对象本身交给容器,对象不再自己 new 依赖。
- DI(依赖注入):IOC 的具体实现方式,容器把依赖「注入」给对象。
// 传统:对象自己创建依赖(强耦合)
public class OrderService {
private UserService userService = new UserService();
}
// IOC:依赖由容器注入(解耦)
@Service
public class OrderService {
@Autowired
private UserService userService; // 容器注入
}好处:解耦、易测试、易扩展、统一管理生命周期。
二、IOC 容器的体系结构
考察点:BeanFactory → ApplicationContext 的继承关系,能画图。
graph TD
BF["BeanFactory<br/>getBean 顶层接口"]
BF --> LB["ListableBeanFactory<br/>可列举 Bean"]
BF --> HB["HierarchicalBeanFactory<br/>父子容器"]
BF --> AB["AutowireCapableBeanFactory<br/>自动装配"]
HB --> CB["ConfigurableBeanFactory"]
LB --> CLB["ConfigurableListableBeanFactory"]
AB --> CLB
CB --> CLB
CLB --> DLB["DefaultListableBeanFactory<br/>核心实现"]
style BF fill:#e8f4fd
style DLB fill:#e6f7e6两个核心概念:
- BeanFactory:最底层的容器,提供
getBean,懒加载。 - ApplicationContext:BeanFactory 的增强,提供国际化、事件、资源加载、AOP 等,启动时预加载单例。
// ApplicationContext 继承了多个接口
public interface ApplicationContext extends ListableBeanFactory,
HierarchicalBeanFactory, MessageSource, ApplicationEventPublisher,
ResourcePatternResolver { }面试常问:BeanFactory 是「基础容器」,ApplicationContext 是「高级容器」,实际开发都用后者。
三、BeanDefinition
考察点:Bean 在容器中的「元数据」描述。
Bean 注册到容器时,被包装成 BeanDefinition,记录:
- Bean 的类名(className)。
- 作用域(scope:singleton/prototype)。
- 是否懒加载(lazyInit)。
- 依赖、构造参数、属性。
- 初始化/销毁方法。
- 是否 primary、是否 abstract 等。
// BeanDefinition 的核心属性(简化)
public interface BeanDefinition {
String getBeanClassName();
String getScope(); // singleton / prototype
boolean isLazyInit();
String getInitMethodName();
String getDestroyMethodName();
boolean isPrimary();
// ...
}四、Bean 的注册
考察点:BeanDefinitionRegistry。
// 默认注册中心 DefaultListableBeanFactory 实现
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) {
// 存入 beanDefinitionMap(ConcurrentHashMap)
this.beanDefinitionMap.put(beanName, beanDefinition);
// 记录 Bean 名称列表
this.beanDefinitionNames.add(beanName);
}- 所有 BeanDefinition 存在
beanDefinitionMap中。 - 注解扫描(
@ComponentScan)最终也是调registerBeanDefinition注册。
五、容器启动:refresh() 流程
考察点:refresh 是 Spring 容器启动的核心,12+ 个步骤。
public void refresh() {
prepareRefresh(); // 1. 预处理(校验必要属性)
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory(); // 2. 获取 BeanFactory
prepareBeanFactory(beanFactory); // 3. 设置类加载器、SpEL 等
postProcessBeanFactory(beanFactory); // 4. 子类扩展点(模板方法)
invokeBeanFactoryPostProcessors(beanFactory); // 5. 执行 BeanFactoryPostProcessor ⭐
registerBeanPostProcessors(beanFactory); // 6. 注册 BeanPostProcessor ⭐
initMessageSource(); // 7. 国际化
initApplicationEventMulticaster(); // 8. 事件广播器
onRefresh(); // 9. 子类扩展(SpringBoot 建 Tomcat)
registerListeners(); // 10. 注册监听器
finishBeanFactoryInitialization(beanFactory); // 11. 实例化所有单例 Bean ⭐
finishRefresh(); // 12. 发布刷新完成事件
}graph TD
A["prepareRefresh"] --> B["obtainFreshBeanFactory"]
B --> C["prepareBeanFactory"]
C --> D["postProcessBeanFactory"]
D --> E["invokeBeanFactoryPostProcessors<br/>处理@Configuration/@ComponentScan"]
E --> F["registerBeanPostProcessors"]
F --> G["initMessageSource / EventMulticaster"]
G --> H["registerListeners"]
H --> I["finishBeanFactoryInitialization<br/>实例化所有单例Bean"]
I --> J["finishRefresh"]
style E fill:#fff3cd
style I fill:#e6f7e6三个最关键步骤:
invokeBeanFactoryPostProcessors:执行ConfigurationClassPostProcessor,扫描@ComponentScan、解析@Configuration、@Import、@Bean。registerBeanPostProcessors:注册AutowiredAnnotationBeanPostProcessor、CommonAnnotationBeanPostProcessor等。finishBeanFactoryInitialization:遍历 beanDefinitionNames,实例化所有非懒加载单例 Bean。
六、Bean 的获取流程
考察点:getBean → doGetBean 的完整链路。
protected <T> T doGetBean(String name, ...) {
// ① 先从三级缓存拿(可处理循环依赖)
Object bean = getSingleton(beanName);
if (bean != null) return (T) bean;
// ② 合并 BeanDefinition(处理父子定义)
RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
// ③ 单例创建(getSingleton 内部调用 createBean)
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, () -> createBean(beanName, mbd, args));
}
return sharedInstance;
}三级缓存
getSingleton详见Spring循环依赖源码深挖.md。
七、Bean 的创建流程:doCreateBean
考察点:实例化 → 属性填充 → 初始化 三步。
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, Object[] args) {
// ① 实例化(构造器创建,此时属性都为空)
BeanWrapper instanceWrapper = createBeanInstance(beanName, mbd, args);
Object bean = instanceWrapper.getWrappedInstance();
// ② 提前暴露到三级缓存(处理循环依赖)
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
// ③ 属性填充(依赖注入)
populateBean(beanName, mbd, instanceWrapper);
// ④ 初始化(Aware 回调 + BeanPostProcessor + init 方法)
Object exposedObject = initializeBean(beanName, exposedObject, mbd);
return exposedObject;
}graph LR
A["① 实例化<br/>createBeanInstance"] --> B["② 加入三级缓存"]
B --> C["③ 属性填充<br/>populateBean 依赖注入"]
C --> D["④ 初始化<br/>initializeBean"]
style A fill:#fff3cd
style C fill:#e6f7e6
style D fill:#e8f4fd八、Bean 生命周期(完整版)
考察点:面试最高频之一,能完整背出。
graph TD
A["实例化(构造器)"] --> B["属性填充(依赖注入)"]
B --> C["BeanNameAware"]
C --> D["BeanFactoryAware"]
D --> E["ApplicationContextAware"]
E --> F["BeanPostProcessor.postProcessBeforeInitialization"]
F --> G["@PostConstruct"]
G --> H["InitializingBean.afterPropertiesSet"]
H --> I["init-method"]
I --> J["BeanPostProcessor.postProcessAfterInitialization<br/>AOP 代理在这里创建"]
J --> K["使用中"]
K --> L["@PreDestroy"]
L --> M["DisposableBean.destroy"]
M --> N["destroy-method"]
style F fill:#fff3cd
style J fill:#e6f7e6// 生命周期各阶段对应代码
@Component
public class MyBean implements BeanNameAware, BeanFactoryAware,
ApplicationContextAware, InitializingBean, DisposableBean {
@Autowired
private UserService userService; // ② 属性填充
public void setBeanName(String name) { } // ③ Aware
public void setBeanFactory(BeanFactory bf) { } // ④ Aware
public void setApplicationContext(ApplicationContext ac) { } // ⑤ Aware
@PostConstruct
public void postConstruct() { } // ⑦ 初始化
public void afterPropertiesSet() { } // ⑧ InitializingBean
public void initMethod() { } // ⑨ init-method
@PreDestroy
public void preDestroy() { } // ⑫ 销毁
public void destroy() { } // ⑬ DisposableBean
}九、BeanPostProcessor 的作用
考察点:AOP、@Autowired 都是靠它实现。
BeanPostProcessor 是 Bean 级后处理器,在每个 Bean 初始化前后做增强:
public interface BeanPostProcessor {
default Object postProcessBeforeInitialization(Object bean, String beanName) {
return bean; // 初始化前
}
default Object postProcessAfterInitialization(Object bean, String beanName) {
return bean; // 初始化后(AOP 在这里生成代理)
}
}典型实现:
AutowiredAnnotationBeanPostProcessor:处理@Autowired、@Value注入。CommonAnnotationBeanPostProcessor:处理@PostConstruct、@PreDestroy、@Resource。AnnotationAwareAspectJAutoProxyCreator:创建 AOP 代理。
// 自定义 BeanPostProcessor
@Component
public class MyBeanPostProcessor implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) {
if (bean instanceof OrderService) {
System.out.println("OrderService 初始化前处理");
}
return bean;
}
}十、BeanFactoryPostProcessor vs BeanPostProcessor
考察点:两个高频混淆的概念。
| 对比 | BeanFactoryPostProcessor | BeanPostProcessor |
|---|---|---|
| 作用对象 | 容器级,操作 BeanDefinition | Bean 级,操作 Bean 实例 |
| 时机 | Bean 实例化前 | Bean 初始化前后 |
| 典型实现 | ConfigurationClassPostProcessor(扫描注解) | AutowiredAnnotationBeanPostProcessor(注入) |
| 用途 | 修改 Bean 定义、处理占位符 | 依赖注入、AOP 代理 |
记忆:Factory 在前(改定义),Bean 在后(改实例)。
十一、注解驱动:@ComponentScan 如何工作
考察点:注解扫描的底层。
refresh()第 5 步执行ConfigurationClassPostProcessor(一个 BeanFactoryPostProcessor)。- 它识别
@Configuration类,解析@ComponentScan。 - 扫描包下所有
@Component(含@Service/@Repository/@Controller)。 - 把扫描到的类包装成 BeanDefinition 并注册。
@Configuration
@ComponentScan("com.example") // 扫描该包下的组件
public class AppConfig {
@Bean
public DataSource dataSource() {
return new DataSource();
}
}十二、依赖注入的方式
考察点:三种注入方式的对比。
| 方式 | 注解 | 特点 |
|---|---|---|
| 构造器注入 | 构造方法参数 | 依赖不可变,推荐,可解决 final 依赖 |
| Setter 注入 | @Autowired 方法 | 可选依赖,可重新配置 |
| 字段注入 | @Autowired 字段 | 简洁,但不利于测试、隐藏依赖 |
// 构造器注入(推荐,可加 final)
@Service
public class OrderService {
private final UserService userService;
public OrderService(UserService userService) {
this.userService = userService;
}
}十三、面试话术总结
面试官问「讲讲 Spring IOC」,按这个层次答:
概念:IOC 把对象创建和依赖管理交给容器,DI 是注入方式,好处是解耦。
容器体系:BeanFactory 是基础容器(getBean、懒加载),ApplicationContext 是其增强(国际化、事件、AOP、预加载单例),核心实现是 DefaultListableBeanFactory。
BeanDefinition:Bean 注册时包装成 BeanDefinition,存类名、作用域、懒加载等元数据。
refresh 流程:容器启动执行 refresh,关键三步是「执行 BeanFactoryPostProcessor 扫描注解 → 注册 BeanPostProcessor → 实例化所有单例 Bean」。
Bean 生命周期:实例化 → 属性填充 → Aware 回调 → BeanPostProcessor 前置 → 初始化(@PostConstruct/afterPropertiesSet/init-method)→ BeanPostProcessor 后置(AOP 代理)→ 使用 → 销毁。
BeanPostProcessor:AOP、@Autowired 都靠它实现,是 Spring 的扩展核心。