Spring中IOC容器的初始化过程

Spring IOC容器初始化过程分为Resource定位,载入解析,注册。IOC容器初始化过程中不包含Bean的依赖注入。Bean的依赖注入一般会发生在第一次通过getBean向容器索取Bean的时候。

ClassPathXmlApplicationContext初始化过程

实际的构造方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)
throws BeansException {
//super方法为容器设置好Bean资源加载器
//该方法最终会调用到AbstractApplicationContext的无参构造方法
//这里会默认设置解析路径的模式为Ant-style
super(parent);
//设置Bean定义资源文件的路径
setConfigLocations(configLocations);
if (refresh) {
//调用容器的refresh,载入BeanDefinition的入口
refresh();
}
}

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
58
59
60
61
62
63
64
65
66
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// 调用容器准备刷新的方法,此方法中会获取容器的当前时间,给容器设置同步标识
//初始化前的准备工作,例如对系统属性或环境变量进行准备以及验证。
prepareRefresh();

//通知子类启动refreshBeanFactory的调用
//初始化BeanFactory,并进行XML文件读取
//ClassPathXmlApplicationContext包含着BeanFactory所提供的一切特征
//这一步会复用BeanFactory中的配置文件读取解析以及其他功能
//这一步之后ClassPathXmlApplicationContext已经包含了BeanFactory所提供的功能,可以进行Bean的提取等基础操作了。
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

//准备当前上下文用的BeanFactory,为BeanFactory配置容器特性,例如类加载器,事件处理器等各种功能填充。
//对BeanFactory各种功能的填充,比如@Qualifier和@Autowired注解就是在这一步增加的支持
prepareBeanFactory(beanFactory);

try {
//为子类设置BeanFactory的后置处理器
//子类覆盖方法做额外的处理。
postProcessBeanFactory(beanFactory);

//调用BeanFactoryPostProcessor,激活各种BeanFactory处理器
invokeBeanFactoryPostProcessors(beanFactory);

// Register bean processors that intercept bean creation.
//注册拦截Bean创建的Bean处理器,这里只是注册,真正调用实在getBean的时候。
registerBeanPostProcessors(beanFactory);

// Initialize message source for this context.
//为上下文初始化Message源,国际化处理
initMessageSource();

// Initialize event multicaster for this context.
//初始化应用消息广播器,并放入applicationEventMulticaster bean中
initApplicationEventMulticaster();

// Initialize other special beans in specific context subclasses.
留给子类来初始化其他的Bean
onRefresh();

// Check for listener beans and register them.
在所有注册的bean中查找Listener bean,注册到消息广播器中
registerListeners();

// Instantiate all remaining (non-lazy-init) singletons.
//初始化剩下的单实例,非惰性的
finishBeanFactoryInitialization(beanFactory);

// Last step: publish corresponding event.
完成刷新过程,通知生命周期处理器lifecycleProcessor刷新过程,同时发出ContextRefreshEvent通知别人
finishRefresh();
}

catch (BeansException ex) {
// Destroy already created singletons to avoid dangling resources.
destroyBeans();

// Reset 'active' flag.
cancelRefresh(ex);

// Propagate exception to caller.
throw ex;
}
}
}

重点看下ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();这句,告诉子类启动refreshBeanFactory方法以及通过getBeanFactory获得BeanFactory:

1
2
3
4
5
6
7
8
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
refreshBeanFactory();
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
if (logger.isDebugEnabled()) {
logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
}
return beanFactory;
}

refreshBeanFactory方法在AbstractRefreshableApplicationContext实现:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
protected final void refreshBeanFactory() throws BeansException {
//如果已经存在BeanFactory,销毁并关闭
if (hasBeanFactory()) {
destroyBeans();
closeBeanFactory();
}
try {
//创建IOC容器,创建了DefaultListableBeanFactory容器,给ApplicationContext使用
DefaultListableBeanFactory beanFactory = createBeanFactory();
beanFactory.setSerializationId(getId());
customizeBeanFactory(beanFactory);
//启动对BeanDefinitions的载入
loadBeanDefinitions(beanFactory);
synchronized (this.beanFactoryMonitor) {
this.beanFactory = beanFactory;
}
}
catch (IOException ex) {
throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
}
}

对BeanDefinition的载入,loadBeanDefinitions方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
//创建bean读取器,容器使用该读取器去读取Bean定义资源
XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

//配置bean读取器
beanDefinitionReader.setEnvironment(this.getEnvironment());
beanDefinitionReader.setResourceLoader(this);
beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));

