SpringApplication的启动过程

已于 2022-04-25 18:05:40 修改
阅读量1.5k 收藏
点赞数
分类专栏： Spring/SpringBoot/SpringCloud 文章标签： spring spring boot java
于 2022-04-25 10:14:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44885775/article/details/124397540
版权

参考视频：

https://www.ixigua.com/7090148232243708446?wid_try=1

public class SpringApplication {
    ...
    ...
    单参数构造方法
    public SpringApplication(Class... primarySources) {
        调用双参构造方法
        this((ResourceLoader)null, primarySources);
    }
    双参数构造方法
    public SpringApplication(ResourceLoader resourceLoader, Class... primarySources) {
        这个构造函数相当于初始化各种属性参数等操作.......
        在1.0之前这个构造函数是作为init方法存在.........
        this.sources = new LinkedHashSet();
        this.bannerMode = Mode.CONSOLE;
        this.logStartupInfo = true;
        this.addCommandLineProperties = true;
        this.addConversionService = true;
        this.headless = true;
        this.registerShutdownHook = true;
        this.additionalProfiles = Collections.emptySet();
        this.isCustomEnvironment = false;
        this.lazyInitialization = false;
        this.applicationContextFactory = ApplicationContextFactory.DEFAULT;
        this.applicationStartup = ApplicationStartup.DEFAULT;
        this.resourceLoader = resourceLoader;
        断言你传过来的字节码文件不能为空，如果为空就给你打印后面这句话
        Assert.notNull(primarySources, "PrimarySources must not be null");
        this.primarySources = new LinkedHashSet(Arrays.asList(primarySources));
        this.webApplicationType = WebApplicationType.deduceFromClasspath();
        this.bootstrapRegistryInitializers = this.getBootstrapRegistryInitializersFromSpringFactories();
        this.setInitializers(this.getSpringFactoriesInstances(ApplicationContextInitializer.class));
        this.setListeners(this.getSpringFactoriesInstances(ApplicationListener.class));
        this.mainApplicationClass = this.deduceMainApplicationClass();
    }
    ...
    ...
    run方法
    public static ConfigurableApplicationContext run(Class<?> primarySource, String... args) {
        生成一个新的数组,数组里存的是Class类型，这些class从哪来，从字节码文件中来。
        return run(new Class[]{primarySource}, args);
    }
    ...
    ...
    另一个run方法
    public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
        这里调用了SpringApplication的第一个构造函数
        return (new SpringApplication(primarySources)).run(args);
    }
    ...
    ...
    另另一个run方法
    public ConfigurableApplicationContext run(String... args) {
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        springboot当中用到的最早的一个配置文件类型，它优先加载于application.properties
        DefaultBootstrapContext bootstrapContext = this.createBootstrapContext();
        ConfigurableApplicationContext context = null;
        this.configureHeadlessProperty();
        SpringApplicationRunListeners listeners = this.getRunListeners(args);
        listeners.starting(bootstrapContext, this.mainApplicationClass);

        try {
            ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
            加载环境变量，运行起来控制台会输出类似的Starting Application using Java 1.8.0_131 on PC-202032 with PID 5060(D://.......)
            ConfigurableEnvironment environment = this.prepareEnvironment(listeners, bootstrapContext, applicationArguments);
            this.configureIgnoreBeanInfo(environment);
            控制台打印的花式文字
            Banner printedBanner = this.printBanner(environment);
            创建了spring的核心容器
            context = this.createApplicationContext();
            让你的核心容器跑起来
            context.setApplicationStartup(this.applicationStartup);
            预处理
            this.prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
            刷新整理
            this.refreshContext(context);
            最后刷新
            this.afterRefresh(context, applicationArguments);
            
            stopWatch.stop();
            if (this.logStartupInfo) {
                (new StartupInfoLogger(this.mainApplicationClass)).logStarted(this.getApplicationLog(), stopWatch);
            }

            listeners.started(context);
            this.callRunners(context, applicationArguments);
        } catch (Throwable var10) {
            this.handleRunFailure(context, var10, listeners);
            throw new IllegalStateException(var10);
        }

        try {
            listeners.running(context);
            return context;
        } catch (Throwable var9) {
            this.handleRunFailure(context, var9, (SpringApplicationRunListeners)null);
            throw new IllegalStateException(var9);
        }
    }
    
    
}

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

