Spring boot-初始化器&事件监听器
2018-07-18 #SpringBoot

前言

在第一篇介绍Spring Boot启动的博文中，我们看到了启动过程中会夹杂着一些事件监听器和初始化器，包括类ApplicationContextInitializer、SpringApplicationRunListener、ApplicationListener等。这篇博文会对它们在spring boot启动过程中如何加载以及如何起作用进行分析。

如何加载

在博文中讲述到ApplicationContextInitializer和ApplicationListener的加载是在类SpringApplication的构造函数中完成的，具体都是通过调用函数getSpringFactoriesInstances(Class<T> type)来完成的。顾名思义，这个函数的作用是去查找指定类型的SpringFactoriesInstance。值得继续分析的是，在这个方法内部是如何查找并实例化SpringFactoriesInstance的呢？

方法SpringFactoriesInstance的调用栈结构比较深，直接进入到比较核心的下层代码中去查看。核心的两处代码调用 1）是SpringFactoriesLoader.loadFactoryNames，”Load the fully qualified class names of factory implementations of the given type”。2）是将上一步找到的fully qualified class names实例化为对象。

1
2
3
4
5
6
7
8
9
10
11
private <T> Collection<T> getSpringFactoriesInstances(Class<T> type,
		Class<?>[] parameterTypes, Object... args) {
	ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
	// Use names and ensure unique to protect against duplicates
	Set<String> names = new LinkedHashSet<>(
			SpringFactoriesLoader.loadFactoryNames(type, classLoader));
	List<T> instances = createSpringFactoriesInstances(type, parameterTypes,
			classLoader, args, names);
	AnnotationAwareOrderComparator.sort(instances);
	return instances;
}

接下来看一下SpringFactoriesLoader.loadFactoryNames的具体实现。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public static List<String> loadFactoryNames(Class<?> factoryClass, @Nullable ClassLoader classLoader) {
	String factoryClassName = factoryClass.getName();
	return loadSpringFactories(classLoader).getOrDefault(factoryClassName, Collections.emptyList());
}

private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
	......
	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()) {
				List<String> factoryClassNames = Arrays.asList(
						StringUtils.commaDelimitedListToStringArray((String) entry.getValue()));
				result.addAll((String) entry.getKey(), factoryClassNames);
			}
		}
		cache.put(classLoader, result);
		return result;
	} catch (IOException ex) {......}
}

通过代码可以看到获取factoryClassNames分两步：第一步是通过classLoader从指定位置获取resource location url；第二步是遍历这些url加载Properties。只需要关注一下从哪个文件加载以及文件内容即可。

配置文件加载的路径放置在两个静态常量FACTORIES_RESOURCE_LOCATION，对应的常量值为”META-INF/spring.factories”。至此我们可以得出结论，方法getSpringFactoriesInstances加载的所有springFactory都是提前配置在spring-boot包下的META-INF/spring.factories文件。

接下来看一下文件的内容。文件内容比较多，我们摘抄一下我们比较关心的配置。其中就有我们关心的关于ApplicationContextInitializer、SpringApplicationRunListener和ApplicationListener的配置。下一节会单独对这些配置内容进行分析。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
# 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

OK,看完了loadFactoryNames之后，继续来看一下如何实际进行实例化的。实例化代码在SpringApplication.createSpringFactoriesInstances方法中实现,不出意料通过BeanUtils.instantiateClass调用构造函数来完成实例化。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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) {......}
	}
	return instances;
}

ApplicationContextInitializer

类定义

主要用来在ConfigurableApplicationContext#refresh()之前对ConfigurableApplicationContext进行一些初始化的操作。一般来说主要做一些程序化的操作，比如注册配置源，根据配置激活某个profile等。

下面一小节会介绍一些spring boot中会有哪些默认的ApplicationContextInitializer并起了什么作用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/**
 * Callback interface for initializing a Spring {@link ConfigurableApplicationContext}
 * prior to being {@linkplain ConfigurableApplicationContext#refresh() refreshed}.
 *
 * <p>Typically used within web applications that require some programmatic initialization
 * of the application context. For example, registering property sources or activating
 * profiles against the {@linkplain ConfigurableApplicationContext#getEnvironment()
 * context's environment}. See {@code ContextLoader} and {@code FrameworkServlet} support
 * for declaring a "contextInitializerClasses" context-param and init-param, respectively.
 */
public interface ApplicationContextInitializer<C extends ConfigurableApplicationContext> {
	/**
	 * Initialize the given application context.
	 * @param applicationContext the application to configure
	 */
	void initialize(C applicationContext);
}

实例

在第一节中我们可以看到，spring boot中默认配置了4个ApplicationContextInitializer，我们逐个来看一下都干了些什么。

