SpringBoot学习（四）：内嵌Servlet引擎(Tomcat,Jetty等)的实现原理

概述

SpringBoot使用main方法启动的一个重要特性是，不需要打包成war部署到Tomcat这种Servlet容器中，而是只需打包成jar，然后通过java或mvn等命令运行这个jar包，然后应用就可以在指定的端口监听客户端的连接请求了。
在SpringBoot内部主要是引用了embedded的Tomcat或Jetty等作为Servlet引擎，由该Servlet引擎负责接收Web请求并交给应用处理和生成响应，从而可以将应用打包成jar，直接在命令行启动，以独立进程的方式运行，无需依赖Tomcat等Servlet容器，但是可以实现跟部署到Tomcat中的war包一样处理Web请求和响应。

接口设计

在接口设计层面，对Spring容器而言，是通过拓展ApplicationContext接口来增加Spring容器对Servlet引擎的支持；对Servlet引擎而言，则是定义了WebServer接口来代表Servlet引擎或者说是Web服务器，WebServer接口实现类为具体的Servlet引擎实现。
Spring容器通过包含WebServer的引用来负责Servlet引擎的启动关闭。同时与普通Servlet容器实现（如Tomcat）一样，将Spring应用通过关联一个ServletContext引用来建立与Servlet引擎的关联，同时将自身保存为ServletContext引用的attribute。
应用自身在启动的时候，会创建和启动Spring容器，在Spring容器中通过该WebServer引用来启动对应的Servlet引擎。并在启动Servlet引擎过程中，创建该应用对应的ServletContext，由该ServletContext来间接建立当前应用与Servlet引擎的关联。

Spring容器ApplicationContext体系

WebServerApplicationContext接口：定义获取WebServer引用的方法

/**
 * Interface to be implemented by {@link ApplicationContext application contexts} that
 * create and manage the lifecycle of an embedded {@link WebServer}.
 *
 * @author Phillip Webb
 * @since 2.0.0
 */
public interface WebServerApplicationContext extends ApplicationContext {

	/**
	 * Returns the {@link WebServer} that was created by the context or {@code null} if
	 * the server has not yet been created.
	 * @return the web server
	 */
	WebServer getWebServer();

	/**
	 * Returns the namespace of the web server application context or {@code null} if no
	 * namespace has been set. Used for disambiguation when multiple web servers are
	 * running in the same application (for example a management context running on a
	 * different port).
	 * @return the server namespace
	 */
	String getServerNamespace();

}

ServletWebServerApplicationContext：WebServerApplicationContext接口的具体实现类，包含WebServer的引用，类定义如下：

/**
 * A {@link WebApplicationContext} that can be used to bootstrap itself from a contained
 * {@link ServletWebServerFactory} bean.
 * <p>
 * This context will create, initialize and run an {@link WebServer} by searching for a
 * single {@link ServletWebServerFactory} bean within the {@link ApplicationContext}
 * itself. The {@link ServletWebServerFactory} is free to use standard Spring concepts
 * (such as dependency injection, lifecycle callbacks and property placeholder variables).
 * <p>
 * In addition, any {@link Servlet} or {@link Filter} beans defined in the context will be
 * automatically registered with the web server. In the case of a single Servlet bean, the
 * '/' mapping will be used. If multiple Servlet beans are found then the lowercase bean
 * name will be used as a mapping prefix. Any Servlet named 'dispatcherServlet' will
 * always be mapped to '/'. Filter beans will be mapped to all URLs ('/*').
 * <p>
 * For more advanced configuration, the context can instead define beans that implement
 * the {@link ServletContextInitializer} interface (most often
 * {@link ServletRegistrationBean}s and/or {@link FilterRegistrationBean}s). To prevent
 * double registration, the use of {@link ServletContextInitializer} beans will disable
 * automatic Servlet and Filter bean registration.
 * <p>
 * Although this context can be used directly, most developers should consider using the
 * {@link AnnotationConfigServletWebServerApplicationContext} or
 * {@link XmlServletWebServerApplicationContext} variants.
 *
 * @author Phillip Webb
 * @author Dave Syer
 * @see AnnotationConfigServletWebServerApplicationContext
 * @see XmlServletWebServerApplicationContext
 * @see ServletWebServerFactory
 */
