Springboot之启动分析

最新推荐文章于 2022-08-26 11:02:19 发布
最新推荐文章于 2022-08-26 11:02:19 发布
阅读量102 收藏
点赞数
原文链接：https://my.oschina.net/u/2518341/blog/3063871
版权

    Springboot版本是2.0.5.release.

    如下List-1所示是我们平时使用Springboot的方式，底层上发生了些什么呢，我们接下来分析下。

    List-1

@SpringBootApplication
public class HelloApplication {

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

    SpringApplication的静态方法run，最终会先构造SpringApplication之后调用run方法，如下List-2，primarySources是我们传入的HelloApplication，args数组是List-1中传入的args。

    List-2

public static ConfigurableApplicationContext run(Class<?>[] primarySources,
        String[] args) {
    return new SpringApplication(primarySources).run(args);
}

1、SpringApplication的构造方法

    来看SpringApplication的构造方法，如下List-3，

    List-3

public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
    this.resourceLoader = resourceLoader;
    Assert.notNull(primarySources, "PrimarySources must not be null");
    this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
    this.webApplicationType = deduceWebApplicationType();//1
    setInitializers((Collection) getSpringFactoriesInstances( //2
            ApplicationContextInitializer.class));
    setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));//3
    this.mainApplicationClass = deduceMainApplicationClass();//4
}
  1. 判断是servlet web、reactive web还是普通的应用，如List-4所示，根据classpath是否有对应的类判断是哪种类型，当我们引入spring web依赖和servlet依赖，则是servlet web应用。
  2. 从spring.factories中获得所有ApplicationContextInitializer对应的值，之后实例化并进行排序，之后全部添加到SpringApplication的属性initializers中。
  3. 从spring.factories中获得所有ApplicationListener的值，之后实例化并进行排序，之后全部添加到SpringApplication的属性listeners中。
  4. 有意的抛出一个异常，之后判断哪个含有main方法，即List-1中的HelloApplication。

    List-4

private static final String REACTIVE_WEB_ENVIRONMENT_CLASS = "org.springframework."
			+ "web.reactive.DispatcherHandler";
private static final String MVC_WEB_ENVIRONMENT_CLASS = "org.springframework."
			+ "web.servlet.DispatcherServlet";
private static final String JERSEY_WEB_ENVIRONMENT_CLASS = "org.glassfish.jersey.server.ResourceConfig";

private static final String[] WEB_ENVIRONMENT_CLASSES = { "javax.servlet.Servlet",
			"org.springframework.web.context.ConfigurableWebApplicationContext" };

private WebApplicationType deduceWebApplicationType() {
    if (ClassUtils.isPresent(REACTIVE_WEB_ENVIRONMENT_CLASS, null)
            && !ClassUtils.isPresent(MVC_WEB_ENVIRONMENT_CLASS, null)
            && !ClassUtils.isPresent(JERSEY_WEB_ENVIRONMENT_CLASS, null)) {
        return WebApplicationType.REACTIVE;
    }
    for (String className : WEB_ENVIRONMENT_CLASSES) {
        if (!ClassUtils.isPresent(className, null)) {
            return WebApplicationType.NONE;
        }
    }
    return WebApplicationType.SERVLET;
}

2、SpringApplication的run方法

    如下List-5，内容看着有些多，我们逐个深入

    List-5

