源码学习 Spring 容器初始化流程

2024-12-19

共计 15146 个字符，预计需要花费 38 分钟才能阅读完成。

本文以 ClassPathXmlApplicationContext 源码学习 Spring 初始化流程，那么首先要了解它实现了哪些接口，可以直观地了解到它具备了哪些能力。

源码学习 Spring 容器初始化流程

最重要的一点是它实现了 BeanFactory 接口，BeanFactory 其实就是常说的 ioc 容器，因为它实现了该接口，所以 ClassPathXmlApplicationContext 也是 ioc 容器。重点来了，ClassPathXmlApplicationContext 虽然实现了接口，但是它重写 BeanFactory 的方法都是委托给了成员变量 beanFactory 去实现。下面的代码都是其基类实现的。

// AbstractApplicationContext 实现
@Override
public <T> T getBean(Class<T> requiredType) throws BeansException {
    assertBeanFactoryActive();
    return getBeanFactory().getBean(requiredType);
}

// AbstractRefreshableApplicationContext 实现
@Override
public final ConfigurableListableBeanFactory getBeanFactory() {
    DefaultListableBeanFactory beanFactory = this.beanFactory;
    if (beanFactory == null) {
        throw new IllegalStateException("BeanFactory not initialized or already closed - " +
                "call 'refresh' before accessing beans via the ApplicationContext");
    }
    return beanFactory;
}

ClassPathXmlApplicationContext 不但实现了 BeanFactory 接口，并且实现了其他的接口为容器扩展了功能如：消息国际化、资源解析器、事件发布、获取环境变量等功能。

构造函数时创建 ioc 容器的入口，代码如下：

public ClassPathXmlApplicationContext(
        String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)
        throws BeansException {

    super(parent);
    setConfigLocations(configLocations);
    if (refresh) {
        refresh();
    }
}

执行构造方法，每个 ApplicationContext 都有自己的实现，但是都会初始化容器状态标识 active、closed。

ClassPathXmlApplicationContext 在执行构造方法时，并不会初始化 beanFactory。而 AnnotationConfigApplicationContext 在初始化时并创建好 beanFactory，并将 internalConfigurationAnnotationProcessor、internalAutowiredAnnotationProcessor 等几个后 bean 后处理器注入，用于解析 @Configuration、@Autowired等注解。如果全部以 xml 的形式给容器注入 bean，那么是不需要这几个后处理器的，但是如果需要配置文件的方式也能使用注解，就需要配置 <context:annotation-config/>

不管怎么说，都会执行 refresh() 方法用于刷新容器。其中 AbstractApplicationContext 的 refresh() 方法，代码如下：

@Override
public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
        // 执行刷新容器前的一些必要方法
        prepareRefresh();

        // 调用子类获取到 bean 工厂
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

        // 配置 bean 工厂，以增强功能
        prepareBeanFactory(beanFactory);

        try {
            // 修改和调整 Bean 的定义（默认没有实现）
            postProcessBeanFactory(beanFactory);

            // 调用后置处理器
            invokeBeanFactoryPostProcessors(beanFactory);

            // 注册 BeanPostProcessor，用于修改和增强 bean 的功能
            registerBeanPostProcessors(beanFactory);

            // 为上下文初始化 Message 源，即对不同语言的消息体进行国际化处理
            initMessageSource();

            // 初始化容器事件传播器
            initApplicationEventMulticaster();

            // 调用子类的某些特殊 Bean 初始化方法
            onRefresh();

            // 为事件传播器注册事件监听器（这里用到了观察者模式）
            registerListeners();

            // 初始化 Bean，并对 lazy-init 属性进行处理
            finishBeanFactoryInitialization(beanFactory);

            // Last step: publish corresponding event.
            finishRefresh();
        }

        catch (BeansException ex) {
            if (logger.isWarnEnabled()) {
                logger.warn("Exception encountered during context initialization - " +
                        "cancelling refresh attempt: " + ex);
            }

            // 销毁创建的单态 Bean
            destroyBeans();

            // 取消 refresh 操作，重置容器的同步标识.
            cancelRefresh(ex);

            // Propagate exception to caller.
            throw ex;
        }

        finally {
            // Reset common introspection caches in Spring's core, since we
            // might not ever need metadata for singleton beans anymore...
            resetCommonCaches();
        }
    }
}

1. `prepareRefresh`

