SpringBoot-嵌入式Servlet容器原理

WebServerFactory自动配置

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

	// Servlet Web Server 通用配置，将ServerProperties注入到定制器中，实现application.properties中的配置信息配置 Servlet Web Server
	@Bean
	public ServletWebServerFactoryCustomizer servletWebServerFactoryCustomizer(ServerProperties serverProperties) {
	return new ServletWebServerFactoryCustomizer(serverProperties);
	}

	// Tomcat Servlet Web Server 配置信息
	@Bean
	@ConditionalOnClass(
	name = {"org.apache.catalina.startup.Tomcat"}
	)
	public TomcatServletWebServerFactoryCustomizer tomcatServletWebServerFactoryCustomizer(ServerProperties serverProperties) {
	return new TomcatServletWebServerFactoryCustomizer(serverProperties);
	}
}

EmbeddedTomcat 嵌入式Tomcat

@Configuration
// 判断当前是否引入了 org.apache.catalina.startup.Tomcat 依赖
@ConditionalOnClass({Servlet.class, Tomcat.class, UpgradeProtocol.class})
// 当没有 ServletWebServerFactory 类型的Bean时才注入该组件
@ConditionalOnMissingBean(
	value = {ServletWebServerFactory.class},
	search = SearchStrategy.CURRENT
)
public static class EmbeddedTomcat {
	public EmbeddedTomcat() {
	}

　　// 创建Tomcat容器工厂
	@Bean
	public TomcatServletWebServerFactory tomcatServletWebServerFactory() {
		return new TomcatServletWebServerFactory();
	}
}

　　ServletWebServerFactory（Servlet容器工厂）继承关系

@FunctionalInterface
public interface ServletWebServerFactory {
	// 创建WebServer即Servlet容器 
　　WebServer getWebServer(ServletContextInitializer... initializers);
}

　　WebServer (Servlet容器)　继承关系

public interface WebServer {
    void start() throws WebServerException;

    void stop() throws WebServerException;

    int getPort();
}

　　TomcatServletWebServerFactory 获得Tomcat Servlet 容器（即org.apache.catalina.startup.Tomcat）

public WebServer getWebServer(ServletContextInitializer... initializers) {
	// 创建Tomcat容器	
	Tomcat tomcat = new Tomcat();
　　// 配置Tomcat运行环境
	File baseDir = this.baseDirectory != null ? this.baseDirectory : this.createTempDir("tomcat");
	tomcat.setBaseDir(baseDir.getAbsolutePath());
	Connector connector = new Connector(this.protocol);
	tomcat.getService().addConnector(connector);
	this.customizeConnector(connector);
	tomcat.setConnector(connector);
	tomcat.getHost().setAutoDeploy(false);
	this.configureEngine(tomcat.getEngine());
	Iterator var5 = this.additionalTomcatConnectors.iterator();

	while(var5.hasNext()) {
		Connector additionalConnector = (Connector)var5.next();
		tomcat.getService().addConnector(additionalConnector);
	}

	this.prepareContext(tomcat.getHost(), initializers);
　　// 调用 tomcat.start(); 启动容器
	return this.getTomcatWebServer(tomcat);
}

修改Servlet容器配置信息的方式　

　　1）修改application.properties

server.port=8888

　　2) 添加定制器

package com.wjz.config;

import org.springframework.boot.web.server.ConfigurableWebServerFactory;
import org.springframework.boot.web.server.WebServerFactoryCustomizer;
import org.springframework.stereotype.Component;

@Component
public class WebServerConfig implements WebServerFactoryCustomizer<ConfigurableWebServerFactory> {
    @Override
    public void customize(ConfigurableWebServerFactory factory) {
        factory.setPort(8888);
    }
}

定制器后置处理器

public class WebServerFactoryCustomizerBeanPostProcessor implements BeanPostProcessor, BeanFactoryAware {

	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		if (bean instanceof WebServerFactory) {
			this.postProcessBeforeInitialization((WebServerFactory)bean);
		}

