跳至主要內容

类继承体系图

高松灯大约 6 分钟

两个继承体系图的变化

这两张图展示了从完整 Spring 框架的设计模式到简化的 mini-spring 学习模式的演变。

图 1 (复杂图)：是 Spring 源码中标准的 DefaultListableBeanFactory 继承体系。 图 2 (简化图)：是 mini-spring（或早期/简化版实现）中的继承体系。

核心变化点和理解方式如下：

1. 核心变化点：接口隔离（Interface Segregation）的简化

变化：大量的“能力接口”被移除了。

  • 图 1 中：Spring 严格遵循接口隔离原则 (ISP)。它把 BeanFactory 的不同能力拆分成了极细粒度的接口：

    • ListableBeanFactory：表示具备枚举/列出所有 Bean 的能力。
    • HierarchicalBeanFactory：表示具备父子容器层级管理的能力。
    • ConfigurableBeanFactory：表示具备配置容器（如设置类加载器、属性编辑器）的能力。
    • AutowireCapableBeanFactory：表示具备自动装配的能力。
    • ConfigurableListableBeanFactory：集大成者，聚合了上述接口。

  • 图 2 中：这些细碎的接口都不见了（或被隐藏了）。

    • 只保留了最核心的 BeanFactory（获取 Bean）和 BeanDefinitionRegistry（注册 Bean 定义）。
    • 实现类（Abstract...）的继承关系没有变，依然是 DefaultSingletonBeanRegistry -> AbstractBeanFactory -> AbstractAutowireCapableBeanFactory -> DefaultListableBeanFactory。

2. 如何理解这种变化

你可以从以下三个维度来理解这种简化：

A. “骨架”未变，“皮肤”简化

  • 骨架（类继承）：你可以看到中间蓝色的类继承链条（AbstractBeanFactory 系列）在两张图中几乎是一样的。这意味着Bean 的生命周期处理逻辑、模板方法模式的运用核心逻辑没有变。
  • 皮肤（接口实现）：图 1 就像是一个即使在外部看也非常精密复杂的机器，每个按钮都有专门的标签（接口）。图 2 则是把外壳拆掉，只关注机器内部引擎是如何运转的。对于学习者来说，图 2 干扰更少，能让你聚焦于“类是如何通过继承复用代码的”。

B. 关注点转移：从“规范”到“实现”

  • 图 1 (Spring 原生)：侧重于定义规范。如果我是 Spring 的使用者，我拿到一个 ListableBeanFactory 接口，我就知道我只能遍历 Bean，不能修改配置。这是为了安全性、解耦和规范。
  • 图 2 (Mini-Spring)：侧重于理解实现。在手写 Spring 时，我们不需要过早地定义那么多复杂的接口来限制自己。我们主要目的是把 getBean 的流程跑通（实例化 -> 填充属性 -> 初始化）。

C. 循序渐进的学习路径

图 2 实际上是 Spring 容器最底层的物理结构。

  • DefaultSingletonBeanRegistry：管单例缓存的（Map<String, Object>）。
  • AbstractBeanFactory：管通用流程的（定义了 getBean 的模板方法）。
  • AbstractAutowireCapableBeanFactory：管创建 Bean 的（createBean, doCreateBean, populateBean）。
  • DefaultListableBeanFactory：管 BeanDefinition 存储的（Map<String, BeanDefinition>）。

总结： 这种变化是为了降低认知负荷。图 2 帮你剥离了复杂的接口定义干扰，让你直接看清 Spring 容器是如何通过这四层类的继承，一步步把一个 Bean 从定义变成实例的。当掌握了核心逻辑后，再回头看图 1，就会明白那些接口只是为了对这些能力进行更好的分类和暴露而已。

图一展示了 Spring 框架中 IoC 容器（BeanFactory） 最核心、最经典的继承体系。这个体系通过接口隔离原则将容器的能力拆分得非常细致。

我们可以将图一中的组件分为三大类来理解：顶层核心接口、能力扩展接口、以及骨架抽象类。

1. 顶层核心接口（定义“是什么”）