protected void prepareRefresh() {

    // 设置容器的启动时间，以便在刷新容器时进行时间跟踪
    this.startupDate = System.currentTimeMillis();
    // 容器在关闭时会设置该值为true，此时容器不能再进行一些初始化操作。
    this.closed.set(false);
    // 将容器的活动状态设置为true，表示容器当前处于活动状态。
    this.active.set(true);

    if (logger.isDebugEnabled()) {
        if (logger.isTraceEnabled()) {
            logger.trace("Refreshing " + this);
        }
        else {
            logger.debug("Refreshing " + getDisplayName());
        }
    }

    // 初始化容器中可能使用的占位符属性源，例如 ${some.property}，确保这些占位符被正确解析和设置。（这里的属性包含 JVM 属性 systemProperties，和操作系统的环境变量 systemEnvironment）
    // 这是个空方法，是留给子类实现的。
    initPropertySources();

    // 验证所需要的属性都存在，否则抛出异常
    getEnvironment().validateRequiredProperties();

    // 设置监听器
    if (this.earlyApplicationListeners == null) {
        this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
    }
    else {
        // Reset local application listeners to pre-refresh state.
        this.applicationListeners.clear();
        this.applicationListeners.addAll(this.earlyApplicationListeners);
    }

    this.earlyApplicationEvents = new LinkedHashSet<>();
}

通过继承 ClassPathXmlApplicationContext 可以重写 initPropertySources() 方法，启动时校验必要参数。

public class MyInitApplicationContext extends ClassPathXmlApplicationContext {

    public MyInitApplicationContext(String configLocation) throws BeansException {
        super(configLocation);
    }

    @Override
    protected void initPropertySources() {
        super.initPropertySources();
        System.out.println("test");
        getEnvironment().setRequiredProperties("aaa");
    }
}

2. `obtainFreshBeanFactory`

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {

    // 自己定义了抽象的 refreshBeanFactory() 方法，具体实现交给了自己的子类
    refreshBeanFactory();
    return getBeanFactory();
}

protected abstract void refreshBeanFactory() throws BeansException, IllegalStateException;

obtainFreshBeanFactory 方法用于创建 bean 工厂，调用 refreshBeanFactory 方法为一个抽象方法，需要子类自行实现。这里有一个好处，就是比如使用 xml 文件和注解方式，因为他们获取 bean 信息方式不同，可以通过自己重写该方法创建工厂。

refreshBeanFactory() 方法交由子类 AbstractRefreshableApplicationContext 实现：

@Override
protected final void refreshBeanFactory() throws BeansException {
    // 如果已经建立了 IoC 容器，则销毁并关闭容器
    if (hasBeanFactory()) {
        destroyBeans();
        closeBeanFactory();
    }
    try {
        // 创建 beanFactory 容器，DefaultListableBeanFactory 类实现了 ConfigurableListableBeanFactory 接口
        DefaultListableBeanFactory beanFactory = createBeanFactory();
        beanFactory.setSerializationId(getId());
        // 添加一些自定义操作
        customizeBeanFactory(beanFactory);
        // 载入 BeanDefinition，在当前类中只定义了抽象的 loadBeanDefinitions() 方法，具体实现 调用子类容器
        loadBeanDefinitions(beanFactory);
        this.beanFactory = beanFactory;
    }
    catch (IOException ex) {
        throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
    }
}

loadBeanDefinitions() 方法交由子类 AbstractXmlApplicationContext 实现：

@Override
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
    // 创建用于从 Xml 中读取 BeanDefinition 的读取器
    XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

    // 配置 BeanDefinition 的读取器
    beanDefinitionReader.setEnvironment(this.getEnvironment());
    // 为 beanDefinition 读取器设置 资源加载器，由于本类的基类 AbstractApplicationContext
    // 继承了 DefaultResourceLoader，因此，本容器自身也是一个资源加载器
    beanDefinitionReader.setResourceLoader(this);
    // 设置 SAX 解析器，SAX（simple API for XML）是另一种 XML 解析方法。相比于 DOM，SAX 速度更快，占用内存更小。
    // 它逐行扫描文档，一边扫描一边解析。相比于先将整个 XML 文件扫描进内存，再进行解析的 DOM，SAX 可以在解析文档的
    // 任意时刻停止解析，但操作也比 DOM 复杂。
    beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));

    // 初始化
    initBeanDefinitionReader(beanDefinitionReader);
    // Bean 读取器真正实现加载的方法
    loadBeanDefinitions(beanDefinitionReader);
}

读取 BeanDefinition 的真正方法：

/**
 * ClassPathXmlApplicationContext 与 FileSystemXmlApplicationContext 在这里的调用出现分歧，
 * 各自按不同的方式加载解析 Resource 资源，最后在具体的解析和 BeanDefinition 定位上又会殊途同归。
 */
protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {

    Resource[] configResources = getConfigResources();
    if (configResources != null) {
        reader.loadBeanDefinitions(configResources);
    }
    String[] configLocations = getConfigLocations();
    if (configLocations != null) {
        reader.loadBeanDefinitions(configLocations);
    }
}

