← 课程目录 🚀 从零到一
📐 学习维度 阶段7 · 第27章 手写框架系列 🚀 从零到一 📚 课程目录 🏠 首页 🛤️ 学习路径

27.1 手写 IoC 容器复盘:475 行装下 Spring 的心脏

审校 2026-09-25 · 素材来源:zhouyu-mini-spring-vip 源码复盘、L10
📑 本篇章节导航 (共9节,点击直达)
总览:三个 Map 撑起容器createBean:生命周期的微缩胶卷BeanPostProcessor:一切魔法的插口getBean 与作用域scan 的细节:从包名到 class 文件手写之后回看 Spring 源码复盘清单:手写 IoC 的六个坑面试怎么问一句话总结

13.5 走过 mini-spring 的骨架流程,这一节换复盘视角:把一个真实可跑的手写 IoC 容器(四百余行)逐层拆开,看每一块对应 Spring 的哪个设计、手写时最容易在哪翻车——手写框架的价值从来不是造轮子自用,是把「Spring 帮我做了什么」从黑盒变成肌肉记忆,面试聊到 Bean 生命周期、循环依赖、扩展点时,答案全部来自这段代码。

总览:三个 Map 撑起容器

手写容器的全部状态就三个集合:beanDefinitionMap(beanName→BeanDefinition, Bean 的「图纸」)、singletonObjects(beanName→实例,单例池)、beanPostProcessorList(后置处理器链)。启动两阶段:先 scan(解析配置类上的 @ComponentScan,把包路径转目录,遍历 class 文件,带 @Component 注解的类登记进 beanDefinitionMap——beanName 默认 Introspector.decapitalize(类名));后实例化(遍历图纸,单例且非懒加载的逐个 createBean,BPP 类型的优先创建——后置处理器必须先于普通 Bean 存在,否则第一个 Bean 就错过了增强机会,这是新手第一坑)。两阶段分离正对应 Spring 的 loadBeanDefinitions 与 refresh 的分野:图纸与实例分开管,才能支持懒加载、prototype、条件装配这些花活。

createBean:生命周期的微缩胶卷


Object instance = beanClass.getConstructor().newInstance();   // 1 实例化
for (Field f : beanClass.getDeclaredFields())                  // 2 依赖注入
  if (f.isAnnotationPresent(Autowired.class)) {
    f.setAccessible(true); f.set(instance, getBean(f.getName()));
  }
for (BeanPostProcessor p : bppList)                            // 3 初始化前 BPP
  instance = p.postProcessBeforeInitialization(instance, beanName);
for (Method m : beanClass.getDeclaredMethods())                // 4 @PostConstruct
  if (m.isAnnotationPresent(PostConstruct.class)) m.invoke(instance);
if (instance instanceof InitializingBean ib) ib.afterPropertiesSet(); // 5
if (instance instanceof BeanNameAware a) a.setBeanName(beanName);     // 6 Aware回调
if (instance instanceof ApplicationContextAware a) a.setApplicationContext(this);
for (BeanPostProcessor p : bppList)                            // 7 初始化后 BPP
  instance = p.postProcessAfterInitialization(instance, beanName);

七步对齐 13.2 的生命周期长卷:实例化→属性填充→Aware 回调→初始化前→初始化→初始化后。手写时最扎心的是顺序细节:@Autowired 按字段名 getBean(name) 递归获取依赖——依赖注入的本质就是递归 createBean;递归没有终止保护,A 依赖 B、B 又依赖 A 就无限循环栈溢出。Spring 用三级缓存解(13.2 讲过原理),手写版想支持循环依赖,最小改法是实例化与属性填充两步之间先把半成品引用放进单例池(提前曝光)——写一遍才知道为什么 Spring 必须是「三级」而不是「一级」:一级只能解单例 setter 注入,构造器注入与 prototype 仍然无解,多出来的缓存层级是为了代理场景的正确性。

BeanPostProcessor:一切魔法的插口

手写版只注册了一个 BPP——AopBeanPostProcessor(27.2 的主角),但这个插口的分量要从 Spring 侧看:@Autowired 的 AutowiredAnnotationBeanPostProcessor、@PostConstruct 的 CommonAnnotationBeanPostProcessor、AOP 的 AnnotationAwareAspectJAutoProxyCreator 全是 BPP。Spring 把「容器默认行为之外的一切增强」都设计成 BPP 插件——容器核心只负责生命周期流水线,每个环节留出「前后钩子」,功能通过插卡扩展。这是开闭原则的教科书实现:加功能不改容器代码,写一张新卡。手写时体会最深的坑:BPP 的 postProcessAfterInitialization 返回的是新对象(代理),容器必须用返回值替换单例池里的引用——忘了接返回值,代理就白创建了,调用方拿到的还是原生对象,AOP 静默失效(13.3 说过的「事务失效」同源坑)。

