SpringBoot 2.1.6 启动原理解析(一)

小白第一次写博客，如果有不足之处烦请各位大佬指正。

用了好久的SpringBoot了，一直不清楚它内部的一些启动原理，如何加载yml文件、如何初始化bean的，今天就记录一下，新建了一个springboot2.1.6的项目，就从一开始启动类中的SpringApplication.run方法开始，这一部分先看看SpringApplication的构造方法

项目名称: DemoAppication

SpringApploication.run

进入SpringApplication.run(DemoApplication.class, args);之后，是一个静态run方法的重载方法,后面如果方法中也是一个重载方法的话就不贴代码了。

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

进入这个重载的run方法以后，它创建一个SpringApplication的对象并调用了run方法返回

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

先看一下这个SpringApplication的构造方法里干了哪些事情

SpringApplication构造方法

进入SpringApplication之后也是一个构造方法的重载，进入这个重载方法之后是SpringApplication私有变量的一些赋值

	public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
		//resourceLoader -> null
		this.resourceLoader = resourceLoader;
		Assert.notNull(primarySources, "PrimarySources must not be null");
		//primarySources -> DemoApplication，封装成LinkedHashSet
		this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
		this.webApplicationType = WebApplicationType.deduceFromClasspath();
		setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
		setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
		// mainApplicationClass -> DemoApplication
		this.mainApplicationClass = deduceMainApplicationClass();
	}

• webApplicationType有三种类型，分别是NONE(嵌入式)、SERVLET(基于servlet)、REACTIVE(反应式)，根据SpringBoot下的一个工具类ClassUtil判断指定的类是否存在然后确定属于哪种类型，内部调用了Class.forName，如果规定的类不存在的话会报ClassNotFoundException，内部还有一些加载别的类的缓存什么的，不做深入探讨，我这里主要看SERVLET，对其他两种不做深入研究。
• setInitializers 设置初始化器(ApplicationContextInitializer.class )
• setListenerss 设置监听器(ApplicationListener.class)
• getSpringFactoriesInstances(Class clazz) 获取指定类型对象的列表，这里的指定类型指的是初始化器 ApplicationContextInitializer 和监听器 ApplicationListener，先看一下这个方法，比较重要

getSpringFactoriesInstances

进入这个方法之后也先是一个重载的方法，然后进入这个重载的方法，方法中主要有四步

	private <T> Collection<T> getSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, Object... args) {
		//一、获取类加载器
		ClassLoader classLoader = getClassLoader();
		//二、根据传入的类型获取名称列表
		Set<String> names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
		//三、根据名称列表创建对象
		List<T> instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
		//四、给这些对象排个序
		AnnotationAwareOrderComparator.sort(instances);
		return instances;
	}

下面分别介绍这四个方法

① getClassLoader

getClassLoader 先通过资源加载器 resourceLoader 获取类加载器，resourceLoader在SpringApplication构造方法中设置为 null，则通过ClassUtils.getDefaultClassLoader获取

	public ClassLoader getClassLoader() {
		if (this.resourceLoader != null) {
			return this.resourceLoader.getClassLoader();
		}
		return ClassUtils.getDefaultClassLoader();
	}

ClassUtils中先是获取当前线程的类加载器，如果为null的话就获取加载ClassUtils(也就是本类)的类加载器，如果为null则获取系统的类加载器，然后返回

public static ClassLoader getDefaultClassLoader() {
		ClassLoader cl = null;
		try {
			//当前线程的类加载器
			cl = Thread.currentThread().getContextClassLoader();
		}
		catch (Throwable ex) {
			// Cannot access thread context ClassLoader - falling back...
		}
		if (cl == null) {
			// No thread context class loader -> use class loader of this class.
			cl = ClassUtils.class.getClassLoader();
			if (cl == null) {
				// getClassLoader() returning null indicates the bootstrap ClassLoader
				try {
					cl = ClassLoader.getSystemClassLoader();
				}
				catch (Throwable ex) {
					// Cannot access system ClassLoader - oh well, maybe the caller can live with null...
				}
			}
		}
		return cl;
	}

② SpringFactoriesLoader.loadFactoryNames

获取指定类型的名称列表，重载的loadSpringFactories会返回一个Map，然后用指定类型的名称从这个Map中获取对象名称列表。

	public static List<String> loadFactoryNames(Class<?> factoryClass, @Nullable ClassLoader classLoader) {
		//获取指定类型的名称
		String factoryClassName = factoryClass.getName();
		return loadSpringFactories(classLoader).getOrDefault(factoryClassName, Collections.emptyList());
	}