public ConfigurableApplicationContext run(String... args) {
    StopWatch stopWatch = new StopWatch();
    stopWatch.start();
    ConfigurableApplicationContext context = null;
    Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
    configureHeadlessProperty();
    SpringApplicationRunListeners listeners = getRunListeners(args);//1
    listeners.starting();//2
    try {
        ApplicationArguments applicationArguments = new DefaultApplicationArguments(
                args);//3
        ConfigurableEnvironment environment = prepareEnvironment(listeners,
                applicationArguments);//4
        configureIgnoreBeanInfo(environment);
        Banner printedBanner = printBanner(environment);//5
        context = createApplicationContext();//6
        exceptionReporters = getSpringFactoriesInstances(//7
                SpringBootExceptionReporter.class,
                new Class[] { ConfigurableApplicationContext.class }, context);
        prepareContext(context, environment, listeners, applicationArguments,//8
                printedBanner);
        refreshContext(context);//9
        afterRefresh(context, applicationArguments);//10
        stopWatch.stop();//11
        if (this.logStartupInfo) {
            new StartupInfoLogger(this.mainApplicationClass)//12
                    .logStarted(getApplicationLog(), stopWatch);
        }
        listeners.started(context);//13
        callRunners(context, applicationArguments);//14
    }
    catch (Throwable ex) {
        handleRunFailure(context, ex, exceptionReporters, listeners);
        throw new IllegalStateException(ex);
    }

    try {
        listeners.running(context);//15
    }
    catch (Throwable ex) {
        handleRunFailure(context, ex, exceptionReporters, null);
        throw new IllegalStateException(ex);
    }
    return context;
}
  1. 从spring.factories中获取SpringApplicationRunListener的值，实例化、排序，之后放到SpringApplicationRunListeners中，SpringApplicationRunListeners使用了组合设计模式。
  2. 调用starting方法。
  3. 构造DefaultApplicationArguments实例。
  4. 获取environment，4里面有很多操作，如List-6所示，getOrCreateEnvironment()方法根据类型创建对应的environment，我们一般是servlet web应用，则创建StandardServletEnvironment；"configureEnvironment(environment, applicationArguments.getSourceArgs())"将List-1中传到main函数的参数数组解析到environment；"bindToSpringApplication(environment)"将environment绑定到SpringApplication中。
  5. 打印banner，如List-7所示，bannerMode默认是Banner.Mode.CONSOLE，即打印到控制台，2位置处打印banner，默认使用的是SpringBootBanner，如List-8所示，List-8中的printBanner方法的参数printStream默认是System.out。
  6. 会根据应用的类型返回对应的applicationContext，以servlet web为例，创建的是AnnotationConfigServletWebServerApplicationContext，具体较为简单，可以看源码。
  7. 从spring.factories中获取SpringBootExceptionReporter的值，实例化排序。
  8. 该方法里面没有太多的操作，会逐个调用SpringApplication的ApplicationContextInitializer.initialize()方法，之后会将environment和printBanner注册到Spring的beanFactory里面。
  9. 其实是调用AbstractApplicationContext的refresh()方法，AbstractApplicationContext的refresh方法里面有很多内容，这里不详细讲。Springboot启动tomcat就是和这里有关了。
  10. 这个方法为空。
  11. StopWatch的stop方法，记录启动springboot用时多少。
  12. 将Springboot启动用时多少时间打印出来，这个就是我们平时在控制台看到类似"15:57:28.657 INFO  Started HelloApplication in 4.643 seconds (JVM running for 5.18)"的代码，如List-9所示。
  13. 调用listeners的started方法。
  14. 如List-10，从BeanFactory中获取ApplicationRunner和CommandLineRunner，之后排序，再逐个调用run方法。

    List-6

private ConfigurableEnvironment prepareEnvironment(
        SpringApplicationRunListeners listeners,
        ApplicationArguments applicationArguments) {
    // Create and configure the environment
    ConfigurableEnvironment environment = getOrCreateEnvironment();
    configureEnvironment(environment, applicationArguments.getSourceArgs());
    listeners.environmentPrepared(environment);
    bindToSpringApplication(environment);
    if (!this.isCustomEnvironment) {
        environment = new EnvironmentConverter(getClassLoader())
                .convertEnvironmentIfNecessary(environment, deduceEnvironmentClass());
    }
    ConfigurationPropertySources.attach(environment);
    return environment;
}
private ConfigurableEnvironment getOrCreateEnvironment() {
    if (this.environment != null) {
        return this.environment;
    }
    switch (this.webApplicationType) {
    case SERVLET:
        return new StandardServletEnvironment();
    case REACTIVE:
        return new StandardReactiveWebEnvironment();
    default:
        return new StandardEnvironment();
    }
}

    List-7

private Banner printBanner(ConfigurableEnvironment environment) {
    if (this.bannerMode == Banner.Mode.OFF) {
        return null;
    }
    ResourceLoader resourceLoader = (this.resourceLoader != null)
            ? this.resourceLoader : new DefaultResourceLoader(getClassLoader());
    SpringApplicationBannerPrinter bannerPrinter = new SpringApplicationBannerPrinter(//1
            resourceLoader, this.banner);
    if (this.bannerMode == Mode.LOG) {
        return bannerPrinter.print(environment, this.mainApplicationClass, logger);
    }
    return bannerPrinter.print(environment, this.mainApplicationClass, System.out);//2
}

    List-8

