spring-容器启动流程

AbstractApplicationContext是对ApplicationContext的第一个实现:
看一下他的几个核心结构:

/** BeanFactoryPostProcessor列表,在bean的创建过程中可以对bean进行进一步的加工 */
private final List<BeanFactoryPostProcessor> beanFactoryPostProcessors = new ArrayList<>();
//生命周期流程,可以接收到整个应用启动,停止,将要刷新和将要关闭
private LifecycleProcessor lifecycleProcessor;
//消息,支持国际化等
private MessageSource messageSource;
//事件广播器
private ApplicationEventMulticaster applicationEventMulticaster;

在各种bean定义加载完成后,都需要对ApplicationContext进行刷新,对bean工厂的各种配置以及bean的创建等都是在这个流程中执行的,
我们重点看一下refresh方法:

// Prepare this context for refreshing.
prepareRefresh();

// Tell the subclass to refresh the internal bean factory.
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

// Prepare the bean factory for use in this context.
prepareBeanFactory(beanFactory);

try {
// Allows post-processing of the bean factory in context subclasses.
postProcessBeanFactory(beanFactory);

// Invoke factory processors registered as beans in the context.
invokeBeanFactoryPostProcessors(beanFactory);

// Register bean processors that intercept bean creation.
registerBeanPostProcessors(beanFactory);

// Initialize message source for this context.
initMessageSource();

// Initialize event multicaster for this context.
initApplicationEventMulticaster();

// Initialize other special beans in specific context subclasses.
onRefresh();

// Check for listener beans and register them.
registerListeners();

// Instantiate all remaining (non-lazy-init) singletons.
finishBeanFactoryInitialization(beanFactory);

// Last step: publish corresponding event.
finishRefresh();

接下来逐个方法看一下:
prepareRefresh:一些启动参数的设置
prepareBeanFactory:对bean工厂的准备配置,咱们自己使用bean工厂的话,可以参照这里

//类加载器
beanFactory.setBeanClassLoader(getClassLoader());
//表达式解析器
beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
//属性资源注册
beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

//设置ApplicationContext的后处理器
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
//下面是一些解析时忽略的接口,这些资源在ApplicationContext刷新过程中已经创建,只需要注入即可
beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);

//这些资源在ApplicationContext刷新过程中已经创建,都是可以解析资源
beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
beanFactory.registerResolvableDependency(ResourceLoader.class, this);
beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
beanFactory.registerResolvableDependency(ApplicationContext.class, this);

//后处理器,能够对实现了事件监听的接口注册到事件广播中
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

// LoadTimeWeaver功能支持
if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
	beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
	// Set a temporary ClassLoader for type matching.
	beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}

//注册环境先关的单列
if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
	beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
}
if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
	beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
}
if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
	beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
}

postProcessBeanFactory:给子类一个参与工厂post的机会,比如在Servlet中:

//添加了一些后处理器,以及注册了各种web相关的scope,以及环境
@Override
protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
	if (this.servletContext != null) {
		beanFactory.addBeanPostProcessor(new ServletContextAwareProcessor(this.servletContext));
		beanFactory.ignoreDependencyInterface(ServletContextAware.class);
	}
	WebApplicationContextUtils.registerWebApplicationScopes(beanFactory, this.servletContext);
	WebApplicationContextUtils.registerEnvironmentBeans(beanFactory, this.servletContext);
}

invokeBeanFactoryPostProcessors:实例化并且执行所有的BeanFactoryPostProcessors流程,实现了该接口的对象,
可以在任何bean实例化前,对bean工厂,做进一步的加工处理
registerBeanPostProcessors:对bean工厂注册BeanPostProcessors,注册顺序,先注册PriorityOrdered,然后Ordered,然后其他未实现order的
看一下源码:

String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

// First, register the BeanPostProcessors that implement PriorityOrdered.
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

// Next, register the BeanPostProcessors that implement Ordered.
sortPostProcessors(orderedPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, orderedPostProcessors);

// Now, register all regular BeanPostProcessors.
registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

initMessageSource:初始化MessageSource,没有的话委托给父容器
initApplicationEventMulticaster:初始化事件广播
onRefresh:通知子类,将要刷新,子类执行必要操作
registerListeners:注册事件监听器到广播器上
finishBeanFactoryInitialization:实例化单列bean
finishRefresh:

clearResourceCaches();

// Initialize lifecycle processor for this context.
initLifecycleProcessor();

// Propagate refresh to lifecycle processor first.
getLifecycleProcessor().onRefresh();

// Publish the final event.
publishEvent(new ContextRefreshedEvent(this));

// Participate in LiveBeansView MBean, if active.
LiveBeansView.registerApplicationContext(this);