public class ServletWebServerApplicationContext extends GenericWebApplicationContext
		implements ConfigurableWebServerApplicationContext {

	private static final Log logger = LogFactory
			.getLog(ServletWebServerApplicationContext.class);

	/**
	 * Constant value for the DispatcherServlet bean name. A Servlet bean with this name
	 * is deemed to be the "main" servlet and is automatically given a mapping of "/" by
	 * default. To change the default behavior you can use a
	 * {@link ServletRegistrationBean} or a different bean name.
	 */
	public static final String DISPATCHER_SERVLET_NAME = "dispatcherServlet";

	private volatile WebServer webServer;

	private ServletConfig servletConfig;

	private String serverNamespace;
	
	...

		    
}

由继承体系可知，继承了GenericWebApplicationContext，在GenericWebApplicationContext中定义了ServletContext引用。
由代码注释可知，Spring容器管理了一个ServletWebServerFactory引用，ServletWebServerFactory为WebServer实现类对象的工厂类，通过ServletWebServerFactory来创建servlet引擎WebServer，其中由ServletWebServerFactory创建的WebServer默认在8080端口监听请求，具体为在基类AbstractConfigurableWebServerFactory中定义。
同时注册到Spring容器的Servlet，Filter接口的实现类会自动注册到Servlet引擎，具体为应用对应的ServletContext。

AnnotationConfigServletWebServerApplicationContext：基于注解的Spring容器，继承了ServletWebServerApplicationContext。
XmlServletWebServerApplicationContext：基于XML的Spring容器，继承了ServletWebServerApplicationContext。

Servlet引擎体系

WebServer接口：声明Servlet引擎启动，关闭的方法，相应的实现类实现这些方法来定义启动和关闭逻辑，而对Spring容器ServletWebServerApplicationContext而言，只需依赖这个接口即可，不依赖具体实现，这也是遵循了依赖倒置设计原则。

/**
 * Simple interface that represents a fully configured web server (for example Tomcat,
 * Jetty, Netty). Allows the server to be {@link #start() started} and {@link #stop()
 * stopped}.
 *
 * @author Phillip Webb
 * @author Dave Syer
 * @since 2.0.0
 */
public interface WebServer {

	/**
	 * Starts the web server. Calling this method on an already started server has no
	 * effect.
	 * @throws WebServerException if the server cannot be started
	 */
	void start() throws WebServerException;

	/**
	 * Stops the web server. Calling this method on an already stopped server has no
	 * effect.
	 * @throws WebServerException if the server cannot be stopped
	 */
	void stop() throws WebServerException;

	/**
	 * Return the port this server is listening on.
	 * @return the port (or -1 if none)
	 */
	int getPort();

}

ServletWebServerFactory接口：Servlet引擎WebServer的工厂接口，接口定义如下，声明了getWebServer方法。也是遵循依赖倒置设计原则，即Spring容器ServletWebServerApplicationContext只依赖这个接口，具体为这个接口的getWebServer方法来获取一个Servlet引擎WebServer对象，而该接口的具体实现类，负责实现这个接口。实现类包括：TomcatServletWebServerFactory，JettyServletWebServerFactory，UndertowServletWebServerFactory，具体在embedded包定义。

/**
 * Factory interface that can be used to create a {@link WebServer}.
 *
 * @author Phillip Webb
 * @see WebServer
 * @since 2.0.0
 */
@FunctionalInterface
public interface ServletWebServerFactory {

	/**
	 * Gets a new fully configured but paused {@link WebServer} instance. Clients should
	 * not be able to connect to the returned server until {@link WebServer#start()} is
	 * called (which happens when the {@link ApplicationContext} has been fully
	 * refreshed).
	 * @param initializers {@link ServletContextInitializer}s that should be applied as
	 * the server starts
	 * @return a fully configured and started {@link WebServer}
	 * @see WebServer#stop()
	 */
	WebServer getWebServer(ServletContextInitializer... initializers);

}

Spring容器和Servlet引擎启动过程

Spring容器是在ApplicationContext的refresh方法定义启动流程的，具体为在AbstractApplicationContext中定义refresh方法的流程模板：关于Servlet引擎的启动，是在onRefresh和finishRefresh方法定义的，由onRefresh方法的注释可知，这个方法是设计用来注册有特殊功能的bean对象到Spring容器内部的BeanFactory的。所以Spring容器的设计拓展性是很好的。