//当Bean读取器读取Bean定义的xml资源文件时,启用xml的校验机制
initBeanDefinitionReader(beanDefinitionReader);
//通过beanDefinitionReader加载BeanDefinitions
loadBeanDefinitions(beanDefinitionReader);
}

loadBeanDefinitions(beanDefinitionReader)方法:

1
2
3
4
5
6
7
8
9
10
11
12
protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
//获得Bean配置文件的资源位置
Resource[] configResources = getConfigResources();
if (configResources != null) {
reader.loadBeanDefinitions(configResources);
}
String[] configLocations = getConfigLocations();
if (configLocations != null) {
//最终还是转换成Resource的形式去加载资源
reader.loadBeanDefinitions(configLocations);
}
}

在AbstractBeanDefinitionReader中的loadBeanDefinitions(configResources)方法:

1
2
3
4
5
6
7
8
9
10
public int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException {
Assert.notNull(resources, "Resource array must not be null");
int counter = 0;
for (Resource resource : resources) {
//此处loadBeanDefinitions并没有实现,具体实现在各个子类中
//比如XmlBeanDefinitionReader中
counter += loadBeanDefinitions(resource);
}
return counter;
}

XmlBeanDefinitionReader中的loadBeanDefinitions方法:

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 int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();
if (currentResources == null) {
currentResources = new HashSet<EncodedResource>(4);
this.resourcesCurrentlyBeingLoaded.set(currentResources);
}
try {
//得到xml文件的InputStream
InputStream inputStream = encodedResource.getResource().getInputStream();
try {
//得到InputSource
InputSource inputSource = new InputSource(inputStream);
if (encodedResource.getEncoding() != null) {
inputSource.setEncoding(encodedResource.getEncoding());
}
//doLoadBeanDefinitions是从xml文件中加载BeanDefinitions
return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
}
finally {
inputStream.close();
}
}
catch (IOException ex) {......}
finally {......}
}

xml配置文件的读取以及转化为Bean对象的过程

当Spring定位到xml之后,将xml转换为文件流的形式,作为InputSource和Resource对象传递给文档解析器进行解析,文档解析的开始是XmlDefinitionReader的doLoadBeanDefinitions方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
//inputSource是SAX的InputSource
//resource对象是对xml文件描述的一个对象
protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource) throws BeanDefinitionStoreException {
try {
//xml的解析模式
int validationMode = getValidationModeForResource(resource);
//将inputResource解析为Document对象
Document doc = this.documentLoader.loadDocument(
inputSource, getEntityResolver(), this.errorHandler, validationMode, isNamespaceAware());
//Document传递给registerBeanDefinitions方法
//此方法才是真正把Document对象解析为BeanDefinition对象的具体实现
return registerBeanDefinitions(doc, resource);
}
}

registerBeanDefinitions方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
// Support old XmlBeanDefinitionParser SPI for backwards-compatibility.
if (this.parserClass != null) {
XmlBeanDefinitionParser parser =
(XmlBeanDefinitionParser) BeanUtils.instantiateClass(this.parserClass);
return parser.registerBeanDefinitions(this, doc, resource);
}
//先实例化一个BeanDefinitionDocumentReader,这个对象是通过BeanUtils.instantiateClass方法实例化出来的
//实际上BeanUtils.instantiateClass中是封装了Java的反射的一些方法,通过基本的Java反射来构造实例。
BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();

//记录下注册之前BeanDefinition中对象的个数。
int countBefore = getRegistry().getBeanDefinitionCount();
//开始解析Document
documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
return getRegistry().getBeanDefinitionCount() - countBefore;
}

DefaultBeanDefinitionDocumentReader类中的registerBeanDefinitions方法:

1
2
3
4
5
6
7
//在这里解析Document
public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
this.readerContext = readerContext;
logger.debug("Loading bean definitions");
Element root = doc.getDocumentElement();
doRegisterBeanDefinitions(root);
}

