上一章讲到refreshBeanFactory做了两件事情，一件是创建容器，一件是加载BeanDefinition，即loadBeanDefinitions()。加载BeanDefinition包含两个过程。本章讲第一点。

  1. 加载bean配置文件
  2. 解析bean配置文件

bean配置文件整体加载过程

加载bean配置文件的过程可以分为三个：

  1. 初始化XmlBeanDefinitionReader
  2. 解析资源文件路径
  3. 加载文件内容

loadBeanDefinitions()为抽象方法，由AbstractXmlApplicationContext实现。具体代码如下：

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
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
	// 创建一个Bean读取器，用于读取bean的配置资源，即我们在之前提到的BeanDefinitionReader
	XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

	beanDefinitionReader.setEnvironment(this.getEnvironment());
	// 设置spring资源加载器，其本身继承了DefaultResourceLoader，也是一个ResourceLoader
	beanDefinitionReader.setResourceLoader(this);
	// 设置xml解析器
	beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));

	// 初始化bean读取器的上下文，主要在这里设置了是否校验xml的开关
	initBeanDefinitionReader(beanDefinitionReader);
	// 真正实现加载BeanDefinition
	loadBeanDefinitions(beanDefinitionReader);
}

protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
	Resource[] configResources = getConfigResources();
	if (configResources != null) {
		reader.loadBeanDefinitions(configResources);
	}
	String[] configLocations = getConfigLocations();
	if (configLocations != null) {
		reader.loadBeanDefinitions(configLocations);
	}
}

真正实现加载BeanDefinition是由loadBeanDefinitions()来处理，这里getConfigResources()默认返回null，所以会走到第二个reader.loadBeanDefinitions()。第二个loadBeanDefinitions()在最后也会将configLocations转换成Resource对象，然后会调用到一个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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
// 第二个loadBeanDefinitions()，多次调用重载方法后的源码
public int loadBeanDefinitions(String location, @Nullable Set<Resource> actualResources) throws BeanDefinitionStoreException {
	// 获取初始化时，设置的resourceLoader
	ResourceLoader resourceLoader = getResourceLoader();
	if (resourceLoader == null) {
		throw new BeanDefinitionStoreException(
				"Cannot import bean definitions from location [" + location + "]: no ResourceLoader available");
	}

	if (resourceLoader instanceof ResourcePatternResolver) {
		try {
			// 将指定位置的bean配置信息解析为spring所封装的Resource对象
			Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);
			// 使用委派调用XmlBeanDefinitionReader.loadBeanDefinitions()。也就是上面第一个loadBeanDefinitions()
			int loadCount = loadBeanDefinitions(resources);
			if (actualResources != null) {
				for (Resource resource : resources) {
					actualResources.add(resource);
				}
			}
			if (logger.isDebugEnabled()) {
				logger.debug("Loaded " + loadCount + " bean definitions from location pattern [" + location + "]");
			}
			return loadCount;
		} catch (IOException ex) {
			throw new BeanDefinitionStoreException(
					"Could not resolve bean definition resource pattern [" + location + "]", ex);
		}
	} else {
		// 加载指定单个的Resource对象
		Resource resource = resourceLoader.getResource(location);
		// 使用委派调用XmlBeanDefinitionReader.loadBeanDefinitions()
		int loadCount = loadBeanDefinitions(resource);
		if (actualResources != null) {
			actualResources.add(resource);
		}
		if (logger.isDebugEnabled()) {
			logger.debug("Loaded " + loadCount + " bean definitions from location [" + location + "]");
		}
		return loadCount;
	}
}

小结一下。经过一系列的重载、委托，最后都会走到XmlBeanDefinitionReader.loadBeanDefinitions(Resource)。这也就是真正的加载方法，会在第三小节说明。而走到这个方法，所需要的Resource对象，则是通过resourceLoader.getResources()而来的。

解析资源文件路径

