Spring Boot 之 Servlet容器 配置和启动流程

已于 2022-12-01 16:12:48 修改
阅读量2.1k 收藏 5
点赞数 1
分类专栏： Spring Boot 源码 文章标签： spring boot tomcat servlet
于 2022-11-11 15:38:00 首次发布
原文链接：https://blog.csdn.net/qq_34609889/article/details/86714796
版权

一、内置Servlet容器

1.1 定制和修改Servlet容器配置

（1）在配置文件 application.properties/yaml 中修改。示例：

server.port=8081
#项目路径
server.servlet.context-path=/dmf
server.tomcat.uri-encoding=UTF-8

#通用的Servlet容器配置
server.xxx
#Tomcat的设置
server.tomcat.xxx

这些配置对应的是 ServerProperties，这是个配置类，对应的就是服务的相关配置。
（2）代码里设置。
Spring boot1.x 和 Spring Boot2.x 的配置方法有些不同。
SpringBoot1.x 定制和修改Servlet容器的相关配置示例：

@Configuration
public class MyConfig {
    @Bean  //必须要加到容器中才能生效
    public EmbeddedServletContainerCustomizer embeddedServletContainerCustomizer() {
        return new EmbeddedServletContainerCustomizer() {
            @Override
            public void customize(ConfigurableEmbeddedServletContainer container) {
                //在这里修改相关配置
                container.setPort(8088);
            }
        };
    }
}

SpringBoot2.x定制和修改Servlet容器的相关配置示例：

@Configuration
public class MyConfig {
    @Bean //必须要加到容器中才能生效
	public ConfigurableServletWebServerFactory configurableServletWebServerFactory() {
	    //修改tomcat相关配置
		TomcatServletWebServerFactory factory= new TomcatServletWebServerFactory();
		factory.setPort(8083);
		return factory;
	}
	
    //或者使用下面这种方法，泛型根据具体的servlet容器来写。
    @Bean
	public WebServerFactoryCustomizer<TomcatServletWebServerFactory> webServerFactoryCustomizer() {
		return new WebServerFactoryCustomizer<TomcatServletWebServerFactory>() {
			@Override
			public void customize(TomcatServletWebServerFactory factory) {
				factory.setPort(8084);
			}
		};
	}
}

上面这两种方法二选一，原理都是一样的。


1.2 切换内置Servlet容器

Spring Boot默认使用tomcat作为Servlet容器，同时也支持Jetty、Undertow等内置Sevlet容器，可以根据需要切换相应的Servlet容器。

步骤：
1、在web-Starter里排除tomcat的依赖。

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

2、导入其他的Servlet容器依赖。

<!--引入Jetty-->
    <dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-jetty</artifactId>
	</dependency>
	
	<!--引入Undertow-->
	<dependency>
		<artifactId>spring-boot-starter-undertow</artifactId>
		<groupId>org.springframework.boot</groupId>
	</dependency>

1.3、内置Servlet容器原理

1.3.1 自动配置原理（2.x版本）

这里以2.x版本中的tomcat为例，找到内置Servlet容器的自动配置类，在spring-boot-autoconfigure.jar中的 ServletWebServerFactoryAutoConfiguration 和 EmbeddedWebServerFactoryCustomizerAutoConfiguration。

@Configuration
@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
@ConditionalOnClass(ServletRequest.class)
@ConditionalOnWebApplication(type = Type.SERVLET)
@EnableConfigurationProperties(ServerProperties.class)
@Import({ ServletWebServerFactoryAutoConfiguration.BeanPostProcessorsRegistrar.class,
		ServletWebServerFactoryConfiguration.EmbeddedTomcat.class,
		ServletWebServerFactoryConfiguration.EmbeddedJetty.class,
		ServletWebServerFactoryConfiguration.EmbeddedUndertow.class })