doRegisterBeanDefinitions方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
protected void doRegisterBeanDefinitions(Element root) {
String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
if (StringUtils.hasText(profileSpec)) {
Assert.state(this.environment != null, "environment property must not be null");
String[] specifiedProfiles = StringUtils.tokenizeToStringArray(profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
if (!this.environment.acceptsProfiles(specifiedProfiles)) {
return;
}
}

//BeanDefinitionParserDelegate对象描述了Spring中bean节点中定义的所有属性和子节点
BeanDefinitionParserDelegate parent = this.delegate;
this.delegate = createHelper(readerContext, root, parent);

//xml解析的预处理,可以自己定义一些节点属性等,此方法Spring默认实现为空
preProcessXml(root);
//把Document对象解析为BeanDefinition对象
parseBeanDefinitions(root, this.delegate);
//xml解析的后处理,可以在解析完xml之后,实现自己的逻辑。Spring默认实现为空。
postProcessXml(root);

this.delegate = parent;
}

parseBeanDefinitions方法:

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
//解析在root级别的元素,比如import,alias,bean
protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
//校验是不是Spring的默认命名空间。
//默认命名空间是http://www.springframework.org/schema/beans
//如果是Spring的默认命名空间,就按照默认命名空间来解析,否则就按照自定义标签来解析
if (delegate.isDefaultNamespace(root)) {
NodeList nl = root.getChildNodes();
for (int i = 0; i < nl.getLength(); i++) {
Node node = nl.item(i);
if (node instanceof Element) {
Element ele = (Element) node;
//查看子节点是不是默认命名空间,是就按照默认解析,不是就按照自定义标签进行解析
if (delegate.isDefaultNamespace(ele)) {
//解析Spring默认的标签
parseDefaultElement(ele, delegate);
}
else {
//解析自定义标签
delegate.parseCustomElement(ele);
}
}
}
}
else {
//解析自定义标签
delegate.parseCustomElement(root);
}
}

解析默认的标签,parseDefaultElement方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//此方法会依次解析文档中的import,alias,bean,beans标签
private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
importBeanDefinitionResource(ele);
}
else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
processAliasRegistration(ele);
}
else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
processBeanDefinition(ele, delegate);
}
else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
// recurse
doRegisterBeanDefinitions(ele);
}
}

import标签的解析,importBeanDefinitionResource方法:

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
protected void importBeanDefinitionResource(Element ele) {
//获取import标签中的resource属性,此属性表示资源地址
//resource属性不可为空
String location = ele.getAttribute(RESOURCE_ATTRIBUTE);
if (!StringUtils.hasText(location)) {
getReaderContext().error("Resource location must not be empty", ele);
return;
}

// 解析resource中的占位符为真正的路径,比如"${user.dir}"
location = environment.resolveRequiredPlaceholders(location);

Set<Resource> actualResources = new LinkedHashSet<Resource>(4);

// 解析路径,判断是相对路径还是绝对路径
boolean absoluteLocation = false;
try {
absoluteLocation = ResourcePatternUtils.isUrl(location) || ResourceUtils.toURI(location).isAbsolute();
}
catch (URISyntaxException ex) {...}
//绝对路径
if (absoluteLocation) {
try {
//递归调用Bean的解析过程
int importCount = getReaderContext().getReader().loadBeanDefinitions(location, actualResources);
}
}
else {//相对路径,计算出绝对路径,进行递归调用解析过程
try {
int importCount;
Resource relativeResource = getReaderContext().getResource().createRelative(location);
if (relativeResource.exists()) {
importCount = getReaderContext().getReader().loadBeanDefinitions(relativeResource);
actualResources.add(relativeResource);
}
else {
String baseLocation = getReaderContext().getResource().getURL().toString();
importCount = getReaderContext().getReader().loadBeanDefinitions(
StringUtils.applyRelativePath(baseLocation, location), actualResources);
}
if (logger.isDebugEnabled()) {
logger.debug("Imported " + importCount + " bean definitions from relative location [" + location + "]");
}
}
catch (IOException ex) {......}
}
//解析完成后进行监听器激活处理
Resource[] actResArray = actualResources.toArray(new Resource[actualResources.size()]);
getReaderContext().fireImportProcessed(location, actResArray, extractSource(ele));
}

总结

  • IOC容器初始化入口是在构造方法中调用refresh开始的。
  • 通过ResourceLoader来完成资源文件位置的定位,DefaultResourceLoader是默认的实现,同时上下文本身就给除了ResourceLoader的实现。
  • 创建的IOC容器是DefaultListableBeanFactory。
  • IOC对Bean的管理和依赖注入功能的实现是通过对其持有的BeanDefinition进行相关操作来完成的。
  • 通过BeanDefinitionReader来完成定义信息的解析和Bean信息的注册。
  • XmlBeanDefinitionReader是BeanDefinitionReader的实现了,通过它来解析xml配置中的bean定义。
  • 实际的处理过程是委托给BeanDefinitionParserDelegate来完成的。得到Bean的定义信息,这些信息在Spring中使用BeanDefinition对象来表示。
  • BeanDefinition的注册是由BeanDefinitionRegistry实现的registerBeanDefiition方法进行的。内部使用ConcurrentHashMap来保存BeanDefiition。
坚持原创技术分享,您的支持将鼓励我继续创作!
Fork me on GitHub