Spring中还提供了另一个接口ApplicationContext,继承了BeanFactory,且包含BeanFactory的所有功能,并额外提供了一些其他的功能。比如国际化支持、事件机制、AOP支持等等。
通过ApplicationContext加载xml文件
public static void main(String[] args) {
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
}
进入构造器后主要有两个逻辑
public ClassPathXmlApplicationContext(
String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)
throws BeansException {
super(parent);
setConfigLocations(configLocations);//设置配置路径并支持多个配置文件
if (refresh) {
refresh();
}
}
在setConfigLocations中对路径做了解析,比如${var}这样的,会从环境变量中取到var的变量进行替换,而refresh中基本上包含了ApplicationContext的全部功能。
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// 刷新上下文环境,可通过重写initPropertySource设置环境变量
prepareRefresh();
// Tell the subclass to refresh the internal bean factory.
// 初始化BeanFactory并进行xml文件读取
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// Prepare the bean factory for use in this context.
// 对BeanFactory进行各种功能填充
prepareBeanFactory(beanFactory);
try {
// 空实现,可有子类实现,提供扩展能力
// Allows post-processing of the bean factory in context subclasses.
postProcessBeanFactory(beanFactory);
// 激活各种BeanFactoryPostProcessors处理器
// Invoke factory processors registered as beans in the context.
invokeBeanFactoryPostProcessors(beanFactory);
// 注册BeanPostProcessors处理器
// Register bean processors that intercept bean creation.
registerBeanPostProcessors(beanFactory);
// 国际化支持,初始化MessageSource
// Initialize message source for this context.
initMessageSource();
// 初始化事件广播器,用于通知事件Listener
// Initialize event multicaster for this context.
initApplicationEventMulticaster();
// 空实现,由子类实现
// Initialize other special beans in specific context subclasses.
onRefresh();
// 查找所有注册的Listener,注册到广播器中
// Check for listener beans and register them.
registerListeners();
// 初始化生下的单实例(非惰性)
// Instantiate all remaining (non-lazy-init) singletons.
finishBeanFactoryInitialization(beanFactory);
// 完成刷新过程,并触发ContextRefreshEvent事件通知,通知生命周期处理器刷新过程
// Last step: publish corresponding event.
finishRefresh();
}
catch (BeansException ex) {
if (logger.isWarnEnabled()) {
logger.warn("Exception encountered during context initialization - " +
"cancelling refresh attempt: " + ex);
}
// Destroy already created singletons to avoid dangling resources.
destroyBeans();
// Reset 'active' flag.
cancelRefresh(ex);
// Propagate exception to caller.
throw ex;
}
finally {
// Reset common introspection caches in Spring's core, since we
// might not ever need metadata for singleton beans anymore...
resetCommonCaches();
}
}
}
在refresh中逻辑还是很多的,根据代码块里添加了中文注释的地方逐步解释
在prepareRefresh中是做环境的准备的,环境变量的初始化以及系统属性的验证,可以通过实现initPropertySource方法进行环境变量的赋值操作等
protected void prepareRefresh() {
// Initialize any placeholder property sources in the context environment.
initPropertySources();
// Validate that all properties marked as required are resolvable:
// see ConfigurablePropertyResolver#setRequiredProperties
getEnvironment().validateRequiredProperties();
}
接下来就是加载BeanFactory了,前面已经知道默认是使用XmlBeanDefinitionReader来读取xml的
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
refreshBeanFactory();
return getBeanFactory();
}
@Override
protected final void refreshBeanFactory() throws BeansException {
if (hasBeanFactory()) {
destroyBeans();
closeBeanFactory();
}
try {
DefaultListableBeanFactory beanFactory = createBeanFactory();
beanFactory.setSerializationId(getId());
customizeBeanFactory(beanFactory);
loadBeanDefinitions(beanFactory);
synchronized (this.beanFactoryMonitor) {
this.beanFactory = beanFactory;
}
}
catch (IOException ex) {
throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
}
}
实例化DefaultListableBeanFactory,XmlBeanFactory就是继承DefaultListableBeanFactory的;
在customizeBeanFactory中对BeanFactory进行了定制,设置是否允许覆盖同名对象以及是否允许循环依赖,并设置支持注解的解析器 QualifierAnnotaionAutowireCandidateResolver
在loadBeanDefinitions中就是比较熟悉的了,指定XmlBeanDefinitionReader为解析器,开始执行xml的解析了。
回到前面主流程中,接下来是对prepareBeanFacctory进行功能的填充
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
// Tell the internal bean factory to use the context's class loader etc.
beanFactory.setBeanClassLoader(getClassLoader());
// 设置表达式语言的解析器,提供对SPEL语言的支持
beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
// 增加属性编辑器
beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
// Configure the bean factory with context callbacks.
// 在bean初始化后,对实现Aware接口的实例提供一些资源
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
// 忽略依赖
beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
// BeanFactory interface not registered as resolvable type in a plain factory.
// MessageSource registered (and found for autowiring) as a bean.
// 注册依赖
beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
beanFactory.registerResolvableDependency(ResourceLoader.class, this);
beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
beanFactory.registerResolvableDependency(ApplicationContext.class, this);
// Register early post-processor for detecting inner beans as ApplicationListeners.
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
// Detect a LoadTimeWeaver and prepare for weaving, if found.
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()));
}
// Register default environment beans.
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());
}
}
在setBeanExproeeionResolver中设置了SPEL支持的解析器,比如可以通过#{var}这种方式取值,在bean进行属性填充的时候,会通过这个解析器完成解析
在addPropertyEditorRegistrar中增加了属性注册编辑器,在ResourceEditorRegistrar中的registerCustomEditors中注册了一系列常用类型的属性编辑器;而ResourceEditorRegistrar是通过在AbstractBeanFactory中开始调用的,如下代码
protected void initBeanWrapper(BeanWrapper bw) {
bw.setConversionService(getConversionService());
registerCustomEditors(bw);
}
protected void registerCustomEditors(PropertyEditorRegistry registry) {
PropertyEditorRegistrySupport registrySupport =
(registry instanceof PropertyEditorRegistrySupport ? (PropertyEditorRegistrySupport) registry : null);
if (registrySupport != null) {
registrySupport.useConfigValueEditors();
}
if (!this.propertyEditorRegistrars.isEmpty()) {
for (PropertyEditorRegistrar registrar : this.propertyEditorRegistrars) {
try {
// 遍历属性编辑器注册自定义编辑器
registrar.registerCustomEditors(registry);
}
catch (BeanCreationException ex) {
Throwable rootCause = ex.getMostSpecificCause();
if (rootCause instanceof BeanCurrentlyInCreationException) {
BeanCreationException bce = (BeanCreationException) rootCause;
String bceBeanName = bce.getBeanName();
if (bceBeanName != null && isCurrentlyInCreation(bceBeanName)) {
if (logger.isDebugEnabled()) {
logger.debug("PropertyEditorRegistrar [" + registrar.getClass().getName() +
"] failed because it tried to obtain currently created bean '" +
ex.getBeanName() + "': " + ex.getMessage());
}
onSuppressedException(ex);
continue;
}
}
throw ex;
}
}
}
if (!this.customEditors.isEmpty()) {
this.customEditors.forEach((requiredType, editorClass) ->
registry.registerCustomEditor(requiredType, BeanUtils.instantiateClass(editorClass)));
}
}
接下来是addBeanPostProcessor,类ApplicationContextAwareProcessor实现了BeanPostProcessor接口,即会在bean实例化时候调用的,在postProcessBeforeInitialization中的invokeAwareInterfaces中,使实现了Aware接口的bean在被初始化之后可以取得一些资源
回到主流程,在功能填充后,即激活BeanFactoryPostProcessor,这个接口和BeanPostProcessor类似, BeanFactoryPostProcessor作用域范围是容器级的,允许在容器实际实例化任何其他的bean之前读取配置元数据。典型的应用是PropertyPlaceholderConfigure,在实例化bean之前会将 ${}格式进行变量替换。
注册BeanPostProcessor, 按照排序顺序进行注册,且重复注册情况会先移除在重新注册,保证beanPostProcessor的唯一性,在bean实例化阶段进行调用
在初始化消息 initMessageSource中,首先会查找已经定义的messageSource的bean,如果没有则使用默认的DelegationMessageSource并注册到beanFactory中
初始化事件广播器,和初始化消息差不多,去查找applicationEventMulticater的bean,否则使用默认的SimpleApplicationEventMulticater,在multicasstEvent中会遍历event的listener进行通知,观察者模式的典型应用。
初始化广播器后则是注册所有listener,来接收广播器的通知,即所有实现了ApplicationListener的bean
对于单例的bean(非lazy的),在ApplicationContext中会默认初始化,在preInstantiateSingletons中对单例的且非lazy的bean进行加载,即调用getBean方法。
在finishrefresh中,开始生命周期,通过实现Lifecycle接口,可以在生命周期开始时加载start方法,在最后会推送ContextRefreshEvent事件通知