public class ServletWebServerFactoryAutoConfiguration {
    //往容器中导入了ServletWebServerFactoryCustomizer
    //servletWeb服务工程定制器
	@Bean
	public ServletWebServerFactoryCustomizer servletWebServerFactoryCustomizer(
			ServerProperties serverProperties) {
		return new ServletWebServerFactoryCustomizer(serverProperties);
	}
    //导入了TomcatServletWebServerFactoryCustomizer
	@Bean
	@ConditionalOnClass(name = "org.apache.catalina.startup.Tomcat")//当容器中有Tomcat类就生效
	public TomcatServletWebServerFactoryCustomizer tomcatServletWebServerFactoryCustomizer(
			ServerProperties serverProperties) {
		return new TomcatServletWebServerFactoryCustomizer(serverProperties);
	}
    //这个类的作用是往容器中添加一些组件
	public static class BeanPostProcessorsRegistrar
			implements ImportBeanDefinitionRegistrar, BeanFactoryAware {
		
		private ConfigurableListableBeanFactory beanFactory;
		
		@Override
		public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
			if (beanFactory instanceof ConfigurableListableBeanFactory) {
				this.beanFactory = (ConfigurableListableBeanFactory) beanFactory;
			}
		}
		
		@Override
		public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata,
				BeanDefinitionRegistry registry) {
			if (this.beanFactory == null) {
				return;
			}
			//往容器中添加了WebServerFactoryCustomizerBeanPostProcessor组件（web服务工厂定制器的后置处理器）。
			//这个类实现了BeanPostProcessor，属于bean的后置处理器。作用是在bean初始化前后加一些自己的逻辑处理
			registerSyntheticBeanIfMissing(registry,
					"webServerFactoryCustomizerBeanPostProcessor",
					WebServerFactoryCustomizerBeanPostProcessor.class);
			registerSyntheticBeanIfMissing(registry,
					"errorPageRegistrarBeanPostProcessor",
					ErrorPageRegistrarBeanPostProcessor.class);
		}
		
		private void registerSyntheticBeanIfMissing(BeanDefinitionRegistry registry,
				String name, Class<?> beanClass) {
			if (ObjectUtils.isEmpty(
					this.beanFactory.getBeanNamesForType(beanClass, true, false))) {
				RootBeanDefinition beanDefinition = new RootBeanDefinition(beanClass);
				beanDefinition.setSynthetic(true);
				registry.registerBeanDefinition(name, beanDefinition);
			}
		}
	}
}

@Configuration
@ConditionalOnWebApplication
@EnableConfigurationProperties(ServerProperties.class)
public class EmbeddedWebServerFactoryCustomizerAutoConfiguration {

	@Configuration
	//当容器中存在Tomcat相关类就生效
	@ConditionalOnClass({ Tomcat.class, UpgradeProtocol.class })
	public static class TomcatWebServerFactoryCustomizerConfiguration {
        //导入了TomcatWebServerFactoryCustomizer，TomcatWeb服务工厂定制器
		@Bean
		public TomcatWebServerFactoryCustomizer tomcatWebServerFactoryCustomizer(
				Environment environment, ServerProperties serverProperties) {
			return new TomcatWebServerFactoryCustomizer(environment, serverProperties);
		}
	}
	
	@Configuration
	@ConditionalOnClass({ Server.class, Loader.class, WebAppContext.class })
	public static class JettyWebServerFactoryCustomizerConfiguration {
		@Bean
		public JettyWebServerFactoryCustomizer jettyWebServerFactoryCustomizer(
				Environment environment, ServerProperties serverProperties) {
			return new JettyWebServerFactoryCustomizer(environment, serverProperties);
		}
	}
	
	@Configuration
	@ConditionalOnClass({ Undertow.class, SslClientAuthMode.class })
	public static class UndertowWebServerFactoryCustomizerConfiguration {
		@Bean
		public UndertowWebServerFactoryCustomizer undertowWebServerFactoryCustomizer(
				Environment environment, ServerProperties serverProperties) {
			return new UndertowWebServerFactoryCustomizer(environment, serverProperties);
		}
	}
	
	@Configuration
	@ConditionalOnClass(HttpServer.class)
	public static class NettyWebServerFactoryCustomizerConfiguration {
		@Bean
		public NettyWebServerFactoryCustomizer nettyWebServerFactoryCustomizer(
				Environment environment, ServerProperties serverProperties) {
			return new NettyWebServerFactoryCustomizer(environment, serverProperties);
		}
	}
}

这两个类的作用是往Spring容器中导入了一些Web服务工厂定制器（xxxWebServerFactoryCustomizer）。而 ServletWebServerFactoryAutoConfiguration 中使用了 @Import 注解导入了 BeanPostProcessorsRegistrar、EmbeddedTomcat、EmbeddedJetty 和 EmbeddedUndertow 组件，其中后面三个都在 ServletWebServerFactoryConfiguration 类中，根据依赖的Servle容器使其中一个生效。而 BeanPostProcessorsRegistrar 是 ServletWebServerFactoryAutoConfiguration 的内部类，它的作用是往容器中导入了 WebServerFactoryCustomizerBeanPostProcessor 组件。