3. `prepareBeanFactory`

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    // 设置类加载器和属性、资源解析器
    beanFactory.setBeanClassLoader(getClassLoader());
    beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
    beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

    // 注册 AwareProcessor，用来给实现了 xxxAware 接口的类扩展功能
    beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));

    // 是忽略指定接口类型的属性的自动注入，而通过其他方式实现注入（通过上面的 ApplicationContextAwareProcessor 进行属性注入）
    beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
    beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
    beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
    beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
    beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
    beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);

    // 用于动态注册某些类型的依赖，使其可以被 Spring 容器自动注入
    // 第一个参数为：希望注入的类型，第二个参数为当遇到这种希望注入的类型时，时间注入该对象
    beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
    beanFactory.registerResolvableDependency(ResourceLoader.class, this);
    beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
    beanFactory.registerResolvableDependency(ApplicationContext.class, this);

    // 注册检测和解析实现 ApplicationListener 接口的后处理器
    beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

    // 检测是否包含特定 bean，有则加入对应的后处理器
    if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
        beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
        // Set a temporary ClassLoader for type matching.
        beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
    }

    // 注册默认环境bean。environment、systemProperties、systemEnvironment
    if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
        beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
    }
    if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
        beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
    }
    if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
        beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
    }
}

对 BeanFactory 进行各种功能填充。其实如果自己直接 new 一个 BeanFactory，再添加上某些组件，也能够实现一个简单的容器。

这里主要是设置了一些类加载器和属性、资源解析器，还注册了一些后处理器用户处理实现特定接口的类，还注册了几个环境单例 bean。

4. `postProcessBeanFactory`

protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
}

postProcessBeanFactory 方法主要用于在 Spring 容器实例化 bean 之前，修改和调整 bean 的定义。默认没有实现，子类可以重写。（ClassPathXmlApplicationContext 的基类 AbstractApplicationContext 对该方法并没有实现）

该方法与下面的 invokeBeanFactoryPostProcessors 方法效果一样，都是可以直接操作 beanFactory，可以新增、修改 bean 的定义。

5. `invokeBeanFactoryPostProcessors`

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

    // Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
    // (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)
    if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
        beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
        beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
    }
}

调用各种 BeanFactoryPostProcessor，以实现对 bean 定义的新增和修改等，包括 spring 本身的和自己实现的 BeanFactoryPostProcessor 接口的类，通过委托 PostProcessorRegistrationDelegate 实现。

6. `registerBeanPostProcessors`

protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}

特性	`BeanFactoryPostProcessor`	`BeanPostProcessor`
执行时机	在 Bean 定义加载后、Bean 实例化之前。	在 Bean 实例化后、初始化方法之前或之后。
作用范围	主要用来修改或定制 Bean 定义（如修改属性、构造函数参数等）。	主要用来修改或增强 Bean 实例的行为。
执行对象	操作的是 `BeanFactory` 和 `BeanDefinition`，改变 Bean 的元数据。	操作的是已经实例化的 Bean 对象。
修改内容	可以修改 Bean 的定义，如属性、依赖等。	可以修改实例化后的 Bean，增加自定义逻辑或增强功能。
常见用途	修改 Bean 配置、条件注册 Bean、动态改变 Bean 定义。	增强 Bean 功能、AOP、日志记录、延迟初始化等。

7. `initMessageSource`

protected void initMessageSource() {
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
        this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
        // Make MessageSource aware of parent MessageSource.
        if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
            HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;
            if (hms.getParentMessageSource() == null) {
                // Only set parent context as parent MessageSource if no parent MessageSource
                // registered already.
                hms.setParentMessageSource(getInternalParentMessageSource());
            }
        }
        if (logger.isTraceEnabled()) {
            logger.trace("Using MessageSource [" + this.messageSource + "]");
        }
    }
    else {
        // Use empty MessageSource to be able to accept getMessage calls.
        DelegatingMessageSource dms = new DelegatingMessageSource();
        dms.setParentMessageSource(getInternalParentMessageSource());
        this.messageSource = dms;
        beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
        if (logger.isTraceEnabled()) {
            logger.trace("No '" + MESSAGE_SOURCE_BEAN_NAME + "' bean, using [" + this.messageSource + "]");
        }
    }
}

8. `initApplicationEventMulticaster`

protected void initApplicationEventMulticaster() {
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
        this.applicationEventMulticaster =
                beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
        if (logger.isTraceEnabled()) {
            logger.trace("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
        }
    }
    else {
        this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
        beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
        if (logger.isTraceEnabled()) {
            logger.trace("No '" + APPLICATION_EVENT_MULTICASTER_BEAN_NAME + "' bean, using " +
                    "[" + this.applicationEventMulticaster.getClass().getSimpleName() + "]");
        }
    }
}

事件广播器负责在应用程序中传递事件，确保事件可以从发布者传播到所有的监听者。这个方法的功能是确保容器中有一个有效的 ApplicationEventMulticaster，并根据容器中是否已经存在相应的 bean 来进行初始化。

