罗罗编程学习记录
本页内容 展开查看

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(实例化 + 注入 + 初始化)→ 刷新容器(完成剩余单例、发布事件)。

展开原理

  1. AnnotationConfigApplicationContext 构造时创建 AnnotatedBeanDefinitionReader 和 ClassPathBeanDefinitionScanner。
  2. refresh() 调用 invokeBeanFactoryPostProcessors,执行配置类解析、BeanFactoryPostProcessor。
  3. registerBeanPostProcessors 注册 Bean 后置处理器。
  4. finishBeanFactoryInitialization 冻结配置、实例化所有非懒加载单例。
  5. 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。

展开原理

  1. 实例化:反射调用构造器或工厂方法。
  2. 注入:按依赖解析填充属性/构造参数。
  3. Aware 回调:设置 BeanName、BeanFactory、ApplicationContext。
  4. 前置处理:postProcessBeforeInitialization,AOP 代理通常在这里创建。
  5. 初始化:@PostConstruct → afterPropertiesSet → 自定义 init。
  6. 后置处理:postProcessAfterInitialization。
  7. 销毁:容器关闭时逆序执行销毁回调。

图示

构造
 → 注入依赖
 → 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 是否线程安全