@Configuration
class ServletWebServerFactoryConfiguration {
    
	@Configuration
	//如果有这三个类就生效，即如果依赖了tomcat，这个就生效
	@ConditionalOnClass({ Servlet.class, Tomcat.class, UpgradeProtocol.class })
	//如果有ServletWebServerFactory就不生效，所以容器中应该只有一个ServletWebServerFactory
	@ConditionalOnMissingBean(value = ServletWebServerFactory.class, search = SearchStrategy.CURRENT)
	public static class EmbeddedTomcat {
        //往容器中导入了TomcatServletWebServerFactory 组件，它继承了ServletWebServerFactory类。
		@Bean
		public TomcatServletWebServerFactory tomcatServletWebServerFactory() {
			return new TomcatServletWebServerFactory();
		}
	}
	
	@Configuration
	@ConditionalOnClass({ Servlet.class, Server.class, Loader.class, WebAppContext.class })
	@ConditionalOnMissingBean(value = ServletWebServerFactory.class, search = SearchStrategy.CURRENT)
	public static class EmbeddedJetty {
		@Bean
		public JettyServletWebServerFactory JettyServletWebServerFactory() {
			return new JettyServletWebServerFactory();
		}
	}
	
	@Configuration
	@ConditionalOnClass({ Servlet.class, Undertow.class, SslClientAuthMode.class })
	@ConditionalOnMissingBean(value = ServletWebServerFactory.class, search = SearchStrategy.CURRENT)
	public static class EmbeddedUndertow {
		@Bean
		public UndertowServletWebServerFactory undertowServletWebServerFactory() {
			return new UndertowServletWebServerFactory();
		}
	}
}

EmbeddedTomcat 往容器中导入了一个 TomcatServletWebServerFactory 组件，它实现了 ServletWebServerFactory类，也实现了 WebServerFactory 类。WebServerFactoryCustomizerBeanPostProcessor 在 WebServerFactory 初始化时调用上面自动配置类注入的那些Web服务工厂定制器（xxxWebServerFactoryCustomizer）。

public class WebServerFactoryCustomizerBeanPostProcessor implements BeanPostProcessor, BeanFactoryAware {

    private List<WebServerFactoryCustomizer<?>> customizers;
    
    //bean初始化前调用
	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName)
			throws BeansException {
		//判断这个bean的类型是WebServerFactory
	    //TomcatServletWebServerFactory继承了WebServerFactory，所以它初始化时，会往下执行
		if (bean instanceof WebServerFactory) {
			postProcessBeforeInitialization((WebServerFactory) bean);
		}
		return bean;
	}
	
    //bean初始化后调用
	@Override
	public Object postProcessAfterInitialization(Object bean, String beanName)
			throws BeansException {
		return bean;
	}
	
	@SuppressWarnings("unchecked")
	private void postProcessBeforeInitialization(WebServerFactory webServerFactory) {
		LambdaSafe
		         //获取Web服务工厂定制器（WebServerFactoryCustomizer）
				.callbacks(WebServerFactoryCustomizer.class, getCustomizers(), webServerFactory)
				.withLogger(WebServerFactoryCustomizerBeanPostProcessor.class)
				//调用customizer的customize方法，customize方法就是根据相关配置初始化Servlet容器
				.invoke((customizer) -> customizer.customize(webServerFactory));
	}
	
	private Collection<WebServerFactoryCustomizer<?>> getCustomizers() {
		if (this.customizers == null) {
			this.customizers = new ArrayList<>(getWebServerFactoryCustomizerBeans());
			this.customizers.sort(AnnotationAwareOrderComparator.INSTANCE);
			this.customizers = Collections.unmodifiableList(this.customizers);
		}
		return this.customizers;
	}
	
	@SuppressWarnings({ "unchecked", "rawtypes" })
	private Collection<WebServerFactoryCustomizer<?>> getWebServerFactoryCustomizerBeans() {
	    //返回WebServerFactoryCustomizer类型的bean（定制器）
	    //上面自动配置类注册的Web服务工厂定制器（xxxWebServerFactoryCustomizer）
		return (Collection) this.beanFactory
				.getBeansOfType(WebServerFactoryCustomizer.class, false, false).values();
	}
}