class SpringBootBanner implements Banner {

	private static final String[] BANNER = { "",
			"  .   ____          _            __ _ _",
			" /\\\\ / ___'_ __ _ _(_)_ __  __ _ \\ \\ \\ \\",
			"( ( )\\___ | '_ | '_| | '_ \\/ _` | \\ \\ \\ \\",
			" \\\\/  ___)| |_)| | | | | || (_| |  ) ) ) )",
			"  '  |____| .__|_| |_|_| |_\\__, | / / / /",
			" =========|_|==============|___/=/_/_/_/" };

	private static final String SPRING_BOOT = " :: Spring Boot :: ";

	private static final int STRAP_LINE_SIZE = 42;

	@Override
	public void printBanner(Environment environment, Class<?> sourceClass,
			PrintStream printStream) {
		for (String line : BANNER) {
			printStream.println(line);
		}
		String version = SpringBootVersion.getVersion();
		version = (version != null) ? " (v" + version + ")" : "";
		StringBuilder padding = new StringBuilder();
		while (padding.length() < STRAP_LINE_SIZE
				- (version.length() + SPRING_BOOT.length())) {
			padding.append(" ");
		}

		printStream.println(AnsiOutput.toString(AnsiColor.GREEN, SPRING_BOOT,
				AnsiColor.DEFAULT, padding.toString(), AnsiStyle.FAINT, version));
		printStream.println();
	}
}

    List-9

private StringBuilder getStartedMessage(StopWatch stopWatch) {
    StringBuilder message = new StringBuilder();
    message.append("Started ");
    message.append(getApplicationName());
    message.append(" in ");
    message.append(stopWatch.getTotalTimeSeconds());
    try {
        double uptime = ManagementFactory.getRuntimeMXBean().getUptime() / 1000.0;
        message.append(" seconds (JVM running for " + uptime + ")");
    }
    catch (Throwable ex) {
        // No JVM time available
    }
    return message;
}

    List-10

private void callRunners(ApplicationContext context, ApplicationArguments args) {
    List<Object> runners = new ArrayList<>();
    runners.addAll(context.getBeansOfType(ApplicationRunner.class).values());
    runners.addAll(context.getBeansOfType(CommandLineRunner.class).values());
    AnnotationAwareOrderComparator.sort(runners);
    for (Object runner : new LinkedHashSet<>(runners)) {
        if (runner instanceof ApplicationRunner) {
            callRunner((ApplicationRunner) runner, args);
        }
        if (runner instanceof CommandLineRunner) {
            callRunner((CommandLineRunner) runner, args);
        }
    }
}

3、Springboot是如何启动内嵌的tomcat的

    看List-5的9里面，调用的是AbstractApplicationContext.refresh->AbstractApplicationContext->onRefresh()->ServletWebServerApplicationContext.onRefresh()，AnnotationConfigServletWebServerApplicationContext的父类是ServletWebServerApplicationContext，来看下ServletWebServerApplicationContext的onRefresh方法，如List-11所示，createWebServer()里面，创建web服务容器，有可能是tomcat/jetty等。这样就创建好了web容器，之后refresh完成后就启动web容器了。

    List-11

@Override
protected void onRefresh() {
    super.onRefresh();
    try {
        createWebServer();
    }
    catch (Throwable ex) {
        throw new ApplicationContextException("Unable to start web server", ex);
    }
}
private void createWebServer() {
    WebServer webServer = this.webServer;
    ServletContext servletContext = getServletContext();
    if (webServer == null && servletContext == null) {
        ServletWebServerFactory factory = getWebServerFactory();
        this.webServer = factory.getWebServer(getSelfInitializer());
    }
    else if (servletContext != null) {
        try {
            getSelfInitializer().onStartup(servletContext);
        }
        catch (ServletException ex) {
            throw new ApplicationContextException("Cannot initialize servlet context",
                    ex);
        }
    }
    initPropertySources();
}

    思考: 我们可以修改为使用jetty容器而不是tomcat这是怎么做到的? 看List-11中getWebServerFactory()，从beanFactory中获取ServletWebServerFactory类型的bean，之后用该工厂创建webServer。WebServerFactory的实现类很多，具体使用哪个:

    ServletWebServerFactoryConfiguration如下List-2，根据ConditionalOnClass而后注入不同的WebServerFactory实现，其实还有个ReactiveWebServerFactoryConfiguration，这里面的是reactive的。

    List-2

