上次简单的学习了一下spring boot的整个启动的流程,今天主要详细的学习一下具体每一步做了什么事情!今天主要是学习一下创建SpringApplication实例时比较重要的两步,即initializers和listeners的两个变量的创建过程和它们的作用。开始之前首先改正一个错误,在上次学习spring boot启动分析时,initializers是获取ApplicationContextInitializer其实现类的所有名字,listeners是获取ApplicationListener的所有实现类名称,然后通过反射去创建实例。今天看源码的时候发现我是错的,很尴尬,接下来仔细看一下到底是怎么样一个过程吧!!
一、initializers的初始化
在SpringApplication的构造方法里面是通过set方法完成initializers注入的:
A this.setInitializers(this.getSpringFactoriesInstances(ApplicationContextInitializer.class));
B private <T> Collection<T> getSpringFactoriesInstances(Class<T> type) {
return this.getSpringFactoriesInstances(type, new Class[0]);
}
C private <T> Collection<T> getSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, Object... args) {
ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
a Set<String> names = new LinkedHashSet(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
b List<T> instances = this.createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
AnnotationAwareOrderComparator.sort(instances);
return instances;
}
a public static List<String> loadFactoryNames(Class<?> factoryClass, @Nullable ClassLoader classLoader) {
String factoryClassName = factoryClass.getName();
return (List)loadSpringFactories(classLoader).getOrDefault(factoryClassName, Collections.emptyList());
}
b private <T> List<T> createSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, ClassLoader classLoader, Object[] args, Set<String> names) {
List<T> instances = new ArrayList(names.size());
Iterator var7 = names.iterator();
while(var7.hasNext()) {
String name = (String)var7.next();
try {
Class<?> instanceClass = ClassUtils.forName(name, classLoader);
Assert.isAssignable(type, instanceClass);
Constructor<?> constructor = instanceClass.getDeclaredConstructor(parameterTypes);
T instance = BeanUtils.instantiateClass(constructor, args);
instances.add(instance);
} catch (Throwable var12) {
throw new IllegalArgumentException("Cannot instantiate " + type + " : " + name, var12);
}
}
return instances;
}
上面的方法是initializers完成注入的一个整体流程,A获取到所有initializers实例完成initializers的初始化,它调用的是B方法,且入参为ApplicationContextInitializer的类对象,而后B方法调用了C方法,入参为ApplicationContextInitializer的类对象和一个大小为0的Class数组。关键是C方法,C方法里面又分为a和b方法,a方法是获取所有initializer类的名称,b方法是根据类名成创建出initializer实例(b方法是一个通用方法,创建listener实例也是通过它完成的),另外在C方法里面会对所有的initializer进行排序。
1、获取相关initializer类的名称
先来看下a方法,a方法new了一个HashSet用户存储所有initializer类的名称,而这些类的名称则来自下面的方法:
A public static List<String> loadFactoryNames(Class<?> factoryClass, @Nullable ClassLoader classLoader) {
String factoryClassName = factoryClass.getName();
return (List)loadSpringFactories(classLoader).getOrDefault(factoryClassName, Collections.emptyList());
// 可以简单的这样看:
Map<String, List<String>> map = loadSpringFactories(classLoader);
return (List)map.getOrDefault(factoryClassName, Collections.emptyList());
}
B private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
MultiValueMap<String, String> result = (MultiValueMap)cache.get(classLoader);
if (result != null) {
return result;
} else {
try {
Enumeration<URL> urls = classLoader != null ? classLoader.getResources("META-INF/spring.factories") : ClassLoader.getSystemResources("META-INF/spring.factories");
LinkedMultiValueMap result = new LinkedMultiValueMap();
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();
List<String> factoryClassNames = Arrays.asList(StringUtils.commaDelimitedListToStringArray((String)entry.getValue()));
result.addAll((String)entry.getKey(), factoryClassNames);
}
}
cache.put(classLoader, result);
return result;
} catch (IOException var9) {
throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var9);
}
}
}
上面的方法中A方法先根据ApplicationContextInitializer类对象,获取到它的类名成,即:
org.springframework.context.ApplicationContextInitializer
然后调用B方法,先试着从cache变量中根据类加载器作为key去获取相应的值(这是一个map变量,只是稍微复杂一点,它的类型是Map<ClassLoader, MultiValueMap<String, String>>),如果获取到相应的值,直接返回;否则才会去获取"META-INF/spring.factories",这个是一个URL的枚举,然后遍历该枚举,获取到到每一个"META-INF/spring.factories"配置文件,再遍历所有的配置文件,最后将对应的key(一些类的名称)和对应的value(一个或多个类名称,转成List<String>)添加到result中,然后会将这些值都放到cache变量中,避免再次使用时重新加载,最后返回结果。
在方法A中在B方法返回结果的基础上调用getOrDefault方法,B方法返回结果是一个map,getOrDefault方法就是使用"org.springframework.context.ApplicationContextInitializer"作为key,获取所有对应的initializer的类的名称。所以上次说获取所有ApplicationContextInitializer实现类的名称是错误的,其实获取的是配置文件中指定的以"org.springframework.context.ApplicationContextInitializer"为key的所有类的名称。
自己也查看了一下所有的"spring.factories"配置文件,主要是在3个jar包下面,分别是:
spring-boot-2.0.6.RELEASE.jar
spring-boot-autoconfigure-2.0.6.RELEASE.jar
spring-beans-5.0.10.RELEASE.jar
打开相应的配置文件看一下,就会看到相应的配置,因为配置还是比较多的,所以这里简单的截图看一下:
spring-boot-jar下配置.png
spring-boot-autoconfigure-jar下配置.png
通过图片也可以很直观的看到以"org.springframework.context.ApplicationContextInitializer"为key的value值是多个相关的类名(当然这些类确实也都实现类ApplicationContextInitializer接口)。
2、创建initializer类的实例
方法a返回的是所有需要实列话的initializer类的名称集合,然后在b方法中,先根据类的名称和类加载器获取到对应的Class实例,然后通过反射获取对应类的构造方法,然后调应构造方法的newInstance方法创建出实列,最后将这些initializer返回,最终返回到A方法,并完成initializers变量的初始化,到这里initializers初始化就完成了。
二、listeners的初始化
listeners的初始化和initializer过程完全一样,只是接口类型不同而已,所以这里就不过多介绍了。
三、initializer的作用
因为程序启动的顺序的原因,initializer会在准备context阶段才执行,这里只说initializer的initialize方法执行,不包括一些内部类的相关方法。
this.prepareContext(context, environment, listeners, applicationArguments, printedBanner);
private void prepareContext(ConfigurableApplicationContext context, ConfigurableEnvironment environment, SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments, Banner printedBanner) {
context.setEnvironment(environment);
this.postProcessApplicationContext(context);
// initializer执行
this.applyInitializers(context);
listeners.contextPrepared(context);
if (this.logStartupInfo) {
this.logStartupInfo(context.getParent() == null);
this.logStartupProfileInfo(context);
}
context.getBeanFactory().registerSingleton("springApplicationArguments", applicationArguments);
if (printedBanner != null) {
context.getBeanFactory().registerSingleton("springBootBanner", printedBanner);
}
Set<Object> sources = this.getAllSources();
Assert.notEmpty(sources, "Sources must not be empty");
this.load(context, sources.toArray(new Object[0]));
listeners.contextLoaded(context);
}
initializer执行顺序不太一样,自己大概跟踪了一下每个initializer的执行过程,但是比较乱,所以我就单独的把每一个initializer拿出来,大概说一下它的作用,有的initializer还是非常复杂的。自己就直接根据相应类中的方法简单的介绍一下:
1、org.springframework.boot.context.config.DelegatingApplicationContextInitializer
用户自定义应用环境或者应用上下文时执行的一些初始化操作.
2、org.springframework.boot.context.ContextIdApplicationContextInitializer
主要作用获取当前应用名称,并将名称赋给applicationContext,最后将ContextIdApplicationContextInitializer.ContextId实例作为单例注入到applicationContext的beanFactory中。
3、org.springframework.boot.context.ConfigurationWarningsApplicationContextInitializer
将ConfigurationWarningsPostProcessor实例注入到context的beanFactoryPostProcessors集合中。
4、org.springframework.boot.web.context.ServerPortInfoApplicationContextInitializer
这是一个比较特殊的类,因为它同时实现了ApplicationContextInitializer接口和ApplicationListener接口
它的initialize方法主要是将其本身注入到context的applicationListeners中去。
而它的onApplicationEvent方法监听的则是WebServerInitializedEvent事件,获取web服务器的启动端口,然后添加到环境变量的propertySources中去。
5、org.springframework.boot.autoconfigure.SharedMetadataReaderFactoryContextInitializer
initialize方法将CachingMetadataReaderFactoryPostProcessor注入到context的beanFactoryPostProcessors
集合中。
此外它的另一个内部类SharedMetadataReaderFactoryBean的实现类的onApplicationEvent方法监听ContextRefreshedEvent事件,以清除缓存。
6、org.springframework.boot.autoconfigure.logging.ConditionEvaluationReportLoggingListener
它的initialize方法主要是将context注入到其实例当中,并创建其内部类ConditionEvaluationReportListener的实例,添加到应用context的applicationListener集合中,最后是其report(类型ConditionEvaluationReport)的注入。
其内部类ConditionEvaluationReportListener监听事件ContextRefreshedEvent。
四、listener的作用
listener的作用主要和其监听的事件有关系,一个监听器可能会监听多个事件,并根据事件类型做不同的操作,下面也是根据代码来推断每个监听器的大概功能:
1、org.springframework.boot.context.config.ConfigFileApplicationListener
监听事件ApplicationEnvironmentPreparedEvent和ApplicationPreparedEvent。
在ApplicationEnvironmentPreparedEvent事件中,先以"org.springframework.boot.env.EnvironmentPostProcessor"作为key,获得"META-INF/spring.factories"配置文件夹下的所有类名(这里其实不需要再去加载配置文件的,因为在加载initializer时已经全部加载过了),然后和initializer一样,通过反射创建出三个EnvironmentPostProcessor实现类,然后循环调用它们以及ConfigFileApplicationListener实例的postProcessEnvironment方法。而ConfigFileApplicationListener实例,获取配置文件的加载器,最终会加载用户自定义的配置文件以及指定的配置文件。这个方法有点复杂,感兴趣可以耐心的看看。
在ApplicationPreparedEvent事件中会创建一个内部类PropertySourceOrderingPostProcessor对象,然后添加到context的beanFactoryPostProcessors变量中。
2、org.springframework.boot.context.config.AnsiOutputApplicationListener
监听事件ApplicationEnvironmentPreparedEvent,并通过配置文件设置ANSI是否通过console输出。具体是什么我也不是很清楚。
3、org.springframework.boot.context.logging.LoggingApplicationListener
日志监听器,监听的事件有ApplicationStartingEvent、ApplicationEnvironmentPreparedEvent、ApplicationPreparedEvent、ContextClosedEvent和ApplicationFailedEvent。
ApplicationStartingEvent阶段:日志系统的初始化之前的准备工作
ApplicationEnvironmentPreparedEvent阶段:日志系统初始化,初始化日志级别等。
ApplicationPreparedEvent阶段,把日志系统作为单列注入到bean工厂。这里主要是日志的一些内容,简单了解一下就好。
4、org.springframework.boot.context.logging.ClasspathLoggingApplicationListener
这个感觉也没什么用,判断日志级别是否为debug级别,是的话则输出监听事件信息,否则不做任何操作。监听事件包括ApplicationEnvironmentPreparedEvent和ApplicationFailedEvent。
5、org.springframework.boot.autoconfigure.BackgroundPreinitializer
监听事件ApplicationStartingEvent、ApplicationReadyEvent和ApplicationFailedEvent,
主要是做一些准备工作,比如:字符集的设置、JSON和对象转换相关内容、http请求消息转换器以及tomcat中MBeanFactory的创建等等。
6、org.springframework.boot.context.config.DelegatingApplicationListener
监听事件ApplicationEnvironmentPreparedEvent作用和DelegatingApplicationContextInitializer类似,都是判断用户自定义的一些内容。 spring boot文档 有一些介绍,有兴趣可以看一下。
7、org.springframework.boot.builder.ParentContextCloserApplicationListener
主要监听的是ParentContextAvailableEvent事件,也就是父context可用时,创建一个ContextCloserListener实例,并注入到父context的监听器集合中,父context必须是"ConfigurableApplicationContext"的实例。
8、org.springframework.boot.ClearCachesApplicationListener
监听的ContextRefreshedEvent事件,目的就是清楚类加载器的缓存的方法和字段信息,当前类加载器的类对象通过方法名"clearCache"得到相应的Method对象,然后执行该方法,最后递归调用当前类加载器的父加载器执行以上内容。
9、org.springframework.boot.context.FileEncodingApplicationListener
监听事件ApplicationEnvironmentPreparedEvent,主要是查看环境中的propertySources有没有配置文件字符集,有的话和当前系统的文件字符集比较是否相等,不想等就日志打印错误信息,个人感觉没什么用。
10、org.springframework.boot.liquibase.LiquibaseServiceLocatorApplicationListener
监听ApplicationStartingEvent事件,这个监听器具体做什么的我也不太清楚,跟踪源码发现是使用
ApplicationStartingEvent事件springApplication对象的类加载器去尝试加载名字为"liquibase.servicelocator.CustomResolverServiceLocator"的类或者"liquibase.servicelocator"中子类名称为"CustomResolverServiceLocator"的类。如果没有加载不到就不进行任何操作,加载到则创建LiquibaseServiceLocatorApplicationListener的子类LiquibasePresent的实例,并执行其replaceServiceLocator方法。具体有什么用我也不清楚,我的项目是没有加载到相关的类。
总结:
以上就是initializer和listener的作用,当然这些都是spring boot在配置文件中指定的类的实例。然后单独的分析了每个initializer和listener的用途,实际项目启动过程中要比我们说的复杂的多。另外很多东西都不是上面介绍的那么简单,尤其像ConfigFileApplicationListener自己看了很久都还没有完全的看清整个过程。另外还有一些其他的内容,像beanFactory、postProcessors的等等有哪些作用,tomcat又是如何启动的,这些都是需要去了解的。本以为spring boot简单,但是实际上还是有太多的东西需要去了解,过程远比想象中艰难。只能后面一步步的继续去研究了。
网友评论