public static ConfigurableApplicationContext run(Class<?> primarySource, String... args) {
    // 调用了当前类下的另一个run方法
    return run(new Class[]{primarySource}, args);
}
 
public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
    // 在当前类下的另一个run方法中 调用了当前类的单参构造方法
    return (new SpringApplication(primarySources)).run(args);
}

public SpringApplication(Class... primarySources) {
    // 单参构造方法中，又去调用了双参构造方法
    this((ResourceLoader)null, primarySources);
}

// 在双参构造方法中有这么一个ApplicationContextFactory
this.applicationContextFactory = ApplicationContextFactory.DEFAULT;

public class StopWatch {
        ...
        ...
        public void start(String taskName) throws IllegalStateException {
            if (this.currentTaskName != null) {
                throw new IllegalStateException("Can't start StopWatch: it's already running");
            } else {
                this.currentTaskName = taskName;
                this.startTimeNanos = System.nanoTime();
            }
        }

}

它这个run要这个类的字节码有什么用呢？ 它这个类上面的注解@SpringBootApplication

SpringUtils中的setApplicationContext到底什么时候被执行了？今天我们研究一下。

参考链接：ApplicationContextAware接口的setApplicationContext方法调用过程_大家说的博客-CSDN博客_setapplicationcontext方法


@Component
public class SpringUtils implements ApplicationContextAware {
    ...
    ...
    ...
    private ApplicationContext applicationContext;
    private BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition();
    private DefaultListableBeanFactory autowireCapableBeanFactory;
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        if (this.applicationContext == null) {
            this.applicationContext = applicationContext;
        }
    }
    ...
    ...
}

SpringApplication.java:

public class SpringApplication {
    ...
    ...
    /**
	 * Refresh the underlying {@link ApplicationContext}.
	 * @param applicationContext the application context to refresh
	 */
	protected void refresh(ConfigurableApplicationContext applicationContext) {
		applicationContext.refresh();
	}
    ...
    ...
}

点击refresh进入ConfigurableApplicationContext 接口

public interface ConfigurableApplicationContext extends ApplicationContext, Lifecycle, Closeable {
    ....
    ....

    void refresh() throws BeansException, IllegalStateException;

    ....
    ....
}

点击抽象方法refresh() ，进入实现类AbstractApplicationContext.java

 
在refresh()方法中 点击this.prepareBeanFactory(beanFactory);// 点击进入查看prepareBeanFactory()

public abstract class AbstractApplicationContext extends DefaultResourceLoader implements ConfigurableApplicationContext {
    ...
    ...
     public void refresh() throws BeansException, IllegalStateException {
        Object var1 = this.startupShutdownMonitor;
        synchronized(this.startupShutdownMonitor) {
            StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");
            this.prepareRefresh();
            ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
   1这里---->this.prepareBeanFactory(beanFactory);//---->beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));---->ApplicationContextAwareProcessor.java

            try {
                this.postProcessBeanFactory(beanFactory);
                StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
                this.invokeBeanFactoryPostProcessors(beanFactory);
                this.registerBeanPostProcessors(beanFactory);
                beanPostProcess.end();
                this.initMessageSource();
                this.initApplicationEventMulticaster();
                this.onRefresh();
                this.registerListeners();
      4这里---->this.finishBeanFactoryInitialization(beanFactory);
                this.finishRefresh();
            } catch (BeansException var10) {
                if (this.logger.isWarnEnabled()) {
                    this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var10);
                }

                this.destroyBeans();
                this.cancelRefresh(var10);
                throw var10;
            } finally {
                this.resetCommonCaches();
                contextRefresh.end();
            }

        }
    }
    ...
    ...
    ...
    protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        beanFactory.setBeanClassLoader(this.getClassLoader());
        if (!shouldIgnoreSpel) {
            beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
        }

        beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, this.getEnvironment()));