@Configuration
class ServletWebServerFactoryConfiguration {

	@Configuration
	@ConditionalOnClass({ Servlet.class, Tomcat.class, UpgradeProtocol.class })
	@ConditionalOnMissingBean(value = ServletWebServerFactory.class, search = SearchStrategy.CURRENT)
	public static class EmbeddedTomcat {

		@Bean
		public TomcatServletWebServerFactory tomcatServletWebServerFactory() {
			return new TomcatServletWebServerFactory();
		}

	}

	/**
	 * Nested configuration if Jetty is being used.
	 */
	@Configuration
	@ConditionalOnClass({ Servlet.class, Server.class, Loader.class,
			WebAppContext.class })
	@ConditionalOnMissingBean(value = ServletWebServerFactory.class, search = SearchStrategy.CURRENT)
	public static class EmbeddedJetty {

		@Bean
		public JettyServletWebServerFactory JettyServletWebServerFactory() {
			return new JettyServletWebServerFactory();
		}

	}

	/**
	 * Nested configuration if Undertow is being used.
	 */
	@Configuration
	@ConditionalOnClass({ Servlet.class, Undertow.class, SslClientAuthMode.class })
	@ConditionalOnMissingBean(value = ServletWebServerFactory.class, search = SearchStrategy.CURRENT)
	public static class EmbeddedUndertow {

		@Bean
		public UndertowServletWebServerFactory undertowServletWebServerFactory() {
			return new UndertowServletWebServerFactory();
		}
	}
}

 

Reference

  1. springboot源码

转载于:https://my.oschina.net/u/2518341/blog/3063871

