org.springframework.context.ApplicationContext接口

org.springframework.context.ApplicationContext接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public interface ApplicationContext extends EnvironmentCapable, 
ListableBeanFactory, HierarchicalBeanFactory, MessageSource,
ApplicationEventPublisher, ResourcePatternResolver{

String getId();

String getApplicationName();

String getDisplayName();

long getStartupDate();

ApplicationContext getParent();

AutowireCapableBeanFactory getAutowireCapableBeanFactory() throws IllegalStateException;
}

(〇)通过ApplicationContext加载XML

1
ApplicationContext context = new ClassPathXmlApplicationContext("test.xml");

(一)ClassPathXmlApplicationContext

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
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
public class ClassPathXmlApplicationContext{

//传入配置文件位置的构造器
public ClassPathXmlApplicationContext(String configLocation) throws BeansException{
this(new String[]{configLocation}, true, null);
}

//传入配置文件位置、是否刷新、父上下文的构造器
public ClassPathXmlApplicationContext(String[] configLocations,
boolean refresh, ApplicationContext parent) throws BeansException{
super(parent);
//【设置配置文件路径】
setConfigLocations(configLocations);
//【扩展功能】
if(refresh){
refresh();
}
}

//【扩展功能-刷新】:几乎包含了ApplicationContext提供的全部功能
public void refresh() throws BeansException, IllegalStateException{
synchronized(this.startupShutdownMonitor){
//【准备刷新的上下文环境】
prepareRefresh();

//【初始化BeanFactory,并进行XML文件读取】
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

//【对BeanFactory进行功能填充】
prepareBeanFactory(beanFactory);

try{
//【子类覆盖方法做额外处理】
postProcessBeanFactory(beanFactory);

//【激活各种BeanFactory处理器】
invokeBeanFactoryPostProcessors(beanFactory);

//【注册拦截Bean创建的处理器】
//【这里只是注册,真正调用是在getBean()】
registerBeanPostProcessors(beanFactory);

//【初始化信息源,即不同语言的消息体,国际化处理】
initMessageSource();

//【留给子类来初始化其他Bean】
onRefresh();

//【在所有注册的Bean中查找Listener,注册到消息广播器中】
registerListeners();

//【初始化剩下的非lazy-init单例Bean】
finishBeanFactoryInitialization(beanFactory);

//【完成刷新过程,通知生命周期处理器刷新,
//同时发出ContextRefreshEvent通知别人】
finishRefresh();
}catch(BeansException ex){
//销毁已经创建的单例Bean
destroyBeans();

//active重新设置为false
cancelRefresh(ex);

throw ex;
}
}
}

}

1.设置配置文件路径:setConfigLocations()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public abstract class AbstractRefreshableConfigApplicationContext 
extends AbstractRefreshableApplicationContext
implements BeanNameAware, InitializingBean {

//配置文件位置数组
private String[] configLocations;

//【设置配置文件路径】:
//将配置文件路径以数组的形式传入,Spring对数组解析并进行加载
public void setConfigLocations(String[] locations){
if(locations != null){
//配置文件必须非空
Assert.notNullElements(locations, "Config locations must not be null");
this.configLocations = new String[locations.length];
for(int i = 0; i < locations.length; i++){
//【路径解析】:如果数组中包含特殊符号,如${var},
//那么会用实际搜索到的变量值替换
this.configLocations[i] = resolvePath(locations[i]).trim();
}
}else{
this.configLocations = null;
}
}
}

2.刷新:refresh()

  1. 初始化前的准备工作,例如对系统属性或者环境变量进行准备及验证。

  2. 初始化BeanFactory,并进行XML文件读取。

    在这一步后,ApplicationContext就包含了BeanFactory的全部功能,也就是可以进行Bean的提取等基础操作了。

  3. BeanFactory进行各种功能填充,比如支持@Autowired@Qualifier

  4. 子类覆盖方法的额外处理。

  5. 激活各种BeanFactory处理器。

  6. 注册拦截Bean创建的处理器,这里只是注册,真正调用是在getBean()

  7. 为上下文初始化Message源,即对不同语言的消息体进行国际化处理。

  8. 初始化应用消息广播器,并放入applicationEventMulticaster中。

  9. 留给子类来初始化其他BeanonRefresh()

  10. 在所有注册的Bean中查找Listener,注册到消息广播器中。

  11. 初始化剩下的非lazy-init单例Bean

  12. 完成刷新过程,通知生命周期处理器lifecycleProcessor刷新过程,同时发出ContextRefreshEvent通知别人。