2这里---->beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
3这里---->ApplicationContextAwareProcessor.java
        beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
        beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
        beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
        beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
        beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
        beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
        beanFactory.ignoreDependencyInterface(ApplicationStartupAware.class);
        beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
        beanFactory.registerResolvableDependency(ResourceLoader.class, this);
        beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
        beanFactory.registerResolvableDependency(ApplicationContext.class, this);
        beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
        if (!NativeDetector.inNativeImage() && beanFactory.containsBean("loadTimeWeaver")) {
            beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
            beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
        }

        if (!beanFactory.containsLocalBean("environment")) {
            beanFactory.registerSingleton("environment", this.getEnvironment());
        }

        if (!beanFactory.containsLocalBean("systemProperties")) {
            beanFactory.registerSingleton("systemProperties", this.getEnvironment().getSystemProperties());
        }

        if (!beanFactory.containsLocalBean("systemEnvironment")) {
            beanFactory.registerSingleton("systemEnvironment", this.getEnvironment().getSystemEnvironment());
        }

        if (!beanFactory.containsLocalBean("applicationStartup")) {
            beanFactory.registerSingleton("applicationStartup", this.getApplicationStartup());
        }

    }

    ....
    ....
5这里---->protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
        if (beanFactory.containsBean("conversionService") && beanFactory.isTypeMatch("conversionService", ConversionService.class)) {
            beanFactory.setConversionService((ConversionService)beanFactory.getBean("conversionService", ConversionService.class));
        }

        if (!beanFactory.hasEmbeddedValueResolver()) {
            beanFactory.addEmbeddedValueResolver((strVal) -> {
                return this.getEnvironment().resolvePlaceholders(strVal);
            });
        }

        String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
        String[] var3 = weaverAwareNames;
        int var4 = weaverAwareNames.length;

        for(int var5 = 0; var5 < var4; ++var5) {
            String weaverAwareName = var3[var5];
            this.getBean(weaverAwareName);
        }

        beanFactory.setTempClassLoader((ClassLoader)null);
        beanFactory.freezeConfiguration();
6这里---->beanFactory.preInstantiateSingletons();
    }
    ....
}

在AbstractApplicationContext .java的refresh()的prepareBeanFactory()中查看：beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));

 

我们看到一个new ApplicationContextAwareProcessor(this)类，这个类是一个BeanPostProcessor类型的类。OK，我们先在这里有一个印象，就是在BeanFactory里面加入了一个 ApplicationContextAwareProcessor。
这个过程就是ApplicationContextAwareProcessor的装配过程。

---------------------------------------------------------------------------

AbstractApplicationContext.java的refresh()方法中继续往下执行，执行到AbstractApplicationContext .java的实例化bean的方法
// Instantiate all remaining (non-lazy-init) singletons.
finishBeanFactoryInitialization(beanFactory);
代码执行到这个方法。

  • protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory)

在AbstractApplicationContext.java的finishBeanFactoryInitialization()方法中：

会执行beanFactory.preInstantiateSingletons();

最终会执行到：

  • AbstractAutowireCapableBeanFactory#doCreateBean方法

方法当中：

Object exposedObject = bean;
        try {
            populateBean(beanName, mbd, instanceWrapper);
            if (exposedObject != null) {
                exposedObject = initializeBean(beanName, exposedObject, mbd);
            }
        }
点进去

在这里插入图片描述

 这个方法就是调用 ApplicationContextAwareProcessor的地方，我们进去看看。

在这里插入图片描述

