spring boot 加载web容器tomcat流程源码分析

我本地的springboot版本是2.5.1，后面的分析都是基于这个版本

<parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>2.5.1</version><relativePath/> <!-- lookup parent from repository --> </parent>

我们通过在pom文件中引入

<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId></dependency>

来引入web容器，默认的web容器时tomcat。

本文章主要描述spring boot加载web容器 tomcat的部分，为了避免文章知识点过于分散，其他相关的如bean的加载，tomcat内部流程等不做深入讨论。

1、在springboot web工程中，全局上下文是AnnotationConfigServletWebApplicationContext

下面的部分，我们具体来看下

首先，我们的入口代码一般都是这样写的

public static void main(String[] args) {SpringApplication.run(BootargsApplication.class,args); }

跳转到run方法里面，依次会调用下面两个方法

public static ConfigurableApplicationContext run(Class<?> primarySource, String... args) {return run(new Class<?>[] { primarySource }, args);}

public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) { return new SpringApplication(primarySources).run(args);}

首先会创建SpringApplication实例对象，跳转到SpringApplication的构造方法去看看，依次会调用如下方法

public SpringApplication(Class<?>... primarySources) {this(null, primarySources);}

@SuppressWarnings({ 'unchecked', 'rawtypes' })public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) { ...... //本次不相关的代码全部省略掉，只保留相关代码 //这里的 this.webApplicationType=WebApplicationType.SERVLET， 我们来分析下这个代码的具体的执行赋值 this.webApplicationType = WebApplicationType.deduceFromClasspath(); ......}

继续跳转到WebApplicationType.deduceFromClasspath()去看看

//这个方法主要是在当前类路径下查找指定的class类是否存在，返回对饮枚举类型static WebApplicationType deduceFromClasspath() {// WEBMVC_INDICATOR_CLASS = 'org.springframework.web.servlet.DispatcherServlet';//我们通过pom文件引入spring-boot-starter-web，会简介引入spring-webmvc,上面这个类就在这个webmvc中，所以不会进入这个if分支if (ClassUtils.isPresent(WEBFLUX_INDICATOR_CLASS, null) && !ClassUtils.isPresent(WEBMVC_INDICATOR_CLASS, null)&& !ClassUtils.isPresent(JERSEY_INDICATOR_CLASS, null)) {return WebApplicationType.REACTIVE;}//SERVLET_INDICATOR_CLASSES = { 'javax.servlet.Servlet','org.springframework.web.context.ConfigurableWebApplicationContext' }//javax.servlet.Servlet这个类存在于tomcat-embed-core中 //org.springframework.web.context.ConfigurableWebApplicationContext这个类存在于spring-web中 //这两个jar都是由spring-boot-starter-web间接引入的，所以也不会走这个分支for (String className : SERVLET_INDICATOR_CLASSES) {if (!ClassUtils.isPresent(className, null)) {return WebApplicationType.NONE;}}//所以会从这里返回return WebApplicationType.SERVLET;}

下面看下jar包的引入

回到new SpringApplication(primarySources).run(args)的调用来看run方法的代码

public ConfigurableApplicationContext run(String... args) {.......try {......//我们来看这个context的创建，context=new AnnotationConfigServletWebServerApplicationContext()下面来具体看这块的执行context = createApplicationContext(); ...... //后续几个部分会来说明这个方法refreshContext(context);......}catch (Throwable ex) {......}try {.......}catch (Throwable ex) {.......}return context;}

createApplicationContext()依次会调用如下方法

protected ConfigurableApplicationContext createApplicationContext() {//这里的this.webApplicationType就是上面的WebApplicationType.SERVLETreturn this.applicationContextFactory.create(this.webApplicationType);}

//最终会调用到这个lambda表达式，入参就是上面的WebApplicationType.SERVLETApplicationContextFactory DEFAULT = (webApplicationType) -> {try {switch (webApplicationType) {case SERVLET://会从这里返回return new AnnotationConfigServletWebServerApplicationContext();case REACTIVE:return new AnnotationConfigReactiveWebServerApplicationContext();default:return new AnnotationConfigApplicationContext();}}catch (Exception ex) {throw new IllegalStateException('Unable create a default ApplicationContext instance, '+ 'you may need a custom ApplicationContextFactory', ex);}};

到这里，我们的上下文context就已经创建出来了，这块代码也比较简单。就不多说什么了

2、查找ServletWebServerFactory

再次回到new SpringApplication(primarySources).run(args)的调用来看run方法的代码

public ConfigurableApplicationContext run(String... args) {.......try {......//上面已经对context做过了讲解，context=new AnnotationConfigServletWebServerApplicationContext()context = createApplicationContext(); ...... //下面来看这个方法refreshContext(context);......}catch (Throwable ex) {......}try {.......}catch (Throwable ex) {.......}return context;}

点到refreshContext(context)

private void refreshContext(ConfigurableApplicationContext context) {if (this.registerShutdownHook) {shutdownHook.registerApplicationContext(context);}refresh(context);}

继续点到refresh(context)

protected void refresh(ConfigurableApplicationContext applicationContext) {//这里的applicationContext就是AnnotationConfigServletWebServerApplicationContext的对象，由于这个类没有refresh方法，会跳转到它的父类ServletWebServerApplicationContext的方法中去,我们继续点进去applicationContext.refresh();}

点到ServletWebServerApplicationContext的refresh方法

public final void refresh() throws BeansException, IllegalStateException {try { //继续跳转到父类AbstractApplicationContext方法super.refresh();}catch (RuntimeException ex) {WebServer webServer = this.webServer;if (webServer != null) {webServer.stop();}throw ex;}}

打开AbstractApplicationContext的refresh方法

//springboot 大部分的初始化工作是在这里完成的，不过这不是我们本地的重点，不相关的我们统统略过public void refresh() throws BeansException, IllegalStateException {synchronized (this.startupShutdownMonitor) {......try {......//继续点到这个方法，这里又会跳转到ServletWebServerApplicationContext这个类的方法onRefresh();.....}catch (BeansException ex) {.....}finally {.....}}}

打开ServletWebServerApplicationContext的onRefresh方法

protected void onRefresh() {super.onRefresh();try {//这里就是我们本次的重点，会在这里创建具体的web容器，我们点进去看看，还是ServletWebServerApplicationContext这个类的方法createWebServer();}catch (Throwable ex) {throw new ApplicationContextException('Unable to start web server', ex);}}

打开ServletWebServerApplicationContext的createWebServer方法

private void createWebServer() {WebServer webServer = this.webServer;ServletContext servletContext = getServletContext();//第一次进来webServer servletContext都是null,会进到if分支里面if (webServer == null && servletContext == null) { //这里只是做个标记，不用关注，跳过StartupStep createWebServer = this.getApplicationStartup().start('spring.boot.webserver.create');//这里就会来查找ServletWebServerFactory，也就是web容器的工厂,具体看下getWebServerFactory()方法，还是ServletWebServerApplicationContext这个类的方法ServletWebServerFactory factory = getWebServerFactory();createWebServer.tag('factory', factory.getClass().toString());this.webServer = factory.getWebServer(getSelfInitializer());createWebServer.end();getBeanFactory().registerSingleton('webServerGracefulShutdown',new WebServerGracefulShutdownLifecycle(this.webServer));getBeanFactory().registerSingleton('webServerStartStop',new WebServerStartStopLifecycle(this, this.webServer));}else if (servletContext != null) {try {getSelfInitializer().onStartup(servletContext);}catch (ServletException ex) {throw new ApplicationContextException('Cannot initialize servlet context', ex);}}initPropertySources();}

打开ServletWebServerApplicationContext的getWebServerFactory方法

protected ServletWebServerFactory getWebServerFactory() {// Use bean names so that we don’t consider the hierarchy//从beanFactory中查找ServletWebServerFactory类型的bean的定义，返回对应bean的名字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));}//这里会从beanFactory中返回bean的名字为beanNames[0],类型为ServletWebServerFactory.class的bean对象，如果当前bean还未创建，则此时就会创建bean对象并返回return getBeanFactory().getBean(beanNames[0], ServletWebServerFactory.class);}

从上面的代码并看不出来实际的ServletWebServerFactory对象具体是什么？下面带着大家一起简单过下这部分的加载，这里具体就是springboot 加载bean的流程了，这部分的逻辑比较多，本次就不具体展开。关于springboot 加载bean的流程计划后续专门再写一篇。

springboot在启动过程中会在当前类路径下META-INF/spring.factories这个文件中，key=org.springframework.boot.autoconfigure.EnableAutoConfiguration的属性的作为bean的定义进行加载，在这过程中还会使用key=org.springframework.boot.autoconfigure.AutoConfigurationImportFilterfilter的属性作为过滤，配合META-INF/spring-autoconfigure-metadata.properties对这些类做一个过滤，剔除掉不符合的类(后续还会根据类上的注解判断是否要继续剔除)。

当前这些主要在spring-boot-autoconfigure-2.5.1.jar这个文件中

下面截取上面说的两部分,可以看到这里的过滤器就3个，具体不展开讨论了，自动导入的类就是下面的再加过滤去掉的

# Auto Configuration Import Filtersorg.springframework.boot.autoconfigure.AutoConfigurationImportFilter=org.springframework.boot.autoconfigure.condition.OnBeanCondition,org.springframework.boot.autoconfigure.condition.OnClassCondition,org.springframework.boot.autoconfigure.condition.OnWebApplicationCondition# Auto Configureorg.springframework.boot.autoconfigure.EnableAutoConfiguration=......#下面这个会在创建servelt中使用，下部分我们再关注它org.springframework.boot.autoconfigure.web.servlet.DispatcherServletAutoConfiguration,#下面这个就是我们需要用到的org.springframework.boot.autoconfigure.web.servlet.ServletWebServerFactoryAutoConfiguration,......org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration,......

我们看下上面的org.springframework.boot.autoconfigure.web.servlet.ServletWebServerFactoryAutoConfiguration这个类，这个类在web 场景下，不会被剔除。会被加载。我们看看这个类，我们只看头部就可以了

这里我们看到类上有Import注解，会继续导入这几个类，

ServletWebServerFactoryConfiguration.EmbeddedTomcat.class,ServletWebServerFactoryConfiguration.EmbeddedJetty.class,ServletWebServerFactoryConfiguration.EmbeddedUndertow.class

这三个都是本次相关的，它们都是ServletWebServerFactoryConfiguration的内部类，我们进去看看，类的结构都是一样的，我们就看下ServletWebServerFactoryConfiguration.EmbeddedTomcat类吧

可以看到EmbeddedTomcat上面有ConditionalOnClass，ConditionalOnMissingBean这两个注解，

简单说下，ConditionalOnClass是表示当前类路径下存在对应类是加载

ConditionalOnMissingBean是表示当前beanFactory中没有对应类型bean定义的话加载

多个条件都是and的关系，有一个条件不成立，就不会去进行后续处理。

在这里EmbeddedTomcat类这两个条件是成立的，这时就会继续遍历当前类的所有方法，找到@Bean注解的方法，加载到beanFactory中去

而EmbeddedJetty，EmbeddedUndertow两个类条件是不成立的，就不会进行后续执行，剔除掉了

这里就会把EmbeddedTomcat.tomcatServletWebServerFactory这个方法进行加载，返回值是TomcatServletWebServerFactory类型，我们看下TomcatServletWebServerFactory类的继承图,可以看到它正好是继承了ServletWebServerFactory接口。

再次打开ServletWebServerApplicationContext的getWebServerFactory方法

protected ServletWebServerFactory getWebServerFactory() {.......//所以这里的逻辑实际上会执行ServletWebServerFactoryConfiguration.EmbeddedTomcat类的tomcatServletWebServerFactory方法，返回TomcatServletWebServerFactory对象,相关的属性注入等等这里就不讲述了 return getBeanFactory().getBean(beanNames[0], ServletWebServerFactory.class);}

到这里，整个ServletWebServerFactory的查找就完成了

3、创建DispatcherServletRegistrationBean，DispatcherServlet

再看看上面的META-INF/spring.factories文件

# Auto Configuration Import Filtersorg.springframework.boot.autoconfigure.AutoConfigurationImportFilter=org.springframework.boot.autoconfigure.condition.OnBeanCondition,org.springframework.boot.autoconfigure.condition.OnClassCondition,org.springframework.boot.autoconfigure.condition.OnWebApplicationCondition# Auto Configureorg.springframework.boot.autoconfigure.EnableAutoConfiguration=......#现在我们重点来看这个类org.springframework.boot.autoconfigure.web.servlet.DispatcherServletAutoConfiguration,org.springframework.boot.autoconfigure.web.servlet.ServletWebServerFactoryAutoConfiguration,......org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration,......

我们打开org.springframework.boot.autoconfigure.web.servlet.DispatcherServletAutoConfiguration这个类看看

@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)@Configuration(proxyBeanMethods = false)//我们当前只关注这ConditionalOnWebApplication、ConditionalOnClass注解//ConditionalOnWebApplication是根据type来判断指定类是否存在//当前的type是 Type.SERVLET，是来查找org.springframework.web.context.support.GenericWebApplicationContext类是否存在，这个类存在于spring-web中，所以这个条件是true@ConditionalOnWebApplication(type = Type.SERVLET)//这个注解上面说过了 ，就是查找指定的类是否存在，这个是查找DispatcherServlet.class是否存在，这里也会返回true@ConditionalOnClass(DispatcherServlet.class)//上面两个条件都成立，就会执行后续的操作，去遍历内部类和方法@AutoConfigureAfter(ServletWebServerFactoryAutoConfiguration.class)public class DispatcherServletAutoConfiguration {/** * The bean name for a DispatcherServlet that will be mapped to the root URL '/'. */public static final String DEFAULT_DISPATCHER_SERVLET_BEAN_NAME = 'dispatcherServlet';/** * The bean name for a ServletRegistrationBean for the DispatcherServlet '/'. */public static final String DEFAULT_DISPATCHER_SERVLET_REGISTRATION_BEAN_NAME = 'dispatcherServletRegistration';@Configuration(proxyBeanMethods = false) //这里还是个条件，通过实现Condition接口，通过matches方法来判断 //DefaultDispatcherServletCondition这个类就在当前这个文件里，matches判断的结果也是true@Conditional(DefaultDispatcherServletCondition.class) //ServletRegistration.class这个类存在于tomcat-embed-core里面，这个结果也是true@ConditionalOnClass(ServletRegistration.class) //上面两个条件成立，就会执行后续的操作，去遍历内部类和方法@EnableConfigurationProperties(WebMvcProperties.class)protected static class DispatcherServletConfiguration {//beanFactory会创建这个DispatcherServletbean的定义，bean的名字就是dispatcherServlet@Bean(name = DEFAULT_DISPATCHER_SERVLET_BEAN_NAME)public DispatcherServlet dispatcherServlet(WebMvcProperties webMvcProperties) {DispatcherServlet dispatcherServlet = new DispatcherServlet();dispatcherServlet.setDispatchOptionsRequest(webMvcProperties.isDispatchOptionsRequest());dispatcherServlet.setDispatchTraceRequest(webMvcProperties.isDispatchTraceRequest());dispatcherServlet.setThrowExceptionIfNoHandlerFound(webMvcProperties.isThrowExceptionIfNoHandlerFound());dispatcherServlet.setPublishEvents(webMvcProperties.isPublishRequestHandledEvents());dispatcherServlet.setEnableLoggingRequestDetails(webMvcProperties.isLogRequestDetails());return dispatcherServlet;}@Bean@ConditionalOnBean(MultipartResolver.class)@ConditionalOnMissingBean(name = DispatcherServlet.MULTIPART_RESOLVER_BEAN_NAME)public MultipartResolver multipartResolver(MultipartResolver resolver) {// Detect if the user has created a MultipartResolver but named it incorrectlyreturn resolver;}}@Configuration(proxyBeanMethods = false) //和上面的一样，不说了@Conditional(DispatcherServletRegistrationCondition.class) //和上面的一样，不说了@ConditionalOnClass(ServletRegistration.class)@EnableConfigurationProperties(WebMvcProperties.class) //这里会要在查找DispatcherServletConfiguration.class，并执行加载bean定义的流程，这就是上面的类了@Import(DispatcherServletConfiguration.class)protected static class DispatcherServletRegistrationConfiguration {@Bean(name = DEFAULT_DISPATCHER_SERVLET_REGISTRATION_BEAN_NAME)//ConditionalOnBean查找是否存在指定bean的定义，这个方法要注入参数，需要这个类，当前这里就是上面的dispatcherServlet方法定义的，这里也是存在的@ConditionalOnBean(value = DispatcherServlet.class, name = DEFAULT_DISPATCHER_SERVLET_BEAN_NAME)//DispatcherServlet dispatcherServlet这个就是dispatcherServlet这个方法定义的bean，在创建DispatcherServletRegistrationBean这个bean的时候，就会去查找dispatcherServlet是否存在，如果不存在，先创建dispatcherServlet这个bean,再创建DispatcherServletRegistrationBeanpublic DispatcherServletRegistrationBean dispatcherServletRegistration(DispatcherServlet dispatcherServlet,WebMvcProperties webMvcProperties, ObjectProvider<MultipartConfigElement> multipartConfig) {DispatcherServletRegistrationBean registration = new DispatcherServletRegistrationBean(dispatcherServlet,webMvcProperties.getServlet().getPath());registration.setName(DEFAULT_DISPATCHER_SERVLET_BEAN_NAME);registration.setLoadOnStartup(webMvcProperties.getServlet().getLoadOnStartup());multipartConfig.ifAvailable(registration::setMultipartConfig);return registration;}} ......}

上面就是创建DispatcherServlet，DispatcherServletRegistrationBean的过程了

4、创建tomcat，加载Servlet.class,filter.class，监听器

再次回到ServletWebServerApplicationContext的createWebServer方法

private void createWebServer() {WebServer webServer = this.webServer;ServletContext servletContext = getServletContext();if (webServer == null && servletContext == null) {StartupStep createWebServer = this.getApplicationStartup().start('spring.boot.webserver.create');//上面我们已经看到了这里，factory是TomcatServletWebServerFactory类的一个实例对象ServletWebServerFactory factory = getWebServerFactory(); //这里还是做个标记，不用关注 createWebServer.tag('factory', factory.getClass().toString()); //这里就是具体创建tomcat了，这里的入参getSelfInitializer()是个lambda表达式，这个后续很重要this.webServer = factory.getWebServer(getSelfInitializer());createWebServer.end();getBeanFactory().registerSingleton('webServerGracefulShutdown',new WebServerGracefulShutdownLifecycle(this.webServer));getBeanFactory().registerSingleton('webServerStartStop',new WebServerStartStopLifecycle(this, this.webServer));}else if (servletContext != null) {try {getSelfInitializer().onStartup(servletContext);}catch (ServletException ex) {throw new ApplicationContextException('Cannot initialize servlet context', ex);}}initPropertySources();}

private org.springframework.boot.web.servlet.ServletContextInitializer getSelfInitializer() {return this::selfInitialize;}//是创建webServer的参数private void selfInitialize(ServletContext servletContext) throws ServletException {prepareWebApplicationContext(servletContext);registerApplicationScope(servletContext);WebApplicationContextUtils.registerEnvironmentBeans(getBeanFactory(), servletContext);for (ServletContextInitializer beans : getServletContextInitializerBeans()) {beans.onStartup(servletContext);}}

factory.getWebServer(getSelfInitializer())会调用到TomcatServletWebServerFactory的getWebServer的方法

public WebServer getWebServer(ServletContextInitializer... initializers) {.......//上面的入参会在这里传下去prepareContext(tomcat.getHost(), initializers);return getTomcatWebServer(tomcat);}

点进prepareContext(tomcat.getHost(), initializers)去看看

protected void prepareContext(Host host, ServletContextInitializer[] initializers) {......ServletContextInitializer[] initializersToUse = mergeInitializers(initializers);host.addChild(context);//继续传下去configureContext(context, initializersToUse);postProcessContext(context);}

再点到configureContext(context, initializersToUse)这个调用去看看

protected void configureContext(Context context, ServletContextInitializer[] initializers) {//会传递给TomcatStarter，作为构造参数，下面我们去这里看看TomcatStarter starter = new TomcatStarter(initializers);...... }

下面我们去看看TomcatStarter这个类是怎么使用这个initializers这个构造参数的。

这个类不长class TomcatStarter implements ServletContainerInitializer { ......TomcatStarter(ServletContextInitializer[] initializers) {//入参会作为它的成员属性this.initializers = initializers;}@Overridepublic void onStartup(Set<Class<?>> classes, ServletContext servletContext) throws ServletException {try {for (ServletContextInitializer initializer : this.initializers) {//会在这里调用onStartup方法，这里的入参就是ApplicationContextFacade的对象，里面包装了ApplicationContext，里面再包装了TomcatEmbeddedContext，这要就和tomcat联系起来了，下面的截图就是servletContext的对象结构initializer.onStartup(servletContext);}}catch (Exception ex) {......}

上面的initializer.onStartup(servletContext)会调用到ServletWebServerApplicationContext的selfInitialize方法

private void selfInitialize(ServletContext servletContext) throws ServletException {//这里是将ApplicationContextFacade设置到当前的servletContext上prepareWebApplicationContext(servletContext);//这里是在beanFactory中注册application的scoperegisterApplicationScope(servletContext);//这里还是注册上下文相关的beanWebApplicationContextUtils.registerEnvironmentBeans(getBeanFactory(), servletContext);//我们重点来看这里getServletContextInitializerBeans()是定义个一个ServletContextInitializerBeans对象，我们点进去看看for (ServletContextInitializer beans : getServletContextInitializerBeans()) {beans.onStartup(servletContext);}}

protected Collection<ServletContextInitializer> getServletContextInitializerBeans() {//这里的getBeanFactory()就是全局的beanFactoryreturn new ServletContextInitializerBeans(getBeanFactory());}

public ServletContextInitializerBeans(ListableBeanFactory beanFactory,Class<? extends ServletContextInitializer>... initializerTypes) {this.initializers = new LinkedMultiValueMap<>();//由于我们没有传initializerTypes这个参数，所以this.initializerTypes里面就只有ServletContextInitializer.class这个类this.initializerTypes = (initializerTypes.length != 0) ? Arrays.asList(initializerTypes): Collections.singletonList(ServletContextInitializer.class);//这里主要是从beanFactory中查找this.initializerTypes类型，我们进去看看，就是下面这个方法了addServletContextInitializerBeans(beanFactory);addAdaptableBeans(beanFactory);List<ServletContextInitializer> sortedInitializers = this.initializers.values().stream().flatMap((value) -> value.stream().sorted(AnnotationAwareOrderComparator.INSTANCE)).collect(Collectors.toList());this.sortedList = Collections.unmodifiableList(sortedInitializers);logMappings(this.initializers);}private void addServletContextInitializerBeans(ListableBeanFactory beanFactory) {for (Class<? extends ServletContextInitializer> initializerType : this.initializerTypes) { //默认情况下这里找到就只有上面第3部分的DispatcherServletRegistrationBean对应的beanfor (Entry<String, ? extends ServletContextInitializer> initializerBean : getOrderedBeansOfType(beanFactory,initializerType)) {//这里的key是bean的名字,value就是bean对象，在进去看看，就是下面这个方法addServletContextInitializerBean(initializerBean.getKey(), initializerBean.getValue(), beanFactory);}}}private void addServletContextInitializerBean(String beanName, ServletContextInitializer initializer,ListableBeanFactory beanFactory) {//会走到这个分支if (initializer instanceof ServletRegistrationBean) { //这里返回的servlet也还是第3部分DispatcherServlet对应的beanServlet source = ((ServletRegistrationBean<?>) initializer).getServlet(); //再点进去addServletContextInitializerBean(Servlet.class, beanName, initializer, beanFactory, source);}else if (initializer instanceof FilterRegistrationBean) {Filter source = ((FilterRegistrationBean<?>) initializer).getFilter();addServletContextInitializerBean(Filter.class, beanName, initializer, beanFactory, source);}else if (initializer instanceof DelegatingFilterProxyRegistrationBean) {String source = ((DelegatingFilterProxyRegistrationBean) initializer).getTargetBeanName();addServletContextInitializerBean(Filter.class, beanName, initializer, beanFactory, source);}else if (initializer instanceof ServletListenerRegistrationBean) {EventListener source = ((ServletListenerRegistrationBean<?>) initializer).getListener();addServletContextInitializerBean(EventListener.class, beanName, initializer, beanFactory, source);}else {addServletContextInitializerBean(ServletContextInitializer.class, beanName, initializer, beanFactory,initializer);}}private void addServletContextInitializerBean(Class<?> type, String beanName, ServletContextInitializer initializer,ListableBeanFactory beanFactory, Object source) {//这里的initializers是个map,按照类型，bean对象进行加载，这里的type是javax.servlet.Servlet.class,value是上面的DispatcherServletRegistrationBeanthis.initializers.add(type, initializer);if (source != null) {// Mark the underlying source as seen in case it wraps an existing bean //将DispatcherServlet对应的bean加到这里this.seen.add(source);}if (logger.isTraceEnabled()) {String resourceDescription = getResourceDescription(beanName, beanFactory);int order = getOrder(initializer);logger.trace('Added existing ' + type.getSimpleName() + ' initializer bean ’' + beanName + '’; order='+ order + ', resource=' + resourceDescription);}}

再回到ServletContextInitializerBeans的构造方法,接着看后面的

public ServletContextInitializerBeans(ListableBeanFactory beanFactory,Class<? extends ServletContextInitializer>... initializerTypes) {...... //这里的内容上面已经看过了，我们现在看下面这句，点进去addAdaptableBeans(beanFactory);List<ServletContextInitializer> sortedInitializers = this.initializers.values().stream().flatMap((value) -> value.stream().sorted(AnnotationAwareOrderComparator.INSTANCE)).collect(Collectors.toList());this.sortedList = Collections.unmodifiableList(sortedInitializers);logMappings(this.initializers);}

protected void addAdaptableBeans(ListableBeanFactory beanFactory) {//这句不用关注MultipartConfigElement multipartConfig = getMultipartConfig(beanFactory);//这句不用关注addAsRegistrationBean(beanFactory, Servlet.class, new ServletRegistrationBeanAdapter(multipartConfig));//点到这里去看看addAsRegistrationBean(beanFactory, Filter.class, new FilterRegistrationBeanAdapter());for (Class<?> listenerType : ServletListenerRegistrationBean.getSupportedTypes()) {addAsRegistrationBean(beanFactory, EventListener.class, (Class<EventListener>) listenerType,new ServletListenerRegistrationBeanAdapter());}}

private <T, B extends T> void addAsRegistrationBean(ListableBeanFactory beanFactory, Class<T> type,Class<B> beanType, RegistrationBeanAdapter<T> adapter) {//这里的beanType是 Filter.class,下面这句就是从beanFactory中获取所有类型为Filter.class的beanList<Map.Entry<String, B>> entries = getOrderedBeansOfType(beanFactory, beanType, this.seen);for (Entry<String, B> entry : entries) {String beanName = entry.getKey();B bean = entry.getValue(); //将bean放置到this.seen里面if (this.seen.add(bean)) {// One that we haven’t already seen//包装成RegistrationBean对象RegistrationBean registration = adapter.createRegistrationBean(beanName, bean, entries.size());int order = getOrder(bean);registration.setOrder(order);//同样放置到this.initializers里面this.initializers.add(type, registration);if (logger.isTraceEnabled()) {logger.trace('Created ' + type.getSimpleName() + ' initializer for bean ’' + beanName + '’; order='+ order + ', resource=' + getResourceDescription(beanName, beanFactory));}}}}

再回到上面的addAdaptableBeans方法，看后面的

protected void addAdaptableBeans(ListableBeanFactory beanFactory) {......//这里刚才说过了 //下面这部分不说了，这里基本和上面一样，不过处理的类型变成了ServletContextAttributeListener.class、ServletRequestListener.class、ServletRequestAttributeListener.class、HttpSessionAttributeListener.class、HttpSessionIdListener.class、HttpSessionListener.class、ServletContextListener.class这些类型for (Class<?> listenerType : ServletListenerRegistrationBean.getSupportedTypes()) {addAsRegistrationBean(beanFactory, EventListener.class, (Class<EventListener>) listenerType,new ServletListenerRegistrationBeanAdapter());}}

再回到ServletContextInitializerBeans的构造方法,接着看后面的

public ServletContextInitializerBeans(ListableBeanFactory beanFactory,Class<? extends ServletContextInitializer>... initializerTypes) {......//这里刚才都说过了，看下面//这里就是把上面所有获取到的相关的bean放置到this.sortedList中，下面我是我本地this.sortedList的截图List<ServletContextInitializer> sortedInitializers = this.initializers.values().stream().flatMap((value) -> value.stream().sorted(AnnotationAwareOrderComparator.INSTANCE)).collect(Collectors.toList());this.sortedList = Collections.unmodifiableList(sortedInitializers);logMappings(this.initializers);}

这里ServletContextInitializerBeans的构造方法就完成了，再回过头去看看这个类的定义

public class ServletContextInitializerBeans extends AbstractCollection<ServletContextInitializer>

这个类继承了AbstractCollection类，那它就需要实现下面这个抽象方法

public abstract Iterator<E> iterator();

我们看看ServletContextInitializerBeans的iterator的方法

@Overridepublic Iterator<ServletContextInitializer> iterator() { return this.sortedList.iterator();}

看到了吧，这就是返回上面的this.sortedList.iterator()

我们再次回到ServletWebServerApplicationContext的selfInitialize方法

private void selfInitialize(ServletContext servletContext) throws ServletException {......//这里上面都说过了//getServletContextInitializerBeans()这个方法就是构造了ServletContextInitializerBeans//这里的for循环也是调用了ServletContextInitializerBeans的iterator的方法，实际上遍历的也就是上面的this.sortedListfor (ServletContextInitializer beans : getServletContextInitializerBeans()) {//这里就是把在beanFactory中查找到的Servlet.class,filter.class，监听器等等添加到tomcat容器中,我们就只进到servlet里面去看看//进到DispatcherServletRegistrationBean里面去看看beans.onStartup(servletContext);}}

//这个方法在DispatcherServletRegistrationBean的父类RegistrationBean中//所有的Servlet.class,filter.class，监听器都会走到这里public final void onStartup(ServletContext servletContext) throws ServletException {//这里是返回的表述，不关注String description = getDescription();if (!isEnabled()) {logger.info(StringUtils.capitalize(description) + ' was not registered (disabled)');return;}//这里由不同的子类去实现，DispatcherServletRegistrationBean会调用到ServletRegistrationBean中register(description, servletContext);}

//这个方法是在ServletRegistrationBean这个类中@Overrideprotected ServletRegistration.Dynamic addRegistration(String description, ServletContext servletContext) {String name = getServletName();//这里的servletContext上面的ApplicationContextFacade的对象，这里就会将DispatcherServlet的bean对象加载到TomcatEmbeddedContext中，后续所有的http请求最后都会流转到DispatcherServlet去进行具体的分发return servletContext.addServlet(name, this.servlet);}

到这里Servlet.class,filter.class，监听器就全部加载到tomcat中去

5、创建RequestMappingHandlerMapping

再看看上面的META-INF/spring.factories文件

# Auto Configuration Import Filtersorg.springframework.boot.autoconfigure.AutoConfigurationImportFilter=org.springframework.boot.autoconfigure.condition.OnBeanCondition,org.springframework.boot.autoconfigure.condition.OnClassCondition,org.springframework.boot.autoconfigure.condition.OnWebApplicationCondition# Auto Configureorg.springframework.boot.autoconfigure.EnableAutoConfiguration=......org.springframework.boot.autoconfigure.web.servlet.DispatcherServletAutoConfiguration,org.springframework.boot.autoconfigure.web.servlet.ServletWebServerFactoryAutoConfiguration,......#现在我们重点来看这个类org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration,......

具体的加载和上面部分都类似，就不展开了，直接看我们需要的

//这里会创建RequestMappingHandlerMapping的bean@Bean@Primary@Overridepublic RequestMappingHandlerMapping requestMappingHandlerMapping(@Qualifier('mvcContentNegotiationManager') ContentNegotiationManager contentNegotiationManager,@Qualifier('mvcConversionService') FormattingConversionService conversionService,@Qualifier('mvcResourceUrlProvider') ResourceUrlProvider resourceUrlProvider) {// Must be @Primary for MvcUriComponentsBuilder to workreturn super.requestMappingHandlerMapping(contentNegotiationManager, conversionService,resourceUrlProvider);

看下这个类的继承图

RequestMappingHandlerMapping实现了InitializingBean接口，会在bean对象创建后的invokeInitMethods方法中调用afterPropertiesSet方法,最终会调用的AbstractHandlerMethodMapping的afterPropertiesSet方法中

@Overridepublic void afterPropertiesSet() {initHandlerMethods();}/** * Scan beans in the ApplicationContext, detect and register handler methods. * @see #getCandidateBeanNames() * @see #processCandidateBean * @see #handlerMethodsInitialized */protected void initHandlerMethods() {//这里查找beanFactory中的所有bean进行遍历for (String beanName : getCandidateBeanNames()) {if (!beanName.startsWith(SCOPED_TARGET_NAME_PREFIX)) {//点到这里去看看processCandidateBean(beanName);}}handlerMethodsInitialized(getHandlerMethods());}

protected void processCandidateBean(String beanName) {Class<?> beanType = null;try {//根据beanName获取对应bean的Class对象beanType = obtainApplicationContext().getType(beanName);}catch (Throwable ex) {// An unresolvable bean type, probably from a lazy bean - let’s ignore it.if (logger.isTraceEnabled()) {logger.trace('Could not resolve type for bean ’' + beanName + '’', ex);}}//判断类上是否有Controller.class，RequestMapping.class注解if (beanType != null && isHandler(beanType)) {//这里就会解析beanName上的所有方法进行遍历，查找有 RequestMapping.class注解的方法，创建RequestMappingInfo对象，放置到registry属性中(在AbstractHandlerMethodMapping)中，这样我们所有定义的controller中的http请求就会全部被扫描到detectHandlerMethods(beanName);}}

6、加载RequestMappingHandlerMapping到DispatcherServlet中

在我们第一次请求的时候，会执行到DispatcherServlet的initStrategies方法，这个方法只会执行一次

protected void initStrategies(ApplicationContext context) {......这就会加载之前查找到的RequestMappingHandlerMapping中的我们定义的controllerinitHandlerMappings(context);......}

会调用到这里

private void initHandlerMappings(ApplicationContext context) {this.handlerMappings = null;if (this.detectAllHandlerMappings) {// Find all HandlerMappings in the ApplicationContext, including ancestor contexts.//这里会在beanFactory中查找所有HandlerMapping.class的bean,其中就包含我们第5部分的RequestMappingHandlerMappingMap<String, HandlerMapping> matchingBeans =BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerMapping.class, true, false);if (!matchingBeans.isEmpty()) {//将所有查找到的放置到handlerMappings中this.handlerMappings = new ArrayList<>(matchingBeans.values());// We keep HandlerMappings in sorted order.AnnotationAwareOrderComparator.sort(this.handlerMappings);}}......}

当我们浏览器请求的时候，最终会走到DispatcherServlet的doDispatch的方法，处理我们的请求并返回,简单看看

protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {......try {ModelAndView mv = null;Exception dispatchException = null;try {processedRequest = checkMultipart(request);multipartRequestParsed = (processedRequest != request);// Determine handler for the current request.//在这里，就会请求request的请求路径去查找实际要执行的controller的方法，点进去看看mappedHandler = getHandler(processedRequest);......}

@Nullableprotected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {if (this.handlerMappings != null) { //这其实就是根据遍历，查找对应的路径，这个this.handlerMappings就是就是在initHandlerMappings方法中赋值的for (HandlerMapping mapping : this.handlerMappings) {HandlerExecutionChain handler = mapping.getHandler(request);if (handler != null) {return handler;}}}return null;}

到这里，springboot 加载web容器的整个流程基本就算完成了，这块涉及的东西比较多，所以说的可能比较粗，大家见谅。