Springboot启动流程详细分析

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

public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
		this.resourceLoader = resourceLoader;
		Assert.notNull(primarySources, "PrimarySources must not be null");
		this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
		//此处推断web容器类型是servlet 还是REACTIVE还是啥也不是即当前非web容器
		this.webApplicationType = WebApplicationType.deduceFromClasspath();
		//此处进入springFacories的加载 即SpringFactoriesLoader,不过此处是过滤处所有ApplicationContextInitializer的子类
		setInitializers((Collection) getSpringFactoriesInstances(
				ApplicationContextInitializer.class));
		//从springFactories的缓存中再过滤处	ApplicationListener 的子类	
		setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
		this.mainApplicationClass = deduceMainApplicationClass();
	}

private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
		MultiValueMap<String, String> result = cache.get(classLoader);
		if (result != null) {
			return result;
		}
		try {
			//classLoader 上一步传进来的为AppClassLoader,如果对classLoader不了解需要去看看java的类加载机制，以及双亲委托机制，此处的资源加载也是个双亲委托机制。
			//此处如果appclassLoader不为null，那么遍历遍历这个classLoader所加载的包，中是否存在META-INF/spring.factories这个文件
			//如果存在最终生成一个集合，然后遍历集合
			Enumeration<URL> urls = (classLoader != null ?
					classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :
					ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
			result = new LinkedMultiValueMap<>();
			while (urls.hasMoreElements()) {
				URL url = urls.nextElement();
				//从集合中取出一个spring.factories文件
				UrlResource resource = new UrlResource(url);
				//读取对应文件内容，作为一个properties对象
				Properties properties = PropertiesLoaderUtils.loadProperties(resource);
				//解析文件内容，并将之放入一个LinkedMultiValueMap中，key就是spring.factories中等号前面的部分，值是后面部分根据都好组成的list。并放入缓存备用，缓存的key为对应的classLoader
				for (Map.Entry<?, ?> entry : properties.entrySet()) {
					String factoryClassName = ((String) entry.getKey()).trim();
					for (String factoryName : StringUtils.commaDelimitedListToStringArray((String) entry.getValue())) {
						result.add(factoryClassName, factoryName.trim());
					}
				}
			}
			cache.put(classLoader, result);
			return result;
		}
		catch (IOException ex) {
			throw new IllegalArgumentException("Unable to load factories from location [" +
					FACTORIES_RESOURCE_LOCATION + "]", ex);
		}
	}

result = new LinkedMultiValueMap<>();
list=new LinkList();
list.add("com.baomidou.mybatisplus.autoconfigure.MybatisPlusAutoConfiguration");
list.add("org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration")
result.put("org.springframework.boot.autoconfigure.EnableAutoConfiguration",list);

public static List<String> loadFactoryNames(Class<?> factoryClass, @Nullable ClassLoader classLoader) {
		String factoryClassName = factoryClass.getName();
		return loadSpringFactories(classLoader).getOrDefault(factoryClassName, Collections.emptyList());
	}

private Class<?> deduceMainApplicationClass() {
		try {
			StackTraceElement[] stackTrace = new RuntimeException().getStackTrace();
			for (StackTraceElement stackTraceElement : stackTrace) {
				if ("main".equals(stackTraceElement.getMethodName())) {
					return Class.forName(stackTraceElement.getClassName());
				}
			}
		}
		catch (ClassNotFoundException ex) {
			// Swallow and continue
		}
		return null;
	}

