深入理解SpringApplication.run(PeaApplication.class,args)（1）

运行流程：

前言

本篇将对SpringApplication.run(）方法进行源码溯源，深入理解该方法

在进入该方法后，把第一个class参数转化为数组类型，调用同名方法

这里有2个核心1个是SpringApplication的创建，另1个是其run方法的调用

其中SpringApplication的创建时，进入SpringApplication的构造函数

public SpringApplication(Class<?>... primarySources) {
		this(null, primarySources);
	}
 
 
public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
		//设置资源加载器为null
		this.resourceLoader = resourceLoader;
		//断言加载资源类不能为null
		Assert.notNull(primarySources, "PrimarySources must not be null");
		//将primarySources数组转换为List，最后放到LinkedHashSet集合中
		this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
 
		//【1.1 推断应用类型，后面会根据类型初始化对应的环境。常用的一般都是servlet环境 】
		this.webApplicationType = WebApplicationType.deduceFromClasspath();
		//【1.2 初始化classpath下 META-INF/spring.factories中已配置的ApplicationContextInitializer 设置初始化器】
		setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
		//【1.3 初始化classpath下所有已配置的 ApplicationListener 设置监听器 】
		setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
		//【1.4 根据调用栈，推断出 main 方法的类名 】
		this.mainApplicationClass = deduceMainApplicationClass();
	}

其中初始化与监听器 getSpringFactoriesInstances

        this.setInitializers(this.getSpringFactoriesInstances(ApplicationContextInitializer.class));
        this.setListeners(this.getSpringFactoriesInstances(ApplicationListener.class));

在 setInitializers() 里可以看到 有一个 getSpringFactoriesInstances（）

	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 从META-INF/spring.factories获取 具体的实现类字符串列表
		Set<String> names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
        // 实例化具体的实现类
		List<T> instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
        // 排序
		AnnotationAwareOrderComparator.sort(instances);
		return instances;
	}

 getSpringFactoriesInstances方法的第1行代码

 在传入的ResourceLoader是null时，调用ClassUtils.getDefaultClassLoader()方法

 其实currentThread() 只是Thread 的一个静态方法。返回的正是执行当前代码指令的线程引用:

        Thread.currentThread() 返回的是一个实例。 只不过这个实例确实比较特殊。 这个实例是当前Thread 的引用。

        Thread.currentThread().getContextClassLoader()和Class.getClassLoader的区别

前者是最安全的方法

        如果你使用Test.class.getClassLoader()，可能会导制和当前线程所运行的类加载器不一致。（因为Java天生的多线程）

        Test.class.getClassLoader一般用在getResource，因为资源文件的位置相对是固定的。

理解线程上下文类加载器

        ThreadContextClassLoader，下文使用TCCL表示。

        Java提供了很多服务提供者接口（Service Provider Interface, SPI），允许第三方为这些接口提供实现。常见的SPI有JDBC、JCE、JNDI、JAXP和JBI等。

        这些SPI的接口由Java核心库来提供，而这些SPI的实现代码则作为Java应用所依赖的jar包被包含进classpath里。SPI接口中的代码经常需要加载具体的实现类，那么问题来了，SPI的接口是Java核心库的一部分，是由启动类加载器（Bootstrap Classloader）来加载的，SPI的实现类是由系统类加载器（System ClassLoader）来加载的。引导类加载器是无法找到SPI的实现类的，因为依照双亲委派模型，BootrapClassLoader无法委派AppClassLoader来加载类。

        而线程上下文类加载器破坏了“双亲委派模型”，可以在执行线程中抛弃双亲委派加载链模式，使用程序可以逆向使用类加载器

Thread.currentThread().getContextClassLoader()和Class.getClassLoader的区别_崔世勋的博客-CSDN博客

 

 这个方法就是查找类加载器

Set<String> names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader));

SpringFactoriesLoader.loadFactoryNames(type, classLoader)  

这个type我们知道他是 ApplicationContextInitializer类

 public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
//        拿到org.springframework.context.ApplicationContextInitializer
        ClassLoader classLoaderToUse = classLoader;
        if (classLoader == null) {
            classLoaderToUse = SpringFactoriesLoader.class.getClassLoader();
        }

        String factoryTypeName = factoryType.getName();
        return (List)loadSpringFactories(classLoaderToUse).getOrDefault(factoryTypeName, Collections.emptyList());
    }

    private static Map<String, List<String>> loadSpringFactories(ClassLoader classLoader) {

//看这个意思从cache中先获取当前的类加载器加载过的Map这个类型的Map跟我们平时见到的不太一样，。他是可以一个key对应多个value的
        Map<String, List<String>> result = (Map)cache.get(classLoader);

//      如果不为空直接返回
        if (result != null) {
            return result;
        }else {
//        为空继续往下走

            HashMap result = new HashMap();

            try {

//            spring.factories里面有着自动配置（AutoConfiguration）相关的类名
                Enumeration urls = classLoader.getResources("META-INF/spring.factories");

//大体意思就是循环上面找到的文件，读取文件里面的配置信息放到map中加入缓存

                while(urls.hasMoreElements()) {
                    URL url = (URL)urls.nextElement();
                    UrlResource resource = new UrlResource(url);
                    Properties properties = PropertiesLoaderUtils.loadProperties(resource);
                    Iterator var6 = properties.entrySet().iterator();

                    while(var6.hasNext()) {
                        Entry<?, ?> entry = (Entry)var6.next();
                        String factoryTypeName = ((String)entry.getKey()).trim();
                        String[] factoryImplementationNames = StringUtils.commaDelimitedListToStringArray((String)entry.getValue());
                        String[] var10 = factoryImplementationNames;
                        int var11 = factoryImplementationNames.length;

                        for(int var12 = 0; var12 < var11; ++var12) {
                            String factoryImplementationName = var10[var12];
                            ((List)result.computeIfAbsent(factoryTypeName, (key) -> {
                                return new ArrayList();
                            })).add(factoryImplementationName.trim());
                        }
                    }
                }

                result.replaceAll((factoryType, implementations) -> {
                    return (List)implementations.stream().distinct().collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList));
                });
                cache.put(classLoader, result);
                return result;
            } catch (IOException var14) {
                throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var14);
            }
        }
    }

        可以看得出，loadSpringFactorie方法，会从META-INF/spring.factories文件中读取配置，将其封装为Properties对象，将每个key作为返回的map的key，将key对应的配置集合作为该map的value。

        而loadFactoryNames则是取出key为EnableAutoConfiguration.class的配置集合

        我们查看META-INF/spring.factories的内容（完整路径：org\springframework\boot\spring-boot-autoconfigure\2.1.4.RELEASE\spring-boot-autoconfigure-2.1.4.RELEASE.jar!\META-INF\spring.factories）

        可以看到，EnableAutoConfiguration对应的value，则是我们在开发中经常用到的组件，比如Rabbit、Elasticsearch与Redis等中间件。

        现有7个需要初始化的类

然后通过反射实例化这些instances.开始初始化工厂

	@SuppressWarnings("unchecked")
	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;
	}

Class<?> instanceClass = ClassUtils.forName(name, classLoader);  

        循环names就是上面的7个配置文件的类

最后通过

AnnotationAwareOrderComparator 进行排序  

最终完成init第一步的初始化，如图开头标题的那张图流程一样