loadSpringFactories中先从缓存中查询，有的话直接返回，没有的话就去遍历 FACTORIES_RESOURCE_LOCATION 路径下的spring.factories文件，将资源文件中的key/value添加到result中，然后将result添加到缓存中。至于result的泛型为什么是<String, String>类型而不是<String, List< String >>类型，俺也不知道，有知道的大佬吗

	private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
		MultiValueMap<String, String> result = cache.get(classLoader);
		if (result != null) {
			return result;
		}

		try {
			//FACTORIES_RESOURCE_LOCATION = "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();
				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);
		}
	}

cache类型

private static final Map<ClassLoader, MultiValueMap<String, String>> cache = new ConcurrentReferenceHashMap<>();

• MultiValueMap与通常map区别为一个key可以对应多个value
• ConcurrentReferenceHashMap与ConcurrentHashMap区别为可以指定存放对象的引用级别，默认为软引用。

spring.factories文件在你添加的.jar包中会有，比如mybatis、redis等包





也有SpringBoot默认添加的包，初始化器和监听器是在.m2\repository\org\springframework\boot\spring-boot\2.1.6.RELEASE\spring-boot-2.1.6.RELEASE.jar!\META-INF\spring.factories这个factories下

# PropertySource Loaders
org.springframework.boot.env.PropertySourceLoader=\
org.springframework.boot.env.PropertiesPropertySourceLoader,\
org.springframework.boot.env.YamlPropertySourceLoader

# Run Listeners
org.springframework.boot.SpringApplicationRunListener=\
org.springframework.boot.context.event.EventPublishingRunListener

# Error Reporters
org.springframework.boot.SpringBootExceptionReporter=\
org.springframework.boot.diagnostics.FailureAnalyzers

# Application Context Initializers
org.springframework.context.ApplicationContextInitializer=\
org.springframework.boot.context.ConfigurationWarningsApplicationContextInitializer,\
org.springframework.boot.context.ContextIdApplicationContextInitializer,\
org.springframework.boot.context.config.DelegatingApplicationContextInitializer,\
org.springframework.boot.web.context.ServerPortInfoApplicationContextInitializer

# Application Listeners
org.springframework.context.ApplicationListener=\
org.springframework.boot.ClearCachesApplicationListener,\
org.springframework.boot.builder.ParentContextCloserApplicationListener,\
org.springframework.boot.context.FileEncodingApplicationListener,\
org.springframework.boot.context.config.AnsiOutputApplicationListener,\
org.springframework.boot.context.config.ConfigFileApplicationListener,\
org.springframework.boot.context.config.DelegatingApplicationListener,\
org.springframework.boot.context.logging.ClasspathLoggingApplicationListener,\
org.springframework.boot.context.logging.LoggingApplicationListener,\
org.springframework.boot.liquibase.LiquibaseServiceLocatorApplicationListener

# Environment Post Processors
org.springframework.boot.env.EnvironmentPostProcessor=\
org.springframework.boot.cloud.CloudFoundryVcapEnvironmentPostProcessor,\
org.springframework.boot.env.SpringApplicationJsonEnvironmentPostProcessor,\
org.springframework.boot.env.SystemEnvironmentPropertySourceEnvironmentPostProcessor

# Failure Analyzers
org.springframework.boot.diagnostics.FailureAnalyzer=\
org.springframework.boot.diagnostics.analyzer.BeanCurrentlyInCreationFailureAnalyzer,\
org.springframework.boot.diagnostics.analyzer.BeanDefinitionOverrideFailureAnalyzer,\
org.springframework.boot.diagnostics.analyzer.BeanNotOfRequiredTypeFailureAnalyzer,\
org.springframework.boot.diagnostics.analyzer.BindFailureAnalyzer,\
org.springframework.boot.diagnostics.analyzer.BindValidationFailureAnalyzer,\
org.springframework.boot.diagnostics.analyzer.UnboundConfigurationPropertyFailureAnalyzer,\
org.springframework.boot.diagnostics.analyzer.ConnectorStartFailureAnalyzer,\
org.springframework.boot.diagnostics.analyzer.NoSuchMethodFailureAnalyzer,\
org.springframework.boot.diagnostics.analyzer.NoUniqueBeanDefinitionFailureAnalyzer,\
org.springframework.boot.diagnostics.analyzer.PortInUseFailureAnalyzer,\
org.springframework.boot.diagnostics.analyzer.ValidationExceptionFailureAnalyzer,\
org.springframework.boot.diagnostics.analyzer.InvalidConfigurationPropertyNameFailureAnalyzer,\
org.springframework.boot.diagnostics.analyzer.InvalidConfigurationPropertyValueFailureAnalyzer

# FailureAnalysisReporters
org.springframework.boot.diagnostics.FailureAnalysisReporter=\
org.springframework.boot.diagnostics.LoggingFailureAnalysisReporter

③ createSpringFactoriesInstances

遍历获得的名称列表并通过反射构建对象，并返回对象列表

	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;
	}

