Springboot之启动分析

最新推荐文章于 2024-08-10 21:58:42 发布
最新推荐文章于 2024-08-10 21:58:42 发布
阅读量122 收藏
点赞数
原文链接：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
关注
详细分析Springboot启动流程
m0_73311735的博客
03-27 259
本文会对Springboot启动流程进行详细分析。但是请注意，Springboot启动流程是Springboot的逻辑，请千万不要将Springboot启动流程相关逻辑与Spring的相关逻辑混在一起，比如把Spring的bean生命周期的逻辑混在Springboot启动流程中，那么整个体系就复杂且混乱了。所以本文仅重点关注Springboot启动流程，涉及Spring的部分，会略作说明并跳过。整体的一个结构图如下。Springboot2.4.1Springboot启动时，第一件重要事件就是初始化。
SpringBoot启动分析
isbn0123的博客
07-30 163
SpringBoot启动分析 1）IOC之容器启动阶段 这个阶段主要会进行：加载配置文件并解析，然后将解析后的数据封装为BeanDefinition实例，最后把这些保存了bean定义的BeanDefinition，注册到相应的BeanDefinitionRegistry，这样容器的启动工作就完成了。 配置文件:类似的有xml配置文件还有自动配置类 2）IOC之容器实例化阶段 当某个请求通过BeanFactory的getBean方法请求某个对象，或者因为依赖关系容器需要隐式的调用getBean时，就会触发第二
SpringBoot无废话入门02：SpringBoot启动分析
weixin_34015336的博客
03-14 95
1.核心注解 在上文中，我们讲到了@SpringBootApplication是SpringBoot的核心注解。 可以很方便的在idea中下载源码来查看该注解的源码，如下： 可以看到，该注解本身又被其它注解所叠加。其中最重要的注解是@SpringBootConfiguration和@EnableAutoConfiguration。第一个支持...
Spring boot 启动过程分析
大黄奔跑
08-11 451
文章目录总有人替你做了一些事儿1. SpringBoot启动阶段划分2. Spring boot 的配置过程1. 绕不开的getSpringFactoriesInstances()3. 运行 Spring应用的开始源码简单浏览总结 总有人替你做了一些事儿 我们常常惊叹于 Spring boot 的极大简化开发者的开发流程，将我们从苦逼的 xml 配置中释放出来，可以更加愉快欢乐的摸鱼了。 但是有没有想过几行简单的启动程序，Spring boot 是如何做到的呢？ 下面这个程序可以说是最最根本的一个 Spri
Springboot启动分析（四）
我爱吃红薯的博客
08-12 192
一，程序入口 @SpringBootApplication public class DemoApplication { public static void main(String[] args) { SpringApplication.run(DemoApplication.class, args); } } 二，进入注解@SpringBootApplica...
SpringBoot整个启动过程的分析
08-26
SpringBoot整个启动过程的分析 SpringBoot是一款流行的Java框架，用于构建Web应用程序。在本文中，我们将对SpringBoot的整个启动过程进行分析，从而帮助读者更好地理解SpringBoot的工作机制。 一、SpringBoot的...
可能是全网最全的SpringBoot启动流程源码分析（基于 2.1.5 版本）
01-20
使用 Spring Boot 启动一个微服务十分简单，只需要在启动类上调用 SpringApplication 的run方法即可 点击进入run方法 1 run 静态辅助类，可用于运行使用默认配置（即我们添加的一系列注解）的指定源的 ...
springboot 启动过程源码分析
11-06
SpringBoot 启动过程源码分析 SpringBoot 的启动原理是基于 JavaConfig 形式的配置，使用 @Configuration 注解标注的启动类来配置 IoC 容器。@SpringBootApplication 注解是 SpringBoot 的核心注解，它包括了三个...
SpringBoot打印启动时异常堆栈信息详解
08-25
SpringBoot 打印启动时异常堆栈信息详解 SpringBoot 是一个流行的 Java 框架，用于快速构建生产级别...SpringBoot 的故障分析仪机制可以帮助开发者更好地调试和解决项目启动时的异常问题，提高项目的可靠性和稳定性。
Springboot启动分析
daliucheng的博客
02-24 485
Springboot启动分析 建议先看Spring-@ComponentScan分析 SpringBoot的例子就不写了,最熟悉的代码如下: @SpringBootApplication public class SimpleApplication { public static void main(String[] args) { SpringApplication.run(SimpleApplication.class,args); } } SpringApplication的作用是什么？@S
springboot启动原理及源码赏析
chushao1447的博客
08-01 708
springboot启动原理剖析 2019年8月1日 15:42 我们开发任何一个Spring Boot项目，都会用到如下的启动类 1 @SpringBootApplication 2 public class Application { 3 public stati...
Spring Boot简介、开启与启动分析
王者之峰
02-26 394
简介 说实话我之前没有接触过spring boot以为它是个编写应用程序的框架，无知总不能一直无知下去，不懂就要学习。 spring boot可以认为是一个快速开发的方式方法，但本质还是spring。用过传统spring方式开发你就会发现xml配置比较烦杂，每次重新建个项目都要去配置下有可能还会配错，虽然项目的业务不同但是你会发现你需要配置的东西差不多是一致的，那么为什么不统一配置使用一些大家都默...
Spring Boot 启动原理完整解析
最新发布
Randy的博客
08-10 1280
通过对 Spring Boot 启动过程的详细解析，我们不仅可以深入理解 Spring Boot 的工作原理，还能学习到各种设计模式的实际应用。在面试中，Spring Boot 的启动原理是常见的考察点，掌握这些内容能够帮助我们更好地应对面试，并在实际开发中灵活运用。
springboot启动分析
s674334235的专栏
11-12 173
##springboot启动代码分析 1. 创建SpringApplication对象 1-1 创建SpringApplication时，会调用initialize方法，这个方法会做4件事情。 赋值springApplication的webEnvironment属性。 用来判断是否web环境。 赋值springApplication的initializers属性。 加载spring.factor...
Spring Boot 启动过程分析（一）
zyinn的博客
06-20 304
1. Spring Boot 入口——main方法@SpringBootApplication public class Application { public static void main(String[] args) throws Exception { SpringApplication.run(Application.class, args); } }...
Springboot启动流程分析
qq_40608425的博客
07-09 256
SpringBoot的启动流程分析
SpringBoot微服务启动器源码分析
资源摘要信息: "microservice-starter-springboot-源码.rar" 文件包含了 Spring Boot 微服务的启动项目源代码。这个资源可能是用来创建一个基于Spring Boot的微服务架构项目的起点。Spring Boot 是一个流行的Java...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值