		return bean;
	}

	private void postProcessBeforeInitialization(WebServerFactory webServerFactory) {
		((Callbacks)LambdaSafe.callbacks(WebServerFactoryCustomizer.class, this.getCustomizers(), webServerFactory, new Object[0]).withLogger(WebServerFactoryCustomizerBeanPostProcessor.class)).invoke((customizer) -> {
			customizer.customize(webServerFactory);
		});
	}

	private Collection<WebServerFactoryCustomizer<?>> getCustomizers() {
		if (this.customizers == null) {
			this.customizers = new ArrayList(this.getWebServerFactoryCustomizerBeans());
			this.customizers.sort(AnnotationAwareOrderComparator.INSTANCE);
			this.customizers = Collections.unmodifiableList(this.customizers);
		}

		return this.customizers;
	}

	private Collection<WebServerFactoryCustomizer<?>> getWebServerFactoryCustomizerBeans() {
		return this.beanFactory.getBeansOfType(WebServerFactoryCustomizer.class, false, false).values();
	}
}

Servlet容器启动流程

　　什么时候创建ServletWebServerFactory（Servlet容器工厂），什么时候创建 WebServer （Servlet容器）并启动？

　　1）EmbeddedTomcat.TomcatServletWebServerFactory处和TomcatServletWebServerFactory#getWebServer()处打断点，debug方式启动系统

　　2）创建SpringApplication对象并执行run()方法

　　3）context = this.createApplicationContext();　this.refreshContext(context); SpringBoot刷新IOC容器即创建IOC容器对象并初始化容器，创建容器中的每一个组件

如果是Web环境创建AnnotationConfigServletWebServerApplicationContext，否则创建默认的IOC容器AnnotationConfigApplicationContext

　　4）this.refresh(context); 刷新刚创建好的IOC容器即执行IOC容器的refresh()方法

　　5）this.onRefresh(); Web容器会创建嵌入式Servlet Web Server容器（参见ServletWebServerApplicationContext）

　　6）ServletWebServerFactory factory = this.getWebServerFactory(); 创建ServletWebServerFactory（Servlet容器工厂），后置处理器工作获取所有的定制器定制Servlet容器的相关配置

　　7）this.webServer = factory.getWebServer(new ServletContextInitializer[]{this.getSelfInitializer()}); 创建 WebServer （Servlet容器）并启动

外部Servlet容器&支持JSP

　　1）创建一个war项目

　　2）嵌入式Tomcat依赖指定为provided

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-tomcat</artifactId>
    <scope>provided</scope>
</dependency>

　　3）编写一个SpringBootServletInitializer的子类并复写configure方法

package com.wjz.springboot;

import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;

public class ServletInitializer extends SpringBootServletInitializer {

    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
        return application.sources(SpringBootJspApplication.class);
    }
}

　　4）启动外部Tomcat

外部Servlet容器启动流程

　　1）Servlet3.0的一个规范，容器启动时会创建每一个应用实现了javax.servlet.ServletContainerInitializer的实例

　　2）寻找各个应用每个jar包路径 META-INF/services/ 路径下的文件，文件名为 javax.servlet.ServletContainerInitializer，内容是实现类的全类名，参考 spring-web jar包下对应的路径文件

org.springframework.web.SpringServletContainerInitializer

　　3）还可以使用@HandlesTypes注解，在容器启动时传入类

　　4）SpringServletContainerInitializer将@HandlesTypes({WebApplicationInitializer.class})标注的这个类型的所有类传入到onStartup方法的Set<Class<?>>中，

将这些类型创建实例且调用各自的onStartup方法

　　相当于SpringBootServletInitializer类会创建对象并调用onStartup方法，该方法中会创建IOC容器

public void onStartup(ServletContext servletContext) throws ServletException {
	this.logger = LogFactory.getLog(this.getClass());
	// 创建IOC容器
	WebApplicationContext rootAppContext = this.createRootApplicationContext(servletContext);
	if (rootAppContext != null) {
		servletContext.addListener(new ContextLoaderListener(rootAppContext) {
			public void contextInitialized(ServletContextEvent event) {
			}
		});
	} else {
		this.logger.debug("No ContextLoaderListener registered, as createRootApplicationContext() did not return an application context");
	}
}