纯净、安全、绿色的下载网站

首页

当前位置:首页IT学院IT技术

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

wang03   2021-06-20 我要评论
想了解spring boot 加载web容器tomcat流程源码分析的相关内容吗wang03在本文为您仔细讲解springboot 加载web容器的相关知识和一些Code实例欢迎阅读和指正我们先划重点:spring,boot,加载web容器tomcat流程,springboot,加载web容器下面大家一起来学习吧

我本地的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.SERVLET
		return this.applicationContextFactory.create(this.webApplicationType);
	}
//最终会调用到这个lambda表达式入参就是上面的WebApplicationType.SERVLET
	ApplicationContextFactory 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 Filters
org.springframework.boot.autoconfigure.AutoConfigurationImportFilter=\
org.springframework.boot.autoconfigure.condition.OnBeanCondition,\
org.springframework.boot.autoconfigure.condition.OnClassCondition,\
org.springframework.boot.autoconfigure.condition.OnWebApplicationCondition

# Auto Configure
org.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上面有ConditionalOnClassConditionalOnMissingBean这两个注解

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

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

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

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

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

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

再次打开ServletWebServerApplicationContext的getWebServerFactory方法

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

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

3、创建DispatcherServletRegistrationBeanDispatcherServlet

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

# Auto Configuration Import Filters
org.springframework.boot.autoconfigure.AutoConfigurationImportFilter=\
org.springframework.boot.autoconfigure.condition.OnBeanCondition,\
org.springframework.boot.autoconfigure.condition.OnClassCondition,\
org.springframework.boot.autoconfigure.condition.OnWebApplicationCondition

# Auto Configure
org.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 incorrectly
			return 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,再创建DispatcherServletRegistrationBean
		public 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;
		}

	}
  ......
}

上面就是创建DispatcherServletDispatcherServletRegistrationBean的过程了

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

	@Override
	public 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的scope
		registerApplicationScope(servletContext);
        //这里还是注册上下文相关的bean
		WebApplicationContextUtils.registerEnvironmentBeans(getBeanFactory(), servletContext);
        //我们重点来看这里getServletContextInitializerBeans()是定义个一个ServletContextInitializerBeans对象我们点进去看看
		for (ServletContextInitializer beans : getServletContextInitializerBeans()) {
			beans.onStartup(servletContext);
		}
	}
protected Collection<ServletContextInitializer> getServletContextInitializerBeans() {
		//这里的getBeanFactory()就是全局的beanFactory
		return 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对应的bean
			for (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对应的bean
			Servlet 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是上面的DispatcherServletRegistrationBean
		this.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的bean
		List<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的方法

@Override
public 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.sortedList
	for (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这个类中
	@Override
	protected 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 Filters
org.springframework.boot.autoconfigure.AutoConfigurationImportFilter=\
org.springframework.boot.autoconfigure.condition.OnBeanCondition,\
org.springframework.boot.autoconfigure.condition.OnClassCondition,\
org.springframework.boot.autoconfigure.condition.OnWebApplicationCondition

# Auto Configure
org.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
		@Override
		public RequestMappingHandlerMapping requestMappingHandlerMapping(
				@Qualifier("mvcContentNegotiationManager") ContentNegotiationManager contentNegotiationManager,
				@Qualifier("mvcConversionService") FormattingConversionService conversionService,
				@Qualifier("mvcResourceUrlProvider") ResourceUrlProvider resourceUrlProvider) {
			// Must be @Primary for MvcUriComponentsBuilder to work
			return super.requestMappingHandlerMapping(contentNegotiationManager, conversionService,
					resourceUrlProvider);

看下这个类的继承图

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

@Override
	public 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.classRequestMapping.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中的我们定义的controller
		initHandlerMappings(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部分的RequestMappingHandlerMapping
			Map<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);
				......
	}
@Nullable
	protected 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容器的整个流程基本就算完成了这块涉及的东西比较多所以说的可能比较粗大家见谅


相关文章

猜您喜欢

  • C语言操作符介绍 C语言中各种操作符的仔细讲解(纯干货!)

    想了解C语言中各种操作符的仔细讲解(纯干货!)的相关内容吗我会一直在um在本文为您仔细讲解C语言操作符介绍的相关知识和一些Code实例欢迎阅读和指正我们先划重点:c语言操作符,c语言位操作符,c位运算符详解下面大家一起来学习吧..
  • Pyecharts制作Map3D 详解怎样使用Pyecharts制作Map3D

    想了解详解怎样使用Pyecharts制作Map3D的相关内容吗Mr数据杨在本文为您仔细讲解Pyecharts制作Map3D的相关知识和一些Code实例欢迎阅读和指正我们先划重点:Pyecharts制作Map3D,Python,Pyecharts下面大家一起来学习吧..

网友评论

Copyright 2022 版权所有 软件发布

声明:所有软件和文章来自软件开发商或者作者 如有异议 请与本站联系 联系我们