preface
Have to say that the developers of SpringBoot is for the welfare of the public program ape, we are used to lazy, XML is not configured, even tomcat is lazy configuration, typical one-click boot system, so tomcat in SpringBoot is how to start?
Built-in tomcat
The development phase was sufficient for us to use the built-in Tomcat, but jetty could also be used.
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> < version > 2.1.6. RELEASE < / version > < / dependency >Copy the code@SpringBootApplication
public class MySpringbootTomcatStarter{
public static void main(String[] args) {
Long time=System.currentTimeMillis();
SpringApplication.run(MySpringbootTomcatStarter.class);
System.out.println("=== Application startup time:"+(System.currentTimeMillis()-time)+"= = ="); }}Copy the codeHere is the entrance to the main function, and the two most eye-catching lines of code are the SpringBootApplication annotation and the SpringApplication.run() method.
Release the production
At the time of release, most of the current practice is to exclude the built-in Tomcat, make a war package and deploy it in production Tomcat. Well, what should be done when packaging?
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> <! > <exclusions> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-tomcat</artifactId> </exclusion> </exclusions> </dependency> <! Javax. servlet</groupId> <artifactId> Javax. servlet-api</artifactId> < version > 3.1.0 < / version > < scope > provided < / scope > < / dependency >Copy the codeUpdate the main function, mainly inherited SpringBootServletInitializer, pay equal attention to write the configure () method.
@SpringBootApplication
public class MySpringbootTomcatStarter extends SpringBootServletInitializer {
public static void main(String[] args) {
Long time=System.currentTimeMillis();
SpringApplication.run(MySpringbootTomcatStarter.class);
System.out.println("=== Application startup time:"+(System.currentTimeMillis()-time)+"= = =");
}
@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
return builder.sources(this.getClass()); }}Copy the codeStart with the main function
public static ConfigurableApplicationContext run(Class
primarySource, String... args) {
return run(newClass[]{primarySource}, args); } -- where the run method returnsConfigurableApplicationContext
public static ConfigurableApplicationContext run(Class
[] primarySources, String[] args) {
return (new SpringApplication(primarySources)).run(args);
}
Copy the codepublic 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);
// Print the banner. Here you can doodle it and replace it with your own project logo
Banner printedBanner = this.printBanner(environment);
// Create the application context
context = this.createApplicationContext();
exceptionReporters = this.getSpringFactoriesInstances(SpringBootExceptionReporter.class, new Class[]{ConfigurableApplicationContext.class}, context);
// Preprocess the context
this.prepareContext(context, environment, listeners, applicationArguments, printedBanner);
// Refresh the context
this.refreshContext(context);
// Refresh the context
this.afterRefresh(context, applicationArguments);
listeners.started(context);
this.callRunners(context, applicationArguments);
} catch (Throwable var10) {
}
try {
listeners.running(context);
return context;
} catch (Throwable var9) {
}
}
Copy the codeSince we want to know how tomcat is started in SpringBoot, we focus on creating the application context (createApplicationContext) and the refreshContext (refreshContext) in the run method.
Create context
// Create context
protected ConfigurableApplicationContext createApplicationContext(a) { Class<? > contextClass =this.applicationContextClass;
if (contextClass == null) {
try {
switch(this.webApplicationType) {
case SERVLET:
/ / create 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);
}
Copy the codeHere will create AnnotationConfigServletWebServerApplicationContext class. The inherited ServletWebServerApplicationContext AnnotationConfigServletWebServerApplicationContext class, And this class is finally integrated the AbstractApplicationContext.
Refresh context
//SpringApplication.java
// Refresh the context
private void refreshContext(ConfigurableApplicationContext context) {
this.refresh(context);
if (this.registerShutdownHook) {
try {
context.registerShutdownHook();
} catch (AccessControlException var3) {
}
}
}
/ / direct call the superclass AbstractApplicationContext finally here. The refresh () method
protected void refresh(ApplicationContext applicationContext) {
((AbstractApplicationContext)applicationContext).refresh();
}
Copy the code//AbstractApplicationContext.java
public void refresh(a) 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();
/ / call each subclass onRefresh () method, which is said here to return to subclass: ServletWebServerApplicationContext, calling the class onRefresh () method
this.onRefresh();
this.registerListeners();
this.finishBeanFactoryInitialization(beanFactory);
this.finishRefresh();
} catch (BeansException var9) {
this.destroyBeans();
this.cancelRefresh(var9);
throw var9;
} finally {
this.resetCommonCaches(); }}}Copy the code//ServletWebServerApplicationContext.java
This.createwebserver = this.createWebServer = this.createWebServer;
protected void onRefresh(a) {
super.onRefresh();
try {
this.createWebServer();
} catch (Throwable var2) {
}
}
//ServletWebServerApplicationContext.java
// The webServer is created, but tomcat is not started yet, so the ServletWebServerFactory is created, so let's go to ServletWebServerFactory
private void createWebServer(a) {
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();
}
/ / interface
public interface ServletWebServerFactory {
WebServer getWebServer(ServletContextInitializer... initializers);
}
/ / implementation
AbstractServletWebServerFactory
JettyServletWebServerFactory
TomcatServletWebServerFactory
UndertowServletWebServerFactory
Copy the codeThere are four implementation classes for the ServletWebServerFactory interface
//TomcatServletWebServerFactory.java
/ / here we use tomcat, so we see TomcatServletWebServerFactory. At last, there is a trace of Tomcat.
@Override
public WebServer getWebServer(ServletContextInitializer... initializers) {
Tomcat tomcat = new Tomcat();
File baseDir = (this.baseDirectory ! =null)?this.baseDirectory : createTempDir("tomcat");
tomcat.setBaseDir(baseDir.getAbsolutePath());
// Create the Connector object
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
If you are familiar with the Tomcat source code, you will be familiar with Engine.
public Engine getEngine(a) {
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 is the highest level container, Host is a child of Engine, Context is a child of Host, and Wrapper is a child of Context
Copy the codeThe getWebServer method creates the Tomcat object and does two important things: add the Connector object to Tomcat, configureEngine(tomcat.getengine ()); The getWebServer method returns TomcatWebServer.
//TomcatWebServer.java
// the constructor is called here to instantiate 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(a) throws WebServerException {
// You will see this log on the console
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(); }});//=== Start the Tomcat service ===
this.tomcat.start();
rethrowDeferredStartupExceptions();
try {
ContextBindings.bindClassLoader(context, context.getNamingToken(), getClass().getClassLoader());
}
catch (NamingException ex) {
}
// Enable blocking non-daemons
startDaemonAwaitThread();
}
catch (Exception ex) {
stopSilently();
destroySilently();
throw new WebServerException("Unable to start embedded Tomcat", ex); }}}Copy the code//Tomcat.java
public void start(a) throws LifecycleException {
getServer();
server.start();
}
// server.start will return to TomcatWebServer
public void stop(a) throws LifecycleException {
getServer();
server.stop();
}
Copy the code//TomcatWebServer.java
// Start the Tomcat service
@Override
public void start(a) 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;
// Print this log on the console, where it will be printed if the context is set in 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, context.getNamingToken(), getClass().getClassLoader()); }}}// Stop the Tomcat service
@Override
public void stop(a) 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(); }}}}Copy the codeAttached: Tomcat top-level structure diagram
conclusion
SpringBoot is started by instantiating the SpringApplication. The startup process does the following things: Configure properties, obtain listeners, publish the initial and initial input parameters of the application start event, configure the environment, output banner, create context, preprocess context, refresh context, refresh context, publish the event that the application has started, publish the event that the application has started. The job of starting Tomcat in SpringBoot is one step up from the refresh. The startup of Tomcat instantiates two components: A Tomcat instance is a Server. A Server contains multiple services, that is, multiple applications. Each Service contains multiple Connectors and a Container. A Container contains multiple subcontainers.