06.2.1.1 IoC 容器与 Bean 生命周期
所属:全栈开发面试题库 / 06 后端框架与工程实践 / 06.2 Java Spring 生态 / 06.2.1 Spring Framework
本节要解决的问题
- 为什么不能到处
new对象? - Spring 在启动时到底创建了哪些东西?
- 一个 Bean 从“被扫描到”到“可销毁”经历了哪些步骤?
06.2.1.1-001 什么是 IoC,为什么需要它?
一句话结论
IoC(Inversion of Control,控制反转)是把“创建对象、组装依赖”的控制权从业务代码交给容器;业务类只声明需要什么,容器负责给它。
概念解释
传统写法里,OrderService 自己 new OrderRepository(),于是“谁依赖谁、用哪个实现、什么时候创建”都写死在业务代码里。IoC 把这件事反转过来:容器读配置/注解,先创建对象,再按依赖关系注入。
它解决的问题
- 解耦:业务类不关心实现类怎么构造。
- 可替换:换实现只改配置/注解。
- 可管理:容器统一处理单例、生命周期、代理、销毁。
示例
@Service
public class OrderService {
private final OrderRepository repo;
public OrderService(OrderRepository repo) { // 只声明依赖
this.repo = repo;
}
}
常见误区
- IoC 不等于 DI。IoC 是“控制权交给容器”,DI(依赖注入)是其中一种实现方式。
- 容器不是“自动 new”,而是按 BeanDefinition 元数据创建并缓存。
追问
- IoC 和工厂模式什么关系?工厂是“主动找工厂要对象”,IoC 是“容器把对象送进来”,控制方向相反。
- 没有 IoC 就一定不好吗?小应用、工具类用
new更直接;复杂依赖树才需要容器。
06.2.1.1-002 Spring 容器启动时大致做了什么?
一句话结论
启动分三步:准备 BeanDefinition(扫描 + 解析)→ 创建并初始化单例 Bean(实例化 + 注入 + 初始化)→ 刷新容器(完成剩余单例、发布事件)。
展开原理
AnnotationConfigApplicationContext构造时创建AnnotatedBeanDefinitionReader和ClassPathBeanDefinitionScanner。refresh()调用invokeBeanFactoryPostProcessors,执行配置类解析、BeanFactoryPostProcessor。registerBeanPostProcessors注册 Bean 后置处理器。finishBeanFactoryInitialization冻结配置、实例化所有非懒加载单例。finishRefresh发布ContextRefreshedEvent,启动生命周期处理器。
图示
new ApplicationContext
→ 读取配置类 / 扫描包
→ 生成 BeanDefinition 注册表
→ 执行 BeanFactoryPostProcessor(可改定义)
→ 注册 BeanPostProcessor
→ 实例化单例:构造 → 注入 → 初始化
→ 发布 ContextRefreshedEvent
常见误区
- “容器启动 = 所有 Bean 都创建”。原型 Bean、
@Lazy、FactoryBean 产物不一定在启动时创建。 BeanFactoryPostProcessor阶段 Bean 还没实例化,不能在这里注入业务 Bean。
追问
- 为什么先注册 BeanPostProcessor 再实例化?因为实例化过程中就要回调它们。
ContextRefreshedEvent能重复发布吗?可以,多次refresh()会重复触发,监听器要幂等。
06.2.1.1-003 BeanFactory 和 ApplicationContext 有什么区别?
一句话结论
BeanFactory 是最底层容器接口,负责 Bean 的获取与生命周期;ApplicationContext 在它之上增加了事件、国际化、资源、环境、AOP 等企业级能力。
对比
| 能力 | BeanFactory | ApplicationContext |
|---|---|---|
| 获取 Bean | 支持 | 支持(继承) |
| 事件发布 | 不支持 | 支持 |
| 国际化/资源 | 不支持 | 支持 |
| 自动注册 BeanPostProcessor | 否 | 是 |
| 典型实现 | DefaultListableBeanFactory | AnnotationConfigApplicationContext |
示例
BeanFactory factory = new DefaultListableBeanFactory();
ApplicationContext ctx = new AnnotationConfigApplicationContext(AppConfig.class);
常见误区
- 直接
new DefaultListableBeanFactory()不会自动执行注解扫描和后置处理器,需要手动注册。 ApplicationContext不是“另一个容器”,而是BeanFactory的增强包装。
追问
- 为什么说 BeanFactory 是“骨架”?它定义了
getBean、作用域、类型匹配等最小契约。 - Web 环境用哪个?
WebApplicationContext,额外提供 ServletContext 与 Web 作用域。
06.2.1.1-004 BeanDefinition 是什么,Bean 是如何被注册的?
一句话结论
BeanDefinition 是 Bean 的“元数据图纸”,描述类名、作用域、是否懒加载、构造参数、属性值、初始化方法等;容器根据它创建 Bean。
展开原理
- 来源:注解扫描(
@Component)、@Bean方法、XML、BeanDefinitionRegistryPostProcessor手动注册。 - 关键字段:
beanClassName、scope、lazyInit、dependsOn、autowireCandidate、primary。 - 注册表:
DefaultListableBeanFactory内的beanDefinitionMap,按 beanName 索引。
示例
BeanDefinitionRegistry registry = (BeanDefinitionRegistry) context.getBeanFactory();
BeanDefinition bd = BeanDefinitionBuilder
.genericBeanDefinition(UserService.class)
.setScope(BeanDefinition.SCOPE_SINGLETON)
.getBeanDefinition();
registry.registerBeanDefinition("userService", bd);
常见误区
- BeanDefinition 不等于 Bean 实例;定义可以存在但没有实例化。
- 同名 Bean 覆盖受
allowBeanDefinitionOverriding控制,Boot 2.1 后默认禁止。
追问
- 什么时候修改 BeanDefinition?
BeanFactoryPostProcessor或BeanDefinitionRegistryPostProcessor。 - 为什么需要它?把“配置”和“实例化”分离,才能做条件装配、代理、懒加载。
06.2.1.1-005 请完整说出 Bean 的生命周期。
一句话结论
实例化 → 属性注入 → BeanNameAware/BeanFactoryAware 等回调 → BeanPostProcessor.postProcessBeforeInitialization → @PostConstruct → InitializingBean.afterPropertiesSet → init-method → postProcessAfterInitialization → 使用 → @PreDestroy → DisposableBean.destroy → destroy-method。
展开原理
- 实例化:反射调用构造器或工厂方法。
- 注入:按依赖解析填充属性/构造参数。
- Aware 回调:设置 BeanName、BeanFactory、ApplicationContext。
- 前置处理:
postProcessBeforeInitialization,AOP 代理通常在这里创建。 - 初始化:
@PostConstruct→afterPropertiesSet→ 自定义 init。 - 后置处理:
postProcessAfterInitialization。 - 销毁:容器关闭时逆序执行销毁回调。
图示
构造
→ 注入依赖
→ Aware 回调
→ BPP.before
→ @PostConstruct
→ afterPropertiesSet
→ init-method
→ BPP.after
→ 使用
→ @PreDestroy
→ destroy
常见误区
@PostConstruct执行时 AOP 代理可能还没包上(取决于代理创建时机)。- 原型 Bean 不走完整销毁流程,容器不管理其销毁。
追问
- 为什么
@PostConstruct比构造器适合初始化?此时依赖已注入。 - 销毁顺序是什么?依赖者先销毁,被依赖者后销毁(近似逆序)。
06.2.1.1-006 单例 Bean 是线程安全的吗?
一句话结论
不是。Spring 只保证 Bean 是单实例,不保证其内部状态线程安全;有可变成员变量就有并发风险。
概念解释
单例意味着所有请求共用同一个对象。若 Bean 内有 int count++、SimpleDateFormat、可变缓存等状态,就会出现竞态。
示例
@Service
public class UnsafeService {
private int count; // 共享可变状态
public void inc() { count++; } // 非原子
}
修复:改为无状态、方法内局部变量、ThreadLocal、AtomicInteger 或加锁。
常见误区
- “Spring Bean 默认单例,所以线程安全”是错误因果。
- Controller 里放成员变量
currentUser是高危写法。
追问
- 哪些 Bean 天生安全?无状态 Service、不可变配置、DAO(依赖连接池线程安全)。
- 原型 Bean 就安全吗?每次新实例,但仍可能共享外部静态状态。
06.2.1.1-007 Spring 有哪些 Bean 作用域?
一句话结论
常用 singleton(默认,每容器一个)和 prototype(每次获取新建);Web 环境还有 request、session、application 等作用域。
展开原理
- singleton:缓存于 singletonObjects,生命周期由容器管理。
- prototype:不缓存,每次
getBean创建,销毁不归容器管。 - request/session:由
WebApplicationContext的RequestObjectFactory等作用域对象提供,依赖当前请求上下文。
示例
@Bean
@Scope("prototype")
public Task task() { return new Task(); }
常见误区
- 原型 Bean 注入到单例 Bean 里,只会注入一次,不会每次请求都新建。
- 原型 Bean 用
@PreDestroy不一定被调用。
追问
- 什么时候用原型?有状态、短生命周期、每次需要独立实例的任务对象。
- 单例 Bean 依赖原型 Bean 有什么问题?单例只持有第一次注入的实例,语义不符合预期。
06.2.1.1-008 @Component、@Bean、@Import 有什么区别?
一句话结论
@Component 标在类上让扫描器注册 Bean;@Bean 标在配置方法上由方法返回值注册;@Import 显式引入配置类或普通类,不依赖包扫描。
对比
| 方式 | 适用 | 是否可控制实例化 | 典型场景 |
|---|---|---|---|
@Component |
自己写的类 | 否,构造由容器 | Service/Controller |
@Bean |
第三方类、需要手工构造 | 是,方法内可写逻辑 | 数据源、线程池 |
@Import |
配置类/按需引入 | 否 | 模块化配置 |
示例
@Configuration
public class DataConfig {
@Bean(destroyMethod = "close")
public HikariDataSource dataSource() {
HikariDataSource ds = new HikariDataSource();
ds.setJdbcUrl("jdbc:mysql://localhost/app");
return ds;
}
}
常见误区
@Bean方法所在类必须是@Configuration或至少是配置候选类,否则可能被当普通工厂方法。@Component扫描不到是因为不在扫描包下,或类没被代理/被排除。
追问
@Bean方法之间能互相调用吗?可以,但@Configuration代理保证返回单例;@Component内调用则每次新建。@Import和@ComponentScan怎么选?模块化/第三方配置用 Import,自己包内用扫描。
06.2.1.1-009 FactoryBean 和 BeanFactory 有什么区别?
一句话结论
BeanFactory 是容器本身;FactoryBean 是“生产 Bean 的工厂 Bean”,用来把复杂创建逻辑封装成一个可注入的对象。
概念解释
当创建过程很复杂(如 MyBatis 的 SqlSessionFactory、代理对象),无法简单用构造器表达,就实现 FactoryBean<T>,容器调用 getObject() 得到真正对象。
示例
public class UserClientFactoryBean implements FactoryBean<UserClient> {
public UserClient getObject() { return UserClient.create(); }
public Class<?> getObjectType() { return UserClient.class; }
public boolean isSingleton() { return true; }
}
常见误区
getBean("&factoryBeanName")取工厂本身,getBean("factoryBeanName")取产物。- FactoryBean 产物的生命周期由工厂管理,容器不直接销毁。
追问
- 为什么 MyBatis 用 FactoryBean?因为它要构建代理接口、扫描 Mapper,逻辑不适合裸构造。
- FactoryBean 和
@Bean怎么选?简单对象用@Bean,需要暴露“工厂语义”或被框架识别时用 FactoryBean。
06.2.1.1-010 BeanPostProcessor 是什么,执行顺序如何?
一句话结论
BeanPostProcessor 是容器在 Bean 初始化前后插入的回调,用来修改/包装 Bean;多个处理器按 Ordered/@Order 排序,postProcessBeforeInitialization 顺序执行,postProcessAfterInitialization 逆序执行。
展开原理
- 注册:
PostProcessorRegistrationDelegate按 PriorityOrdered、Ordered、无序分组注册。 - 前置:所有处理器依次调用 before;后置:按注册顺序的逆序调用 after。
- 典型实现:
AutowiredAnnotationBeanPostProcessor(注入)、CommonAnnotationBeanPostProcessor(@PostConstruct)、AbstractAutoProxyCreator(AOP 代理)。
示例
@Component
public class TimingBpp implements BeanPostProcessor {
public Object postProcessAfterInitialization(Object bean, String name) {
return bean; // 可返回代理
}
}
常见误区
- 在后置处理器里返回新对象会替换容器中的 Bean,但依赖已注入的旧引用不会自动更新。
@PostConstruct由CommonAnnotationBeanPostProcessor触发,不是容器直接调用。
追问
- 为什么 AOP 代理在 after 阶段创建?此时 Bean 已完成初始化,代理可安全包裹。
- 如何保证自己的处理器最先执行?实现
PriorityOrdered并设置最高优先级。
本节自检
- [ ] 能说出 IoC 与 DI 的区别
- [ ] 能画出 Bean 生命周期
- [ ] 能解释 BeanDefinition 的作用
- [ ] 能说出 BeanPostProcessor 的 before/after 顺序
- [ ] 能判断一个单例 Bean 是否线程安全