这里需要重提的是，在初始化XmlBeanDefinitionReader的时候，设置resourceLoader，传入的this，也就是ClassPathXmlApplicationContext对象。这里调用resourceLoader.getResources()则是父类(DefaultResourceLoader)所实现的方法。

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
public Resource getResource(String location) {
	Assert.notNull(location, "Location must not be null");

	for (ProtocolResolver protocolResolver : this.protocolResolvers) {
		Resource resource = protocolResolver.resolve(location, this);
		if (resource != null) {
			return resource;
		}
	}

	if (location.startsWith("/")) {
		// 如果是文件路径，走默认处理
		return getResourceByPath(location);
	} else if (location.startsWith(CLASSPATH_URL_PREFIX)) {
		return new ClassPathResource(location.substring(CLASSPATH_URL_PREFIX.length()), getClassLoader());
	} else {
		try {
			// 如果是URL路径，特殊处理
			URL url = new URL(location);
			return (ResourceUtils.isFileURL(url) ? new FileUrlResource(url) : new UrlResource(url));
		} catch (MalformedURLException ex) {
			// 既不是文件路径、也不是url形式路径
			return getResourceByPath(location);
		}
	}
}

protected Resource getResourceByPath(String path) {
	return new ClassPathContextResource(path, getClassLoader());
}

这里主要区分location是不是为url方法传入。如果是直接new一个UrlResource对象，否则会走到getResourceByPath()，而该方法为protected，允许子类重写，例如FileSystemXmlApplicationContext就重写了该方法，处理文件路径的location。如下

1
2
3
4
5
6
7
@Override
protected Resource getResourceByPath(String path) {
	if (path.startsWith("/")) {
		path = path.substring(1);
	}
	return new FileSystemResource(path);
}

加载文件内容

回到第一节留下的坑，XmlBeanDefinitionReader.loadBeanDefinitions(Resource)。

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
public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
	return loadBeanDefinitions(new EncodedResource(resource));
}
public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
	Assert.notNull(encodedResource, "EncodedResource must not be null");
	if (logger.isInfoEnabled()) {
		logger.info("Loading XML bean definitions from " + encodedResource.getResource());
	}
	// 非空处理
	...
	try {
		InputStream inputStream = encodedResource.getResource().getInputStream();
		try {
			// 开始解析，将资源文件转成sax所需的InputSource对象
			InputSource inputSource = new InputSource(inputStream);
			if (encodedResource.getEncoding() != null) {
				inputSource.setEncoding(encodedResource.getEncoding());
			}
			// 真实读取xml内容过程
			return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
		} finally {
			inputStream.close();
		}
	} catch (IOException ex) {
		throw new BeanDefinitionStoreException(
				"IOException parsing XML document from " + encodedResource.getResource(), ex);
	} finally {
		currentResources.remove(encodedResource);
		if (currentResources.isEmpty()) {
			this.resourcesCurrentlyBeingLoaded.remove();
		}
	}
}

protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
		throws BeanDefinitionStoreException {
	try {
		// 将其转成Document对象，到这里就慢慢的像我们自己写的代码了
		Document doc = doLoadDocument(inputSource, resource);
		// 继续将Document往下传，完成解析
		return registerBeanDefinitions(doc, resource);
	} catch ....{
		....
	}
}

protected Document doLoadDocument(InputSource inputSource, Resource resource) throws Exception {
	return this.documentLoader.loadDocument(inputSource, getEntityResolver(), this.errorHandler,
			getValidationModeForResource(resource), isNamespaceAware());
}

到这里为止，又分为两条路，一条就是加载Document对象，一条就是继续真正解析。前者是DefaultDocumentLoader调用jdk的JAXP将xml转换为所需要的Document对象，写过xml的应该很了解，这一块代码就不深入分析了。且看后者：registerBeanDefinitions()

1
2
3
4
5
6
7
8
9
public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
	// 使用委派，获得解析xml的对象
	BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
	int countBefore = getRegistry().getBeanDefinitionCount();
	// 解析过程的入口，具体实现由DefaultBeanDefinitionDocumentReader实现。
	documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
	// 统计解析bean数量
	return getRegistry().getBeanDefinitionCount() - countBefore;
}

总结一下，从最开始的loadBeanDefinitions()方法说起

  1. 初始化XmlBeanDefinitionReader。
  2. 由XmlBeanDefinitionReader调用loadBeanDefinitions()，该方法分两步：解析文件路径、加载文件内容。
  3. 解析文件路径，分别处理传入的location方式，封装成所需的Resource对象。
  4. 加载文件内容，又分为两步。通过jdk的JAXP将xml转换成文档对象、将该文档对象进行解析。

第4点中的第二个步骤:registerBeanDefinitions()下章单独描述。