public ConfigurableApplicationContext run(String... args) {
		//计时器，不管它
		StopWatch stopWatch = new StopWatch();
		stopWatch.start();
		ConfigurableApplicationContext context = null;
		Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
		//告诉程序当前为无头模式，没有外设，如果需要调用外设接口需要你自己模拟，这些内容再awt包中做了，所以你只要告诉它有没有外设就可以了
		configureHeadlessProperty();
		//继续从spring.factories中获取对应的对象，此时listeners中有一个默认实现EventPublishingRunListener，如有需要这里是可进行扩展
		SpringApplicationRunListeners listeners = getRunListeners(args);
		//遍历所有的listeners并调用它的starting方法，广播启动过程中的事件，注意这里是个广播器不是监听器，名字有点不好理解，实现了
		//ApplicationListener的接口就接收到对应事件之后执行对应操作，而我们前面也有设置了个listeners集合，为ApplicationListener
		//此处名字起的让人容易误解，明明是个广播器非要叫RunListener
		listeners.starting();
		try {
			//进行控制台参数解析，具体如何解析，此处不展开，后续对配置文件解析的文章在详细介绍
			ApplicationArguments applicationArguments = new DefaultApplicationArguments(
					args);
			ConfigurableEnvironment environment = prepareEnvironment(listeners,
					applicationArguments);
			//此处配置个内省beanInfo时是否缓存的开关，true就缓存，false，就不缓存		
			configureIgnoreBeanInfo(environment);
			//打印banner，这个不介绍了比较简单的东西
			Banner printedBanner = printBanner(environment);
			//此处开始创建容器，根据给定的容器类型也就是上面获取到的webApplicationType创建对应的容器
			//servlet ：org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext
			//reactive：org.springframework.boot.web.reactive.context.AnnotationConfigReactiveWebServerApplicationContext
			//default:  org.springframework.context.annotation.AnnotationConfigApplicationContext 非web容器
			context = createApplicationContext();
			//异常解析器，如果出现异常了，会在被catch起来，然后通过解析器链进行解析。这个也是从spring.factories中获取的
			exceptionReporters = getSpringFactoriesInstances(
					SpringBootExceptionReporter.class,
					new Class[] { ConfigurableApplicationContext.class }, context);
			//上面创建了容器，这边对容器做一些初始化操作
			//1、设置环境变量env
			//2、执行postProcessApplicationContext 准备beanNameGenerator,resourceLoader,ApplicationConversionService
			//3、调用前面获取到的ApplicationContextInitializer
			//4、广播容器准备完成事件
			//5、添加了一个制定的单例就是banner打印用的
			//6、在加载前，设置是否允许bean被覆盖属性，默认false
			//7、开始加载，入口为main函数传入的primarySources，先创建个BeanDefinitionLoader，并将第二步准备的实例设置给他，
			//最后由BeanDefinitionLoader.load()承当所有的加载动作,加载过程也很长，先按下不表。
			//8、广播容器加载事件
			//到此容器准备完成		
			prepareContext(context, environment, listeners, applicationArguments,
					printedBanner);
			//开始执行spring的refresh方法,此处不多介绍了
			refreshContext(context);
			//容器refresh完成后留了个扩展，也不知道是不是扩展，这个方法需要去自定义启动类，有点奇怪
			afterRefresh(context, applicationArguments);
			stopWatch.stop();
			if (this.logStartupInfo) {
				new StartupInfoLogger(this.mainApplicationClass)
						.logStarted(getApplicationLog(), stopWatch);
			}
			//然后广播启动完成事件
			listeners.started(context);
			//最后执行所有的runners，也就是实现了ApplicationRunner接口的类是最后执行，所以此时你可以做一些其它的动作，比如注册到注册中心，比如启动netty等等。
			callRunners(context, applicationArguments);
		}
		catch (Throwable ex) {
			handleRunFailure(context, ex, exceptionReporters, listeners);
			throw new IllegalStateException(ex);
		}
		//在广播一个运行中的事件
		try {
			listeners.running(context);
		}
		catch (Throwable ex) {
			handleRunFailure(context, ex, exceptionReporters, null);
			throw new IllegalStateException(ex);
		}
		return context;
	}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = {
		@Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
		@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })

  @Target(ElementType.TYPE)
  @Retention(RetentionPolicy.RUNTIME)
  @Documented
  @Inherited
  @AutoConfigurationPackage
  @Import(AutoConfigurationImportSelector.class)
  public @interface EnableAutoConfiguration {