(1)环境准备:prepareRefresh()

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
public abstract class AbstractApplicationContext extends DefaultResourceLoader implements ConfigurableApplicationContext, DisposableBean {

//激活标志,如果为true说明ApplicationContext正在创建中
private final AtomicBoolean active;

//【环境准备】
protected void prepareRefresh(){
this.startupDate = System.currentTimeMillis();
synchronized(this.activeMonitor){
//激活标志设为true,说明上下文正在创建
this.active = true;
}
if(logger.isInfoEnabled()){
logger.info("Refreshing " + this);
}
//留给子类覆盖,进行个性化的属性处理与设置
initPropertySources();
//验证需要的属性文件是否都已经放入环境中
getEnvironment().validateRequiredProperties();
}

//空实现,留给子类覆盖,进行个性化的属性处理与设置
protected void initPropertySources(){
}
}

(2)加载BeanFactoryobtainFreshBeanFactory()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public abstract class AbstractApplicationContext extends DefaultResourceLoader implements ConfigurableApplicationContext, DisposableBean {

//【加载BeanFactory】
protected ConfigurableListableBeanFactory obtainRefreshBeanFactory(){
//初始化BeanFactory,并进行XML文件读取,
//将得到的BeanFactory记录在当前实体的属性中
refreshBeanFactory();
//返回当前实体的beanFactory属性
ConfigurableListable beanFactory = this.getBeanFactory();
if(logger.isDebugEnabled()){
logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
}
return beanFactory;
}
}
初始化&记录BeanFactoryrefreshBeanFactory()
  • AbstractBeanFactoryrefreshBeanFactory()委托给了子类AbstractRefreshableApplicationContext实现。
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
47
48
49
50
51
52
53
public abstract class AbstractRefreshableApplicationContext extends AbstractApplicationContext {
//记录BeanFactory实例
private DefaultListableBeanFactory beanFactory;
//是否允许相同名称、不同定义的对象覆盖
private boolean allowBeanDefinitionOverriding;
//是否允许循环依赖
private boolean allowCircularReference;

//【初始化&记录BeanFactory】
@Override
protected final void refreshBeanFactory() throws BeansException{
//如果BeanFactory已经存在,则删除其所有Bean,关闭Factory
if(hasBeanFactory() ){
destroyBeans();
closeBeanFactory();
}
try{
//创建DefaultListableBeanFactory
DefaultListableBeanFactory beanFactory = createBeanFactory();
//序列化ID
beanFactory.setSerializationId(getId());
//【定制BeanFactory,设置相关属性,包括:
//是否允许覆盖同名称不同定义的对象、
//循环依赖、
//设置@Autowired和@Qualifier注解解析器】
customizeBeanFactory(beanFactory);
//【加载BeanDefinition】:
//初始化DocumentReader,进行XML文件读取和解析
loadBeanDefinitions(beanFactory);
//记录BeanFactory实例
synchronized(this.beanFactoryMonitor){
this.beanFactory = beanFactory;
}
}catch(IOException ex){
throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
}
}

//【定制BeanFactory】
protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory){
//allowBeanDefinitionOverriding:是否允许相同名称、不同定义的对象覆盖
if(this.allowBeanDefinitionOverriding != null){
beanFactory.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
}
//allowCircularReference:是否允许循环依赖
if(this.allowCircularReference != null){
beanFactory.setAllowCircularReference(this.allowCircularReference);
}
//@Autowired、@Qualifier解析器
beanFactory.setAutowireCandidateResolver(new QualifierAnnotationAutowireCandidateResolver());
}

}

(3)功能扩展:prepareBeanFactory()

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
47
public abstract class AbstractApplicationContext extends DefaultResourceLoader implements ConfigurableApplicationContext, DisposableBean {
//【功能扩展】
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory){
//设置beanFactory的classLoader为当前context的classLoader
beanFactory.setBeanClassLoader(getClassLoader());
//设置beanFactory的表达式语言处理器
beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver());
//为beanFactory添加一个默认的propertyEditor,对Bean属性进行设置、管理
beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

//【添加BeanPostProcessor】
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));

//设置了几个忽略自动装配的接口
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);

//设置了几个自动装配的特殊规则
beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
beanFactory.registerResolvableDependency(ResourceLoader.class, this);
beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
beanFactory.registerResolvableDependency(ApplicationContext.class, this);

//添加对AspectJ的支持
if(beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)){
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
//设置一个临时类加载器,用于类型匹配
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}

//添加默认的系统环境Bean
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_ENCIRONMENT_BEAN_NAME)){
beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
}
}
}
-------------本文结束感谢您的阅读-------------

本文标题:org.springframework.context.ApplicationContext接口

文章作者:DragonBaby308

发布时间:2019年10月24日 - 22:34

最后更新:2019年10月25日 - 22:56

原始链接:http://www.dragonbaby308.com/org-springframework-context-ApplicationContext/

许可协议: 署名-非商业性使用-禁止演绎 4.0 国际 转载请保留原文链接及作者。

急事可以使用右下角的DaoVoice,我绑定了微信会立即回复,否则还是推荐Valine留言喔( ఠൠఠ )ノ
0%