@Override
public void refresh() throws BeansException, IllegalStateException {
	synchronized (this.startupShutdownMonitor) {
		// Prepare this context for refreshing.
		prepareRefresh();

		// Tell the subclass to refresh the internal bean factory.
		ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

		// Prepare the bean factory for use in this context.
		prepareBeanFactory(beanFactory);

		try {
			// Allows post-processing of the bean factory in context subclasses.
			postProcessBeanFactory(beanFactory);

			// Invoke factory processors registered as beans in the context.
			invokeBeanFactoryPostProcessors(beanFactory);

			// Register bean processors that intercept bean creation.
			registerBeanPostProcessors(beanFactory);

			// Initialize message source for this context.
			initMessageSource();

			// Initialize event multicaster for this context.
			initApplicationEventMulticaster();

			// Initialize other special beans in specific context subclasses.
			onRefresh();

			// Check for listener beans and register them.
			registerListeners();

			// Instantiate all remaining (non-lazy-init) singletons.
			finishBeanFactoryInitialization(beanFactory);

			// Last step: publish corresponding event.
			finishRefresh();
		}
        
        ...
        
	}
}

ServletWebServerApplicationContext的refresh方法，onRefresh方法，finishRefresh方法。其中onRefresh方法负责Server引擎和ServletContext的创建；finishOnRefresh方法负责Servlet引擎的启动，即调用WebServer的start方法，然后在指定的端口，如8080，监听客户端的请求。

@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));
	}
}

createWebServer方法实现：创建servlet引擎WebServer和ServletContext。

private void createWebServer() {
	WebServer webServer = this.webServer;
	ServletContext servletContext = getServletContext();
	if (webServer == null && servletContext == null) {
		ServletWebServerFactory factory = getWebServerFactory();
		
		// 创建servlet引擎WebServer和ServletContext
		
		this.webServer = factory.getWebServer(getSelfInitializer());
	}
	else if (servletContext != null) {
		try {
		
		// 如果已经启动过，则将应用配置的
		// Servlet规范的Servlet，Filter，Listener再初始化一次ServletContext
		
			getSelfInitializer().onStartup(servletContext);
		}
		catch (ServletException ex) {
			throw new ApplicationContextException("Cannot initialize servlet context",
					ex);
		}
	}
	initPropertySources();
}

startWebServer方法实现：调用Servlet引擎的start方法完成启动。

private WebServer startWebServer() {
	WebServer webServer = this.webServer;
	if (webServer != null) {
		webServer.start();
	}
	return webServer;
}

以下为TomcatWebServer的start方法实现：启动应用在Servlet规范中对应的Context，即TomcatEmbeddedContext

@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) {
			
			// 启动TomcatEmbeddedContext
			
				performDeferredLoadOnStartup();
			}
			checkThatConnectorsHaveStarted();
			this.started = true;
			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());
		}
	}
}

// 启动TomcatEmbeddedContext
private void performDeferredLoadOnStartup() {
	try {
		for (Container child : this.tomcat.getHost().findChildren()) {
			if (child instanceof TomcatEmbeddedContext) {
				((TomcatEmbeddedContext) child).deferredLoadOnStartup();
			}
		}
	}
	catch (Exception ex) {
		if (ex instanceof WebServerException) {
			throw (WebServerException) ex;
		}
		throw new WebServerException("Unable to start embedded Tomcat connectors",
				ex);
	}
}

本文标题：SpringBoot学习（四）：内嵌Servlet引擎(Tomcat,Jetty等)的实现原理

本文链接：https://blog.quwenai.cn/post/3223.html

作者授权：除特别说明外，本文由 toobug 原创编译并授权 TOOBUG信息安全网刊载发布。

本文链接：https://blog.quwenai.cn/post/3223.html

分享到：

正文

SpringBoot学习（四）：内嵌Servlet引擎(Tomcat,Jetty等)的实现原理

概述

接口设计

Spring容器ApplicationContext体系

Servlet引擎体系

Spring容器和Servlet引擎启动过程

相关阅读

【JavaWeb】JDBC：基本操作及封装DBUtil

【Tomcat】第八篇：150代码手写Tomcat（基于BIO，超详细注释）

【Tomcat】第四篇：Tomcat如何实现容器间协作

【Tomcat】第一篇：Tomcat目录结构&配置文件解析&三种应用部署方式

发表评论取消回复

还没有评论，来说两句吧...

目录[+]

概述

接口设计

Spring容器ApplicationContext体系

Servlet引擎体系

Spring容器和Servlet引擎启动过程

相关阅读

【JavaWeb】JDBC：基本操作及封装DBUtil

【Tomcat】第八篇：150代码手写Tomcat（基于BIO，超详细注释）

【Tomcat】第四篇：Tomcat如何实现容器间协作

【Tomcat】第一篇：Tomcat目录结构&amp;配置文件解析&amp;三种应用部署方式

发表评论取消回复

还没有评论，来说两句吧...

目录[+]

【Tomcat】第一篇：Tomcat目录结构&配置文件解析&三种应用部署方式