choubayan4320
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
SpringBoot应用启动过程分析
08-29
SpringBoot应用启动过程分析 SpringBoot是一款流行的Java框架，用于构建Web应用程序。了解SpringBoot应用的启动过程对开发者来说非常重要。在本篇文章中，我们将详细介绍SpringBoot应用的启动过程，并对其进行分析...
SpringBoot整个启动过程的分析
08-26
SpringBoot整个启动过程的分析 SpringBoot是一款流行的Java框架，用于构建Web应用程序。在本文中，我们将对SpringBoot的整个启动过程进行分析，从而帮助读者更好地理解SpringBoot的工作机制。 一、SpringBoot的...
java.lang.NoSuchMethodError: org.springframework.web.context.ConfigurableWebApplicationContext.getEn...
weixin_30782331的博客
05-09 335
在springsecurity学习中,在加入spring有关的jar包后，出现java.lang.NoSuchMethodError: org.springframework.web.context.ConfigurableWebApplicationContext.getEnvironment()Lorg/springframework/core/env/ConfigurableEnv...
springboot出现异常整合
zsx18273117003的博客
06-16 2033
1.缺少注解@SpringBootApplication 异常：org.springframework.context.ApplicationContextException: Unable to start web server; nested exception is org.springframework.context.ApplicationContextException: Unabl...
SpringBoot启动流程详细分析
ChirsPaul3的博客
03-27 517
SpringBoot启动流程详细分析 1.写在前面 SpringBoot框架作为Java开发领域最常用的框架，没有之一。今天就来扯一下实现原理，我们主要关注的时整个框架的启动流程，尤其是Web应用的启动。SpringBoot是基于Spring框架的注解来实现的，SpringBoot程序的启动会调用Spring框架本身的一系列创容器，刷新容器等步骤，真是Spring本身的知识，不再这篇详细介绍，大家可以看一下spring源码深度分析，里面比肩详细的介绍了Spring框架的启动分析。 以下的源码是基于Sprin
Springboot启动分析
daliucheng的博客
02-24 463
Springboot启动分析 建议先看Spring-@ComponentScan分析 SpringBoot的例子就不写了,最熟悉的代码如下: @SpringBootApplication public class SimpleApplication { public static void main(String[] args) { SpringApplication.run(SimpleApplication.class,args); } } SpringApplication的作用是什么？@S
SpringBoot启动流程分析
kyrielx的博客
08-26 196
Springboot启动流程分析，追溯源码，透彻理解
springboot 启动过程源码分析
11-06
SpringBoot 启动过程源码分析 SpringBoot 的启动原理是基于 JavaConfig 形式的配置，使用 @Configuration 注解标注的启动类来配置 IoC 容器。@SpringBootApplication 注解是 SpringBoot 的核心注解，它包括了三个...
SpringBoot打印启动时异常堆栈信息详解
08-25
SpringBoot 打印启动时异常堆栈信息详解 SpringBoot 是一个流行的 Java 框架，用于快速构建生产级别...SpringBoot 的故障分析仪机制可以帮助开发者更好地调试和解决项目启动时的异常问题，提高项目的可靠性和稳定性。
可能是全网最全的SpringBoot启动流程源码分析（基于 2.1.5 版本）
01-20
使用 Spring Boot 启动一个微服务十分简单，只需要在启动类上调用 SpringApplication 的run方法即可 点击进入run方法 1 run 静态辅助类，可用于运行使用默认配置（即我们添加的一系列注解）的指定源的 ...
SpringBoot启动流程
weixin_34059951的博客
10-22 55
SpringBoot核心启动类的SpringApplication。从SpringApplication.run()开始先创建SpringApplication对象，并调用该对象的run方法。 public static ConfigurableApplicationContext run(Object source, String... args) ...
spring boot应用启动原理分析
weixin_34123613的博客
11-30 847
spring boot quick start 在spring boot里，很吸引人的一个特性是可以直接把应用打包成为一个jar/war，然后这个jar/war是可以直接启动的，不需要另外配置一个Web Server。 如果之前没有使用过spring boot可以通过下面的demo来感受下。 下面以这个工程为例，演示如何启动Spr...
SpringBoot无废话入门02：SpringBoot启动分析
weixin_34015336的博客
03-14 79
1.核心注解 在上文中，我们讲到了@SpringBootApplication是SpringBoot的核心注解。 可以很方便的在idea中下载源码来查看该注解的源码，如下： 可以看到，该注解本身又被其它注解所叠加。其中最重要的注解是@SpringBootConfiguration和@EnableAutoConfiguration。第一个支持...
Springboot启动原理解析
weixin_30719711的博客
04-25 875
我们开发任何一个Spring Boot项目，都会用到如下的启动类 @SpringBootApplication public class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args); ...
SpringBoot2 | SpringBoot启动流程源码分析（一）
热门推荐
程序员阿康
08-31 12万+
概述： 前阵子看到了SpringCloud社区的一个开源项目，主要是对服务发现增强的功能。研究项目的时候发现代码简练，优雅，最主要是spring ioc和aop特性应用的得心应手。若非对源码有深入研究，不可能写出这么优秀的开源项目。另外在现有的springboot专栏中，大多数博文旨在应用，对一些中间件的整合之类，源码分析的博客数量有限。鉴于以上两方面，该系列应运而生。 该系列主要还是Spri...
The type org.springframework.context.ConfigurableApplicationContext cannot be resolved.
svneclipse的博客
06-17 1万+
The type org.springframework.context.ConfigurableApplicationContext cannot be resolved.2017年12月28日 17:20:31阅读数：1780eclipse导入maven的spring boot项目时，DemoApplication.java出现的错误。解决方法： 1，在命令行中转到项目目录。 确保您的POM....
SpringBoot启动类及其原理的分析
Harswlgb的博客
10-27 421
本文分析SpringBoot启动类及其原理主要是从一下俩个方面来分析的 解析@SpringBootApplication 解析run方法 解析@SpringBootApplication @SpringBootConfiguration 首先这是一个配置类，继承于@Configuration，本身只是说明这是一个SpringBoot项目的配置类，功能与@Configuration一样，使得Spring容器知道需要跟处理@Configuration注解的类一样处理这个类。 @EnableAutoC.
Spring Boot 启动源码分析
convict_EVA的专栏
04-24 799
spring boot 项目都有个启动类，如下： @SpringBootApplication public class DemoApplication{ public static void main(String[] args) { SpringApplication.run(DemoApplication.class, args); } } 写在前面：...
springboot2启动流程源码分析
最新发布
09-21
SpringBoot2的启动流程是通过@SpringBootApplication注解自动化配置来实现的。该注解包含了多个注解的组合，其中包括@ComponentScan、@EnableAutoConfiguration和@Configuration等。通过这些注解，Spring Boot会自动...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值