IOC初始化可归纳为两个步骤,创建容器、加载bean定义。本文以ApplicationContext为例讲解创建容器过程,其实现类为ClassPathXmlApplicationContext。

    ApplicationContext允许嵌套上下文,可以将父上下文维护在一个上下文中,其原理很类似双亲委托加载。对于使用的话,加载一个bean,会先检查当前上下文,然后检索父上下文,逐级向上。这样为spring应用提供一个共享的bean环境,而不用在多个上下文之间来回切换。

寻找入口

    ApplicationContext主要实现类很多,AnnotationConfigApplicationContext、XmlWebApplicationContext。都继承自父容器AbstractApplicationContext,最后都会调到refresh方法启动,这里以ClassPathXmlApplicationContext为例。通过main方法启动spring。

1
2
3
4
5
6
7
@Test
public void testConfigLocation() {
ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("application.xml");
Service service = (Service) ctx.getBean("service");
ctx.close();
assertTrue(service.isProperlyDestroyed());
}

    代码中只有主要new一个ClassPathXmlApplicationContext对象,就可以使用IOC获取bean了,那么它的初始化,那么我们只有一个入口,也就是它的构造,而在这个构造中,最后会调用以下重载构造方法。

1
2
3
4
5
6
7
8
9
10
public ClassPathXmlApplicationContext(
String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)
throws BeansException {

super(parent);
setConfigLocations(configLocations);
if (refresh) {
refresh();
}
}

加载配置

    通过上面构造方法,在调用refresh()之前会调用父类构造,和调用setConfigLocations()处理传进来配置文件。
    我们先看父类构造,会一直往上调用,直到AbstractApplicationContext,最后我将多个构造合并之后结果如下:

1
2
3
4
5
6
7
8
9
10
public abstract class AbstractApplicationContext ...{
public AbstractApplicationContext(@Nullable ApplicationContext parent) {
this.resourcePatternResolver = getResourcePatternResolver();
setParent(parent);
}
// 用于读取spring bean配置信息
protected ResourcePatternResolver getResourcePatternResolver() {
return new PathMatchingResourcePatternResolver(this);
}
}

    这里其实就是准备一下工作,接下来就是setConfigLocations()了,该方法由AbstractRefreshableConfigApplicationContext实现,进行bean配置的定义。

1
2
3
4
5
6
7
8
9
10
11
12
public void setConfigLocations(@Nullable String... locations) {
if (locations != null) {
Assert.noNullElements(locations, "Config locations must not be null");
this.configLocations = new String[locations.length];
for (int i = 0; i < locations.length; i++) {
//解析bean定义资源文件路径
this.configLocations[i] = resolvePath(locations[i]).trim();
}
} else {
this.configLocations = null;
}
}

    最重要的是resolvePath(),该方法为同一个类中将字符串解析为路劲。并将其保存。

整体启动过程

    之前多多少少都应该知道spring启动是调用refresh()方法的。但是refresh()却是一个模板方法,只规定了spring启动流程,许多实现逻辑,需要深入它的子类实现中。这一节整体的看一下refresh()。

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
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// 容器刷新前,预处理方法。获取启动时间,以及各种标记处理
prepareRefresh();

// 提供抽象方法refreshBeanFactory,由子类刷新BeanFactory
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

// 给BeanFactory对象配置类加载器、事件处理器等
prepareBeanFactory(beanFactory);

try {
// 提供默认方法供子类重写。用于在标准初始化之后,某些子类需要修改应用程序上下文的内部beanFactory。此时IOC初始化已经完成。
postProcessBeanFactory(beanFactory);

// 调用所以注册的BeanFactoryPostProcessor的bean
invokeBeanFactoryPostProcessors(beanFactory);

// 为BeanFacytory注册Post事件处理器,BeanPostProcessor为bean创建后置处理器,可用于监听事件。
registerBeanPostProcessors(beanFactory);

// 初始化信息源,国际化
initMessageSource();

// 初始化容器事件传播器
initApplicationEventMulticaster();

// 提供默认方法供子类重写,处理特殊bean初始化
onRefresh();

// 为事件传播器注册监听器
registerListeners();

// 初始化所有剩余的单例bean,(非懒加载的)
finishBeanFactoryInitialization(beanFactory);

// 发布IOC启动完事件
finishRefresh();
} catch (BeansException ex) {
if (logger.isWarnEnabled()) {
logger.warn("Exception encountered during context initialization - " +
"cancelling refresh attempt: " + ex);
}

// 销毁bean
destroyBeans();

// 需要刷新操作,重置同步标识
cancelRefresh(ex);

throw ex;
} finally {
// 重设公共缓存
resetCommonCaches();
}
}
}

    其实refresh()方法主要为IOC容器的bean管理生命周期。IOC容器载入bean配置信息,由子类的refreshBeanFactory()实现,也就是说obtainFreshBeanFactory()以后的代码都在注册容器的信息源和生命周期。

创建容器

    从obtainFreshBeanFactory()进入,查看其子类的AbstractRefreshableApplicationContext.refreshBeanFactory()。该方法真正完成了IOC的初始化过程。

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
protected final void refreshBeanFactory() throws BeansException {
// 注销之前所有创建beanFactory
if (hasBeanFactory()) {
destroyBeans();
closeBeanFactory();
}
try {
// 创建IOC
DefaultListableBeanFactory beanFactory = createBeanFactory();
beanFactory.setSerializationId(getId());
// 设置一些启动参数,注解装配等
customizeBeanFactory(beanFactory);
// 加载bean配置,由子类实现
loadBeanDefinitions(beanFactory);
synchronized (this.beanFactoryMonitor) {
this.beanFactory = beanFactory;
}
}
catch (IOException ex) {
throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
}
}
protected DefaultListableBeanFactory createBeanFactory() {
return new DefaultListableBeanFactory(getInternalParentBeanFactory());
}

    refreshBeanFactory()值得注意的是,它会先销毁之前的beanfactory,然后在createBeanFactory()方法中new一个DefaultListableBeanFactory的对象,以保证后续所有的方法,都调用先创建的beanFactory。它还做了另一件事情就是loadBeanDefinitions()这个方法用于解析bean的配置信息,然后转换成BeanDefinition对象,供spring使用。下一章再详细解说。