springboot应用启动流程分析，嵌入式tomcat

已于 2022-07-16 18:02:39 修改
阅读量402 收藏
点赞数
分类专栏： Spring 文章标签： spring boot tomcat servlet
于 2020-07-01 13:50:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LeoHan163/article/details/107059484
版权

之前我们分析了下springboot自动装载的原理，现在我们看看springboot应用启动的流程：
一般调用如下：

// 应用代码

 SpringApplication.run(MiddlewareApplication.class, args);
// SpringApplication.java
	public static ConfigurableApplicationContext run(Class<?> primarySource, String... args) {
		return run(new Class<?>[] { primarySource }, args);
	}
	public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
		return new SpringApplication(primarySources).run(args);
	}
	public SpringApplication(Class<?>... primarySources) {
		this(null, primarySources);
	}
	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 = WebApplicationType.deduceFromClasspath();
		setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
		setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
		this.mainApplicationClass = deduceMainApplicationClass();
	}
	public ConfigurableApplicationContext run(String... args) {
		StopWatch stopWatch = new StopWatch();
		stopWatch.start();
		ConfigurableApplicationContext context = null;
		Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
		configureHeadlessProperty();
		SpringApplicationRunListeners listeners = getRunListeners(args);
		listeners.starting();
		try {
			ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
			ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
			configureIgnoreBeanInfo(environment);
			Banner printedBanner = printBanner(environment);
			context = createApplicationContext();
			exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class,
					new Class[] { ConfigurableApplicationContext.class }, context);
			prepareContext(context, environment, listeners, applicationArguments, printedBanner);
			refreshContext(context);
			afterRefresh(context, applicationArguments);
			stopWatch.stop();
			if (this.logStartupInfo) {
				new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
			}
			listeners.started(context);
			callRunners(context, applicationArguments);
		}
		catch (Throwable ex) {
			handleRunFailure(context, ex, exceptionReporters, listeners);
			throw new IllegalStateException(ex);
		}

		try {
			listeners.running(context);
		}
		catch (Throwable ex) {
			handleRunFailure(context, ex, exceptionReporters, null);
			throw new IllegalStateException(ex);
		}
		return context;
	}


public enum WebApplicationType {

	/**
	 * The application should not run as a web application and should not start an
	 * embedded web server.
	 */
	NONE,

	/**
	 * The application should run as a servlet-based web application and should start an
	 * embedded servlet web server.
	 */
	SERVLET,

	/**
	 * The application should run as a reactive web application and should start an
	 * embedded reactive web server.
	 */
	REACTIVE;

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

	private static final String WEBMVC_INDICATOR_CLASS = "org.springframework." + "web.servlet.DispatcherServlet";

	private static final String WEBFLUX_INDICATOR_CLASS = "org." + "springframework.web.reactive.DispatcherHandler";

	private static final String JERSEY_INDICATOR_CLASS = "org.glassfish.jersey.servlet.ServletContainer";

	private static final String SERVLET_APPLICATION_CONTEXT_CLASS = "org.springframework.web.context.WebApplicationContext";

	private static final String REACTIVE_APPLICATION_CONTEXT_CLASS = "org.springframework.boot.web.reactive.context.ReactiveWebApplicationContext";

	static WebApplicationType deduceFromClasspath() {
		if (ClassUtils.isPresent(WEBFLUX_INDICATOR_CLASS, null) && !ClassUtils.isPresent(WEBMVC_INDICATOR_CLASS, null)
				&& !ClassUtils.isPresent(JERSEY_INDICATOR_CLASS, null)) {
			return WebApplicationType.REACTIVE;
		}
		for (String className : SERVLET_INDICATOR_CLASSES) {
			if (!ClassUtils.isPresent(className, null)) {
				return WebApplicationType.NONE;
			}
		}
		return WebApplicationType.SERVLET;
	}

	static WebApplicationType deduceFromApplicationContext(Class<?> applicationContextClass) {
		if (isAssignable(SERVLET_APPLICATION_CONTEXT_CLASS, applicationContextClass)) {
			return WebApplicationType.SERVLET;
		}
		if (isAssignable(REACTIVE_APPLICATION_CONTEXT_CLASS, applicationContextClass)) {
			return WebApplicationType.REACTIVE;
		}
		return WebApplicationType.NONE;
	}

	private static boolean isAssignable(String target, Class<?> type) {
		try {
			return ClassUtils.resolveClassName(target, null).isAssignableFrom(type);
		}
		catch (Throwable ex) {
			return false;
		}
	}
}

