社区 › 安全 › 手写Spring框架-壹

俞秋荣 发表于 2025-11-5 11:16:12

手写Spring框架-壹

背景

最近工作比较轻松，于是趁着手里没有活，就打算自己写一个简单的Spring框架，因为之前背Spring的八股的时候老是背了就忘。
--本来前面写的好好的，也能勉强理解，但是到了第七章写应用上下文时，一下子来了十多个接口和抽象类，直接就蒙了，于是打算画图帮助理解，并且写博客记录，防止以后又忘了。。
参考

小傅哥：https://bugstack.cn/md/spring/develop-spring/2021-05-16-第1章：开篇介绍，手写Spring能给你带来什么？.html
因为前面第七章前面并不难，所以直接从第七章开始。
首先介绍一下Bean的生命周期：
1. 容器启动阶段

加载配置（XML、注解、JavaConfig）
解析成 BeanDefinition（class、scope、依赖等元信息）
注册到 BeanDefinitionRegistry
2. BeanFactoryPostProcessor 阶段

触发时机：在任何 Bean 实例化之前
作用：修改 BeanDefinition 的元信息
典型用途：占位符替换 ${}、动态修改属性值等
注意：此时 Bean 还没有被创建。
3. Bean 实例化阶段

Spring 调用构造方法 / 工厂方法，new 出对象。
此时只是一个“空壳对象”，还没有属性。
4. 属性填充（依赖注入）

Spring 根据 BeanDefinition 里的信息，进行 依赖注入：
XML 里配置的属性注入
构造器 / Setter 注入
时机：实例化之后，初始化之前
5. BeanPostProcessor 前置处理

调用 postProcessBeforeInitialization(bean, beanName)
在 Bean 初始化方法之前执行
6. 初始化方法

如果实现了 InitializingBean，执行 afterPropertiesSet()
7. BeanPostProcessor 后置处理

调用 postProcessAfterInitialization(bean, beanName)
8. Bean 就绪

现在 Bean 已经完全可用了，交给容器管理。
正文

本章的目标是实现满足于在 Bean 对象从容器启动到Bean可用的过程中执行用户的自定义操作，但是如果只是添加这两个接口，不做任何包装，那么对于使用者来说还是非常麻烦的。我们希望于开发 Spring 的上下文操作类，把相应的 XML 加载 、注册、实例化以及新增的修改和扩展都融合进去，让 Spring 可以自动扫描到我们的新增服务，便于用户使用。

提供给用户的扩展接口

首先是BeanFactoryPostProcessor接口,该接口是spring提供给用户使用的接口,用户实现该接口就可以在Bean实例化之前使用BeanFactory对Bean的注册信息进行操作。
注意：此时 Bean 还没被创建。
public interface BeanFactoryPostProcessor {
    /**
   * 在所有的 BeanDefinition 加载完成后，实例化 Bean 对象之前，提供修改 BeanDefinition 属性的机制
   *
   * @param beanFactory
   * @throws BeansException
   */
    void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;
}然后是实现BeanPostProcessor接口,该接口是spring提供给用户使用的接口，用户通过实现该接口，就可以在Bean初始化前后对Bean进行操作。
public interface BeanPostProcessor {
    /**
   * 在 Bean 对象执行初始化方法之前，执行此方法
   *
   * @param bean
   * @param beanName
   * @return
   * @throws BeansException
   */
    Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;

    /**
   * 在 Bean 对象执行初始化方法之后，执行此方法
   *
   * @param bean
   * @param beanName
   * @return
   * @throws BeansException
   */
    Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;
}Spring内部使用的接口

上面讲的是Spring提供给用户使用的接口，而spring内部也得有相关的定义，才能支持这种扩展
ListableBeanFactory接口

该接口的作用是可以获取IOC容器里的多个Bean，是对BeanFactory的扩展，BeanFactory一次只能获取一个Bean
public interface ListableBeanFactory extends BeanFactory{
    /**
   * 按照类型返回 Bean 实例
   * @param type
   * @param <T>
   * @return
   * @throws BeansException
   */
    <T> Map<String, T> getBeansOfType(Class<T> type) throws BeansException;

    /**
   * Return the names of all beans defined in this registry.
   *
   * 返回注册表中所有的Bean名称
   */
    String[] getBeanDefinitionNames();
}HierarchicalBeanFactory接口

这是一个标记性接口，定义了spring容器分层的概念
public interface HierarchicalBeanFactory extends BeanFactory {
}AutowireCapableBeanFactory接口

这个接口很容易与前面的BeanPostFactory接口混淆，这个接口是Spring内部使用的！！！
继承BeanFactory接口是需要获得getBean的能力,它本身提供了两个方法，用于在Bean初始化前后
public interface AutowireCapableBeanFactory extends BeanFactory {

