2. 程式人生 > 程式設計 >SpringBoot內建tomcat啟動原理

SpringBoot內建tomcat啟動原理

阿新 • • 發佈：2019-12-31

前言

不得不說SpringBoot的開發者是在為大眾程式猿某福利，把大家都慣成了懶漢，xml不配置了，連tomcat也懶的配置了，典型的一鍵啟動系統，那麼tomcat在springboot是怎麼啟動的呢？

內建tomcat

開發階段對我們來說使用內建的tomcat是非常夠用了，當然也可以使用jetty。

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
   <version>2.1.6.RELEASE</version>
</dependency>
複製程式碼
 
@SpringBootApplication
public class MySpringbootTomcatStarter{
    public static void main(String[] args) {
        Long time=System.currentTimeMillis();
        SpringApplication.run(MySpringbootTomcatStarter.class);
        System.out.println("===應用啟動耗時："+(System.currentTimeMillis()-time)+"===");
    }
}
複製程式碼

這裡是main函式入口，兩句程式碼最耀眼，分別是SpringBootApplication註解和SpringApplication.run()方法。

釋出生產

釋出的時候，目前大多數的做法還是排除內建的tomcat，打瓦包（war）然後部署在生產的tomcat中，好吧，那打包的時候應該怎麼處理？

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <!-- 移除嵌入式tomcat外掛 -->
    <exclusions>
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<!--新增servlet-api依賴--->
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>3.1.0</version>
    <scope>provided</scope>
</dependency>
複製程式碼

更新main函式，主要是繼承SpringBootServletInitializer，並重寫configure()方法。

@SpringBootApplication
public class MySpringbootTomcatStarter extends SpringBootServletInitializer {
    public static void main(String[] args) {
        Long time=System.currentTimeMillis();
        SpringApplication.run(MySpringbootTomcatStarter.class);
        System.out.println("===應用啟動耗時："+(System.currentTimeMillis()-time)+"===");
    }

    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
        return builder.sources(this.getClass());
    }
}
複製程式碼

從main函式說起

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

--這裡run方法返回的是ConfigurableApplicationContext
public static ConfigurableApplicationContext run(Class<?>[] primarySources,String[] args) {
	return (new SpringApplication(primarySources)).run(args);
}
複製程式碼
public ConfigurableApplicationContext run(String... args) {
	ConfigurableApplicationContext context = null;
	Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList();
	this.configureHeadlessProperty();
	SpringApplicationRunListeners listeners = this.getRunListeners(args);
	listeners.starting();

	Collection exceptionReporters;
	try {
		ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
		ConfigurableEnvironment environment = this.prepareEnvironment(listeners,applicationArguments);
		this.configureIgnoreBeanInfo(environment);
		
		//列印banner，這裡你可以自己塗鴉一下，換成自己專案的logo
		Banner printedBanner = this.printBanner(environment);
		
		//建立應用上下文
		context = this.createApplicationContext();
		exceptionReporters = this.getSpringFactoriesInstances(SpringBootExceptionReporter.class,new Class[]{ConfigurableApplicationContext.class},context);

		//預處理上下文
		this.prepareContext(context,environment,listeners,applicationArguments,printedBanner);
		
		//重新整理上下文
		this.refreshContext(context);
		
		//再重新整理上下文
		this.afterRefresh(context,applicationArguments);
		
		listeners.started(context);
		this.callRunners(context,applicationArguments);
	} catch (Throwable var10) {
		
	}

	try {
		listeners.running(context);
		return context;
	} catch (Throwable var9) {
		
	}
}
複製程式碼

既然我們想知道tomcat在SpringBoot中是怎麼啟動的，那麼run方法中，重點關注建立應用上下文（createApplicationContext）和重新整理上下文（refreshContext）。

建立上下文

//建立上下文
protected ConfigurableApplicationContext createApplicationContext() {
	Class<?> contextClass = this.applicationContextClass;
	if (contextClass == null) {
		try {
			switch(this.webApplicationType) {
				case SERVLET:
                    //建立AnnotationConfigServletWebServerApplicationContext
				    contextClass = Class.forName("org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext");
					break;
				case REACTIVE:
					contextClass = Class.forName("org.springframework.boot.web.reactive.context.AnnotationConfigReactiveWebServerApplicationContext");
					break;
				default:
					contextClass = Class.forName("org.springframework.context.annotation.AnnotationConfigApplicationContext");
			}
		} catch (ClassNotFoundException var3) {
			throw new IllegalStateException("Unable create a default ApplicationContext,please specify an ApplicationContextClass",var3);
		}
	}

	return (ConfigurableApplicationContext)BeanUtils.instantiateClass(contextClass);
}
複製程式碼