可以看到，这里首先会判断当前ApplicaitonContext的类型，判断的依据是判断当前环境下是否存在对应的类，返回相应的WebApplicationType，获取到响应WebApplicationType之后会初始化对应的ApplicationContext：

protected ConfigurableApplicationContext createApplicationContext() {
		Class<?> contextClass = this.applicationContextClass;
		if (contextClass == null) {
			try {
				switch (this.webApplicationType) {
				case SERVLET:
					contextClass = Class.forName(DEFAULT_SERVLET_WEB_CONTEXT_CLASS);
					break;
				case REACTIVE:
					contextClass = Class.forName(DEFAULT_REACTIVE_WEB_CONTEXT_CLASS);
					break;
				default:
					contextClass = Class.forName(DEFAULT_CONTEXT_CLASS);
				}
			}
			catch (ClassNotFoundException ex) {
				throw new IllegalStateException(
						"Unable create a default ApplicationContext, " + "please specify an ApplicationContextClass",
						ex);
			}
		}
		return (ConfigurableApplicationContext) BeanUtils.instantiateClass(contextClass);
	}

默认情况下，如果没有web相关类的话，初始化的是：
org.springframework.context.annotation.AnnotationConfigApplicationContext,这个我们在讲解springboot自动装配的时候有过说明。
如果是web的话，比如我们默认使用的基于Servlet：
org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext

public class AnnotationConfigServletWebServerApplicationContext extends ServletWebServerApplicationContext
		implements AnnotationConfigRegistry {
	private final AnnotatedBeanDefinitionReader reader;
	private final ClassPathBeanDefinitionScanner scanner;
	private final Set<Class<?>> annotatedClasses = new LinkedHashSet<>();
	private String[] basePackages;

	public AnnotationConfigServletWebServerApplicationContext() {
		this.reader = new AnnotatedBeanDefinitionReader(this);
		this.scanner = new ClassPathBeanDefinitionScanner(this);
	}
	...
}

可以看到，这里还是和AnnotationConfigApplicationContext一样，使用了AnnotatedBeanDefinitionReader和ClassPathBeanDefinitionScanner.

我们看下，大家有时候在基于springboot构建web应用的时候，只要导入相应的jar包，就可以开启web相关应用，我们看下实现逻辑：
在这里插入图片描述
在其父类ServletWebServerApplicationContext我们发现如下方法：

// ServletWebServerApplicationContext.java
protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		beanFactory.addBeanPostProcessor(new WebApplicationContextServletContextAwareProcessor(this));
		beanFactory.ignoreDependencyInterface(ServletContextAware.class);
		registerWebApplicationScopes();
	}
	@Override
	public final void refresh() throws BeansException, IllegalStateException {
		try {
			super.refresh();
		}
		catch (RuntimeException ex) {
			stopAndReleaseWebServer();
			throw ex;
		}
	}

	@Override
	protected void onRefresh() {
		super.onRefresh();
		try {
			createWebServer();
		}
		catch (Throwable ex) {
			throw new ApplicationContextException("Unable to start web server", ex);
		}
	}
	@Override
	protected void finishRefresh() {
		super.finishRefresh();
		WebServer webServer = startWebServer();
		if (webServer != null) {
			publishEvent(new ServletWebServerInitializedEvent(webServer, this));
		}
	}

	@Override
	protected void onClose() {
		super.onClose();
		stopAndReleaseWebServer();
	}
	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();
	}
	protected ServletWebServerFactory getWebServerFactory() {
		// Use bean names so that we don't consider the hierarchy
		String[] beanNames = getBeanFactory().getBeanNamesForType(ServletWebServerFactory.class);
		if (beanNames.length == 0) {
			throw new ApplicationContextException("Unable to start ServletWebServerApplicationContext due to missing "
					+ "ServletWebServerFactory bean.");
		}
		if (beanNames.length > 1) {
			throw new ApplicationContextException("Unable to start ServletWebServerApplicationContext due to multiple "
					+ "ServletWebServerFactory beans : " + StringUtils.arrayToCommaDelimitedString(beanNames));
		}
		return getBeanFactory().getBean(beanNames[0], ServletWebServerFactory.class);
	}

可以看到在onFresh的时候，执行了createWebServer，在这里创建了webserver，
而这里的ServletWebServerFactory就是创建webserver的关键