所以当Spring容器创建 TomcatServletWebServerFactory 实例时，会调用 WebServerFactoryCustomizerBeanPostProcessor ，然后获取所有的Web服务工厂定制器（xxxWebServerFactoryCustomizer），调用它的 customize 方法，这个方法是根据配置创建servlet容器。

这就是我们在代码实现Servlet容器配置时，需要往容器中注入一个 WebServerFactoryCustomizer，而它的 customize 方法实际上也是设置传入的 WebServerFactory 的属性。

也可以通过手动注入一个 ConfigurableServletWebServerFactory 来实现。ConfigurableServletWebServerFactory 实现了 ServletWebServerFactory，所以自动配置的 TomcatServletWebServerFactory 不生效。而 ConfigurableServletWebServerFactory 又实现了 WebServerFactory，所以它会走 WebServerFactoryCustomizerBeanPostProcessor 的流程，被Web服务工厂定制器配置。


1.3.2 启动原理

步骤：
1、Spring Boot启动运行 run 方法，执行到 SpringApplication 的 run(String… args) 方法。

public class SpringApplication {

    public ConfigurableApplicationContext run(String... args) {
	    ...
		ConfigurableApplicationContext context = null;
	    ...
	    //调用createApplicationContext方法，返回AnnotationConfigServletWebServerApplicationContext
	    context = createApplicationContext();
	    ...
		refreshContext(context);
	    ...
		return context;
    }
    
    protected ConfigurableApplicationContext createApplicationContext() {
		Class<?> contextClass = this.applicationContextClass;
		if (contextClass == null) {
			try {
				switch (this.webApplicationType) {
				case SERVLET:
					contextClass = Class.forName(DEFAULT_SERVLET_WEB_CONTEXT_CLASS);
					break;
				case REACTIVE:
					contextClass = Class.forName(DEFAULT_REACTIVE_WEB_CONTEXT_CLASS);
					break;
				default:
					contextClass = Class.forName(DEFAULT_CONTEXT_CLASS);
				}
			}
			catch (ClassNotFoundException ex) {
				throw new IllegalStateException(
						"Unable create a default ApplicationContext, "
								+ "please specify an ApplicationContextClass",
						ex);
			}
		}
		return (ConfigurableApplicationContext) BeanUtils.instantiateClass(contextClass);
	}
}

如果是web应用，context的类型就是 AnnotationConfigServletWebServerApplicationContext。

2、执行 refreshContext(context) 方法。SpringBoot刷新IOC容器（创建bean对象，并初始化容器，创建容器中的每一个组件）。一路执行，到 refresh(ApplicationContext applicationContext) 方法。

protected void refresh(ApplicationContext applicationContext) {
	Assert.isInstanceOf(AbstractApplicationContext.class, applicationContext);
	//将applicationContext强转成AbstractApplicationContext类型，然后调用refresh()方法。
	((AbstractApplicationContext) applicationContext).refresh();
}

AbstractApplicationContext 的 refresh() 方法。

@Override
public void refresh() throws BeansException, IllegalStateException {
	synchronized (this.startupShutdownMonitor) {
		prepareRefresh();
		ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
		prepareBeanFactory(beanFactory);
		try {
			postProcessBeanFactory(beanFactory);
			invokeBeanFactoryPostProcessors(beanFactory);
			registerBeanPostProcessors(beanFactory);
			initMessageSource();
			initApplicationEventMulticaster();
			onRefresh();
			registerListeners();
			finishBeanFactoryInitialization(beanFactory);
			finishRefresh();
		}
		catch (BeansException ex) {
			if (logger.isWarnEnabled()) {
				logger.warn("Exception encountered during context initialization - " +
							"cancelling refresh attempt: " + ex);
			}
			destroyBeans();
			cancelRefresh(ex);
			throw ex;
		}
		finally {
			resetCommonCaches();
		}
	}
}

主要是 onRefresh() 方法。因为 AbstractApplicationContext 是由 applicationContext 强转的，而 applicationContext 是 AnnotationConfigServletWebServerApplicationContext 类型的，所以调用的其实是 AnnotationConfigServletWebServerApplicationContext 的 onRefresh() 方法，而它的 onRefresh() 方法是从它的父类继承过来的，也就是 ServletWebServerApplicationContext 的 onRefresh() 方法。