這裡會建立AnnotationConfigServletWebServerApplicationContext類。 而AnnotationConfigServletWebServerApplicationContext類繼承了ServletWebServerApplicationContext，而這個類是最終集成了AbstractApplicationContext。

重新整理上下文

//SpringApplication.java
//重新整理上下文
private void refreshContext(ConfigurableApplicationContext context) {
	this.refresh(context);
	if (this.registerShutdownHook) {
		try {
			context.registerShutdownHook();
		} catch (AccessControlException var3) {
		}
	}
}

//這裡直接呼叫最終父類AbstractApplicationContext.refresh()方法
protected void refresh(ApplicationContext applicationContext) {
	((AbstractApplicationContext)applicationContext).refresh();
}
複製程式碼
//AbstractApplicationContext.java
public void refresh() throws BeansException,IllegalStateException {
	synchronized(this.startupShutdownMonitor) {
		this.prepareRefresh();
		ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
		this.prepareBeanFactory(beanFactory);

		try {
			this.postProcessBeanFactory(beanFactory);
			this.invokeBeanFactoryPostProcessors(beanFactory);
			this.registerBeanPostProcessors(beanFactory);
			this.initMessageSource();
			this.initApplicationEventMulticaster();
			//呼叫各個子類的onRefresh()方法，也就說這裡要回到子類：ServletWebServerApplicationContext，呼叫該類的onRefresh()方法
			this.onRefresh();
			this.registerListeners();
			this.finishBeanFactoryInitialization(beanFactory);
			this.finishRefresh();
		} catch (BeansException var9) {
			this.destroyBeans();
			this.cancelRefresh(var9);
			throw var9;
		} finally {
			this.resetCommonCaches();
		}

	}
}
複製程式碼
//ServletWebServerApplicationContext.java
//在這個方法裡看到了熟悉的面孔，this.createWebServer，神祕的面紗就要揭開了。
protected void onRefresh() {
	super.onRefresh();
	try {
		this.createWebServer();
	} catch (Throwable var2) {
		
	}
}

//ServletWebServerApplicationContext.java
//這裡是建立webServer，但是還沒有啟動tomcat，這裡是通過ServletWebServerFactory建立，那麼接著看下ServletWebServerFactory
private void createWebServer() {
	WebServer webServer = this.webServer;
	ServletContext servletContext = this.getServletContext();
	if (webServer == null && servletContext == null) {
		ServletWebServerFactory factory = this.getWebServerFactory();
		this.webServer = factory.getWebServer(new ServletContextInitializer[]{this.getSelfInitializer()});
	} else if (servletContext != null) {
		try {
			this.getSelfInitializer().onStartup(servletContext);
		} catch (ServletException var4) {
		
		}
	}

	this.initPropertySources();
}

//介面
public interface ServletWebServerFactory {
    WebServer getWebServer(ServletContextInitializer... initializers);
}

//實現
AbstractServletWebServerFactory
JettyServletWebServerFactory
TomcatServletWebServerFactory
UndertowServletWebServerFactory
複製程式碼

這裡ServletWebServerFactory介面有4個實現類

QQ截圖20190820132505.jpg
而其中我們常用的有兩個：TomcatServletWebServerFactory和JettyServletWebServerFactory。

//TomcatServletWebServerFactory.java
//這裡我們使用的tomcat，所以我們檢視TomcatServletWebServerFactory。到這裡總算是看到了tomcat的蹤跡。
@Override
public WebServer getWebServer(ServletContextInitializer... initializers) {
	Tomcat tomcat = new Tomcat();
	File baseDir = (this.baseDirectory != null) ? this.baseDirectory : createTempDir("tomcat");
	tomcat.setBaseDir(baseDir.getAbsolutePath());
    //建立Connector物件
	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);
}

//Tomcat.java
//返回Engine容器，看到這裡，如果熟悉tomcat原始碼的話，對engine不會感到陌生。
public Engine getEngine() {
    Service service = getServer().findServices()[0];
    if (service.getContainer() != null) {
        return service.getContainer();
    }
    Engine engine = new StandardEngine();
    engine.setName( "Tomcat" );
    engine.setDefaultHost(hostname);
    engine.setRealm(createDefaultRealm());
    service.setContainer(engine);
    return engine;
}
//Engine是最高階別容器，Host是Engine的子容器，Context是Host的子容器，Wrapper是Context的子容器
複製程式碼

getWebServer這個方法建立了Tomcat物件，並且做了兩件重要的事情：把Connector物件新增到tomcat中，configureEngine(tomcat.getEngine());            getWebServer方法返回的是TomcatWebServer。

