@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);
				//讀取對應文件內(nèi)容，作為一個properties對象
				Properties properties = PropertiesLoaderUtils.loadProperties(resource);
				//解析文件內(nèi)容，并將之放入一個LinkedMultiValueMap中，key就是spring.factories中等號前面的部分，值是后面部分根據(jù)都好組成的list。并放入緩存?zhèn)溆?，緩存的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<>();
		//告訴程序當前為無頭模式，沒有外設，如果需要調(diào)用外設接口需要你自己模擬，這些內(nèi)容再awt包中做了，所以你只要告訴它有沒有外設就可以了
		configureHeadlessProperty();
		//繼續(xù)從spring.factories中獲取對應的對象，此時listeners中有一個默認實現(xiàn)EventPublishingRunListener，如有需要這里是可進行擴展
		SpringApplicationRunListeners listeners = getRunListeners(args);
		//遍歷所有的listeners并調(diào)用它的starting方法，廣播啟動過程中的事件，注意這里是個廣播器不是監(jiān)聽器，名字有點不好理解，實現(xiàn)了
		//ApplicationListener的接口就接收到對應事件之后執(zhí)行對應操作，而我們前面也有設置了個listeners集合，為ApplicationListener
		//此處名字起的讓人容易誤解，明明是個廣播器非要叫RunListener
		listeners.starting();
		try {
			//進行控制臺參數(shù)解析，具體如何解析，此處不展開，后續(xù)對配置文件解析的文章在詳細介紹
			ApplicationArguments applicationArguments = new DefaultApplicationArguments(
					args);
			ConfigurableEnvironment environment = prepareEnvironment(listeners,
					applicationArguments);
			//此處配置個內(nèi)省beanInfo時是否緩存的開關，true就緩存，false，就不緩存		
			configureIgnoreBeanInfo(environment);
			//打印banner，這個不介紹了比較簡單的東西
			Banner printedBanner = printBanner(environment);
			//此處開始創(chuàng)建容器，根據(jù)給定的容器類型也就是上面獲取到的webApplicationType創(chuàng)建對應的容器
			//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();
			//異常解析器，如果出現(xiàn)異常了，會在被catch起來，然后通過解析器鏈進行解析。這個也是從spring.factories中獲取的
			exceptionReporters = getSpringFactoriesInstances(
					SpringBootExceptionReporter.class,
					new Class[] { ConfigurableApplicationContext.class }, context);
			//上面創(chuàng)建了容器，這邊對容器做一些初始化操作
			//1、設置環(huán)境變量env
			//2、執(zhí)行postProcessApplicationContext 準備beanNameGenerator,resourceLoader,ApplicationConversionService
			//3、調(diào)用前面獲取到的ApplicationContextInitializer
			//4、廣播容器準備完成事件
			//5、添加了一個制定的單例就是banner打印用的
			//6、在加載前，設置是否允許bean被覆蓋屬性，默認false
			//7、開始加載，入口為main函數(shù)傳入的primarySources，先創(chuàng)建個BeanDefinitionLoader，并將第二步準備的實例設置給他，
			//最后由BeanDefinitionLoader.load()承當所有的加載動作,加載過程也很長，先按下不表。
			//8、廣播容器加載事件
			//到此容器準備完成		
			prepareContext(context, environment, listeners, applicationArguments,
					printedBanner);
			//開始執(zhí)行spring的refresh方法,此處不多介紹了
			refreshContext(context);
			//容器refresh完成后留了個擴展，也不知道是不是擴展，這個方法需要去自定義啟動類，有點奇怪
			afterRefresh(context, applicationArguments);
			stopWatch.stop();
			if (this.logStartupInfo) {
				new StartupInfoLogger(this.mainApplicationClass)
						.logStarted(getApplicationLog(), stopWatch);
			}
			//然后廣播啟動完成事件
			listeners.started(context);
			//最后執(zhí)行所有的runners，也就是實現(xiàn)了ApplicationRunner接口的類是最后執(zhí)行，所以此時你可以做一些其它的動作，比如注冊到注冊中心，比如啟動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 {