SpringApplication.run(xxx.class, args)背后的东东——实现原理

现在springboot已经成为web应用开发的事实标准，所以为了能更好的应用springboot特性，有必要深入研究下背后的实现原理。

在分析之前，先抛出几个问题，后续章节也是围绕解决这几个问题展开：

1、springboot是如何依赖几个注解就零配置启动spring容器?

2、springboot开发出来的jar，如何实现内嵌tomcat？

3、springboot开发经常用到的springmvc中的dispathservlet是如何关联到内嵌tomcat?

首先咱们直接从main方法上的  @SpringBootApplication 组合注解开始，里面实现零配置的注解就是  @EnableAutoConfiguration ，它利用 @Import 一个 AutoConfigurationImportSelector，该类主要利用类SPI的机制，获取META-INFO下面需要自动装配的 @Configuration，至于SPI后续将详细介绍。

说到这里，估计大家会有一个疑问，springboot如何一开始就知道这个重要 @Import  注解呢，肯定有个注解解析的地方，下面需要说的就是spring容器的启动（跟着main方法走）：

context = this.createApplicationContext()

　　这里是创建重要的ApplicationContext，其实就是BeanFactory，不过springboot会自动推断创建针对servlet应用的 AnnotationConfigServletWebServerApplicationContext。

org.springframework.context.support.AbstractApplicationContext#refresh

　　熟悉spring源码的同学就会知道，这里就是刷新容器的地方，

org.springframework.context.support.AbstractApplicationContext#invokeBeanFactoryPostProcessors

org.springframework.context.annotation.ConfigurationClassParser#processImports

这个方法里面就有对 @Import 注解做解析

　　解析逻辑比较复杂，有兴趣可以自己看下，说白了就是开头讲的找到需要自动装配的 @Configuration 对应的类，这里列出来三个重要的如下：

@Configuration(proxyBeanMethods = false)
@ConditionalOnWebApplication(type = Type.SERVLET)
@ConditionalOnClass({ Servlet.class, DispatcherServlet.class, WebMvcConfigurer.class })
@ConditionalOnMissingBean(WebMvcConfigurationSupport.class)
@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE + 10)
@AutoConfigureAfter({ DispatcherServletAutoConfiguration.class, TaskExecutionAutoConfiguration.class,
		ValidationAutoConfiguration.class })
