Springboot 启动时Bean的创建与注入-面试热点-springboot源码解读-xunznux

Springboot 启动时Bean的创建与注入,以及对应的源码解读

文章目录

    • [Springboot 启动时Bean的创建与注入,以及对应的源码解读](#Springboot 启动时Bean的创建与注入,以及对应的源码解读)
    • 构建Web项目流程图:
    • 堆栈信息:
    • 堆栈信息简介
    • 堆栈信息源码详解
      • [1、`main:10, DemoApplication (com.xun.demo)`](#1、main:10, DemoApplication (com.xun.demo))
      • [2、`run:1352, SpringApplication (org.springframework.boot)`](#2、run:1352, SpringApplication (org.springframework.boot))
      • [3、run:1363, SpringApplication (org.springframework.boot)](#3、run:1363, SpringApplication (org.springframework.boot))
      • [4、run:335, SpringApplication (org.springframework.boot)](#4、run:335, SpringApplication (org.springframework.boot))
      • [5、refreshContext:456, SpringApplication (org.springframework.boot)](#5、refreshContext:456, SpringApplication (org.springframework.boot))
      • [6、refresh:754, SpringApplication (org.springframework.boot)](#6、refresh:754, SpringApplication (org.springframework.boot))
      • [7、refresh:146, ServletWebServerApplicationContext (org.springframework.boot.web.servlet.context)](#7、refresh:146, ServletWebServerApplicationContext (org.springframework.boot.web.servlet.context))
      • [8、refresh:624, AbstractApplicationContext (org.springframework.context.support)](#8、refresh:624, AbstractApplicationContext (org.springframework.context.support))
      • [9、finishBeanFactoryInitialization:962, AbstractApplicationContext (org.springframework.context.support)](#9、finishBeanFactoryInitialization:962, AbstractApplicationContext (org.springframework.context.support))
      • [10、preInstantiateSingletons:975, DefaultListableBeanFactory (org.springframework.beans.factory.support)](#10、preInstantiateSingletons:975, DefaultListableBeanFactory (org.springframework.beans.factory.support))
    • 其他内容

出于研究springboot启动时bean的创建到注入中发生的函数调用的这个目的,搭建一个最简单的springboot应用,只有一个controller bean,没有再手动指定任何其他bean。

先展示一下如何在idea中快速构建一个springboot web demo项目:

构建Web项目流程图:





在这里推荐一个插件,可以在插件市场中搜索 Maven Search安装,用于寻找依赖:


为了得到堆栈调用信息,需要找到InjectionMetadata 类中的 inject 方法打断点调试:

堆栈信息:

java 复制代码
inject:142, InjectionMetadata (org.springframework.beans.factory.annotation)
postProcessProperties:508, AutowiredAnnotationBeanPostProcessor (org.springframework.beans.factory.annotation)
populateBean:1421, AbstractAutowireCapableBeanFactory (org.springframework.beans.factory.support)
doCreateBean:599, AbstractAutowireCapableBeanFactory (org.springframework.beans.factory.support)
createBean:522, AbstractAutowireCapableBeanFactory (org.springframework.beans.factory.support)
lambda$doGetBean$0:337, AbstractBeanFactory (org.springframework.beans.factory.support)
getObject:-1, AbstractBeanFactory$$Lambda$330/0x0000020b811ebab8 (org.springframework.beans.factory.support)
getSingleton:234, DefaultSingletonBeanRegistry (org.springframework.beans.factory.support)
doGetBean:335, AbstractBeanFactory (org.springframework.beans.factory.support)
getBean:200, AbstractBeanFactory (org.springframework.beans.factory.support)
preInstantiateSingletons:975, DefaultListableBeanFactory (org.springframework.beans.factory.support)
finishBeanFactoryInitialization:962, AbstractApplicationContext (org.springframework.context.support)
refresh:624, AbstractApplicationContext (org.springframework.context.support)
refresh:146, ServletWebServerApplicationContext (org.springframework.boot.web.servlet.context)
refresh:754, SpringApplication (org.springframework.boot)
refreshContext:456, SpringApplication (org.springframework.boot)
run:335, SpringApplication (org.springframework.boot)
run:1363, SpringApplication (org.springframework.boot)
run:1352, SpringApplication (org.springframework.boot)
main:10, DemoApplication (com.xun.demo)

堆栈信息简介

这个堆栈信息展示了 Spring Boot 在启动过程中如何创建和注入 bean 的详细过程。下面是对每个函数调用的简单解释,详细代码解释在后面进行:

  1. inject:142, InjectionMetadata (org.springframework.beans.factory.annotation)
    InjectionMetadata 是一个 Spring 类,用于处理注入点元数据。inject 方法负责实际的注入操作,根据注解(如 @Autowired)将依赖注入到目标 bean 中。

  2. postProcessProperties:508, AutowiredAnnotationBeanPostProcessor (org.springframework.beans.factory.annotation)
    AutowiredAnnotationBeanPostProcessor 是一个 BeanPostProcessor,负责处理 @Autowired@Value 注解。postProcessProperties 方法在 Spring 容器实例化 bean 之后但在它们的依赖项被注入之前被调用,用于处理依赖注入。

  3. populateBean:1421, AbstractAutowireCapableBeanFactory (org.springframework.beans.factory.support)
    populateBean 方法用于填充给定 bean 实例的属性。这包括对 @Autowired@Value 等注解的处理,并将相应的依赖注入到 bean 中。

  4. doCreateBean:599, AbstractAutowireCapableBeanFactory (org.springframework.beans.factory.support)
    doCreateBean 方法负责实际创建一个新的 bean 实例,包括调用其构造函数、应用工厂后处理器、自动装配和初始化。

  5. createBean:522, AbstractAutowireCapableBeanFactory (org.springframework.beans.factory.support)
    createBean 方法是 doCreateBean 的高层次包装器,负责创建并初始化一个新的 bean 实例。

  6. lambda$doGetBean$0:337, AbstractBeanFactory (org.springframework.beans.factory.support)

    这是一个 lambda 表达式,作为回调传递给 getSingleton 方法,负责返回一个单例 bean 实例。

  7. getObject:-1, AbstractBeanFactory$$Lambda$330/0x0000020b811ebab8 (org.springframework.beans.factory.support)

    这是 lambda 表达式的实际实现,用于从单例注册表中获取或创建一个单例 bean。

  8. getSingleton:234, DefaultSingletonBeanRegistry (org.springframework.beans.factory.support)
    getSingleton 方法从单例缓存中获取 bean 实例,如果 bean 不存在,则创建并缓存它。

  9. doGetBean:335, AbstractBeanFactory (org.springframework.beans.factory.support)
    doGetBean 方法负责实际获取一个 bean 实例,包括处理依赖注入和初始化。

  10. getBean:200, AbstractBeanFactory (org.springframework.beans.factory.support)
    getBean 方法是 doGetBean 的高层次包装器,用于获取一个 bean 实例。

  11. preInstantiateSingletons:975, DefaultListableBeanFactory (org.springframework.beans.factory.support)
    preInstantiateSingletons 方法负责提前实例化所有非延迟加载的单例 bean,确保它们在应用启动时就被创建和初始化。

  12. finishBeanFactoryInitialization:962, AbstractApplicationContext (org.springframework.context.support)
    finishBeanFactoryInitialization 方法在 Spring 容器刷新期间被调用,完成 bean 工厂的初始化,包括实例化所有剩余的单例 bean。

  13. refresh:624, AbstractApplicationContext (org.springframework.context.support)
    refresh 方法是 Spring 应用上下文刷新逻辑的入口点,负责重新加载 bean 定义、初始化 Spring 环境和 bean 工厂。

  14. refresh:146, ServletWebServerApplicationContext (org.springframework.boot.web.servlet.context)

    这是 ServletWebServerApplicationContext 类中 refresh 方法的实现,用于刷新 Web 应用上下文。

  15. refresh:754, SpringApplication (org.springframework.boot)
    refresh 方法是 Spring Boot 应用启动过程中刷新应用上下文的关键步骤。

  16. refreshContext:456, SpringApplication (org.springframework.boot)
    refreshContext 方法用于刷新 Spring 应用上下文,确保所有 bean 定义和依赖关系都被正确加载和初始化。

  17. run:335, SpringApplication (org.springframework.boot)
    run 方法是 Spring Boot 应用的主要入口点,负责启动 Spring 应用上下文。

  18. run:1363, SpringApplication (org.springframework.boot)

    这是 run 方法的一种签名,通常用于启动 Spring Boot 应用。

  19. run:1352, SpringApplication (org.springframework.boot)

    这是 run 方法的一种签名,通常用于启动 Spring Boot 应用。

  20. main:10, DemoApplication (com.xun.demo)

    这是应用的主类 DemoApplicationmain 方法,是 Spring Boot 应用的入口点。

通过这些方法调用,Spring Boot 应用在启动过程中创建和注入 bean,确保所有依赖关系都被正确解析和注入。

堆栈信息源码详解

先从栈底部的main方法开始看起。

1、main:10, DemoApplication (com.xun.demo)

java 复制代码
@SpringBootApplication
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

}

这个代码是一个典型的 Spring Boot 应用程序的入口类,下面是对每个部分的详细解释:

  1. @SpringBootApplication
    这个注解是一个组合注解,它结合了以下三个常用的 Spring 注解:
  • @SpringBootConfiguration: 表示这是一个 Spring Boot 配置类,等同于 Spring 的 @Configuration 注解。
  • @EnableAutoConfiguration: 这个注解告诉 Spring Boot 根据添加的依赖自动配置 Spring 应用程序。
  • @ComponentScan: 这个注解启用组件扫描,让 Spring 找到并注册带有 @Component@Service@Repository@Controller 等注解的类。
  1. public class DemoApplication

    这是 Spring Boot 应用的主类,命名为 DemoApplication。按照惯例,Spring Boot 应用的主类通常位于源码目录的根包下,以便能够扫描到该包及其子包中的所有组件。

  2. public static void main(String[] args)

    这是 Java 应用程序的入口点。main 方法是应用程序启动时第一个执行的方法。

  3. SpringApplication.run(DemoApplication.class, args)

    这个静态方法启动了 Spring Boot 应用程序。以下是一些关键点:

  • SpringApplication.run 方法负责启动 Spring 应用上下文,启动内嵌的服务器(例如 Tomcat),并初始化 Spring 环境。
  • DemoApplication.class 是应用的主类,它包含 @SpringBootApplication 注解,使其成为 Spring Boot 应用的配置类。
  • args 是传递给应用的命令行参数。

SpringApplication.run 被调用时,Spring Boot 会执行以下步骤:

  1. 创建并启动 SpringApplication 实例。
  2. 准备 SpringApplication 实例(例如,读取并解析命令行参数)。
  3. 创建并刷新应用上下文(包括创建所有单例 bean)。
  4. 启动嵌入式服务器(例如 Tomcat)。
  5. 执行所有 CommandLineRunnerApplicationRunner bean。

这个简单的 Spring Boot 应用程序入口类通过 @SpringBootApplication 注解和 SpringApplication.run 方法启动了一个完整的 Spring Boot 应用,包含自动配置和内嵌服务器,简化了 Spring 应用的开发和部署。

2、run:1352, SpringApplication (org.springframework.boot)

java 复制代码
/**
 * Static helper that can be used to run a {@link SpringApplication} from the
 * specified source using default settings.
 * @param primarySource the primary source to load
 * @param args the application arguments (usually passed from a Java main method)
 * @return the running {@link ApplicationContext}
 */
public static ConfigurableApplicationContext run(Class<?> primarySource, String... args) {
	return run(new Class<?>[] { primarySource }, args);
}
  • 这是一个静态辅助方法,可以使用默认设置从指定的源运行一个 SpringApplication。
  • 参数 primarySource 是要加载的主要源,通常是一个带有 @SpringBootApplication 注解的主类。
  • 参数 args 是应用程序的参数,通常是从 Java 主方法传递的命令行参数。
  • 返回正在运行的 ApplicationContext,这是 Spring 应用程序上下文的表示。

这个静态 run 方法是启动 Spring Boot 应用程序的便捷方法。它接受一个主要源类和应用程序参数,将主要源类包装成一个数组,然后调用另一个 run 方法来启动应用程序。最终返回一个 ConfigurableApplicationContext,表示应用程序的运行上下文。

3、run:1363, SpringApplication (org.springframework.boot)

java 复制代码
/**
 * Static helper that can be used to run a {@link SpringApplication} from the
 * specified sources using default settings and user supplied arguments.
 * @param primarySources the primary sources to load
 * @param args the application arguments (usually passed from a Java main method)
 * @return the running {@link ApplicationContext}
 */
public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
	return new SpringApplication(primarySources).run(args);
}

这个静态 run 方法是启动 Spring Boot 应用程序的便捷方法。它接受一个主要源类数组和应用程序参数,创建一个 SpringApplication 实例,并调用它的 run 方法来启动应用程序。最终返回一个 ConfigurableApplicationContext,表示应用程序的运行上下文。

4、run:335, SpringApplication (org.springframework.boot)

java 复制代码
/**
 * Run the Spring application, creating and refreshing a new {@link ApplicationContext}.
 * @param args the application arguments (usually passed from a Java main method)
 * @return a running {@link ApplicationContext}
 */
public ConfigurableApplicationContext run(String... args) {
    // 创建一个用于记录启动时间和事件的 Startup 实例
    Startup startup = Startup.create();
    
    // 如果启用了 registerShutdownHook,注册一个 JVM 关闭钩子
    if (this.registerShutdownHook) {
        SpringApplication.shutdownHook.enableShutdownHookAddition();
    }
    
    // 创建一个 DefaultBootstrapContext 实例,用于引导应用程序上下文的初始化
    DefaultBootstrapContext bootstrapContext = createBootstrapContext();
    
    // 声明一个 ConfigurableApplicationContext 变量
    ConfigurableApplicationContext context = null;
    
    // 配置 headless 属性,防止某些图形环境相关的问题
    configureHeadlessProperty();
    
    // 获取应用程序运行的监听器,用于在不同阶段触发事件
    SpringApplicationRunListeners listeners = getRunListeners(args);
    
    // 通知监听器应用程序正在启动
    listeners.starting(bootstrapContext, this.mainApplicationClass);
    
    try {
        // 创建一个 ApplicationArguments 实例,解析命令行参数
        ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
        
        // 准备并配置环境变量
        ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);
        
        // 打印启动横幅
        Banner printedBanner = printBanner(environment);
        
        // 创建应用程序上下文
        context = createApplicationContext();
        
        // 设置应用程序启动器
        context.setApplicationStartup(this.applicationStartup);
        
        // 准备应用程序上下文,配置相关属性和资源
        prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
        
        // 刷新应用程序上下文,加载所有 Bean 定义并启动应用程序
        refreshContext(context);
        
        // 在上下文刷新后进行后续操作
        afterRefresh(context, applicationArguments);
        
        // 记录启动时间
        startup.started();
        
        // 如果 logStartupInfo 为 true,记录启动信息
        if (this.logStartupInfo) {
            new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), startup);
        }
        
        // 通知监听器应用程序已启动
        listeners.started(context, startup.timeTakenToStarted());
        
        // 调用所有 CommandLineRunner 和 ApplicationRunner 实现类
        callRunners(context, applicationArguments);
    }
    catch (Throwable ex) {
        // 捕获异常并处理启动失败的情况
        throw handleRunFailure(context, ex, listeners);
    }
    
    try {
        // 如果上下文正在运行,通知监听器应用程序已就绪
        if (context.isRunning()) {
            listeners.ready(context, startup.ready());
        }
    }
    catch (Throwable ex) {
        // 捕获异常并处理启动失败的情况
        throw handleRunFailure(context, ex, null);
    }
    
    // 返回运行中的 ConfigurableApplicationContext 实例
    return context;
}

这个 run 方法执行了 Spring Boot 应用程序的完整启动过程,从准备环境、创建应用程序上下文到通知监听器和调用运行器。通过多个步骤,确保应用程序在启动过程中正确配置和初始化。最终返回一个正在运行的 ApplicationContext 实例。

该方法运行一个 Spring 应用程序,创建并刷新一个新的 ApplicationContext 实例。ApplicationContext 是 Spring 框架中的核心接口之一,代表了 Spring 的 IoC 容器,用于管理 Spring 应用中的 beans。

以下是 run 方法的主要流程和作用:

  1. 创建启动记录实例 : 创建一个 Startup 实例,用于记录应用启动的时间和事件。

  2. 注册 JVM 关闭钩子 : 如果配置了 registerShutdownHook,则注册一个 JVM 关闭钩子,以确保在 JVM 关闭时能正确地进行清理工作。

  3. 创建引导上下文 : 创建一个 DefaultBootstrapContext 实例,用于在应用上下文初始化期间保存引导信息。

  4. 配置 headless 属性 : 配置 headless 属性,以防止在没有显示器环境中运行时的一些问题。

  5. 获取运行监听器 : 获取 SpringApplicationRunListeners 实例,用于在不同的应用启动阶段触发事件。

  6. 通知监听器应用程序正在启动: 通知监听器应用程序启动的开始。

  7. 解析命令行参数 : 创建 ApplicationArguments 实例,解析传入的命令行参数。

  8. 准备并配置环境: 准备并配置 Spring 的环境对象。

  9. 打印启动横幅: 根据环境配置打印应用启动横幅。

  10. 创建应用上下文 : 创建 ApplicationContext 实例,用于管理 Spring beans。

  11. 设置应用启动器: 将应用启动器设置到上下文中。

  12. 准备应用上下文: 准备应用上下文,包括加载 bean 定义等。

  13. 刷新应用上下文: 刷新应用上下文,实际启动 Spring 容器。

  14. 执行刷新后操作: 在上下文刷新后执行一些必要的操作。

  15. 记录启动时间: 记录应用程序启动的时间。

  16. 记录启动信息: 如果启用了启动信息日志,则记录启动信息。

  17. 通知监听器应用程序已启动: 通知监听器应用程序已经启动完成。

  18. 调用命令行运行器 : 调用所有实现 CommandLineRunnerApplicationRunner 接口的类。

  19. 处理启动失败: 捕获并处理启动过程中出现的异常。

  20. 通知监听器应用程序已就绪: 通知监听器应用程序已经准备就绪,可以处理请求。

  21. 返回应用上下文 : 返回运行中的 ConfigurableApplicationContext 实例。

5、refreshContext:456, SpringApplication (org.springframework.boot)

java 复制代码
private void refreshContext(ConfigurableApplicationContext context) {
	if (this.registerShutdownHook) {
		shutdownHook.registerApplicationContext(context);
	}
	refresh(context);
}
  • 注册关闭钩子:如果配置了 registerShutdownHook,则调用 shutdownHook 的 registerApplicationContext 方法,注册应用上下文以便在 JVM 关闭时执行清理操作。
  • 刷新应用上下文:调用 refresh(context) 方法,这个方法是 AbstractApplicationContext 中定义的抽象方法,用于刷新应用上下文,包括初始化所有单例 beans。

这个过程确保应用上下文在启动时被正确初始化和配置,并且所有必要的单例 beans 被实例化和装配。

6、refresh:754, SpringApplication (org.springframework.boot)

java 复制代码
/**
 * Refresh the underlying {@link ApplicationContext}.
 * @param applicationContext the application context to refresh
 */
protected void refresh(ConfigurableApplicationContext applicationContext) {
	// 调用 ApplicationContext 的 refresh() 方法来执行刷新操作
	applicationContext.refresh();
}

方法用于执行给定应用上下文的刷新操作,确保所有的配置和 beans 都是最新的。

7、refresh:146, ServletWebServerApplicationContext (org.springframework.boot.web.servlet.context)

java 复制代码
/**
 * 覆盖父类的 refresh() 方法,执行应用上下文的刷新操作。
 * @throws BeansException 如果 bean 创建或初始化过程中出现问题
 * @throws IllegalStateException 如果应用上下文已经刷新过或处于不合法状态
 */
@Override
public final void refresh() throws BeansException, IllegalStateException {
    try {
        // 调用父类的 refresh() 方法,执行应用上下文的刷新操作
        super.refresh();
    }
    catch (RuntimeException ex) {
        // 如果在刷新过程中出现运行时异常,则捕获异常并处理
        WebServer webServer = this.webServer;
        if (webServer != null) {
            // 如果存在 WebServer,停止并销毁它
            webServer.stop();
            webServer.destroy();
        }
        // 抛出捕获到的运行时异常,向上层传递异常信息
        throw ex;
    }
}

这段代码中的 refresh() 方法是 ApplicationContext 接口的实现方法,在 Spring 应用上下文初始化后被调用,用于执行上下文的刷新操作。

8、refresh:624, AbstractApplicationContext (org.springframework.context.support)

java 复制代码
 /**
 * 加载或刷新配置的持久表示,该配置可能来自基于Java的配置、XML文件、属性文件、
 * 关系数据库模式或其他某种格式。
 * <p>
 * 由于这是一个启动方法,如果失败,它应该销毁已创建的单例,
 * 以避免悬挂资源。换句话说,在调用此方法之后,要么所有单例都被实例化,
 * 要么根本没有单例被实例化。
 * 
 * @throws BeansException 如果bean工厂无法初始化
 * @throws IllegalStateException 如果已经初始化并且不支持多次刷新尝试
 */
@Override
public void refresh() throws BeansException, IllegalStateException {
        // 获取锁以确保刷新过程的线程安全
        this.startupShutdownLock.lock();
        try {
                // 记录当前线程作为执行刷新操作的线程
                this.startupShutdownThread = Thread.currentThread();

                // 开始一个启动步骤,用于上下文刷新过程
                StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");

                // 准备刷新过程
                prepareRefresh();

                // 通知子类刷新内部bean工厂
                // 获得一个新的bean工厂实例
                ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

                // 为这个上下文准备bean工厂
                prepareBeanFactory(beanFactory);

                try {
                        // 允许上下文子类对bean工厂进行后处理
                        postProcessBeanFactory(beanFactory);

                        // 开始一个启动步骤,用于bean后处理
                        StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
                        // 调用注册在上下文中的bean工厂后处理器
                        invokeBeanFactoryPostProcessors(beanFactory);
                        // 注册拦截bean创建的bean后处理器
                        registerBeanPostProcessors(beanFactory);
                        // 结束bean后处理的启动步骤
                        beanPostProcess.end();

                        // 初始化消息源
                        initMessageSource();

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

                        // 在特定的上下文子类中初始化其他特殊bean
                        onRefresh();

                        // 检查监听器bean并注册它们
                        registerListeners();

                        // 实例化所有剩余(非懒加载初始化)的单例
                        finishBeanFactoryInitialization(beanFactory);

                        // 完成刷新过程
                        finishRefresh();
                }

                // 捕获任何运行时异常或错误
                catch (RuntimeException | Error ex) {
                        // 如果警告日志启用,记录异常并取消刷新尝试
                        if (logger.isWarnEnabled()) {
                                logger.warn("在上下文初始化过程中遇到异常 - 取消刷新尝试: " + ex);
                        }

                        // 销毁已创建的单例以避免资源泄露(如果失败,应该销毁已创建的单例)
                        destroyBeans();

                        // 重置'活动'标志
                        cancelRefresh(ex);

                        // 将异常传播给调用者
                        throw ex;
                }

                // 确保结束上下文刷新的启动步骤
                finally {
                        contextRefresh.end();
                }
        }
        // 无论刷新成功还是失败,都释放锁
        finally {
                this.startupShutdownThread = null;
                this.startupShutdownLock.unlock();
        }
}

该方法是 AbstractApplicationContext 类中的 refresh() 方法的实现,用于刷新 Spring 应用上下文的整个流程。以下是其详细流程总结:

  1. 获取启动和关闭锁 : 获取 startupShutdownLock 锁,确保在应用上下文刷新期间不会被其他线程中断。
  2. 设置当前线程为启动/关闭线程 : 将当前线程设置为 startupShutdownThread,以便在需要时能够进行相应处理。
  3. 应用启动步骤记录 : 使用 applicationStartup 记录应用启动步骤,标记为 "spring.context.refresh"。用于记录上下文刷新过程的性能指标。
  4. 准备刷新操作 : 调用 prepareRefresh() 方法,为刷新操作做准备。包括设置必要的环境属性和初始化一些状态。
  5. 获取新的 Bean 工厂 : 调用 obtainFreshBeanFactory() 方法获取一个新的 ConfigurableListableBeanFactory 实例。通常是通过重新加载Bean定义来实现的。
  6. 为使用准备 Bean 工厂 : 调用 prepareBeanFactory(beanFactory) 方法,为当前上下文的使用准备 Bean 工厂。包括设置类加载器、注册默认的环境Bean等。
  7. 后处理 Bean 工厂 : 调用 postProcessBeanFactory(beanFactory) 方法,允许子类对 Bean 工厂进行后处理。
  8. 调用 Bean 工厂后处理器 : 调用 invokeBeanFactoryPostProcessors(beanFactory) 方法,执行注册在上下文中的 Bean 工厂后处理器。
  9. 注册 Bean 后处理器 : 调用 registerBeanPostProcessors(beanFactory) 方法,注册拦截 Bean 创建的 Bean 后处理器。
  10. 初始化消息源 : 调用 initMessageSource() 方法,初始化该上下文的消息源。
  11. 初始化应用事件广播器 : 调用 initApplicationEventMulticaster() 方法,初始化该上下文的应用事件广播器。用于发布和监听应用事件。
  12. 特定上下文子类的初始化 : 调用 onRefresh() 方法,初始化特定于该上下文子类的其他特殊 Bean。
  13. 注册监听器 : 调用 registerListeners() 方法,检查并注册监听器 Bean。
  14. 完成 Bean 工厂的初始化 : 调用 finishBeanFactoryInitialization(beanFactory) 方法,实例化所有剩余的非延迟初始化单例 Bean。
  15. 完成刷新操作 : 调用 finishRefresh() 方法,完成应用上下文的刷新。
  16. 处理异常 : 在执行上述步骤的任何过程中,如果捕获到 RuntimeExceptionError,则进入异常处理块。
  • 记录警告日志,取消刷新尝试。
  • 销毁已创建的单例 Bean,避免资源泄漏。
  • 设置 active 标志为 false。
  • 向上层抛出捕获到的异常。
  1. 结束应用启动步骤记录 : 无论是否发生异常,都会调用 contextRefresh.end() 结束应用启动步骤记录。
  2. 释放启动和关闭锁 : 最后在 finally 块中释放 startupShutdownThread,解锁 startupShutdownLock,确保安全地结束刷新过程。

这个方法的主要目的是确保 Spring 应用上下文能够在启动时进行正确的初始化和配置,包括加载配置、注册 Bean、初始化消息源和事件广播器等重要步骤,最终保证应用程序能够正常运行。

9、finishBeanFactoryInitialization:962, AbstractApplicationContext (org.springframework.context.support)

java 复制代码
/**
 * 完成本上下文的bean工厂初始化,初始化所有剩余的单例bean。
 * <p>
 * 此方法执行以下操作:
 * 1. 初始化此上下文的转换服务,如果存在名为CONVERSION_SERVICE_BEAN_NAME的bean且类型为ConversionService。
 * 2. 如果没有BeanFactoryPostProcessor注册过内嵌的值解析器,则注册一个默认的环境占位符解析器。
 * 3. 早期初始化LoadTimeWeaverAware类型的beans,以便于尽早注册它们的transformer。
 * 4. 停止使用临时类加载器进行类型匹配。
 * 5. 冻结bean定义元数据,不再期望进一步的变化。
 * 6. 实例化所有剩余的(非懒加载初始化)单例。
 * 
 * @param beanFactory 当前的可配置列表bean工厂
 */
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
        // 如果存在转换服务bean,初始化转换服务(为此上下文初始化转换服务)
        if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
                        beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
                // 设置bean工厂的转换服务
                beanFactory.setConversionService(
                                beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
        }

        // 如果没有任何 BeanFactoryPostProcessor(例如 PropertySourcesPlaceholderConfigurer bean)
        // 之前注册过嵌入值解析器,则注册一个默认的嵌入值解析器:
        // 此时,主要用于解析注解属性值中的占位符。
        if (!beanFactory.hasEmbeddedValueResolver()) {
                beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
        }

        // 提前初始化 LoadTimeWeaverAware beans,以便及早注册它们的转换器 transformer。
        String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
        for (String weaverAwareName : weaverAwareNames) {
                beanFactory.getBean(weaverAwareName, LoadTimeWeaverAware.class);
        }

        // 停止使用临时类加载器进行类型匹配
        beanFactory.setTempClassLoader(null);

        // 冻结配置,允许缓存所有的Bean定义元数据,不再期望有进一步的更改。
        beanFactory.freezeConfiguration();

        // 实例化所有剩余的(非懒加载初始化)单例 Bean
        beanFactory.preInstantiateSingletons();
}

这个方法的主要作用是完成Spring应用上下文中Bean工厂的初始化过程,特别是初始化所有剩余的单例Bean。具体来说,它执行了一系列步骤来确保Bean工厂的配置和Bean实例的准备工作都已完成。以下是每个步骤的详细解释:

  • 初始化转换服务:检查是否存在名为CONVERSION_SERVICE_BEAN_NAME的Bean,并且该Bean的类型匹配ConversionService。如果存在,则将其设置为Bean工厂的转换服务。这一步确保了在Bean属性转换时使用正确的转换服务。
  • 注册默认嵌入值解析器:如果没有嵌入值解析器,则添加一个默认的解析器,用于解析注解属性值中的占位符。这一步确保了注解中的占位符能够被正确解析。
  • 提前初始化LoadTimeWeaverAware bean:获取所有实现了LoadTimeWeaverAware接口的Bean名称,并提前初始化这些Bean,以便及早注册它们的类加载时转换器。这一步确保了类加载时的增强功能能够正确注册。
  • 停止使用临时ClassLoader:停止使用临时的ClassLoader进行类型匹配。这一步通常是在Bean定义解析和类型匹配完成后进行的清理工作。
  • 冻结Bean定义元数据:冻结Bean定义元数据,表示不再期望有进一步的更改。这一步确保了Bean定义的稳定性和一致性。
  • 实例化所有剩余的单例Bean:实例化所有剩余的(非懒加载的)单例Bean。这一步确保了所有需要立即初始化的单例Bean都已创建并准备就绪。

总结:这个方法的整体作用是**确保Spring应用上下文中的Bean工厂已经完全初始化,并且所有需要的单例Bean都已实例化。**它通过一系列步骤来配置转换服务、解析占位符、注册类加载时转换器、清理临时资源、冻结配置并最终实例化所有单例Bean,从而确保应用上下文的稳定性和一致性。

10、preInstantiateSingletons:975, DefaultListableBeanFactory (org.springframework.beans.factory.support)

java 复制代码
/**
 * 确保所有非懒加载的单例Bean都被实例化,同时考虑{@link org.springframework.beans.factory.FactoryBean FactoryBeans}。
 * 通常在工厂设置结束时调用(如果需要)。
 * @throws BeansException 如果某个单例Bean无法创建。
 * 注意:这可能会导致工厂中已经初始化了一些Bean!
 * 在这种情况下,请调用{@link #destroySingletons()}进行完全清理。
 * @see #destroySingletons()
 */
@Override
public void preInstantiateSingletons() throws BeansException {
    // 如果日志级别为TRACE,则记录预实例化单例Bean的操作。
    if (logger.isTraceEnabled()) {
        logger.trace("Pre-instantiating singletons in " + this);
    }

    // 迭代一个Bean定义名称的副本,以允许在初始化方法中注册新的Bean定义。
    // 虽然这可能不是常规工厂引导的一部分,但在其他情况下工作正常。
    List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

    // 触发所有非懒加载单例Bean的初始化...
    for (String beanName : beanNames) {
        RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
        // 检查Bean定义是否不是抽象的、是单例的并且不是懒加载的。
        if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
            // 如果是FactoryBean,则获取FactoryBean实例。
            if (isFactoryBean(beanName)) {
                Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
                // 如果是SmartFactoryBean并且需要急切初始化,则获取Bean实例。
                if (bean instanceof SmartFactoryBean<?> smartFactoryBean && smartFactoryBean.isEagerInit()) {
                    getBean(beanName);
                }
            }
            else {
                // 否则,直接获取Bean实例。
                getBean(beanName);
            }
        }
    }

    // 触发所有适用Bean的后初始化回调...
    for (String beanName : beanNames) {
        Object singletonInstance = getSingleton(beanName);
        // 如果Bean实例是SmartInitializingSingleton,则调用其afterSingletonsInstantiated方法。
        if (singletonInstance instanceof SmartInitializingSingleton smartSingleton) {
            StartupStep smartInitialize = getApplicationStartup().start("spring.beans.smart-initialize")
                    .tag("beanName", beanName);
            smartSingleton.afterSingletonsInstantiated();
            smartInitialize.end();
        }
    }
}

这段代码是 DefaultListableBeanFactory 类中的 preInstantiateSingletons 方法,用于预实例化所有非延迟初始化的单例 Beans,同时考虑到 FactoryBean主要作用是预实例化Spring应用上下文中的所有非懒加载单例Bean,并在所有单例Bean实例化后触发相应的回调方法。通过预实例化,可以确保所有必要的Bean在应用启动时已经准备就绪,从而提高应用的响应速度和稳定性。

以下是方法的流程总结:

  1. 日志记录

    • 如果日志级别为 trace,则记录日志,指示正在预实例化单例 Beans。
  2. 复制 Bean 名称列表

    • 创建一个 beanNames 列表,复制当前 Bean 工厂中所有的 Bean 名称。这样做是为了允许在初始化方法期间可能注册新的 Bean 定义。(可以安全地在初始化过程中注册新的bean定义)
  3. 实例化所有非延迟初始化的单例 Beans

    • 遍历 beanNames 列表中的每个 Bean 名称。
    • 获取与当前 Bean 名称关联的合并的 RootBeanDefinition。
    • 检查该 Bean 定义是否为非抽象、单例且非延迟初始化。
    • 如果是工厂Bean FactoryBean,则首先获取其对应的 FactoryBean 实例,如果是 SmartFactoryBean 并且设置为 eagerInit(需要急切初始化),则立即获取其实例。
    • 否则,直接通过 getBean(beanName) 方法获取该 Bean 的实例。
  4. 触发所有适用 Bean 的后初始化回调

    • 再次遍历 beanNames 列表中的每个 Bean 名称。
    • 获取每个 Bean 名称对应的单例实例。
    • 如果该实例实现了 SmartInitializingSingleton 接口,调用其 afterSingletonsInstantiated() 方法,执行后初始化逻辑。这是一个回调方法,用于在所有单例Bean实例化后执行一些自定义逻辑。

preInstantiateSingletons方法的**主要作用是确保所有非懒加载的单例beans在应用上下文完全启动之前已经被实例化和初始化。**这一步骤对于依赖于这些beans的其他组件来说至关重要,因为它保证了这些beans的可用性。同时,它还提供了对那些希望在所有单例beans实例化后执行某些操作的beans的支持,通过调用SmartInitializingSingleton接口的afterSingletonsInstantiated方法。

总之,preInstantiateSingletons方法是Spring框架上下文启动流程中的一个关键环节,它负责最终确定所有非懒加载单例beans的状态,为整个应用提供了一个完整且一致的运行时环境。

注:由于内容过长,剩余的核心方法解释放在下一篇文章中。

其他内容

如果对 Golang 实现的Raft共识算法、Golang实现的负载均衡或者 Golang web 项目的demo实现感兴趣的可以看看我的主页,各个部分都带有详细的代码解释,也可以通过代码仓库获取源码,直接运行。
gitee链接

相关推荐
跃ZHD2 分钟前
前后端分离,Jackson,Long精度丢失
java
blammmp23 分钟前
Java:数据结构-枚举
java·开发语言·数据结构
momo_aa29 分钟前
mac找到主目录下的文件夹
经验分享
独行soc39 分钟前
#渗透测试#SRC漏洞挖掘#深入挖掘XSS漏洞02之测试流程
web安全·面试·渗透测试·xss·漏洞挖掘·1024程序员节
暗黑起源喵41 分钟前
设计模式-工厂设计模式
java·开发语言·设计模式
WaaTong1 小时前
Java反射
java·开发语言·反射
理想不理想v1 小时前
‌Vue 3相比Vue 2的主要改进‌?
前端·javascript·vue.js·面试
齐 飞1 小时前
MongoDB笔记01-概念与安装
前端·数据库·笔记·后端·mongodb
狂放不羁霸1 小时前
idea | 搭建 SpringBoot 项目之配置 Maven
spring boot·maven·intellij-idea
九圣残炎1 小时前
【从零开始的LeetCode-算法】1456. 定长子串中元音的最大数目
java·算法·leetcode