还有个顺序细节值得一记:初始化前 BPP 与 Aware 回调谁先谁后,手写版可以随意排,Spring 源码里是严格的——Aware 回调在最早(BeanNameAware→BeanFactoryAware→ApplicationContextAware),然后初始化前 BPP,然后 @PostConstruct 与 afterPropertiesSet,最后初始化后 BPP。为什么 Aware 必须最先?因为它注入的是「容器视角的信息」(我叫什么、我在哪个容器),后面的初始化逻辑可能就要用这些信息;而代理为什么必须在最后?因为 @PostConstruct 里如果已经拿了代理外的原对象引用,后织入就换不掉了——顺序不是规定出来的,是场景推导出来的。

getBean 与作用域


public Object getBean(String beanName) {
  BeanDefinition bd = beanDefinitionMap.get(beanName);
  if (bd.getScope().equals("singleton")) {
    Object bean = singletonObjects.get(beanName);
    if (bean == null) { bean = createBean(beanName, bd);
      singletonObjects.put(beanName, bean); }
    return bean;
  }
  return createBean(beanName, bd);   // prototype 每次新建
}

十行代码讲清两个作用域:单例「池里有就还、没有就造」,prototype「每次都造不进池」。scan 时 @Scope 注解决定图纸的 scope 字段,getBean 时按图施工——作用域是图纸属性不是实例属性,这个设计让同一个类可以按不同配置注册不同作用域。对照 13.2:Spring 还有 request/session/websocket 等_web_作用域,本质是「池」换成 requestMap/sessionMap,套路不变。

scan 的细节:从包名到 class 文件

scan 这一步手写时最容易想当然。配置类上的 @ComponentScan("com.demo.service") 只是一个字符串,要变成「哪些类该注册」,中间有三跳:类加载器把包名的点换成斜杠拿到资源路径(ClassLoader.getResources("com/demo/service")),资源 URL 转成 File 目录后递归遍历拿 class 文件清单,文件名去后缀再反射成 Class 对象读注解。三跳里每一跳都藏着版本差异:打进 jar 包里的类没有「目录」概念,文件系统遍历直接失效——手写版只支持目录形态是已知边界,Spring 生产环境用 ASM 直接读字节码流,连类都不加载就拿到了注解信息:扫描阶段不触发类初始化,是刻意的性能与安全设计——五十个类里只有一个带 @Component,为判断注解就把五十个类全初始化一遍是巨大浪费。这个细节面试可以主动讲:它解释了为什么 Spring 的扫描工具类叫 ClassPathScanningCandidateComponentProvider——「候选」二字说明扫描只提名、注册另审。

手写之后回看 Spring 源码

跑通手写版再翻 Spring 源码,地图会瞬间对上:beanDefinitionMap 对应 DefaultListableBeanFactory 的 beanDefinitionMap 字段,singletonObjects 对应 DefaultSingletonBeanRegistry 的同名一级缓存,getBean 的入口在 AbstractBeanFactory#doGetBean——方法体里「先查三级缓存、miss 才 createBean」的结构与手写版「先查池、miss 才造」只差缓存层数。refresh 方法十二步里,手写版覆盖了 registerBeanPostProcessors 与 finishBeanFactoryInitialization 两步的核心语义:Spring 的复杂度是工程化的复杂度(生命周期钩子的完整性、并发的正确性、错误的可诊断性),不是思想的复杂度。带着手写版的四百行去读源码,读的是「它在哪一步比我多做了什么」——这个读法比从第一行硬啃高效一个数量级,也是手写复盘真正的收官动作。

复盘清单:手写 IoC 的六个坑

一,BPP 没优先创建——普通 Bean 错过增强;二,BPP 返回值没接——代理静默丢失;三,scan 只扫一级目录——File.listFiles() 不递归,子包全丢(Spring 用 ASM 读字节码扫全层级);四,beanName 没做 decapitalize——UserService 注册成 userService 才与 Spring 口径一致,否则 @Autowired byName 找不到;五,异常全包成 RuntimeException——排查时丢根因,至少保留 cause 链;六,懒加载只写了字段没实现逻辑——图纸与 getBean 联动才算数。

面试怎么问

一句话总结

四百行手写 IoC 的价值:scan/图纸/单例池/BPP 四个概念一旦亲手跑通,Spring 的生命周期、循环依赖、扩展点就全从「背的」变成「见的」——面试聊原理时的底气,就来自这四百行。