ConfigurationWarningsApplicationContextInitializer

可以看到，在initialize方法中会给application context中添加一个ConfigurationWarningsPostProcessor，主要用来检查一些错误的configuration。

1
2
3
4
5
6
7
8
9
10
11
12
/**
 * {@link ApplicationContextInitializer} to report warnings for common misconfiguration
 * mistakes.
* /
public class ConfigurationWarningsApplicationContextInitializer
		implements ApplicationContextInitializer<ConfigurableApplicationContext> {
	@Override
	public void initialize(ConfigurableApplicationContext context) {
		context.addBeanFactoryPostProcessor(
				new ConfigurationWarningsPostProcessor(getChecks()));
	}
}

ContextIdApplicationContextInitializer
类ContextIdApplicationContextInitializer主要用来设置contextId。

1
2
3
4
5
6
7
8
9
10
public class ContextIdApplicationContextInitializer implements
		ApplicationContextInitializer<ConfigurableApplicationContext>, Ordered {
	@Override
	public void initialize(ConfigurableApplicationContext applicationContext) {
		ContextId contextId = getContextId(applicationContext);
		applicationContext.setId(contextId.getId());
		applicationContext.getBeanFactory().registerSingleton(ContextId.class.getName(),
				contextId);
	}
}

DelegatingApplicationContextInitializer
类DelegatingApplicationContextInitializer主要用来委派执行ConfigurableEnvironment中定义的那些ApplicationContextInitializer。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/**
 * {@link ApplicationContextInitializer} that delegates to other initializers that are
 * specified under a {@literal context.initializer.classes} environment property.
 */
public class DelegatingApplicationContextInitializer implements
		ApplicationContextInitializer<ConfigurableApplicationContext>, Ordered {
	@Override
	public void initialize(ConfigurableApplicationContext context) {
		ConfigurableEnvironment environment = context.getEnvironment();
		List<Class<?>> initializerClasses = getInitializerClasses(environment);
		if (!initializerClasses.isEmpty()) {
			applyInitializerClasses(context, initializerClasses);
		}
	}
}

ServerPortInfoApplicationContextInitializer
类ServerPortInfoApplicationContextInitializer用来设置server的端口至Environment properties。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
/**
 * {@link ApplicationContextInitializer} that sets {@link Environment} properties for the
 * ports that {@link WebServer} servers are actually listening on. The property
 * {@literal "local.server.port"} can be injected directly into tests using
 * {@link Value @Value} or obtained via the {@link Environment}.
 * <p>
 * If the {@link WebServerInitializedEvent} has a
 * {@link WebServerApplicationContext#getServerNamespace() server namespace} , it will be
 * used to construct the property name. For example, the "management" actuator context
 * will have the property name {@literal "local.management.port"}.
 * <p>
 * Properties are automatically propagated up to any parent context.
 */
public class ServerPortInfoApplicationContextInitializer
		implements ApplicationContextInitializer<ConfigurableApplicationContext>,
		ApplicationListener<WebServerInitializedEvent> {

	@Override
	public void initialize(ConfigurableApplicationContext applicationContext) {
		applicationContext.addApplicationListener(this);
	}
}

SpringApplicationRunListener

类定义

类SpringApplicationRunListener主要用来监听SpringApplication启动的各种事件。事件触发的时候在方法注释中都已经加以解释。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
public interface SpringApplicationRunListener {
	/**
	 * Called immediately when the run method has first started. Can be used for very
	 * early initialization.
	 */
	void starting();
	/**
	 * Called once the environment has been prepared, but before the
	 * {@link ApplicationContext} has been created.
	 */
	void environmentPrepared(ConfigurableEnvironment environment);
	/**
	 * Called once the {@link ApplicationContext} has been created and prepared, but
	 * before sources have been loaded.
	 */
	void contextPrepared(ConfigurableApplicationContext context);
	/**
	 * Called once the application context has been loaded but before it has been
	 * refreshed.
	 */
	void contextLoaded(ConfigurableApplicationContext context);
	/**
	 * The context has been refreshed and the application has started but
	 * {@link CommandLineRunner CommandLineRunners} and {@link ApplicationRunner
	 * ApplicationRunners} have not been called.
	 */
	void started(ConfigurableApplicationContext context);
	/**
	 * Called immediately before the run method finishes, when the application context has
	 * been refreshed and all {@link CommandLineRunner CommandLineRunners} and 
	 * {@link ApplicationRunner ApplicationRunners} have been called.
	 */
	void running(ConfigurableApplicationContext context);
	/**
	 * Called when a failure occurs when running the application.
	 */
	void failed(ConfigurableApplicationContext context, Throwable exception);
}

实例