我们可以看到，确实在BeanPostProcessors容器中有一个ApplicationContextAwareProcessor类。那么我们进到ApplicationContextAwareProcessor这个类的postProcessBeforeInitialization方法中。

在这里插入图片描述

在这里插入图片描述 根据这个源码，我们知道了，确实调用到了setApplicationContext()方法。

 

 

罗汉翔
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java解决报错】IDEA中Spring Boot启动报错Application startup failed（记录调试rentcars项目）
Mtart liu的博客
12-08 7252
看了网上的攻略，说是这样的 原因：工程要求的JDK版本与环境所配置的JDK版本不同所致。 pom.xml文件中所要求的为 1.7 我的项目里不是1.7 并且我的设置里面sdk的版本是1.8 这里可以下载1.7版本，也可以把pom.xml文件里的1.7版本改成1.8! 我是把pom.xml文件里的改成了1.8 ...
SpringBoot应用启动过程分析
08-29
SpringBoot应用启动过程的入口点是SpringApplication类的静态方法run()。该方法有两个重载版本，一个是public static ConfigurableApplicationContext run(Object source, String... args)，另一个是public static ...
springboot之Application Startup tracking程序启动轨迹
weixin_56666956的博客
11-24 1560
在SpringApplication实例中加入setApplicationStartup(ApplicationStartup的一个实现类)来获得其StartupStep对象 BufferingApplicationStartup:将启动步骤并缓存放在一个外部系统中 FlightRecorderApplicationStartup:使用Java飞行记录器来描绘程序和将spring的上下文与JVM事件关联在一起 运行飞行记录器命令
Spring 启动顺序
最新发布
Wells974
06-12 1232
加载配置文件: 读取或等配置文件。创建 Spring 容器: 初始化。Bean 定义加载: 通过扫描和配置文件加载 Bean 定义。Bean 实例化: 根据 Bean 定义创建 Bean 实例。依赖注入: 将所需的依赖注入到 Bean 中。Bean 初始化: 调用初始化方法。完成启动: 应用完全启动并准备好处理请求。Spring 容器会根据配置文件和注解扫描路径加载 Bean 定义。在这个阶段，Spring 解析配置文件中的 Bean 定义和注解（如@Component@Service等）。
Spring源码解析之-doCreateBean() 详解
一直打铁
08-05 3928
目录一、介绍二、流程以及源码分析2.1 doCreateBean 流程图和分析2.2 doCreateBean 源码解析三、具体调用方法的详细逻辑四、总结 一、介绍 doCreateBean 是 AbstractBeanFactory#getBean 里面的核心，getBean 相关的整个流程可以查看 Spring源码解析之-SpringAbstractBeanFactory#getBean() 详解 主要是getBean 里面的流程细节比较多，这里单独介绍doCreateBean 的处理逻辑 二、流程以
讲一讲 @SpringBootApplication 这个注解
weixin_30750335的博客
07-04 86
当我们点击进去，会发现 @Configuration的注解类标识这个类可以使用Spring IoC容器作为bean定义的来源。@Bean注解告诉Spring，一个带有@Bean的注解方法将返回一个对象，该对象应该被注册为在Spring应用程序上下文中的bean。 @EnableAutoConfiguration：能够自动配置spring的上下文，试图猜测和配置你想要的bean类，通常会自动...
SpringApplication启动过程和AutoConfiguration实现
简单，坚持
08-23 1420
本文讲解了SpringApplication启动的全过程，并讲了SpringBootApplication中使用SpringFactoriesLoader来加载配置类的实现；通过本文的讲解读者能够明白spring-boot-configure中配置类的加载时机 和 过程。
Spring Boot启动过程完全解析(一)
08-30
Spring Boot启动过程完全解析 Spring Boot启动过程是指从应用程序启动到Spring Boot应用程序完全启动的整个过程。这个过程可以分为多个阶段，每个阶段都有一些重要的步骤和机制。下面将详细地介绍Spring Boot启动...
SpringBoot整个启动过程的分析
08-26
本文对SpringBoot的整个启动过程进行了分析，总结了`SpringBootApplication`注解的作用、`SpringApplication`类的构造方法和`initialize`方法的作用，以及SpringBoot的整个启动过程。通过对SpringBoot的启动过程的...
Spring Boot启动过程完全解析（二）
08-30
本文将深入探讨Spring Boot启动过程的第二部分，主要包括Spring Boot上下文的刷新、BeanFactory的获取与准备，以及Bean工厂的预处理。 首先，我们关注的是`refreshContext(context)`方法。此方法在检查`context`...
Spring Boot启动流程断点过程解析
08-25
Spring Boot启动流程断点过程解析 Spring Boot是当前最流行的Java框架之一，它提供了许多功能强大的特性来帮助开发者快速构建企业级应用程序。然而，对于Spring Boot的启动流程断点过程的理解是至关重要的。只有当...
springBoot学习笔记（三）源码分析之springApplication初始化过程
拐柒的博客
06-14 134
springBoot学习笔记（三）源码分析之springApplication初始化过程SpringApplication初始化SpringApplicationrun方法获取并启动监听器构造应用上下文环境prepareEnvironment SpringApplication springboot 启动的main放中的SpringApplication.run(DemoApplication.class, args)中的run方法其实是调用了SpringApplication中的run方法。 publ
spring startup
欢迎光临雨落星辰的博客
04-23 779
首先引入依赖。 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-actuator</artifactId> </dependency> 启动类： SpringApplication application = n
探索SpringApplication启动Spring
qq_24095055的博客
11-01 300
文章目录SpringContext创建bean的加载Spring扩展属性的加载总结 内容出自《Spring源码深度解析》 我们找到主函数入口SpringBootDemoApplication，发现这个入口的启动还是比较奇怪的，这也是Spring Boot启动的必要做法，那么，这也可以作为我们分析Spring Boot的入口： @SpringBootApplication public clas...
5.2 Application Startup
weixin_28726801的博客
11-25 671
1.Startup类 提供了应用程序的入口。必须实现Configure方法，可以选择定义一个ConfigureService方法。 2.Configure方法 Configure方法用于指定ASP.NET应用程序将如何响应每一个HTTP请求，类似于iis的管道，更复杂的管道配置可以封装于中间件中，并通过扩展方法添加到IpplicationBuilder上。如app.UseAuthentica...
Spring核心技术-启动流程
ALONG的博客
01-11 965
  启动入口为org.springframework.boot.SpringApplication#run(java.lang.String...)。 run方法创建并且刷新ApplicationContext。 public ConfigurableApplicationContext run(String... args) { StopWatch stopWatch = new StopWatch(); stopWatch.start(); DefaultBootstrapContext b
Springboot启动过程分析
一直在努力的小渣渣
02-20 576
SpringBoot的版本是v3.0.2，下面进行详细的分析。
SpringBoot启动探究（三）
weixin_45712835的博客
05-05 529
前两个小节，我们分别了解了SpringBootApplication注解和自动配置的加载过程，这一小节就可以正式地探究SpringBoot的启动原理了。
spring ApplicationContext启动过程
ac_dao_di的专栏
03-31 1531
本文对spring ApplicationContext启动过程进行详细解析，介绍刷新过程中的10个阶段的作用，包括ConfigurationClassPostProcessor处理java config注入beanDefinition，注册BeanPostProcessor对所有bean的构建进行初始化，创建内嵌tomcat容器注册servlet
SpringBoot的启动过程
09-02
这个接口用于支持对SpringApplication启动错误的自定义报告。其中，SpringBootExceptionReporter接口包含了报告启动失败的方法。 3. 初始化IOC容器：SpringBoot会在启动过程中初始化IOC容器。在这个阶段，Spring会...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值