//TomcatWebServer.java
//這裡呼叫建構函式例項化TomcatWebServer
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())) {
					removeServiceConnectors();
				}
			});

			//===啟動tomcat服務===
			this.tomcat.start();

			rethrowDeferredStartupExceptions();

			try {
				ContextBindings.bindClassLoader(context,context.getNamingToken(),getClass().getClassLoader());
			}
			catch (NamingException ex) {
                
			}
            
            //開啟阻塞非守護程式
			startDaemonAwaitThread();
		}
		catch (Exception ex) {
			stopSilently();
			destroySilently();
			throw new WebServerException("Unable to start embedded Tomcat",ex);
		}
	}
}
複製程式碼
//Tomcat.java
public void start() throws LifecycleException {
	getServer();
	server.start();
}
//這裡server.start又會回到TomcatWebServer的
public void stop() throws LifecycleException {
	getServer();
	server.stop();
}
複製程式碼
//TomcatWebServer.java
//啟動tomcat服務
@Override
public void start() throws WebServerException {
	synchronized (this.monitor) {
		if (this.started) {
			return;
		}
		try {
			addPreviouslyRemovedConnectors();
			Connector connector = this.tomcat.getConnector();
			if (connector != null && this.autoStart) {
				performDeferredLoadOnStartup();
			}
			checkThatConnectorsHaveStarted();
			this.started = true;
			//在控制檯列印這句日誌，如果在yml設定了上下文，這裡會列印
			logger.info("Tomcat started on port(s): " + getPortsDescription(true) + " with context path '"
					+ getContextPath() + "'");
		}
		catch (ConnectorStartFailedException ex) {
			stopSilently();
			throw ex;
		}
		catch (Exception ex) {
			throw new WebServerException("Unable to start embedded Tomcat server",ex);
		}
		finally {
			Context context = findContext();
			ContextBindings.unbindClassLoader(context,getClass().getClassLoader());
		}
	}
}

//關閉tomcat服務
@Override
public void stop() throws WebServerException {
	synchronized (this.monitor) {
		boolean wasStarted = this.started;
		try {
			this.started = false;
			try {
				stopTomcat();
				this.tomcat.destroy();
			}
			catch (LifecycleException ex) {
				
			}
		}
		catch (Exception ex) {
			throw new WebServerException("Unable to stop embedded Tomcat",ex);
		}
		finally {
			if (wasStarted) {
				containerCounter.decrementAndGet();
			}
		}
	}
}
複製程式碼

附：tomcat頂層結構圖

20180109094904328.jpg
      tomcat最頂層容器是Server，代表著整個伺服器，一個Server包含多個Service。從上圖可以看除Service主要包括多個Connector和一個Container。Connector用來處理連線相關的事情，並提供Socket到Request和Response相關轉化。Container用於封裝和管理Servlet，以及處理具體的Request請求。那麼上文提到的Engine>Host>Context>Wrapper容器又是怎麼回事呢？ 我們來看下圖：
20180109095032618.jpg
      綜上所述，一個tomcat只包含一個Server，一個Server可以包含多個Service，一個Service只有一個Container，但有多個Connector，這樣一個服務可以處理多個連線。       多個Connector和一個Container就形成了一個Service，有了Service就可以對外提供服務了，但是Service要提供服務又必須提供一個宿主環境，那就非Server莫屬了，所以整個tomcat的宣告週期都由Server控制。

總結

SpringBoot的啟動主要是通過例項化SpringApplication來啟動的，啟動過程主要做了以下幾件事情：配置屬性、獲取監聽器，釋出應用開始啟動事件初、始化輸入引數、配置環境，輸出banner、建立上下文、預處理上下文、重新整理上下文、再重新整理上下文、釋出應用已經啟動事件、釋出應用啟動完成事件。在SpringBoot中啟動tomcat的工作在重新整理上下這一步。而tomcat的啟動主要是例項化兩個元件：Connector、Container，一個tomcat例項就是一個Server，一個Server包含多個Service，也就是多個應用程式，每個Service包含多個Connector和一個Container，而一個Container下又包含多個子容器。

相關推薦

SpringBoot內建tomcat啟動原理

前言 不得不說SpringBoot的開發者是在為大眾程式猿某福利，把大家都慣成了懶漢，xml不配置了，連tomcat也懶的配置了，典型的一鍵啟動系統，那麼tomcat在springboot是怎麼啟動的呢？

SpringBoot內建tomcat啟動過程及原理

作者：李巖科 1 背景 SpringBoot 是一個框架，一種全新的程式設計規範，他的產生簡化了框架的使用，同時也提供了很多便捷的功能，比如內建 tomcat 就是其中一項，他讓我們省去了搭建 tomcat 容器，生成 war，部署，啟

SpringBoot如何取消內建Tomcat啟動並改用外接Tomcat

