SpringBoot（一）内嵌tomcat原理和DispatcherServlet配置原理
Springboot使用起来很简单，在pom中引入如下依赖：
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.5.3</version>
</parent>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-autoconfigure</artifactId>
</dependency>
</dependencies>
其实就可以起来一个web服务，可以写controller了。
启动入口也很简单。
@SpringBootApplication public class ApplicationStart { public static void main(String[] args) { SpringApplication.run(ApplicationStart.class); } }
对于启动流程来说，主要看SpringApplication.run方法了。
先挑着看，具体每步做什么，在启动流程中分析。
1：看创建的容器 public ConfigurableApplicationContext run(String... args) {
StopWatch stopWatch = new StopWatch(); stopWatch.start(); DefaultBootstrapContext bootstrapContext = this.createBootstrapContext(); ConfigurableApplicationContext context = null; this.configureHeadlessProperty(); SpringApplicationRunListeners listeners = this.getRunListeners(args); listeners.starting(bootstrapContext, this.mainApplicationClass); try { ApplicationArguments applicationArguments = new DefaultApplicationArguments(args); ConfigurableEnvironment environment = this.prepareEnvironment(listeners, bootstrapContext, applicationArguments); this.configureIgnoreBeanInfo(environment); Banner printedBanner = this.printBanner(environment);
// 创建的容器，分为三种 AnnotationConfigServletWebServerApplicationContext AnnotationConfigReactiveWebServerApplicationContext
// AnnotationConfigApplicationContext
context = this.createApplicationContext(); context.setApplicationStartup(this.applicationStartup); this.prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
// 在这里启动容器 this.refreshContext(context); this.afterRefresh(context, applicationArguments); stopWatch.stop(); if (this.logStartupInfo) { (new StartupInfoLogger(this.mainApplicationClass)).logStarted(this.getApplicationLog(), stopWatch); } listeners.started(context); this.callRunners(context, applicationArguments); } catch (Throwable var10) { this.handleRunFailure(context, var10, listeners); throw new IllegalStateException(var10); } try { listeners.running(context); return context; } catch (Throwable var9) { this.handleRunFailure(context, var9, (SpringApplicationRunListeners)null); throw new IllegalStateException(var9); } }
1.1创建容器：
protected ConfigurableApplicationContext createApplicationContext() { return this.applicationContextFactory.create(this.webApplicationType); }
使用默认的容器工厂：是一个函数式接口。
会根据是servlet编程还是响应式编程来创建容器。
我们这里是servlet编程，使用 AnnotationConfigServletWebServerApplicationContext容器
2：启动容器 this.refreshContext(context);
private void refreshContext(ConfigurableApplicationContext context) { if (this.registerShutdownHook) { shutdownHook.registerApplicationContext(context); } this.refresh(context); } protected void refresh(ConfigurableApplicationContext applicationContext) { applicationContext.refresh(); }
是调用AnnotationConfigServletWebServerApplicationContext 中的refresh()方法，这是spring启动过程中的主要方法。
这个refresh()方法是在父类 AbstractApplicationContext 中的
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();
// 这里是spring提供的一个扩展点，在父类中是个空方法，要由子类重写，这里就是springboot中的容器重写了 this.onRefresh(); this.registerListeners(); this.finishBeanFactoryInitialization(beanFactory); this.finishRefresh(); } catch (BeansException var9) { if (this.logger.isWarnEnabled()) { this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var9); } this.destroyBeans(); this.cancelRefresh(var9); throw var9; } finally { this.resetCommonCaches(); } } }
AnnotationConfigServletWebServerApplicationContext 的父类中ServletWebServerApplicationContext重写了onResresh()方法
ServletWebServerApplicationContext#onResresh()
protected void onRefresh() { super.onRefresh(); try {
//内嵌的服务就是这里面创建的 this.createWebServer(); } catch (Throwable var2) { throw new ApplicationContextException("Unable to start web server", var2); } }
private void createWebServer() { WebServer webServer = this.webServer;
// 得到servlet上下文 ServletContext servletContext = this.getServletContext();
// 这里判断了下servlet上下文是否为空？？？见下面补充 if (webServer == null && servletContext == null) { StartupStep createWebServer = this.getApplicationStartup().start("spring.boot.webserver.create");
// 如果没有上下文就要创建服务了 ServletWebServerFactory factory = this.getWebServerFactory(); createWebServer.tag("factory", factory.getClass().toString());
// 执行TomcatServletServerWebServerFactory this.webServer = factory.getWebServer(new ServletContextInitializer[]{this.getSelfInitializer()}); createWebServer.end(); this.getBeanFactory().registerSingleton("webServerGracefulShutdown", new WebServerGracefulShutdownLifecycle(this.webServer)); this.getBeanFactory().registerSingleton("webServerStartStop", new WebServerStartStopLifecycle(this, this.webServer)); } else if (servletContext != null) { try { this.getSelfInitializer().onStartup(servletContext); } catch (ServletException var5) { throw new ApplicationContextException("Cannot initialize servlet context", var5); } } this.initPropertySources(); }
补充：上面为什么会有判断servlet上下文是否为空的逻辑呢？
因为对于springboot项目可以部署到tomcat，jetty，undertow等web服务器中，默认是使用tomcat的。如果像使用其他web服务器，就要使用配置文件了来修改默认的属性。这是约定大于配置。因为没有配置文件springboot也可以起一个web服务，因为由一些默认的配置。
对于jar部署的springboot项目，入口就是main方法，它要先读取配置才能启动servlet容器。这个时候走到上面的逻辑是没有servlet上下文的。
如果是war包部署的web服务，是tomcat先启动的，那走到上面逻辑的时候已经有了servlet上下文。
需要看下这里创建的到底是什么：ServletWebServerFactory factory = this.getWebServerFactory();
就是找一个ServletWebServerFactory的一个实现类类。
protected ServletWebServerFactory getWebServerFactory() { String[] beanNames = this.getBeanFactory().getBeanNamesForType(ServletWebServerFactory.class); if (beanNames.length == 0) { throw new ApplicationContextException("Unable to start ServletWebServerApplicationContext due to missing ServletWebServerFactory bean."); } else if (beanNames.length > 1) { throw new ApplicationContextException("Unable to start ServletWebServerApplicationContext due to multiple ServletWebServerFactory beans : " + StringUtils.arrayToCommaDelimitedString(beanNames)); } else { return (ServletWebServerFactory)this.getBeanFactory().getBean(beanNames[0], ServletWebServerFactory.class); } }
这个接口呢有下面几个实现类：我们这里肯定要看tomcat的实现类，那这个TomcatServletWebServerFactory 是在哪里加载进来的呢
怎么加载的就要看springboot的自动配置原理了，在springboot中自动配置原理也是spi机制的一种原理，只不过加载的spring.factories文件这个后面再具体分析。
里面有一个ServletWebServerFactoryAutoConfiguration类，通过@Import导入了一个EmbeddedTomcat类。
这里就是 TomcatServletWebServerFactory 放入spring容器中的地方。
回到上面的逻辑，得到TomcatServletWebServerFactory调用其getWebServer 方法。
这里就是创建内嵌tomcat的地方，下面的写法是内嵌tomcat中创建有关tomcat组件的写法。
public WebServer getWebServer(ServletContextInitializer... initializers) { if (this.disableMBeanRegistry) { Registry.disableRegistry(); } // new 一个tomcat实例 Tomcat tomcat = new Tomcat(); File baseDir = this.baseDirectory != null ? this.baseDirectory : this.createTempDir("tomcat"); tomcat.setBaseDir(baseDir.getAbsolutePath());
// tomcat中的Connector组件 Connector connector = new Connector(this.protocol); connector.setThrowOnFailure(true); 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); } // DispatcherServlet就是在这里初始化的 this.prepareContext(tomcat.getHost(), initializers);
// tomcat的start，和socket启动阻塞都在这个方法里 return this.getTomcatWebServer(tomcat); }
protected TomcatWebServer getTomcatWebServer(Tomcat tomcat) { return new TomcatWebServer(tomcat, this.getPort() >= 0, this.getShutdown()); }
public TomcatWebServer(Tomcat tomcat, boolean autoStart, Shutdown shutdown) { this.monitor = new Object(); this.serviceConnectors = new HashMap(); Assert.notNull(tomcat, "Tomcat Server must not be null"); this.tomcat = tomcat; this.autoStart = autoStart; this.gracefulShutdown = shutdown == Shutdown.GRACEFUL ? new GracefulShutdown(tomcat) : null; this.initialize(); }
private void initialize() throws WebServerException { logger.info("Tomcat initialized with port(s): " + this.getPortsDescription(false)); synchronized(this.monitor) { try { this.addInstanceIdToEngineName(); Context context = this.findContext(); context.addLifecycleListener((event) -> { if (context.equals(event.getSource()) && "start".equals(event.getType())) { this.removeServiceConnectors(); } });
// tomcat就是在这里启动的 this.tomcat.start(); this.rethrowDeferredStartupExceptions(); try { ContextBindings.bindClassLoader(context, context.getNamingToken(), this.getClass().getClassLoader()); } catch (NamingException var5) { } // 这里就是设置socket监听 this.startDaemonAwaitThread(); } catch (Exception var6) { this.stopSilently(); this.destroySilently(); throw new WebServerException("Unable to start embedded Tomcat", var6); } } }
private void startDaemonAwaitThread() { Thread awaitThread = new Thread("container-" + containerCounter.get()) { public void run() { TomcatWebServer.this.tomcat.getServer().await(); } }; awaitThread.setContextClassLoader(this.getClass().getClassLoader()); awaitThread.setDaemon(false); awaitThread.start(); }
上面就是内嵌tomcat的启动过程，下面分析下DispatcherServlet加载的源码分析。
在上面createServer方法中有一行调用： this.webServer = factory.getWebServer(new ServletContextInitializer[]{this.getSelfInitializer()});
参数是一个ServletContextInitializer 的数组，是从getSelfInitializer() 方法中得到，DispatcherServlet就是这里加载的。
// 但是这里返回是个lambda 表达式，ServletContextInitializer是个一个函数式接口，里面只有一个onStartup方法，这里相当于返回了一个接口的实例，只是这个实例不再容器中
// 只是这个实例的onStartup的逻辑就是下面的selfInitialize方法， 调用getSerlfInitializer方法的时候，下面那个方法不会马上执行。
private ServletContextInitializer getSelfInitializer() { return this::selfInitialize; } private void selfInitialize(ServletContext servletContext) throws ServletException { this.prepareWebApplicationContext(servletContext); this.registerApplicationScope(servletContext); WebApplicationContextUtils.registerEnvironmentBeans(this.getBeanFactory(), servletContext);
// 这里就是找ServletContextInitializer的实现类 Iterator var2 = this.getServletContextInitializerBeans().iterator(); while(var2.hasNext()) {
// 这里遍历调用onStarup方法 ServletContextInitializer beans = (ServletContextInitializer)var2.next(); beans.onStartup(servletContext); } }
@FunctionalInterface public interface ServletContextInitializer { void onStartup(ServletContext servletContext) throws ServletException; }
回到上面的getWebServer方法，它的参数就是getSelfInitializer（）得到的lamda表达式。在调用 this.prepareContext(tomcat.getHost(), initializers);
时初始化DispatcherServlet。这是在TomcatServletWebServerFactory 中的。
protected void prepareContext(Host host, ServletContextInitializer[] initializers) { File documentRoot = this.getValidDocumentRoot();
// 这个new出来的类，继承自tomcat中的StandardContext
// tomcat在初始化过程中会触发StandardContext中的一个全局变量 Map<ServletContainerInitializer,Set<Class<?>>> initializers
// 遍历它并执行ServletContainerInitializer.onStartup方法 这个过程在springmvc初始化servlet中有提到过 TomcatEmbeddedContext context = new TomcatEmbeddedContext(); if (documentRoot != null) { context.setResources(new TomcatServletWebServerFactory.LoaderHidingResourceRoot(context)); } context.setName(this.getContextPath()); context.setDisplayName(this.getDisplayName()); context.setPath(this.getContextPath()); File docBase = documentRoot != null ? documentRoot : this.createTempDir("tomcat-docbase"); context.setDocBase(docBase.getAbsolutePath()); context.addLifecycleListener(new FixContextListener()); context.setParentClassLoader(this.resourceLoader != null ? this.resourceLoader.getClassLoader() : ClassUtils.getDefaultClassLoader()); this.resetDefaultLocaleMapping(context); this.addLocaleMappings(context); try { context.setCreateUploadTargets(true); } catch (NoSuchMethodError var8) { } this.configureTldPatterns(context); WebappLoader loader = new WebappLoader(); loader.setLoaderClass(TomcatEmbeddedWebappClassLoader.class.getName()); loader.setDelegate(true); context.setLoader(loader); if (this.isRegisterDefaultServlet()) { this.addDefaultServlet(context); } if (this.shouldRegisterJspServlet()) { this.addJspServlet(context); this.addJasperInitializer(context); } context.addLifecycleListener(new TomcatServletWebServerFactory.StaticResourceConfigurer(context)); ServletContextInitializer[] initializersToUse = this.mergeInitializers(initializers); host.addChild(context);
// 到这里 initializersToUse还是上面的lambda表达式，只是做了一些合并操作 ，执行也是在这里面的 this.configureContext(context, initializersToUse); this.postProcessContext(context); }
this.configureContext(context, initializersToUse);
protected void configureContext(Context context, ServletContextInitializer[] initializers) {
// 它就实现了ServletContainerInitializer的接口 并通过构造函数把上面的那个lambda表达式传递进去
// 它里面的onStartup方法，就会在执行的时候遍历这个数组中的实例执行其onStartup方法，也就时执行了上面的lambda表达式 TomcatStarter starter = new TomcatStarter(initializers); if (context instanceof TomcatEmbeddedContext) { TomcatEmbeddedContext embeddedContext = (TomcatEmbeddedContext)context; embeddedContext.setStarter(starter); embeddedContext.setFailCtxIfServletStartFails(true); } // 这个context就是StandardContext的子类，把starter添加进去，上面TomcatStarter能执行也是这一步把它添加到了StandardContext的全局变量中了。 context.addServletContainerInitializer(starter, NO_CLASSES); Iterator var7 = this.contextLifecycleListeners.iterator(); while(var7.hasNext()) { LifecycleListener lifecycleListener = (LifecycleListener)var7.next(); context.addLifecycleListener(lifecycleListener); } var7 = this.contextValves.iterator(); while(var7.hasNext()) { Valve valve = (Valve)var7.next(); context.getPipeline().addValve(valve); } var7 = this.getErrorPages().iterator(); while(var7.hasNext()) { ErrorPage errorPage = (ErrorPage)var7.next(); org.apache.tomcat.util.descriptor.web.ErrorPage tomcatErrorPage = new org.apache.tomcat.util.descriptor.web.ErrorPage(); tomcatErrorPage.setLocation(errorPage.getPath()); tomcatErrorPage.setErrorCode(errorPage.getStatusCode()); tomcatErrorPage.setExceptionType(errorPage.getExceptionName()); context.addErrorPage(tomcatErrorPage); } var7 = this.getMimeMappings().iterator(); while(var7.hasNext()) { Mapping mapping = (Mapping)var7.next(); context.addMimeMapping(mapping.getExtension(), mapping.getMimeType()); } this.configureSession(context); (new DisableReferenceClearingContextCustomizer()).customize(context); var7 = this.getWebListenerClassNames().iterator(); while(var7.hasNext()) { String webListenerClassName = (String)var7.next(); context.addApplicationListener(webListenerClassName); } var7 = this.tomcatContextCustomizers.iterator(); while(var7.hasNext()) { TomcatContextCustomizer customizer = (TomcatContextCustomizer)var7.next(); customizer.customize(context); } }
知道了怎么走到ServletContextInitializer接口的onStartup方法，看下它有那些实现类。
这里会走到这个RegistrationBean，为什么会是它，而且看下也没有加上什么注解，它是怎么加载到spring容器中的呢，下面会说。在这个类里有onStartup方法。
它里面有一个注册方法this.register(description, servletContext); ，这个方法实在子类DynamicRegistrationBean中的
protected final void register(String description, ServletContext servletContext) { D registration = this.addRegistration(description, servletContext); if (registration == null) { logger.info(StringUtils.capitalize(description) + " was not registered (possibly already registered?)"); } else { this.configure(registration); } }
这个register方法中又有一个this.addRegistration(description, servletContext); 方法的调用，这个方法还是子类中调用的。子类是ServletRegistrationBean
到这里才真正看到Servlet的影子。
protected Dynamic addRegistration(String description, ServletContext servletContext) { String name = this.getServletName(); return servletContext.addServlet(name, this.servlet); }
上面三个的继承关系如下：
那上面那个servlet哪里来的呢？ 这又要说到springboot的自动装配了，在spring.factories中有一个DispatcherServletAutoConfiguration 的配置类。
在这个配置类中有两个重要的地方和DispatcherServlet有关。
首先定义了一个DispatcherServlet
把它和上面的ServletRegistrationBean 关联起来的是下面的一个Bean
这个dispatcherServletRegistration 的bean中会自动注入上面创建的DispatcherServlet，然后把它传递给了DispatcherServletRegistrationBean构造函数。
从这个bean的继承和构造函数的调用就应该能明白，这里把DispatcherServlet传递给了ServletRegistrationBean
这就把上面整个串起来了。
这里贴上上面两个流程的图解，有助于理解。可能图的版本和贴出来的代码版本不一致，但是不影响理解主线的流程。
tomcat内嵌：
dispatcherServlet的装配