9. `onRefresh`

protected void onRefresh() throws BeansException {
    // For subclasses: do nothing by default.
}

空方法，用于留给子类进行扩展。

10. `registerListeners`

protected void registerListeners() {
    // Register statically specified listeners first.
    for (ApplicationListener<?> listener : getApplicationListeners()) {
        getApplicationEventMulticaster().addApplicationListener(listener);
    }

    // Do not initialize FactoryBeans here: We need to leave all regular beans
    // uninitialized to let post-processors apply to them!
    String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
    for (String listenerBeanName : listenerBeanNames) {
        getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
    }

    // Publish early application events now that we finally have a multicaster...
    Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
    this.earlyApplicationEvents = null;
    if (!CollectionUtils.isEmpty(earlyEventsToProcess)) {
        for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
            getApplicationEventMulticaster().multicastEvent(earlyEvent);
        }
    }
}

所有注册的 bean 中查找监听器，注册到应用事件广播器中。

11. `finishBeanFactoryInitialization`

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
    // 如果有的话，初始化默认转换服务。
    if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
            beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
        beanFactory.setConversionService(
                beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
    }

    // 注册嵌入式值解析器，以支持占位符（placeholders）解析的功能。例如：${property.name}
    if (!beanFactory.hasEmbeddedValueResolver()) {
        beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
    }

    // 初始化 LoadTimeWeaverAware 实例
    String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
    for (String weaverAwareName : weaverAwareNames) {
        getBean(weaverAwareName);
    }

    // 停止使用临时类加载器，并将其清除。
    beanFactory.setTempClassLoader(null);

    // 锁定 beanFactory 配置。一旦进入这个阶段，Spring 假设所有的 Bean 定义已经准备就绪，锁定配置，以提升性能。
    // 1. 不再允许新增或修改 Bean 定义 2. 可以更高效地缓存元数据，例如 Bean 的依赖关系或类型信息。
    beanFactory.freezeConfiguration();

    // 实例化所有非延迟加载的 bean
    beanFactory.preInstantiateSingletons();
}

初始化剩下的非懒加载实例，程序员自己编写的大部分 bean 都是在这里进行初始化的。在这里调用了 getBean 方法，创建了非惰性的 bean 实例。getBean 方法其中会调用 createBean 方法，毕竟 getBean 所需要获取的 bean

这里具体就涉及到了 bean 的生命周期，比较复杂，可以当作另外一个探究的点。

12. `finishRefresh`

protected void finishRefresh() {
    // 清楚资源缓存
    clearResourceCaches();

    // 初始化生命周期处理器
    initLifecycleProcessor();

    // 触发生命周期处理器的刷新事件
    getLifecycleProcessor().onRefresh();

    // 发布上下文刷新事件
    publishEvent(new ContextRefreshedEvent(this));

    // 注册到 LiveBeansView
    // LiveBeansView 是 Spring 提供的工具类，用于调试和监控应用中定义的 bean。
    LiveBeansView.registerApplicationContext(this);
}

Tips:清朝云网络工作室

阅读剩余

版权声明网站名称： 清朝云资源网
本文章网址：https://www.qcyqq.com/8144.html
本站提供的一切软件、教程和内容信息仅限用于学习和研究目的。
不得将上述内容用于商业或者非法用途，否则，一切后果请用户自负。
我们非常重视版权问题，如有侵权请邮件与我们联系处理。敬请谅解！邮件：766378891@qq.com
网站部分内容来源于网络，版权争议与本站无关。请在下载后的24小时内从您的设备中彻底删除上述内容。
如无特别声明本文即为原创文章仅代表个人观点，版权归《清朝云资源网》所有，欢迎转载，转载请保留原文链接。

THE END

亚马逊无服务器计算 lambda 的初体验

<<上一篇

Docker 搭建在线练习英语软件

下一篇>>

源码学习 Spring 容器初始化流程

0. 简介

1. prepareRefresh

2. obtainFreshBeanFactory

3. prepareBeanFactory

4. postProcessBeanFactory

5. invokeBeanFactoryPostProcessors

6. registerBeanPostProcessors

7. initMessageSource

8. initApplicationEventMulticaster

9. onRefresh

10. registerListeners

11. finishBeanFactoryInitialization

12. finishRefresh

1. `prepareRefresh`

2. `obtainFreshBeanFactory`

3. `prepareBeanFactory`

4. `postProcessBeanFactory`

5. `invokeBeanFactoryPostProcessors`

6. `registerBeanPostProcessors`

7. `initMessageSource`

8. `initApplicationEventMulticaster`

9. `onRefresh`

10. `registerListeners`

11. `finishBeanFactoryInitialization`

12. `finishRefresh`