这些接口定义了容器最基本的功能契约。

  • BeanFactory (顶端)

    • 地位：Spring IoC 容器的根接口。
    • 职责：定义了获取 Bean 的最基本方法，如 getBean(String name)、containsBean、isSingleton 等。它是客户端（Client）看待容器的视角——“我只管找你要对象，不关心你怎么创建的”。

  • SingletonBeanRegistry (左上)

    • 职责：定义了单例对象（Singleton Object）的注册和获取标准。
    • 核心逻辑：Spring 默认的单例池（三级缓存）就是为了满足这个接口的契约。

  • BeanDefinitionRegistry (左下)

    • 职责：定义了Bean 定义信息（BeanDefinition）的注册、移除和查询标准。
    • 比喻：如果说 BeanFactory 是生产车间，那这个 Registry 就是“图纸库”，管理着所有 Bean 的设计图纸。

2. 能力扩展接口（定义“能做什么”）

Spring 将不同的能力拆解到不同的接口中，只有实现了特定接口的容器才具备相应的功能。

  • ListableBeanFactory (右上)

    • 职责：赋予容器批量查询/枚举 Bean 的能力。
    • 场景：BeanFactory 只能一个一个拿 Bean，而这个接口支持 getBeansOfType（获取所有某个类型的 Bean）、getBeanDefinitionNames（获取所有 Bean 的名字）。

  • HierarchicalBeanFactory (中上)

    • 职责：赋予容器父子层级管理的能力。
    • 场景：允许容器有一个 Parent Factory。当在当前容器找不到 Bean 时，去父容器找（类似于 Java 类加载器的双亲委派）。MVC 场景中常用（Service层容器是 Controller层容器的父容器）。

  • AutowireCapableBeanFactory (中间)

    • 职责：赋予容器自动装配（Autowire）和完整创建 Bean 的能力。
    • 核心：定义了 createBean、autowireBean、initializeBean 等方法。它是真正干活的接口，负责 Bean 的生命周期（实例化 -> 属性填充 -> 初始化）。通常是框架内部使用，普通用户很少直接用。

  • ConfigurableBeanFactory (中间)

    • 职责：赋予容器可配置的能力。
    • 场景：设置类加载器、设置 BeanPostProcessor、设置类型转换器等。它包含了 SingletonBeanRegistry 和 HierarchicalBeanFactory。

  • ConfigurableListableBeanFactory (右下)

    • 职责：集大成者。
    • 地位：它是大多数 ApplicationContext（应用上下文）组合使用的底层 BeanFactory 类型。它聚合了上述几乎所有接口的能力（除了 BeanDefinitionRegistry）。

3. 骨架抽象类（定义“怎么做”）

这些抽象类通过模板方法模式实现了上述接口的通用逻辑，留出钩子（Hook）给子类去定制。

  • DefaultSingletonBeanRegistry (左上)

    • 实现：实现了 SingletonBeanRegistry 接口。
    • 核心贡献：实现了单例缓存池（那个著名的 Map<String, Object> singletonObjects 就在这里）。它解决了“单例 Bean 存在哪”的问题。

  • AbstractBeanFactory (中间)

    • 实现：继承自 DefaultSingletonBeanRegistry，实现了 ConfigurableBeanFactory。
    • 核心贡献：实现了 getBean 的主流程。它定义了获取 Bean 的标准算法骨架（先查缓存 -> 没命中则创建 -> 处理父容器 -> 处理依赖等），但具体的创建动作（Create）留给了子类。

  • AbstractAutowireCapableBeanFactory (中间下)

    • 实现：继承自 AbstractBeanFactory，实现了 AutowireCapableBeanFactory。
    • 核心贡献：实现了 Bean 的创建流程（createBean）。
    • 细节：它实现了 Bean 的实例化（反射/CGLIB）、属性填充（populateBean）、初始化（initializeBean）等最核心的生命周期逻辑。

总结图一的结构逻辑

图一展示了一个倒金字塔般的构建过程：

  1. 最上面是接口，定义各种单一职责（查单例、查列表、配父子、做装配）。
  2. 中间是抽象类，一层层地实现逻辑：
    • 先管好单例存取（DefaultSingletonBeanRegistry）
    • 再管好获取流程（AbstractBeanFactory）
    • 最后管好生产流程（AbstractAutowireCapableBeanFactory）
  3. 最下面是 DefaultListableBeanFactory，它继承了所有抽象类的实现逻辑，同时实现了 BeanDefinitionRegistry 接口（管理图纸），成为了 Spring 默认的、功能最全的 Bean 工厂。