public class WebMvcAutoConfiguration {

　　

@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
@Configuration(proxyBeanMethods = false)
@ConditionalOnWebApplication(type = Type.SERVLET)
@ConditionalOnClass(DispatcherServlet.class)
@AutoConfigureAfter(ServletWebServerFactoryAutoConfiguration.class)
public class DispatcherServletAutoConfiguration {

　　

@Configuration(proxyBeanMethods = false)
@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 {

　　其实这三个都是通过 @AutoConfigureAfter 依赖关系加载的，加载这些的目的就是为了getBean时可以拿到具体的实例对象。

咱们再回到刷新spring器中的方法中

org.springframework.context.support.AbstractApplicationContext#onRefresh

　　该方法对应servlet的实现是

org.springframework.boot.web.servlet.context.ServletWebServerApplicationContext#onRefresh

　　里面就是创建WebServer，可以理解为就是咱们的tomcat，不过它是由工厂方法创建的

protected ServletWebServerFactory getWebServerFactory() {
        String[] beanNames = this.getBeanFactory().getBeanNamesForType(ServletWebServerFactory.class);

　　核心代码来了，这里就会触发getBean，去拿到 ServletWebServerFactory的实例，也就会触发Bean的生命周期调用，

@Configuration(proxyBeanMethods = false)
class ServletWebServerFactoryConfiguration {

	@Configuration(proxyBeanMethods = false)
	@ConditionalOnClass({ Servlet.class, Tomcat.class, UpgradeProtocol.class })
	@ConditionalOnMissingBean(value = ServletWebServerFactory.class, search = SearchStrategy.CURRENT)
	static class EmbeddedTomcat {

		@Bean
		TomcatServletWebServerFactory tomcatServletWebServerFactory(
				ObjectProvider<TomcatConnectorCustomizer> connectorCustomizers,
				ObjectProvider<TomcatContextCustomizer> contextCustomizers,
				ObjectProvider<TomcatProtocolHandlerCustomizer<?>> protocolHandlerCustomizers) {
			TomcatServletWebServerFactory factory = new TomcatServletWebServerFactory();
			factory.getTomcatConnectorCustomizers()
					.addAll(connectorCustomizers.orderedStream().collect(Collectors.toList()));
			factory.getTomcatContextCustomizers()
					.addAll(contextCustomizers.orderedStream().collect(Collectors.toList()));
			factory.getTomcatProtocolHandlerCustomizers()
					.addAll(protocolHandlerCustomizers.orderedStream().collect(Collectors.toList()));
			return factory;
		}

	}

　　其实就是到这里来获取 TomcatServletWebServerFactory 实例，这个也就是前面自动配置 @Import扫描出来的 ServletWebServerFactoryAutoConfiguration 导入的beandefinition

这个工厂实现了 ErrorPageRegistry 接口

org.springframework.boot.web.server.ErrorPageRegistry

　　而ServletWebServerFactory在getBean的生命周期中会触发BeanPostProcessor实现类的调用

public class ErrorPageRegistrarBeanPostProcessor implements BeanPostProcessor, BeanFactoryAware {

	private ListableBeanFactory beanFactory;

	private List<ErrorPageRegistrar> registrars;

	@Override
	public void setBeanFactory(BeanFactory beanFactory) {
		Assert.isInstanceOf(ListableBeanFactory.class, beanFactory,
				"ErrorPageRegistrarBeanPostProcessor can only be used with a ListableBeanFactory");
		this.beanFactory = (ListableBeanFactory) beanFactory;
	}

	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		if (bean instanceof ErrorPageRegistry) {
			postProcessBeforeInitialization((ErrorPageRegistry) bean);
		}
		return bean;
	}

　　也就是实例化 TomcatServletWebServerFactory 之前，会去先实例化 ErrorPageRegistrar

	private Collection<ErrorPageRegistrar> getRegistrars() {
		if (this.registrars == null) {
			// Look up does not include the parent context
			this.registrars = new ArrayList<>(
					this.beanFactory.getBeansOfType(ErrorPageRegistrar.class, false, false).values());
			this.registrars.sort(AnnotationAwareOrderComparator.INSTANCE);
			this.registrars = Collections.unmodifiableList(this.registrars);
		}
		return this.registrars;
	}

　　跟着代码，实例化 ErrorPageRegistrar 又会先去实例化  DispatcherServletPath，它只有一个实现类 DispatcherServletRegistrationBean

protected ErrorPageCustomizer(ServerProperties properties, DispatcherServletPath dispatcherServletPath) {
			this.properties = properties;
			this.dispatcherServletPath = dispatcherServletPath;
		}

　　

public DispatcherServletRegistrationBean(DispatcherServlet servlet, String path) {
		super(servlet);
		Assert.notNull(path, "Path must not be null");
		this.path = path;
		super.addUrlMappings(getServletUrlMapping());
	}

　　这里就看到熟悉的 DispatcherServlet了，有人可能会问，DispatcherServlet哪里来的？其实又要回到前面扫描处理的三个自动装配类中的 DispatcherServletAutoConfiguration

至此，我们终于通过spring容器的启动，将DispatcherServlet实例化出来了，同理负责创建tomcat容器的TomcatServletWebServerFactory也实例化出来了。

下面就是负责创建内嵌tomcat了，以及建立tomcat与DispatcherServlet实例的关联

org.springframework.boot.web.embedded.tomcat.TomcatServletWebServerFactory#getWebServer

　　

tomcat容器启动后，因为它实现了servlet规范，内部会回调实现了所有实现了ServletContainerInitializer类的onStartup方法

javax.servlet.ServletContainerInitializer#onStartup

　　具体代码需要关联tomcat源码，这里只是简单记录下，后续再深入分析tomcat实现原理

org.apache.catalina.core.StandardContext#startInternal

while(var27.hasNext()) {
                Entry entry = (Entry)var27.next();

                try {
                    ((ServletContainerInitializer)entry.getKey()).onStartup((Set)entry.getValue(), this.getServletContext());
                } catch (ServletException var22) {
                    log.error(sm.getString("standardContext.sciFail"), var22);
                    ok = false;
                    break;
                }
            }

      而TomcatStarter正好实现了ServletContainerInitializer接口，所以tomcat启动会触发这个方法的调用　　

org.springframework.boot.web.embedded.tomcat.TomcatStarter#onStartup

　　方法内部调用了spring中实现了ServletContextInitializer接口的类的onStartup方法，恰好又是DispatcherServletRegistrationBean，而它的父类RegistrationBean就将DispatcherServlet绑定到tomcat容器的ServletContext上了

org.springframework.boot.autoconfigure.web.servlet.DispatcherServletRegistrationBean

org.springframework.boot.web.servlet.RegistrationBean#onStartup

　　

最后，tomcat容器启动了，spring容器也启动了，访问tomcat的请求也可以通过关联的DispatcherServlet进行分发处理了，咱们前面的三个问题也应该有答案了。