从第1节的配置中可以看到在spring boot中默认配置的SpringApplicationRunListener是EventPublishingRunListener。

类SpringApplicationRunListener会将事件广播给SimpleApplicationEventMulticaster，而从下边的构造函数中可以看到`SimpleApplicationEventMulticaster``的听众包含了所有注册的ApplicationListener。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/**
 * {@link SpringApplicationRunListener} to publish {@link SpringApplicationEvent}s.
 * Uses an internal {@link ApplicationEventMulticaster} for the events that are fired
 * before the context is actually refreshed.

 */
public class EventPublishingRunListener implements SpringApplicationRunListener, Ordered {

	private final SpringApplication application;

	private final String[] args;

	private final SimpleApplicationEventMulticaster initialMulticaster;

	public EventPublishingRunListener(SpringApplication application, String[] args) {
		this.application = application;
		this.args = args;
		this.initialMulticaster = new SimpleApplicationEventMulticaster();
		for (ApplicationListener<?> listener : application.getListeners()) {
			this.initialMulticaster.addApplicationListener(listener);
		}
	}
}

ApplicationListener

类定义

接口ApplicationListener是基于观察者模式监听ApplicationEvent并触发指定的操作。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/**
 * Interface to be implemented by application event listeners.
 * Based on the standard {@code java.util.EventListener} interface
 * for the Observer design pattern.
 *
 * <p>As of Spring 3.0, an ApplicationListener can generically declare the event type
 * that it is interested in. When registered with a Spring ApplicationContext, events
 * will be filtered accordingly, with the listener getting invoked for matching event
 * objects only.
@FunctionalInterface
public interface ApplicationListener<E extends ApplicationEvent> extends EventListener {
	/**
	 * Handle an application event.
	 * @param event the event to respond to
	 */
	void onApplicationEvent(E event);
}

实例

从第1节的配置中可以看到在spring boot中默认配置的ApplicationListener还挺多的，我们就摘抄几个比较重要的分析一下。

ConfigFileApplicationListener

类ConfigFileApplicationListener是一个非常重要的监听器，除了是一个监听器之外，它实现了接口EnvironmentPostProcessor。在监听到事件时，会从指定的文件加载配置并配置application context。

可以看到继承实现了接口EnvironmentPostProcessor的方法postProcessEnvironment，负责对SpringApplication的Environment进行处理。具体实现上可以看到创建了一个Loader，这个Loader会负责去javadoc描述得地方去查找文件并加载配置。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
/**
 * {@link EnvironmentPostProcessor} that configures the context environment by loading
 * properties from well known file locations. By default properties will be loaded from
 * 'application.properties' and/or 'application.yml' files in the following locations:
 * <ul>
 * <li>classpath:</li>
 * <li>file:./</li>
 * <li>classpath:config/</li>
 * <li>file:./config/:</li>
 * </ul>
 * <p>
 * Alternative search locations and names can be specified using
 * {@link #setSearchLocations(String)} and {@link #setSearchNames(String)}.
 * <p>
 * Additional files will also be loaded based on active profiles. For example if a 'web'
 * profile is active 'application-web.properties' and 'application-web.yml' will be
 * considered.
 * <p>
 * The 'spring.config.name' property can be used to specify an alternative name to load
 * and the 'spring.config.location' property can be used to specify alternative search
 * locations or specific files.
 * <p>
 *
public class ConfigFileApplicationListener
		implements EnvironmentPostProcessor, SmartApplicationListener, Ordered {
    private void onApplicationEnvironmentPreparedEvent(
    		ApplicationEnvironmentPreparedEvent event) {
    	List<EnvironmentPostProcessor> postProcessors = loadPostProcessors();
    	postProcessors.add(this);
    	AnnotationAwareOrderComparator.sort(postProcessors);
    	for (EnvironmentPostProcessor postProcessor : postProcessors) {
    		postProcessor.postProcessEnvironment(event.getEnvironment(),
    				event.getSpringApplication());
    	}
    }
    @Override
    public void postProcessEnvironment(ConfigurableEnvironment environment,
    		SpringApplication application) {
    	addPropertySources(environment, application.getResourceLoader());
    }
    protected void addPropertySources(ConfigurableEnvironment environment,
    		ResourceLoader resourceLoader) {
    	RandomValuePropertySource.addToEnvironment(environment);
    	new Loader(environment, resourceLoader).load();
    }
}

重点看一下方法onApplicationEnvironmentPreparedEvent。在监听到ApplicationEnvironmentPreparedEvent事件之后，除了将自己加入到List<EnvironmentPostProcessor>之外，还会调用函数loadPostProcessors去加载在文件META-INF/spring.factories配置的EnvironmentPostProcessor，最后执行所有的postProcessEnvironment方法。