从0开始深入理解Spring(1)--SpringApplication构造

从0开始深入理解Spring-启动类构造

引言:
从本篇开始，打算深入理解Spring执行过程及原理，个人理解极有可能有偏差，评论区欢迎指正错误，下面开始进入正片内容。
ps: springboot版本使用2.4.8

Springboot项目启动时，是通过main方法中编写启动类的形式启动的，按照下面格式编写启动类

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

其核心为SpringApplication.run(SpringFrameStudyApplication.class)方法，下面深入探讨该方法的执行

SpringApplication.java位于org.springframework.boot包下，是Springboot项目启动的核心类。点击run()方法。进入该方法

这里run方法不做过多解析，下篇会详解run方法的具体执行过程

SpringApplication.java

	public static ConfigurableApplicationContext run(Class<?> primarySource, String... args) {
		return run(new Class<?>[] { primarySource }, args);
	}
	
	public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
		// 在这里创建了SpringApplication对象，并执行run方法。执行完毕后返回配置好的上下文对象ConfigurableApplicationContext
		return new SpringApplication(primarySources).run(args);
	}
	// 构造方法
	public SpringApplication(Class<?>... primarySources) {
		this(null, primarySources);
	}
	
	// SpringApplication核心构造方法
	public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
		// 资源加载器: 如果按照上述方法进行构造时，为null
		this.resourceLoader = resourceLoader;
		Assert.notNull(primarySources, "PrimarySources must not be null");
		this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
		// webApplicationType属性用于判断运行容器: 为Servlet还是Reactive。Reactive为响应式的架构: SpringWebFlex
		this.webApplicationType = WebApplicationType.deduceFromClasspath();
		// 这里重点介绍下。从SpringFactories中获得Boot的注册器及初始化器等相关信息并将springfatory中的信息初始化至缓存中的
		this.bootstrapRegistryInitializers = getBootstrapRegistryInitializersFromSpringFactories();
		// 设置Application上下文初始化器 相关属性(赋值操作)
		setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
		// 设置应用监听初始化器 相关属性(赋值操作)
		setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
		// 赋值 jvm线程栈中 main方法栈所在类
		this.mainApplicationClass = deduceMainApplicationClass();
	}

这里避免类代码过长过重，拆分两部分进行代码讲解。下面这一部分介绍getBootstrapRegistryInitializersFromSpringFactories()是如何从MATE-INFO/spring.factory中获取相关属性

SpringApplication.java


	private List<BootstrapRegistryInitializer> getBootstrapRegistryInitializersFromSpringFactories() {
		ArrayList<BootstrapRegistryInitializer> initializers = new ArrayList<>();
		// 核心方法,获得Bootstrapper类有关的SpringFactory实例
		getSpringFactoriesInstances(Bootstrapper.class).stream()
				.map((bootstrapper) -> ((BootstrapRegistryInitializer) bootstrapper::initialize))
				.forEach(initializers::add);
		// 获得BootstrapRegistryInitializer类有关的SpringFactory实例
		initializers.addAll(getSpringFactoriesInstances(BootstrapRegistryInitializer.class));
		return initializers;
	}
	
	public void setInitializers(Collection<? extends ApplicationContextInitializer<?>> initializers) {
		this.initializers = new ArrayList<>(initializers);
	}
	
	public void setListeners(Collection<? extends ApplicationListener<?>> listeners) {
		this.listeners = new ArrayList<>(listeners);
	}
	
	/**
     * 根据类型获得SpringFacotries实例
     * @param type
     */
	private <T> Collection<T> getSpringFactoriesInstances(Class<T> type) {
		return getSpringFactoriesInstances(type, new Class<?>[] {});
	}
	
	/**
     * 根据类型获得SpringFacotries实例
     * @param type 类类型
     * @param parameterTypes 参数类型
     * @param args 构造方法的参数
     */
	private <T> Collection<T> getSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, Object... args) {
		// 这里getClassLoader()为内部的一个方法
		ClassLoader classLoader = getClassLoader();
		// 根据传入的类获得SpringFactories中的限定名称
		Set<String> names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
		// 根据名称集合创建实例
		List<T> instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
		// 按照order进行排序
		AnnotationAwareOrderComparator.sort(instances);
		return instances;
	}

	public ClassLoader getClassLoader() {
		if (this.resourceLoader != null) {
		    // 正常默认启动时，resourceLoader为空
			return this.resourceLoader.getClassLoader();
		}
		// 默认返回当前主线程
		return ClassUtils.getDefaultClassLoader();
	}

SpringFactoriesLoader.java

	// 获取spring.factories中的所在位置
	public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";
	
	public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
		ClassLoader classLoaderToUse = classLoader;
		if (classLoaderToUse == null) {
			classLoaderToUse = SpringFactoriesLoader.class.getClassLoader();
		}
		String factoryTypeName = factoryType.getName();
		// 加载所有springfactories的实现类并 根据factoryTypeName获得该实现类的名称
		return loadSpringFactories(classLoaderToUse).getOrDefault(factoryTypeName, Collections.emptyList());
	}

	private static Map<String, List<String>> loadSpringFactories(ClassLoader classLoader) {
	    // 从缓存中获取已经加载的类 名称
		Map<String, List<String>> result = cache.get(classLoader);
		if (result != null) {
			return result;
		}
		// 如果没有
		result = new HashMap<>();
		try {
		    // 类加载器中获得spring.factories的所在url地址
			Enumeration<URL> urls = classLoader.getResources(FACTORIES_RESOURCE_LOCATION);
			while (urls.hasMoreElements()) {
				URL url = urls.nextElement();
				UrlResource resource = new UrlResource(url);
				// 加载resource资源
				Properties properties = PropertiesLoaderUtils.loadProperties(resource);
				for (Map.Entry<?, ?> entry : properties.entrySet()) {
					String factoryTypeName = ((String) entry.getKey()).trim();
					String[] factoryImplementationNames =
							StringUtils.commaDelimitedListToStringArray((String) entry.getValue());
					for (String factoryImplementationName : factoryImplementationNames) {
						// 添加实现类名称
						result.computeIfAbsent(factoryTypeName, key -> new ArrayList<>())
								.add(factoryImplementationName.trim());
					}
				}
			}

			// 将其列表去重并修改为不可修改的集合
			result.replaceAll((factoryType, implementations) -> implementations.stream().distinct()
					.collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList)));
			// 加入缓存中 key为classLoader
			cache.put(classLoader, result);
		}
		catch (IOException ex) {
			throw new IllegalArgumentException("Unable to load factories from location [" +
					FACTORIES_RESOURCE_LOCATION + "]", ex);
		}
		return result;
	}