    /**
   * 执行 BeanPostProcessors 接口实现类的 postProcessBeforeInitialization 方法
   * 在Bean初始化之前执行一些操作-BeforeInitialization
   *
   * @param existingBean
   * @param beanName
   * @return
   * @throws BeansException
   */
    Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName) throws BeansException;

    /**
   * 执行 BeanPostProcessors 接口实现类的 postProcessorsAfterInitialization 方法
   * 在Bean初始化之后执行一些操作-AfterInitialization
   *
   * @param existingBean
   * @param beanName
   * @return
   * @throws BeansException
   */
    Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName) throws BeansException;
}ConfigurableBeanFactory接口

继承HierarchicalBeanFactory代表支持容器分层的能力
继承SingletonBeanRegistry代表有获取单例Bean的能力
它的功能是在BeanFactory基础上，一个支持父子容器、单例缓存并且可以有生命周期扩展(BeanPostProcessor-Bean初始化前后扩展处理的能力)
并且具有保存和管理 BeanPostProcessor 列表的能力，定义了addBeanPostProcessor()方法
public interface ConfigurableBeanFactory extends HierarchicalBeanFactory, SingletonBeanRegistry {

    /**
   * 两种作用域
   */
    String SCOPE_SINGLETON = "singleton";

    String SCOPE_PROTOTYPE = "prototype";

    void addBeanPostProcessor(BeanPostProcessor beanPostProcessor);
}ConfigurableListableBeanFactory接口

这个接口非常重要，它继承了ListableBeanFactory(支持一次获取多个Bean的能力)、AutowireCapableBeanFactory(支持自动注入能力-创建和装配Bean)、
ConfigurableBeanFactory(支持作用域、配置、Bean初始化前后扩展的能力)
这代表了这个接口能够完整实现IOC容器的所有职责，实现了它就代表了是一个完整Spring容器！！！
public interface ConfigurableListableBeanFactory extends ListableBeanFactory, AutowireCapableBeanFactory, ConfigurableBeanFactory {
    BeanDefinition getBeanDefinition(String beanName) throws BeansException;

    void preInstantiateSingletons() throws BeansException;
}到了这里，Spring内部管理Bean实例的接口就创建好了，接下来创建上下文相关接口
ApplicationContext是对外的接口，给用户使用的，所以得继承ListableBeanFactory来获得对Bean的查询能力,方便用户获取Bean。
问题：为什么不继承其他继承了BeanFactory的接口,比如ConfigurableBeanFactory，它也有这些功能?
解答：还是上面那句话，ApplicationContext是给用户使用的，而ConfigurableBeanFactory是给容器内部使用的
ApplicationContext接口

public interface ApplicationContext extends ListableBeanFactory {
}ConfigurableApplicationContext接口

refresh()是spring容器的核心启动方法
这也是给spring内部容器使用的，所以单独创建了它，而不是在ApplicationContext里定义refresh()方法
public interface ConfigurableApplicationContext extends ApplicationContext{

    /**
   * 刷新容器
   * @throws BeansException
   */
    void refresh() throws BeansException;
}AbstractApplicationContext抽象类

该抽象类用模板方法模式实现了refresh()方法逻辑
并且继承了DefaultResourceLoader来获得加载资源的能力，因为refresh()需要解析xml文件加载Bean
public abstract class AbstractApplicationContext extends DefaultResourceLoader implements ConfigurableApplicationContext {
    @Override
    public void refresh() throws BeansException {
      // 1. 创建 BeanFactory，并加载 BeanDefinition
      refreshBeanFactory();

      // 2. 获取 BeanFactory
      ConfigurableListableBeanFactory beanFactory = getBeanFactory();

      // 3. 在 Bean 实例化之前，执行 BeanFactoryPostProcessor (Invoke factory processors registered as beans in the context.)
      // 真正执行了
      invokeBeanFactoryPostProcessors(beanFactory);

      // 4. BeanPostProcessor 需要提前于其他 Bean 对象实例化之前执行注册操作
      // 只是注册，加入到执行链中，并没有执行
      registerBeanPostProcessors(beanFactory);

      // 5. 提前实例化单例Bean对象
      beanFactory.preInstantiateSingletons();
    }