@Override
protected void onRefresh() {
	super.onRefresh();
	try {
		createWebServer();
	}
	catch (Throwable ex) {
		throw new ApplicationContextException("Unable to start web server", ex);
	}
}

这里调用了 createWebServer 方法。

private void createWebServer() {
	WebServer webServer = this.webServer;
	ServletContext servletContext = getServletContext();
	if (webServer == null && servletContext == null) {
	    //获取ServletWebServerFactory
		ServletWebServerFactory factory = getWebServerFactory();
		//执行getWebServer方法
		this.webServer = factory.getWebServer(getSelfInitializer());
	}
	else if (servletContext != null) {
		try {
			getSelfInitializer().onStartup(servletContext);
		}
		catch (ServletException ex) {
			throw new ApplicationContextException("Cannot initialize servlet context", ex);
		}
	}
	initPropertySources();
}

protected ServletWebServerFactory getWebServerFactory() {
	//获取ServletWebServerFactory类型的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));
	}
	return getBeanFactory().getBean(beanNames[0], ServletWebServerFactory.class);
}

因为自动配置类往容器中注入了 TomcatServletWebServerFactory（以tomcat为例，其他Servlet容器相同），它实现了 ServletWebServerFactory，所以最后执行的是 TomcatServletWebServerFactory 的 getWebServer 方法来创建 WebServer：

@Override
public WebServer getWebServer(ServletContextInitializer... initializers) {
    //创建了tomcat容器对象
	Tomcat tomcat = new Tomcat();
	//配置tomcat相关配置
	File baseDir = (this.baseDirectory != null) ? this.baseDirectory
				: createTempDir("tomcat");
	tomcat.setBaseDir(baseDir.getAbsolutePath());
	Connector connector = new Connector(this.protocol);
	tomcat.getService().addConnector(connector);
	customizeConnector(connector);
	tomcat.setConnector(connector);
	tomcat.getHost().setAutoDeploy(false);
	configureEngine(tomcat.getEngine());
	for (Connector additionalConnector : this.additionalTomcatConnectors) {
		tomcat.getService().addConnector(additionalConnector);
	}
	prepareContext(tomcat.getHost(), initializers);
	return getTomcatWebServer(tomcat);
}

protected TomcatWebServer getTomcatWebServer(Tomcat tomcat) {
	return new TomcatWebServer(tomcat, getPort() >= 0);
}

public class TomcatWebServer implements WebServer {
   ...
   public TomcatWebServer(Tomcat tomcat, boolean autoStart) {
		Assert.notNull(tomcat, "Tomcat Server must not be null");
		this.tomcat = tomcat;
		this.autoStart = autoStart;
		initialize();
	}
	
	private void initialize() throws WebServerException {
		logger.info("Tomcat initialized with port(s): " + getPortsDescription(false));
		synchronized (this.monitor) {
			try {
				addInstanceIdToEngineName();
				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.
						removeServiceConnectors();
					}
				});
				
				// Start the server to trigger initialization listeners
				//启动tomcat
				this.tomcat.start();
				
				// We can re-throw failure exception directly in the main thread
				rethrowDeferredStartupExceptions();
				try {
					ContextBindings.bindClassLoader(context, context.getNamingToken(),
							getClass().getClassLoader());
				}
				catch (NamingException ex) {
				}
				// Unlike Jetty, all Tomcat threads are daemon threads. We create a
				// blocking non-daemon to stop immediate shutdown
				startDaemonAwaitThread();
			}
			catch (Exception ex) {
				stopSilently();
				throw new WebServerException("Unable to start embedded Tomcat", ex);
			}
		}
	}
}

二、外置Servlet容器

2.1 使用外置Servlet容器

嵌入式的Servlet的容器有个缺点：默认不支持jsp，优化定制比较复杂。所以在适当场景下，我们还是需要外部的servlet容器。

使用外置Servlet容器步骤：
1、创建war类型的maven项目。创建好web项目的目录结构（必须有web.xml文件）。
2、将嵌入式的servlet容器依赖的scope指定为provided。

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

3、编写一个 SpringBootServletInitializer 类型的子类，并重写 configure 方法。

