用过springboot的人都知道，springboot只需要通过一个main方法就能够启动，然后就可以直接在浏览器中敲入映射的地址就可以访问资源，那么springboot是如何将web服务器嵌入进去的人，这里我们只分析tomcat（因为我对tomcat更熟悉）
那么问题来了，这个Tomcat是在哪里启动的嘞！
springboot启动的web容器是ServletWebServerApplicationContext，这个类实现了onRefresh方法。
protected void org.springframework.boot.web.servlet.context.ServletWebServerApplicationContext.onRefresh() {
//调用父类的onRefresh方法
super.onRefresh();
try {
//创建web服务器
//(*1*)
createWebServer();
}
catch (Throwable ex) {
throw new ApplicationContextException("Unable to start web server", ex);
}
}
//(*1*)
private void ServletWebServerApplicationContext.createWebServer() {
//在未创建web服务时，这里的webServer与ServletContext都是null
WebServer webServer = this.webServer;
ServletContext servletContext = getServletContext();
if (webServer == null && servletContext == null) {
//获取创建webServer的工厂
ServletWebServerFactory factory = getWebServerFactory();
//我们先来看下getSelfInitializer()方法
//(*1*)
this.webServer = factory.getWebServer(getSelfInitializer());
}
else if (servletContext != null) {
try {
//做了这么几件事，spring容器保存到servletContext中，注册于web相关的scope，比如requestScope，sessionScope，application级别的
//ServletContextScope，注册web相关的一些依赖，如ServletRequest，ServletResponse，jsf等
//注册servletContext，servletConfig，contextParameters，contextAttribute为单例bean到容器中
//重点：从容器中获取ServletContextInitializer，如果是ServletRegistrationBean，它可以向tomcat的context中注册Servlet
//FilterRegistrationBean注册Filter，ServletListenerRegistrationBean注册监听器
getSelfInitializer().onStartup(servletContext);
}
catch (ServletException ex) {
throw new ApplicationContextException("Cannot initialize servlet context",
ex);
}
}
//将servletContext作为属性源设置到Environment中去
initPropertySources();
}
//(*1*)
private org.springframework.boot.web.servlet.ServletContextInitializer getSelfInitializer() {
//(*2*)
//java8拉姆达语法
return this::selfInitialize;
}
//(*2*)
private void selfInitialize(ServletContext servletContext) throws ServletException {
//将spring容器存储到ServletContext中
prepareWebApplicationContext(servletContext);
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
//获取存在的scope
ExistingWebApplicationScopes existingScopes = new ExistingWebApplicationScopes(
beanFactory);
//注册web相关的scope，比如RequestScope，SessionScope，ServletContextScope，设置一些web相关的依赖，比如ServletRequest，ServletResponse等
WebApplicationContextUtils.registerWebApplicationScopes(beanFactory,
getServletContext());
//重新设置scope，覆盖旧的，并打印日志，提醒
existingScopes.restore();
//注册单例bean，比如ServletContext，ServletConfig，contextParameter，contextAttribute
WebApplicationContextUtils.registerEnvironmentBeans(beanFactory,
getServletContext());
//servlet容器初始化器，主要用于注册Servlet，Filter，ServletListener
for (ServletContextInitializer beans : getServletContextInitializerBeans()) {
beans.onStartup(servletContext);
}
}
获取ServletWebServer工厂
protected ServletWebServerFactory org.springframework.boot.web.servlet.context.ServletWebServerApplicationContext.getWebServerFactory() {
// Use bean names so that we don't consider the hierarchy
//从容器中获取ServletWebServerFactory
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);
}
从上面的代码上看，当我们有没有明确指定使用什么web容器的时候，springboot肯定在某个地方设置了ServletWebServerFactory，那么springboot会在哪里设置呢？在前一节的分析中我们知道，springboot会有些自动配置，那我们到自动配置里面找找看，果不其然发现了一个叫做ServletWebServerFactoryAutoConfiguration的自动配置
//元注解为@Component
@Configuration
//自动配置顺序为最高
@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
//当存在ServletRequest时
@ConditionalOnClass(ServletRequest.class)
//当spring容器类型为Servlet时
@ConditionalOnWebApplication(type = Type.SERVLET)
//启动配置属性，实际上就是利用@Import注解引入其他的配置类
@EnableConfigurationProperties(ServerProperties.class)
//这里我们比较关心ServletWebServerFactoryConfiguration.EmbeddedTomcat.class
@Import({ ServletWebServerFactoryAutoConfiguration.BeanPostProcessorsRegistrar.class,
ServletWebServerFactoryConfiguration.EmbeddedTomcat.class,
ServletWebServerFactoryConfiguration.EmbeddedJetty.class,
ServletWebServerFactoryConfiguration.EmbeddedUndertow.class })
public class ServletWebServerFactoryAutoConfiguration {
。。。。。。
}
嵌入的tomcat配置类
class ServletWebServerFactoryConfiguration {
@Configuration
//当存在Servlet，Tomcat，UpgradeProtocol时
@ConditionalOnClass({ Servlet.class, Tomcat.class, UpgradeProtocol.class })
//当当前容器中没有其他的ServletWebServerFactory类型的bean时，启用TomcatServletWebServerFactory
@ConditionalOnMissingBean(value = ServletWebServerFactory.class, search = SearchStrategy.CURRENT)
public static class EmbeddedTomcat {
@Bean
public TomcatServletWebServerFactory tomcatServletWebServerFactory() {
return new TomcatServletWebServerFactory();
}
}
。。。。。。
}
获取webServer
public WebServer org.springframework.boot.web.embedded.tomcat.TomcatServletWebServerFactory.getWebServer(ServletContextInitializer... initializers) {
//这个类主要用于维护Server实例，端口，密码，用户身份，角色，基路径等信息
Tomcat tomcat = new Tomcat();
//基路径，如果用户没有设置，那么生成临时路径
File baseDir = (this.baseDirectory != null ? this.baseDirectory
: createTempDir("tomcat"));
tomcat.setBaseDir(baseDir.getAbsolutePath());
//连接器，内部顺带创建协议处理器（默认Http11NioProtocol），这里的操作逻辑和tomcat源码分析的连接器处理是一样的
//不过多的说明了，详细可查看tomcat源码分析文章
Connector connector = new Connector(this.protocol);
//添加连接器
tomcat.getService().addConnector(connector);
//定制连接器，比如设置端口，给协议处理器设置未来端点的绑定地址，编码等
customizeConnector(connector);
//关联上连接器
tomcat.setConnector(connector);
//是否自动部署（为true时，当tomcat管理的web应用资源发生修改时，tomcat会进行热部署）
//这里设置为false，通常我们的内容发生变化的时候，由springboot进行热部署
tomcat.getHost().setAutoDeploy(false);
//配置引擎，添加管道阀，设置tomcat容器后台线程延时时间
configureEngine(tomcat.getEngine());
//添加偏好连接器，比如我添加了一个其他协议的连接器
for (Connector additionalConnector : this.additionalTomcatConnectors) {
tomcat.getService().addConnector(additionalConnector);
}
//准备tomcat的context容器
prepareContext(tomcat.getHost(), initializers);
return getTomcatWebServer(tomcat);
}
准备tomcat的context容器
protected void org.springframework.boot.web.embedded.tomcat.TomcatServletWebServerFactory.prepareContext(Host host, ServletContextInitializer[] initializers) {
//获取有效的web目录
//springboot尝试从DocumentRoot的代码所在目录中查找war
//也会尝试是否存在src/main/webapp目录
File documentRoot = getValidDocumentRoot();
//创建嵌入的tomcat的context
TomcatEmbeddedContext context = new TomcatEmbeddedContext();
if (documentRoot != null) {
//设置根资源，tomcat可以通过根资源浏览其下所有资源
context.setResources(new LoaderHidingResourceRoot(context));
}
context.setName(getContextPath());
context.setDisplayName(getDisplayName());
context.setPath(getContextPath());
File docBase = (documentRoot != null ? documentRoot
: createTempDir("tomcat-docbase"));
//设置web应用的基路径，tomcat基于这个路径去获取资源
context.setDocBase(docBase.getAbsolutePath());
//添加生命周期监听器，这个监听器对CONFIGURE_START_EVENT（配置开始）感兴趣，主要用于
//扫描web注解，比如@Resource，@DeclareRoles
context.addLifecycleListener(new FixContextListener());
//设置加载器
context.setParentClassLoader(
this.resourceLoader != null ? this.resourceLoader.getClassLoader()
: ClassUtils.getDefaultClassLoader());
//设置默认的Locale与字符集映射，比如(Locale.ENGLISH-》utf-8
resetDefaultLocaleMapping(context);
//添加定义的Locale与字符集映射
addLocaleMappings(context);
context.setUseRelativeRedirects(false);
//配置tld文件跳过规则
configureTldSkipPatterns(context);
//创建WebappLoader，我们在tomcat源码分析的文章中有深入分析过tomcat为每个web应用创建类加载器的过程
WebappLoader loader = new WebappLoader(context.getParentClassLoader());
loader.setLoaderClass(TomcatEmbeddedWebappClassLoader.class.getName());
//设置类加载模式，这里为true，表示使用父类先加载，双亲委派
loader.setDelegate(true);
//设置类加载器
context.setLoader(loader);
//是否注册默认的Servlet，也就是注册org.apache.catalina.servlets.DefaultServlet，映射路径为/
if (isRegisterDefaultServlet()) {
addDefaultServlet(context);
}
//注册jsp servlet，用于处理jsp
if (shouldRegisterJspServlet()) {
addJspServlet(context);
addJasperInitializer(context);
}
//添加声明周期监听器，对CONFIGURE_START_EVENT（配置开始）感兴趣，主要用于注册资源信息
context.addLifecycleListener(new StaticResourceConfigurer(context));
//合并ServletContextInitializer，其实就是额外添加ServletContextInitializer，比如用于向ServletContext设置初始化参数等等
ServletContextInitializer[] initializersToUse = mergeInitializers(initializers);
//给host添加子容器
host.addChild(context);
//配置web应用容器，主要是设置session，添加生命周期监听器，设置TomcatStarter
//（一个复合ServletContainerInitializer，维护着多个ServletContainerInitializer）
//添加管道阀，添加错误提示页面，添加扩展名与媒体类型的映射，定制context
configureContext(context, initializersToUse);
//空操作
postProcessContext(context);
}
一切准备就绪，那么就可以启动服务了
getTomcatWebServer
protected TomcatWebServer org.springframework.boot.web.embedded.tomcat.TomcatServletWebServerFactory.getTomcatWebServer(Tomcat tomcat) {
//(*1*)
return new TomcatWebServer(tomcat, getPort() >= 0);
}
//(*1*)
public org.springframework.boot.web.embedded.tomcat.TomcatWebServer.TomcatWebServer(Tomcat tomcat, boolean autoStart) {
Assert.notNull(tomcat, "Tomcat Server must not be null");
this.tomcat = tomcat;
this.autoStart = autoStart;
//(*2*)
initialize();
}
//(*2*)
private void initialize() throws WebServerException {
TomcatWebServer.logger
.info("Tomcat initialized with port(s): " + getPortsDescription(false));
synchronized (this.monitor) {
try {
//设置Engine名
addInstanceIdToEngineName();
//从Host中获取Context容器
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.
//移除service中的连接器，并存储到org.springframework.boot.web.embedded.tomcat.TomcatWebServer.serviceConnectors
//中，防止启动tomcat服务时进行地址绑定
removeServiceConnectors();
}
});
// Start the server to trigger initialization listeners
//启动服务，内部调用Tomcat的Server的start方法，启动方式可查阅tomcat源码分析文章，此处不过多的赘述
this.tomcat.start();
// We can re-throw failure exception directly in the main thread
//如果tomcat启动的过程中，ServletContextInier抛出了错误，或者启动状态不是Started，也就是启动不成功
//那么抛错错误
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
//启动阻塞线程，调用server的await方法，防止退出
startDaemonAwaitThread();
}
catch (Exception ex) {
throw new WebServerException("Unable to start embedded Tomcat", ex);
}
}
}
从上面的代码中，我们注意到了一点，那就是在spring容器在onRefresh阶段启动的tomcat并没有启动Connector，因为移除了Service中的Connector，并把Connector储存到了TomcatWebServer类中的serviceConnectors属性中，那么为什么要移除它呢？那它在什么时候才会去启动Connector呢？
首先移除Connector是因为spring的容器还未完全刷新完，比如还没有注册监听器，还没有初始化eager的bean
在finishRefresh的时候，springboot就会将connector设置回service中
protected void org.springframework.boot.web.servlet.context.ServletWebServerApplicationContext.finishRefresh() {
super.finishRefresh();
//(*1*)
WebServer webServer = startWebServer();
if (webServer != null) {
publishEvent(new ServletWebServerInitializedEvent(webServer, this));
}
}
//(*1*)
private WebServer startWebServer() {
WebServer webServer = this.webServer;
if (webServer != null) {
//(*2*)
webServer.start();
}
return webServer;
}
//(*2*)
public void start() throws WebServerException {
synchronized (this.monitor) {
if (this.started) {
return;
}
try {
//将之前移除的Connector重新设置回去
addPreviouslyRemovedConnectors();
Connector connector = this.tomcat.getConnector();
if (connector != null && this.autoStart) {
//启动连接
startConnector();
}
//检查Connector是否启动成功
checkThatConnectorsHaveStarted();
this.started = true;
。。。。。。
}
到这里tomcat的启动就算完成了，但是还有一个疑问，那就是spring的DispatcherServlet是什么时候设置进去的？？？
如果进行debug的话，你会发现，springboot创建了一个TomcatStarter，它实现了ServletContainerInitializer,它是个复合类，它维护着一个ServletContainerInitializer集合，这个集合中的内容有部分是从spring容器中获取的，通过debug可以看到其中包含一个用于注册DispatcherServlet的ServletRegistrationBean，TomcatStarter又被springboot注册到了tomcat，我们在tomcat源码分析的文章中提到过，实现了ServletContainerInitializer的类会参与StandardContext（web应用）的启动，这个时候你可以向tomcat动态注册servlet，filter，listener。
protected void org.springframework.boot.web.embedded.tomcat.TomcatServletWebServerFactory.configureContext(Context context,
ServletContextInitializer[] initializers) {
//创建TomcatStarter，一个复合类
TomcatStarter starter = new TomcatStarter(initializers);
if (context instanceof TomcatEmbeddedContext) {
// Should be true
((TomcatEmbeddedContext) context).setStarter(starter);
}
//向tomcat的web应用context中注册ServletContainerInitializer
context.addServletContainerInitializer(starter, NO_CLASSES);
。。。。。。
}
TomcatStarter的onStartup方法
public void onStartup(Set<Class<?>> classes, ServletContext servletContext)
throws ServletException {
try {
//循环调用每个ServletContextInitializer的onStartup方法
for (ServletContextInitializer initializer : this.initializers) {
initializer.onStartup(servletContext);
}
}
catch (Exception ex) {
this.startUpException = ex;
// Prevent Tomcat from logging and re-throwing when we know we can
// deal with it in the main thread, but log for information here.
if (logger.isErrorEnabled()) {
logger.error("Error starting Tomcat context. Exception: "
+ ex.getClass().getName() + ". Message: " + ex.getMessage());
}
}
}
这样springboot的DispatcherServlet就会被注册到tomcat的web应用context中，那问题又来了，这个DispatcherServlet是什么时候后被包装成ServletRegistrationBean注册到spring的容器中的呢？
我们没有在任何地方配置这个DispatcherServlet，很显然它肯定是被springboot自动配置进去的，所以我们再次从springboot的自动配置spring.factories中查找，果不其然找到了一个叫做DispatcherServletAutoConfiguration的配置类，其内部类DispatcherServletRegistrationConfiguration配置了DispatcherServlet的ServletRegistrationBean
@Bean(name = DEFAULT_DISPATCHER_SERVLET_REGISTRATION_BEAN_NAME)
@ConditionalOnBean(value = DispatcherServlet.class, name = DEFAULT_DISPATCHER_SERVLET_BEAN_NAME)
public ServletRegistrationBean<DispatcherServlet> dispatcherServletRegistration(
DispatcherServlet dispatcherServlet) {
ServletRegistrationBean<DispatcherServlet> registration = new ServletRegistrationBean<>(
dispatcherServlet,
this.serverProperties.getServlet().getServletMapping());
registration.setName(DEFAULT_DISPATCHER_SERVLET_BEAN_NAME);
registration.setLoadOnStartup(
this.webMvcProperties.getServlet().getLoadOnStartup());
if (this.multipartConfig != null) {
registration.setMultipartConfig(this.multipartConfig);
}
return registration;
}
DispatcherServlet的初始化，将会启动spring的web容器，这里面的启动源码，可参考springMVC源码分析文章。