在这里插入图片描述
还记之前在研究springboot装载的时候会按照响应条件加载META-INF/spring.factories中相关配置类，其中有一个
org.springframework.boot.autoconfigure.web.servlet.ServletWebServerFactoryAutoConfiguration这个就是装载webserver类的处理：

@Configuration
@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
@ConditionalOnClass(ServletRequest.class)
@ConditionalOnWebApplication(type = Type.SERVLET)
@EnableConfigurationProperties(ServerProperties.class)
@Import({ ServletWebServerFactoryAutoConfiguration.BeanPostProcessorsRegistrar.class,
		ServletWebServerFactoryConfiguration.EmbeddedTomcat.class,
		ServletWebServerFactoryConfiguration.EmbeddedJetty.class,
		ServletWebServerFactoryConfiguration.EmbeddedUndertow.class })
public class ServletWebServerFactoryAutoConfiguration {
...
}
@Configuration
class ServletWebServerFactoryConfiguration {

	@Configuration
	@ConditionalOnClass({ Servlet.class, Tomcat.class, UpgradeProtocol.class })
	@ConditionalOnMissingBean(value = ServletWebServerFactory.class, search = SearchStrategy.CURRENT)
	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)
	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)
	static class EmbeddedUndertow {

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

	}

}

可以看到只要相应webserver对应的类能够存在导入，则会导入对应的web服务类型，我们以tomcat
为例,，如果存在tomcat服务器相关类型后，则使用TomcatServletWebServerFactory
：

// TomcatServletWebServerFactory.java
public WebServer getWebServer(ServletContextInitializer... initializers) {
		Tomcat tomcat = new Tomcat();
		File baseDir = (this.baseDirectory != null) ? this.baseDirectory : createTempDir("tomcat");
		tomcat.setBaseDir(baseDir.getAbsolutePath());
		Connector connector = new Connector(this.protocol);
		tomcat.getService().addConnector(connector);
		customizeConnector(connector);
		tomcat.setConnector(connector);
		tomcat.getHost().setAutoDeploy(false);
		configureEngine(tomcat.getEngine());
		for (Connector additionalConnector : this.additionalTomcatConnectors) {
			tomcat.getService().addConnector(additionalConnector);
		}
		prepareContext(tomcat.getHost(), initializers);
		return getTomcatWebServer(tomcat);
	}
	protected TomcatWebServer getTomcatWebServer(Tomcat tomcat) {
		return new TomcatWebServer(tomcat, getPort() >= 0);
	}

// TomcatWebServer.java
public TomcatWebServer(Tomcat tomcat, boolean autoStart) {
		Assert.notNull(tomcat, "Tomcat Server must not be null");
		this.tomcat = tomcat;
		this.autoStart = autoStart;
		initialize();
	}

	private void initialize() throws WebServerException {
		logger.info("Tomcat initialized with port(s): " + getPortsDescription(false));
		synchronized (this.monitor) {
			try {
				addInstanceIdToEngineName();

				Context context = findContext();
				context.addLifecycleListener((event) -> {
					if (context.equals(event.getSource()) && Lifecycle.START_EVENT.equals(event.getType())) {
						// Remove service connectors so that protocol binding doesn't
						// happen when the service is started.
						removeServiceConnectors();
					}
				});

				// Start the server to trigger initialization listeners
				this.tomcat.start();

				// We can re-throw failure exception directly in the main thread
				rethrowDeferredStartupExceptions();

				try {
					ContextBindings.bindClassLoader(context, context.getNamingToken(), getClass().getClassLoader());
				}
				catch (NamingException ex) {
					// Naming is not enabled. Continue
				}

				// Unlike Jetty, all Tomcat threads are daemon threads. We create a
				// blocking non-daemon to stop immediate shutdown
				startDaemonAwaitThread();
			}
			catch (Exception ex) {
				stopSilently();
				destroySilently();
				throw new WebServerException("Unable to start embedded Tomcat", ex);
			}
		}
	}

这里能够基于注解自动装载tomcat服务器，而不是像一般用的打成war包然后部署到tomcat服务器里面去，tomcat提供了嵌入式tomcat支持，能够像普通写代码一样，在代码里直接生成tomcat web容器。

Leo Han
关注
专栏目录
springBoot整合 Eureka 体验Spring Could报错：Unable to start embedded Tomcat
qq_37666892的博客
11-05 328
springBoot整合 Eureka 体验Spring Could报错：Caused by: org.springframework.boot.web.server.WebServerException: Unable to start embedded Tomcat 错误： Caused by: org.springframework.boot.web.server.WebServerExce...
springboot使用外置的tomcat，启动的时候没有启动springboot应用
simle168的博客
10-19 5662
  springboot使用外置的tomcat，启动的时候没有启动springboot应用，虽然可以访问首页 但是点击超链接访问controller却是404错误， 前台 &lt;%-- Created by IntelliJ IDEA. User: jillion Date: 2018/10/18 Time: 23:30 To change this templ...