public class ServletInitializer extends SpringBootServletInitializer {

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

4、启动容器。


2.2 外置Servlet容器启动原理

原理对比;
jar 方式：执行SpringBoot主类的main方法，调用 SpringApplication 的 run 方法，启动Spring的ioc容器，创建嵌入式的Servlet容器。
war 方式：启动服务器，服务器启动SpringBoot的 SpringBootServletInitializer，启动Spring的ioc容器。

Servlet3.0+定义了几个web应用在启动时的规则：
（1）容器在启动时会去每个jar包下找 META-INF/services/javax.servlet.ServletContainerInitializer 文件，如果有则根据这个文件内容创建 ServletContainerInitializer 的实现类实例。
（2）可以使用 @HandlesTypes 注解加载需要的类。

启动原理：

1、启动tomcat容器。
2、容器根据Servlet的规则创建 SpringServletContainerInitializer 。该类在在 spring-web-xxx.jar 下，这个jar包的 META-INF/services/javax.servlet.ServletContainerInitializer 文件内容就是 SpringServletContainerInitializer 的全类名。

@HandlesTypes(WebApplicationInitializer.class)
public class SpringServletContainerInitializer implements ServletContainerInitializer {
    //@HandlesTypes标注的类型的所有类都传入到onStartup方法的参数Set中
    @Override
	public void onStartup(@Nullable Set<Class<?>> webAppInitializerClasses, ServletContext servletContext)
			throws ServletException {
        List<WebApplicationInitializer> initializers = new LinkedList<>();
		if (webAppInitializerClasses != null) {
			for (Class<?> waiClass : webAppInitializerClasses) {
			    //如果这个类不是接口和抽象类，就会创建实例
				if (!waiClass.isInterface() && !Modifier.isAbstract(waiClass.getModifiers()) &&
						WebApplicationInitializer.class.isAssignableFrom(waiClass)) {
					try {
						initializers.add((WebApplicationInitializer) ReflectionUtils.accessibleConstructor(waiClass).newInstance());
					}
					catch (Throwable ex) {
						throw new ServletException("Failed to instantiate WebApplicationInitializer class", ex);
					}
				}
			}
		}
		
		if (initializers.isEmpty()) {
			servletContext.log("No Spring WebApplicationInitializer types detected on classpath");
			return;
		}
        
		servletContext.log(initializers.size() + " Spring WebApplicationInitializers detected on classpath");
		AnnotationAwareOrderComparator.sort(initializers);
		for (WebApplicationInitializer initializer : initializers) {
		   //每个WebApplicationInitializer调用自己的onStartup方法。
			initializer.onStartup(servletContext);
		}
	}
}

3、SpringBootServletInitializer 实现了 WebApplicationInitializer 接口，所以我们自定义的 SpringBootServletInitializer 的子类（ServletInitializer）会被创建对象，并执行 onStartup 方法。
4、SpringBootServletInitializer 的 onStartup 方法被调用时，调用了 createRootApplicationContext 方法，启动了Spring的ioc容器。

protected WebApplicationContext createRootApplicationContext(ServletContext servletContext) {
		SpringApplicationBuilder builder = createSpringApplicationBuilder();
		builder.main(getClass());
		ApplicationContext parent = getExistingRootWebApplicationContext(servletContext);
		if (parent != null) {
			this.logger.info("Root context already created (using as parent).");
			servletContext.setAttribute(
					WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, null);
			builder.initializers(new ParentContextApplicationContextInitializer(parent));
		}
		builder.initializers(
				new ServletContextApplicationContextInitializer(servletContext));
		builder.contextClass(AnnotationConfigServletWebServerApplicationContext.class);
		//子类（ServletInitializer ）重写了这个方法，将SpringBoot的主程序类传入进来
		builder = configure(builder);
		builder.listeners(new WebEnvironmentPropertySourceInitializer(servletContext));
		//使用builder创建一个Spring应用
		SpringApplication application = builder.build();
		if (application.getAllSources().isEmpty() && AnnotationUtils
				.findAnnotation(getClass(), Configuration.class) != null) {
			application.addPrimarySources(Collections.singleton(getClass()));
		}
		Assert.state(!application.getAllSources().isEmpty(),
				"No SpringApplication sources have been defined. Either override the "
						+ "configure method or add an @Configuration annotation");
		// Ensure error pages are registered
		if (this.registerErrorPageFilter) {
			application.addPrimarySources(
					Collections.singleton(ErrorPageFilterConfiguration.class));
		}
		//启动Spring容器
		return run(application);
}

5、SpringBoot应用启动后就创建ioc容器。执行到这一步就和内置Servlet容器启动原理相同了。

my_sky_
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot配置拦截器、过滤器、监听器和Servlet
weixin_47251999的博客
04-23 1778
拦截器与过滤器区别 Filter：(实现 javax.servlet.Filter 接口) 属于Servlet 容器 请求到达 Servlet 之前就处理，可以修改request 只能作用web程序 过滤器使用场景： 过滤敏感词汇（防止sql注入） 设置字符编码 URL级别的权限访问控制 压缩响应信息 Interceptor：(实现 org.springframework.web.servlet.HandlerInterceptor 接口) 属于Spring容器，可以通过注入到IoC容器来管理 拦截.
Spring Boot中使用及配置Servlet
q1054261752的博客
08-20 762
注册自定义Servlet使用ServletRegistrationBean类，该类的主要作用是注。第二种是使用@WebServlet注解和@ServletComponentScan注解配置和使用自定义。在自定义配置类中通过@Bean注解注册自定义Servlet，设置访问URL。MVC中一样可以使用自定义Servlet。第一种是使用配置类的方式进行配置和使用Servlet。自定义Servlet类集成HttpSevlet抽象类。Boot项目和Spring。册自定义的servlet。
【javaWeb &第十篇】（SpringBoot ）yml配置文件
最新发布
weixin_62513677的博客
04-02 1246
yml 配置文件
Servlet & Spring Boot Web请求
weixin_53622554的博客
04-21 2329
一. 请求那我们所编写的XxxController 是如何处理请求的，又与Servlet之间有什么联系呢？通过该流程我们可以看出DispatcherServlet在Web请求当中是一个非常核心的一个类，所以这个类在Spring Boot当中我们称为核心控制器或者叫前端控制器。我们如何在Servlet程序当中来获取请求的参数呢？那Tomcat怎么就知道要给浏览器响应哪些数据呢？这就是Web应用程序整体的请求访问流程，对于我们来说，我们需要重点关注的就是我们所编写的Controller控制器程序。
Spring boot项目启动时no active profile set, falling back to default profiles: default
weixin_50741972的博客
08-24 1666
首先排除配置文件的问题，项目配置文件的确是按照Spring多profile文件形式编写的，包含application.yml和application-dev.yml，而且在application.yml中指定了profile为dev：spring.profiles.active=dev。查看pom， 发现打包类型用的是pom。删除这一行，再次运行，就不会报no active profile set，看来就是这个地方的问题了。
使用springmvc配置servlet
小老头叔叔的博客
11-14 4118
使用springmvc配置servlet 将springmvc引入系统 设置web.xml 在web.xml中 添加servlet的相关配置，进而引入springmvc springmvc提供了一个servlet，能够拦截所有的请求 servlet-mapping设置了servlet的检查路径，路径设置为"/" <?xml version="1.0" encoding="UTF-8"?> <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchem
（maven中的scope问题）SpringBoot启动报错： No active profile set, falling back to default profiles: default
Zebras_zhku的博客
01-07 1780
1.（maven中的scope问题）SpringBoot启动报错： No active profile set, falling back to default profiles: default 经验证，系 pom 文件配置的 tomcat 发生错误导致，原配置tomcat如下： <dependency> <groupId>org.springframework.boo...
深入讲解spring boot中servlet的启动过程与原理
08-27
Spring Boot 中 Servlet 的启动过程与原理 在本文中，我们将深入探讨 Spring Boot 中 Servlet 的启动过程与原理，帮助读者更好地理解 Spring Boot 的工作机制。 启动过程 在 Spring Boot 应用程序中，启动过程是...
SpringBoot配置嵌入式Servlet容器和使用外置Servlet容器的教程图解
08-18
SpringBoot配置嵌入式Servlet容器和使用外置Servlet容器的教程图解 本文主要介绍了SpringBoot配置嵌入式Servlet容器和使用外置Servlet容器的教程，通过图文并茂的形式给大家介绍的非常详细，对大家的学习或工作具有...
spring-boot-starter-netty:一个基于Netty实现的Spring Boot内置Servlet容器。a Spring Boot embedded servlet container project base on netty API (4.1.12.Final)
05-26
这是一个基于netty API（4.1.12.Final）的Spring Boot嵌入式servlet容器项目。 该项目已发布到Maven中心存储库中，请参阅 。 Maven依赖 将以下依赖项添加到您的Maven项目中： <!-- exludes embedded Tomcat --...
Spring Boot启动流程断点过程解析
08-25
Spring Boot启动流程断点过程解析 ...Spring Boot的启动流程断点过程是一个复杂的过程，涉及到多个组件和技术。只有当我们了解了这些技术和组件时，我们才能更好地使用Spring Boot来构建高效、可靠的应用程序。
Spring Boot 中的Servlet简单使用
08-30
在spring boot中添加自己的Servlet有两种方法，代码注册Servlet和注解自动注册（Filter和Listener也是如此）。这篇文章主要介绍了Spring Boot 中的Servlet简单使用,需要的朋友可以参考下
详解在spring boot中配置多个DispatcherServlet
08-31
好在 Spring Boot 提供了另外的方式配置 Servlet。 一、@WebServlet 注解 @WebServlet 注解是 JavaEE 的注解，是 Servlet 3.0 以后提供的。Spring Boot 会扫描这个注解，并将这个注解的类注册到 web 容器中作为一...
转：springboot servlet使用配置
PacosonSWJTU的博客
11-24 753
转自： springboot servlet使用配置_奔跑的蜗牛的博客-CSDN博客在spring boot中添加自己的Servlet有两种方法，代码注册Servlet和注解自动注册（Filter和Listener也是如此）。一、代码注册通过ServletRegistrationBean 获得控制。也可以通过实现 ServletContextInitializer 接口直接注册。package com.kerry.servlet;import java.ihttps://blog.csdn.net/l..
SpringBoot整合servlet两种方式
幽冥微波
07-04 605
目录结构 pom.xml文件 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://m...
【spring-boot】spring-boot-使用外置的Servlet容器学习
日拱一卒，不期速成！
03-30 1149
9、使用外置的Servlet容器 嵌入式Servlet容器：应用打成可执行的jar ​ 优点：简单、便携； ​ 缺点：默认不支持JSP、优化定制比较复杂（使用定制器【ServerProperties、自定义EmbeddedServletContainerCustomizer】，自己编写嵌入式Servlet容器的创建工厂【EmbeddedServletContainerFactory】）； ...
SpringBoot初始教程之Servlet、Filter、Listener配置(七)
热门推荐
veZunShao的专栏
11-10 5万+
SpringBoot初始教程之Servlet、Filter、Listener配置(七)1.介绍通过之前的文章来看，SpringBoot涵盖了很多配置，但是往往一些配置是采用原生的Servlet进行的，但是在SpringBoot中不需要配置web.xml的 因为有可能打包之后是一个jar包的形式，这种情况下如何解决？SpringBoot 提供了两种方案进行解决2.快速开始2.1 方案一方案一采用原生
springboot 配置 servlet 三大组件（Servlet、Filter、Listener）
贵在坚持
05-03 902
Servlet、Filter、Listener 是 JavaEE Web 服务规定的服务器动态组件，由开发者编写，由 Web 容器创建，并保证单例以及线程安全性，其中加载顺序为 Linstener —> Fliter —> Servlet 。
SpringBoot配置嵌入式Servlet容器
qq_33240556的博客
07-24 382
SpringBoot默认使用的是Tomcat作为嵌入式的Servlet容器，那么肯定会和外置的Tomcat有区别，那么就这些区别来谈一谈SpringBoot中对于容器的一些配置操作 如何定制和修改Servlet容器的相关配置 在内置的Tomcat中，不再有web.xml文件可以供我们修改，那么我们应该怎样去修改Servlet容器相关的配置呢？在SpringBoot中有两种方式可供选择，一种是在配置文件中修改，还有一种是通过配置类的方式去修改 配置文件中修改（具体修改的参数可以查看ServerProperti
spring boot内嵌servlet容器吗
06-03
在应用程序启动时，Spring Boot会自动将所选的Servlet容器嵌入到应用程序中，并为应用程序提供运行环境和资源。同时，Spring Boot还提供了一些方便的配置选项，可以通过配置文件或代码来调整Servlet容器的性能、安全...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值