springboot启动原理，基于2.1.6（1）--SpringApplication实例化

1.项目入口

//springboot项目入口
public static void main(String[] args) {
		SpringApplication.run(GoodsCenterApplication.class, args);
	}

2.run方法的操作流程将在下一节进行分析

public static ConfigurableApplicationContext run(Class<?> primarySource, String... args) {
		return run(new Class<?>[] { primarySource }, args);
	}

public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
                //new SpringApplicaiton对象，并调用run方法
		return new SpringApplication(primarySources).run(args);
	}

public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
		//资源加载器
                this.resourceLoader = resourceLoader;
		Assert.notNull(primarySources, "PrimarySources must not be null");
                //主资源Class，存储当前主类Class对象
		this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
                //web容器类型  REACTIVE、NONE、SERVLET
		this.webApplicationType = WebApplicationType.deduceFromClasspath();
                //设置ApplicationContextInitializer的对象集合  1.
		setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
                //设置ApplicationListener的对象集合 2.
		setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
                //启动类Class
		this.mainApplicationClass = deduceMainApplicationClass();
	}

3.实例化SpringApplicaiton对象主要流程

     1.设置resourceLoader（这里是null值）

      2.设置primarySource，这里是主类的Class

      3.设置webApplicationType，SERVLET：类路径下Servlet、ConfigurableWebApplicationContext

      4.设置ApplicationContextInitializer对象集合

      5.设值ApplicationListener对象集合

4.ApplicationContextInitializer、ApplicationListener对象集合实例过程，两个集合对象元素的实例化过程一模一样

setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));

private <T> Collection<T> getSpringFactoriesInstances(Class<T> type) {
		return getSpringFactoriesInstances(type, new Class<?>[] {});
	}


private <T> Collection<T> getSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, Object... args) {
		ClassLoader classLoader = getClassLoader();
		// Use names and ensure unique to protect against duplicates
                //加载type实现类的类名，使用Set来确保类名唯一
		Set<String> names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
                //实例化所有type的对象
		List<T> instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
                //排序AnnotationAwareOrderComparator继承自OrderComparator最终会根据                             //doCompare方法来判断，如果两个对象有一个实现了PriorityOrdered，则该对象排前面
//实现order，根据getOrder方法返回值排序
//如果都没有实现，根据Integer.MAX_VALUE来排
		AnnotationAwareOrderComparator.sort(instances);
		return instances;
	}

5.SpringFactoriesLoader.loadFactoryName根据Class加载实现类全路径限定名称集合

public static List<String> loadFactoryNames(Class<?> factoryClass, @Nullable ClassLoader classLoader) {
                //className
		String factoryClassName = factoryClass.getName();
                //获取factoryClassName 对应的所有类名
		return loadSpringFactories(classLoader).getOrDefault(factoryClassName, Collections.emptyList());
	}

//加载所有类路径下META-INF/spring.factories文件，并缓存到cache属性
//private static final Map<ClassLoader, MultiValueMap<String, String>> cache = new //ConcurrentReferenceHashMap<>();
//返回MultiValueMap<String, String>
private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
		MultiValueMap<String, String> result = cache.get(classLoader);
		if (result != null) {
			return result;
		}

		try {
			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();
				UrlResource resource = new UrlResource(url);
				Properties properties = PropertiesLoaderUtils.loadProperties(resource);
				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);
		}
	}

加载META-INF/spring.factories方法，最终结果集如下

6.createSpringFactoriesInstances，实例化集合对象方法

//可以看到是使用反射获取类的构造器，然后根据构造器来实例化对象
//ClassUtils是spring封装的Class工具类，其中使用了map作为缓存，缓存了一些数据类型的Class对象，比如基本类型、包装类型、Throwable、Serializable、Comparable、基本类型的数组类型等
//BeanUtils是spring封装的Bean工具类，包含了一些对反射方法的封装
private <T> List<T> createSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes,
			ClassLoader classLoader, Object[] args, Set<String> names) {
		List<T> instances = new ArrayList<>(names.size());
		for (String name : names) {
			try {
				Class<?> instanceClass = ClassUtils.forName(name, classLoader);
				Assert.isAssignable(type, instanceClass);
				Constructor<?> constructor = instanceClass.getDeclaredConstructor(parameterTypes);
				T instance = (T) BeanUtils.instantiateClass(constructor, args);
				instances.add(instance);
			}
			catch (Throwable ex) {
				throw new IllegalArgumentException("Cannot instantiate " + type + " : " + name, ex);
			}
		}
		return instances;
	}

7.至此，SpringApplication对象创建完毕。

其中，initializers有如下对象

00 = {DelegatingApplicationContextInitializer@2094}
1 = {SharedMetadataReaderFactoryContextInitializer@2095}
2 = {ContextIdApplicationContextInitializer@2096}
3 = {ConfigurationWarningsApplicationContextInitializer@2097}
4 = {ServerPortInfoApplicationContextInitializer@2098}
5 = {ConditionEvaluationReportLoggingListener@2099}

listeners有如下对象

0 = {BootstrapApplicationListener@2102}
1 = {LoggingSystemShutdownListener@2103}
2 = {ConfigFileApplicationListener@2104}
3 = {AnsiOutputApplicationListener@2105}
4 = {LoggingApplicationListener@2106}
5 = {ClasspathLoggingApplicationListener@2107}
6 = {BackgroundPreinitializer@2108}
7 = {DelegatingApplicationListener@2109}
8 = {RestartListener@2110}
9 = {ParentContextCloserApplicationListener@2111}
10 = {ClearCachesApplicationListener@2112}
11 = {FileEncodingApplicationListener@2113}
12 = {LiquibaseServiceLocatorApplicationListener@2114}

总结：可以自己实现ApplicationContextInitializer、ApplicationListener，并加入到META-INF/spring.factories，实现容器的初始化调用逻辑、以及监听容器事件，ClassUtils、BeanUtils spring封装的工具类，也可以拿来使用。