springboot内嵌tomcat启动流程
weixin_43940116的博客
04-02 105
https://blog.csdn.net/fei1234456/article/details/106789568/
【异常解决】Unable to start embedded Tomcat Nacos 启动报错
最新发布
No8g攻城狮的博客
07-15 1899
Windows 本地启动 Nacos（2.2.0） 服务，控制台报错 Unable to start embedded Tomcat。进入到nacos安装目录下的bin文件夹下，输入 startup.cmd -m standalone 回车即可。即可访问控制台 http://localhost:8848/nacos/index.html。原因一：启动方式不对，直接双击打开或者是通过命令行启动（startup.cmd）默认是集群模式。Nacos 配置的默认端口号是 8848，请检查这个端口是否被占用。
springboot源码2---内嵌、外嵌tomcat启动流程
piliang719719的博客
11-21 453
DispatcherServletRegistrationBean、DispatcherServlet注册及组件初始化、内嵌/外嵌tomcat启动流程
Springboot如何启动内置的tomcat（源码解析）？
ke1ying的博客
12-02 1397
传统项目为了启动，会放在tomcat下面，那么springboot为何不需要放在tomcat启动呢？？因为springboot有内置tomcat启动项目，这篇文章从源码分析springboot如何启动内置tomcat。 // Allows post-processing of the bean factory in context subclasses. postProcessBeanFactory(beanFactory); // Invoke factory processo
Unable to start embedded Tomcat
热门推荐
qq_34638435的博客
05-29 1万+
org.springframework.context.ApplicationContextException: Unable to start embedded container; nested exception is org.springframework.boot.context.embedded.EmbeddedServletContainerException: Unable to ...
SpringBoot中如何启动Tomcat流程
08-26
因此，SpringBoot 中的 Tomcat 启动流程可以概括为以下步骤： 1. 创建 ApplicationContext 2. 加载和实例化 Context 类 3. 调用 Context 的 refresh 方法 4. 创建嵌入式 Servlet 容器 5. 启动 Tomcat 通过这些步骤...
springboot启动周期流程
10-27
- **引导加载器（Bootstrap ClassLoader）**：SpringBoot应用的启动是从`main`方法开始的，这个方法通常位于一个`SpringBootApplication`类型的类中。执行`SpringApplication.run()`会启动引导过程。 - **设置环境...
Tomcat启动springboot项目war包报错：启动子级时出错的问题
09-29
在Spring Boot应用部署到Tomcat服务器的过程中，遇到“启动子级时出错”的问题，这通常是由于多种原因导致的。以下是一些可能的原因和解决策略： 1. **配置错误**： - 检查`web.xml`配置，确保没有错误的配置项，...
SpringBoot-2.7.6构建WAR包外置Tomcat调试启动过程
qq_38127559的博客
02-23 1355
新项目直接采用SpringBoot提供的插件可以很方便的构建现代的可执行的“uber jar”。历史项目很多是采用外置tomcat容器进行部署的，在用SpringBoot框架重构项目后，需要在不更改部署方式的情况，要求SpringBoot要能支持传统的部署形式，本文基于SpringBoot官方文档，调试了SpringBoot支持的传统war部署方式。
springboot配置https访问报错
qq_45849231的博客
05-10 1065
是由于不同的springboot版本配置文件中ssl的写法问题导致，在较早的版本用。后面的版本（我是2.5.4）用。
SpringBoot - Unable to Start embedded TomCat
man_8211的专栏
12-05 1万+
在springboot启动项目的时候 偶然报错 报错的信息如下，在网上查询了一下， 有的是jar包冲突http://blog.csdn.net/dengchenrong/article/details/77005815 有的是版本问题 http://blog.csdn.net/riyunzhu/article/details/63259718 但是都不能解决我的问题，后来发现是端口号的问题。
SpringBoot的启动流程
06-09
4. 开始运行应用程序，Spring Boot 会启动嵌入式的 Web 服务器（如 Tomcat、Jetty 等），并将请求转发给对应的 Controller 进行处理。 5. 应用程序关闭，Spring Boot 会自动销毁应用程序中的 Bean，并关闭嵌入式的 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值