    /**
   * 获取所有实现了BeanPostProcessor的Bean，将它加到BeanPostProcessor执行链，getBeansOfType()返回的就是beanDefinitionMap的遍历顺序，也就是注册顺序
   * 即BeanPostProcessor执行链里执行的顺序是它的注册顺序
   * 如果需要改变执行的优先级，可以实现 PriorityOrdered 或 Ordered 接口
   * @param beanFactory
   */
    private void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
      Map<String, BeanPostProcessor> beanPostProcessorMap = beanFactory.getBeansOfType(BeanPostProcessor.class);
      for (BeanPostProcessor beanPostProcessor : beanPostProcessorMap.values()) {
            beanFactory.addBeanPostProcessor(beanPostProcessor);
      }
    }

    /**
   * 直接执行了BeanFactoryProcessor
   * @param beanFactory
   */
    private void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
      Map<String, BeanFactoryPostProcessor> beanFactoryPostProcessorMap = beanFactory.getBeansOfType(BeanFactoryPostProcessor.class);
      for (BeanFactoryPostProcessor beanFactoryPostProcessor:beanFactoryPostProcessorMap.values()){
            beanFactoryPostProcessor.postProcessBeanFactory(beanFactory);
      }
    }

    /**
   * 门面+委托模式的应用，在这里再次实现getBeansOfType只是因为ApplicationContext是对用户使用的，
   * 这里再次实现只是提供一个门面，但是真正实现还是委托给DefaultListableBeanFactory去做
   * @param type
   * @return
   * @param <T>
   * @throws BeansException
   */
    @Override
    public <T> Map<String, T> getBeansOfType(Class<T> type) throws BeansException {
      return getBeanFactory().getBeansOfType(type);
    }

    @Override
    public String[] getBeanDefinitionNames() {
      return getBeanFactory().getBeanDefinitionNames();
    }

    @Override
    public Object getBean(String beanName) {
      return getBeanFactory().getBean(beanName);
    }

    @Override
    public Object getBean(String beanName, Object... args) {
      return getBeanFactory().getBean(beanName, args);
    }

    @Override
    public <T> T getBean(String name, Class<T> requiredType) throws BeansException {
      return getBeanFactory().getBean(name, requiredType);
    }

    protected abstract void refreshBeanFactory() throws BeansException;

    protected abstract ConfigurableListableBeanFactory getBeanFactory();
}AbstractRefreshableApplicationContext抽象类

实现了父类AbstractApplicationContext的refreshBeanFactory()和getBeanFactory()方法
分担了父类AbstractApplicationContext的解析xml文件并创建beanFactory的职责
自己实现了创建beanFactory的功能
并且定义了抽象方法loadBeanDefinitions将解析xml文件的职责下发给子类
public abstract class AbstractRefreshableApplicationContext extends AbstractApplicationContext{
    private DefaultListableBeanFactory beanFactory;

    @Override
    protected void refreshBeanFactory() throws BeansException {
      DefaultListableBeanFactory beanFactory = createBeanFactory();
      loadBeanDefinitions(beanFactory);
      this.beanFactory = beanFactory;
    }

    protected abstract void loadBeanDefinitions(DefaultListableBeanFactory beanFactory);

    private DefaultListableBeanFactory createBeanFactory() {
      return new DefaultListableBeanFactory();
    }

    @Override
    protected ConfigurableListableBeanFactory getBeanFactory() {
      return this.beanFactory;
    }
}AbstractXmlApplicationContext抽象类

负责解析配置文件并注册Bean的功能
定义抽象方法getConfigLocations()将获取配置文件的职责下发
public abstract class AbstractXmlApplicationContext extends AbstractRefreshableApplicationContext{
    @Override
    protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) {
      XmlBeanDefinitionReader xmlBeanDefinitionReader = new XmlBeanDefinitionReader(this, beanFactory);
      String[] configLocations = getConfigLocations();
      if(null != configLocations && configLocations.length > 0) {
            xmlBeanDefinitionReader.loadBeanDefinitions(configLocations);
      }
    }

    protected abstract String[] getConfigLocations();
}ClassPathXmlApplicationContext抽象类

负责获取xml文件
ClassPathXmlApplicationContext是这条继承链的终点，也是spring容器启动的起点
通过调用refresh()来启动容器
public class ClassPathXmlApplicationContext extends AbstractXmlApplicationContext {
    private String[] configLocations;

    public ClassPathXmlApplicationContext() {}

    public ClassPathXmlApplicationContext(String configLocation) {
      this(new String[]{configLocation});
    }

    public ClassPathXmlApplicationContext(String[] configLocations) {
      this.configLocations = configLocations;
      //开启容器启动流程
      refresh();
    }

    @Override
    protected String[] getConfigLocations() {
      return configLocations;
    }
}spring容器内部在哪扩展？

BeanFactoryPostProcessor在AbstractApplicationContext抽象类的refresh()方法里直接执行，
而BeanPostProcessor只是在这里把所有实现了BeanPostProcessor的接口加入到BeanPostProcessor执行链。
而真正执行BeanPostProcessor是在Bean实例化之后，初始化前后，也就是AbstractAutowireCapableBeanFactory的createBean方法初始化前后
目前第七章的架构图



来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

查看完整版本: 手写Spring框架-壹