BeanUtils.instantiateClass主要是调用setAccessible设置成true，然后newInstance，Kotlin方面没了解过，看源码也是加载classpath下的类，就当不存在就好了，全当成false来看

	public static <T> T instantiateClass(Constructor<T> ctor, Object... args) throws BeanInstantiationException {
		Assert.notNull(ctor, "Constructor must not be null");
		try {
			ReflectionUtils.makeAccessible(ctor);
			return (KotlinDetector.isKotlinReflectPresent() && KotlinDetector.isKotlinType(ctor.getDeclaringClass()) ?
					KotlinDelegate.instantiateClass(ctor, args) : ctor.newInstance(args));
		}
		//...省略catch代码....
	}

④ AnnotationAwareOrderComparator.sort

	public static void sort(List<?> list) {
		if (list.size() > 1) {
			//INSTANCE = new AnnotationAwareOrderComparator();
			list.sort(INSTANCE);
		}
	}

将加载的对象排个序，内部直接使用List的排序，那我们就来看看这个Comparator中的compare是怎么写的吧，在AnnotationAwareOrderComparator找了一圈也没找到compare，那么就看看父类OrderComparator中的comparator，sourceProvider为 null

	@Override
	public int compare(@Nullable Object o1, @Nullable Object o2) {
		return doCompare(o1, o2, null);
	}

	private int doCompare(@Nullable Object o1, @Nullable Object o2, @Nullable OrderSourceProvider sourceProvider) {
		boolean p1 = (o1 instanceof PriorityOrdered);
		boolean p2 = (o2 instanceof PriorityOrdered);
		if (p1 && !p2) {
			return -1;
		}
		else if (p2 && !p1) {
			return 1;
		}

		int i1 = getOrder(o1, sourceProvider);
		int i2 = getOrder(o2, sourceProvider);
		return Integer.compare(i1, i2);
	}

进入getOrder方法之后再进入重载的方法，通过findOrder方法返回order，findOrder方法返回null则直接返回 Integer.MAX_VALUE

	private int getOrder(@Nullable Object obj, @Nullable OrderSourceProvider sourceProvider) {
		Integer order = null;
		if (obj != null && sourceProvider != null) {
			//...省略代码...
		}
		return (order != null ? order : getOrder(obj));
	}

	protected int getOrder(@Nullable Object obj) {
		if (obj != null) {
			Integer order = findOrder(obj);
			if (order != null) {
				return order;
			}
		}
		//int LOWEST_PRECEDENCE = Integer.MAX_VALUE;
		return Ordered.LOWEST_PRECEDENCE;
	}

findOrder方法在AnnotationAwareOrderComparator重写，如果obj实现了Order接口则直接返回实现的order，否则就从@Order或@Priority注解上获取order，都没有的话返回null，具体的实现不在本文中细讲

protected Integer findOrder(Object obj) {
		// 如果obj实现了Order接口则直接返回order
		Integer order = super.findOrder(obj);
		if (order != null) {
			return order;
		}
		/*
		protected Integer findOrder(Object obj) {
			return (obj instanceof Ordered ? ((Ordered) obj).getOrder() : null);
		}
		*/

		// 在类上、方法上、注解上检查是否带有 @Order 或 @Priority 来判断order的值
		if (obj instanceof Class) {
			return OrderUtils.getOrder((Class<?>) obj);
		}
		else if (obj instanceof Method) {
			Order ann = AnnotationUtils.findAnnotation((Method) obj, Order.class);
			if (ann != null) {
				return ann.value();
			}
		}
		else if (obj instanceof AnnotatedElement) {
			Order ann = AnnotationUtils.getAnnotation((AnnotatedElement) obj, Order.class);
			if (ann != null) {
				return ann.value();
			}
		}
		else {
			order = OrderUtils.getOrder(obj.getClass());
			if (order == null && obj instanceof DecoratingProxy) {
				order = OrderUtils.getOrder(((DecoratingProxy) obj).getDecoratedClass());
			}
		}

		return order;
	}

再回到一开始的SpringApplication构造方法上来，setInitializers 和 setListeners就是给 SpringApplication中的变量赋值而已，没什么好说的

	public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
		//resourceLoader -> null
		this.resourceLoader = resourceLoader;
		Assert.notNull(primarySources, "PrimarySources must not be null");
		//primarySources -> DemoApplication，封装成LinkedHashSet
		this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
		this.webApplicationType = WebApplicationType.deduceFromClasspath();
		//初始化器初始化 我词穷了，听着真别扭
		setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
		//监听器初始化
		setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
		// mainApplicationClass -> DemoApplication
		this.mainApplicationClass = deduceMainApplicationClass();
	}

deduceMainApplicationClass

确认主方法在的类，原来还有这种方式判断主方法所在的类，学到了

	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;
	}

本文就先介绍SpringApplication的构造方法，未完待续......