這篇文章主要介紹了SpringBoot如何取消內建Tomcat啟動並改用外接Tomcat,文中通過示例程式碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下

Springboot內建tomcat配置虛擬路徑過程解析

　　在Springboot中預設的靜態資源路徑有：classpath:/METAINF/resources/，classpath:/resources/，classpath:/static/，classpath:/public/，從這裡可以看出這裡的靜態資源路徑都是在classpath中（也就是在專案路徑

淺談springboot內建tomcat和外部獨立部署tomcat的區別

前兩天，我去面了個試，面試官問了我個問題，獨立部署的tomcat跟springboot內建的tomcat有什麼區別，為什麼存在要禁掉springboot的tomcat然後將專案部署到獨立的tomcat當中？

實戰Springboot內建Tomcat配置調優

我們在使用springboot(版本：2.0.3.RELEASE)開發web專案時，大多數時候採用的是內建的Tomcat（當然也可以配置支援內建的jetty），內建Tomcat有什麼好處呢？

【SpringBoot】原理分析（二）：啟動流程原始碼分析（包括內嵌tomcat啟動分析）

技術標籤：Spring系列spring bootjavatomcat 看 SpringBoot 的啟動流程原始碼的入口很好找，就是啟動類的 SpringApplication.run(DemoApplication.class, args)，點進run方法如下：

SpringBoot應用--03-Web Servlet啟動內建Tomcat伺服器

1. 實現類擴充套件的onRefresh|finishRefresh方法 ServletWebServerApplicationContext類中的具體方法

SpringBoot配置內建Tomcat的虛擬路徑對映（顯示本地圖片）

轉載：https://blog.csdn.net/weixin_42236404/article/details/90758737 由於Springboot使用的是內建的tomcat，因此我們需要建立如下一個配置類，繼承WebMvcConfigurer，重寫其方法

SpringBoot如何內建Tomcat

SpringBoot如何內建Tomcat 一、前言 在初次接觸 SpringBoot 的時候，就很奇怪為什麼直接執行主類的main方法就可以啟動程式，但卻一直沒有深究，直到前段時間，突然聽說了一個詞，叫做 Cargo Cult ，才開始對自己有所

springboot專案打包移除內建tomcat

修改入口類 @SpringBootApplication @MapperScan(\"com.xxx.dao\") - public class TestApplication{ + public class TestApplicationextends SpringBootServletInitializer {

淺談SpringBoot內嵌Tomcat的實現原理解析

一、序言 使用SpringBoot經常會使用內嵌的tomcat做為專案的啟動容器，本文將從原始碼的角度出發，剖析SpringBoot內嵌Tomcat的實現原理，討論Tomcat何時建立、何時啟動以及怎麼啟動。

很簡單的原始碼剖析-SpringBoot內嵌Tomcat原理

Spring Boot預設支援Tomcat，Jetty，和Undertow作為底層容器。而Spring Boot預設使用Tomcat，一旦引入spring-boot-starter-web模組，就預設使用Tomcat容器。

Python檔案操作及內建函式flush原理解析

1、開啟檔案得到檔案控制代碼並賦值給一個變數 2、通過控制代碼對檔案進行操作

使用內建tomcat建立WEB專案

大家知道，WEB應用程式有四個組成部分：網頁、WEB伺服器、瀏覽器、以及http協議。四個組成部分中，最為重要的就是WEB伺服器。

springboot內建瀏覽器_深入學習SpringBoot(二):SpringBoot入門"Hello SpringBoot

技術標籤：springboot內建瀏覽器 springboot是一個微框架,其設計的目的是為了簡化spring框架的搭建和配置過程.從而使開發人員不再需要定義樣板化的配置.下面是springboot的入門案例:它演示了利用springboot省去

內建tomcat註冊監聽器和過濾器

內建tomcat對於web元件的註冊，和外接tomcat有很大的區別。比如，在外接tomcat中註冊servlet，是使用web.xml檔案中的<servlet>標籤和<servlet-mapping>標籤，或者用@WebServlet註解進行註冊。而內建tomc

SpringBoot內嵌Tomcat併發容量問題

https://www.cnblogs.com/better-farther-world2099/articles/14400857.html 一、SpringBoot內嵌Tomcat預設配置與優化

檢視和指定SpringBoot內嵌Tomcat的版本

檢視當前使用的Tomcat版本號# Maven Repository中檢視# 比如我們需要查Spring Boot 2.1.4-RELEASE的內嵌Tomcat版本, 可以開啟連結：

SpringBoot內建常用工具類

參考連結：https://mp.weixin.qq.com/s/Hxu6_zzk-Z4itNd7ZAzZ3w 1、 Assert 斷言工具類：斷言是一個邏輯判斷，用於檢查不應該發生的情況，通常用於資料合法性檢查