Spring源码解读之BeanDefinition读取器
Spring源码解读之BeanDefinition读取器
BeanDefinitionReader
1、这个接口的功能就是将资源文件（spring的配置文件） 中的信息转换成BeanDefinition形式
2、这个是个顶级接口，其继承关系如下：
I BeanDefinitionReader
--- c AbastractBeanDefinitionReader
---- c PropertiesBeanDefinitionReader
-----c XmlBeanDefinitionReader
3、源码如下，其中定义了一些接口
public interface BeanDefinitionReader {
//获取BeanDefinitionRegistry对象，这个类的主要作用将BeanDefinition注册到BeanDefinition的注册表中
BeanDefinitionRegistry getRegistry();
//获取资源加载器，主要就是根据路径和ClassLoader获取Resource，之后通过Resource获取输入流读取文件
ResourceLoader getResourceLoader();
//Bean的类加载器
ClassLoader getBeanClassLoader();
//Bean的名字生成器，为匿名bean生成一个名字，就是id
BeanNameGenerator getBeanNameGenerator();
//加载 BeanDefiniton，从配置文件中通过ResouceLoader和Resource这个两个类加载资源
int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException;
int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException;
int loadBeanDefinitions(String location) throws BeanDefinitionStoreException;
int loadBeanDefinitions(String... locations) throws BeanDefinitionStoreException;
}
子类
AbstractBeanDefinitionReader
1、这个是抽象类，实现了BeanDefinitionReader这个接口
2、下面将是这个类重要方法loadBeanDefinitions，加载资源，根据用户输入路径结合资源加载器，获取Resource对象或者数组，之后将会调用loadBeanDefinitions(Resource resource)，这个方法在当前类中都没有定义，但是在其两个子类中定义了。
3、使用资源加载器分为加载单个资源的ResourceLoader和加载多个资源的ResourcePatternResolver
1、这个方法的主要思想就是根据用户提供的资源加载器的类型判断到底是加载单个资源还是加载多个资源
//加载资源的实际方法
public int loadBeanDefinitions(String location, Set<Resource> actualResources) throws BeanDefinitionStoreException {
//获取资源加载器，主要的功能就是根据路径和类加载器获取Resource对象
ResourceLoader resourceLoader = getResourceLoader();
//判断资源加载器是否为空
if (resourceLoader == null) {
throw new BeanDefinitionStoreException(
"Cannot import bean definitions from location [" + location + "]: no ResourceLoader available");
}
//ResourcePatternResolver 这个是用于加载多个文件或者能够加载Ant风格路径的文件资源，这个是ResouceLoader的子类，同样是接口
if (resourceLoader instanceof ResourcePatternResolver) {
try {
//使用ResourcePatternResolver这个接口中的getResouces方法，返回一个Resouce[]数组，实际上就是调用类加载器的getResouces(path）方法
Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);
//调用loadBeanDefinitions(Resource[] resource)的方法
int loadCount = loadBeanDefinitions(resources);
//如果actualResources不为空，将加载完成的数据添加到其中
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 { //加载单个文件资源
//直接使用ResouceLoader加载即可，不需要使用ResourcePatternReslover这个接口
Resource resource = resourceLoader.getResource(location);
//调用loadBeanDefinitions(Resource resource)
int loadCount = loadBeanDefinitions(resource);
//不为空，添加到其中
if (actualResources != null) {
actualResources.add(resource);
}
if (logger.isDebugEnabled()) {
logger.debug("Loaded " + loadCount + " bean definitions from location [" + location + "]");
}
return loadCount; //返回个数
}
}
4、从上面的源码可以知道，想要继续进行执行下去，需要子类提供的方法loadBeanDefinitions(Resource resource)。
XmlBeanDefinitionReader
1、这个类继承了抽象类AbstractBeanDefinitionReader，定义了loadBeanDefinitions(Resource resource)，完成了抽象类的资源加载
2、这个类主要就是加载XML文件
3、下面来看看loadBeanDefinitions(Resource resource)这个方法。
1、返回值表示从配置文件中加载的BeanDefiniton的数量，主要的思想是：在未加载之前从统计注册表中的数量，加载完成之后再次统计注册表中的数量，相减即可
@Override
public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
//调用该类中的重载方法，源码如下解析
return loadBeanDefinitions(new EncodedResource(resource));
}
4、loadBeanDefinitions(EncodedResource encodedResource) ：EncodedResource是用来指定编码解析XML文件资源
1、实际的作用就是将资源封装成InputSource对象，之后调用同类的doLoadBeanDefinitions(InputSource,Resource)
2、这个类用到了本地线程变量存储当前正在加载的资源，应该是开启多线程加载资源，之后会仔细研究下
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());
}
//从本地线程变量中获取当前的正在加载的资源
Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();
//如果本地线程变量中不存在正在加载的资源，那么将其添加进去
if (currentResources == null) {
currentResources = new HashSet<EncodedResource>(4);
this.resourcesCurrentlyBeingLoaded.set(currentResources);
}
//如果encodedResource添加进入currentResources失败，表明其中已经存在这个资源，只不过还没有加载完成，抛出重复加载的异常
if (!currentResources.add(encodedResource)) {
throw new BeanDefinitionStoreException(
"Detected cyclic loading of " + encodedResource + " - check your import definitions!");
}
try {
//获取文件的输入流
InputStream inputStream = encodedResource.getResource().getInputStream();
try {
//封装成InputSource，其中指定了输入流和编码格式
InputSource inputSource = new InputSource(inputStream);
//如果存在编码，那么将其添加进入InputSource中，
if (encodedResource.getEncoding() != null) {
inputSource.setEncoding(encodedResource.getEncoding());
}
//调用同类的方法继续解析
return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
}
finally {
//关闭输入流
inputStream.close();
}
}
catch (IOException ex) {
throw new BeanDefinitionStoreException(
"IOException parsing XML document from " + encodedResource.getResource(), ex);
}
finally {
//最后，加载完毕之后，从currentResources中移除
currentResources.remove(encodedResource);
//如果currentResources是空的，本地线程变量移除
if (currentResources.isEmpty()) {
this.resourcesCurrentlyBeingLoaded.remove();
}
}
}
5、继续上面的解析，现在调用doLoadBeanDefinitions(InputSource inputSource, Resource resource) 方法
1、创建Document对象，其实相当于js中的文档树的概念，可以获取文档的所有根节点等等方法
2、调用registerBeanDefinitions方法，详解看下一个
3、剩下的就是捕捉一些异常，并且抛出
protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
throws BeanDefinitionStoreException {
try {
//创建Document对象，这个HTML和XML的文档对象，相当于js中document树
//使用这个Document可以获取XML文件中的节点并且创建节点等等，实际上js中的document就是这个原理
Document doc = doLoadDocument(inputSource, resource);
//执行registerBeanDefinitions方法
return registerBeanDefinitions(doc, resource);
}
6、继续深入的调用registerBeanDefinitions(Document doc, Resource resource) 这个方法
1、创建BeanDefinitionDocumentReader对象，底层使用的BeanUtils创建的，其实使用的是反射机制创建的，这个在后面将会讲解到BeanUtils的源码
2、获取未加载之前的注册表中BeanDefiniton中的数量，保存在countBefore
//Document : 文档对象 Resource ： 资源对象
public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
//创建BeanDefinitionDocumentReader，这个是实际读取BeanDefiniton从XML的DOM树中
BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
//获取注册表beanDefinitionMap的数量，就是加载之前的注册表中存在的BeanDefiniton的数量
int countBefore = getRegistry().getBeanDefinitionCount();
//从XML文件读取内容，并且注册到BeanDefiniton注册表中，详情请看第7步
documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
return getRegistry().getBeanDefinitionCount() - countBefore;
}
//创建XmlReaderContext，使用Resource，需要指定资源提取器，问题报告等等
public XmlReaderContext createReaderContext(Resource resource) {
return new XmlReaderContext(resource, this.problemReporter, this.eventListener,
this.sourceExtractor, this, getNamespaceHandlerResolver());
}
7、BeanDefinitionDocumentReader中的registerBeanDefinitions方法，这只是一个接口，在他的默认时实现类org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader中有具体的实现
1、指定成员属性readerContext
2、获取根节点
3、继续调用doRegisterBeanDefinitions方法
@Override
public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
//指定上下文读取对象
this.readerContext = readerContext;
logger.debug("Loading bean definitions");
//获取根节点 root
Element root = doc.getDocumentElement();
//继续调用doRegisterBeanDefinitions（root)方法，详情看第8步
doRegisterBeanDefinitions(root);
}
8、doRegisterBeanDefinitions方法，解析
1、BeanDefinitionParserDelegate ：这个是BeanDefintion解析委托类，其中定义了spring配置文件中的节点内容，比如bean，property，byType等等
2、
protected void doRegisterBeanDefinitions(Element root) {
//BeanDefinitionParserDelegate ：这个是BeanDefintion解析委托类，其中主要
BeanDefinitionParserDelegate parent = this.delegate;
this.delegate = createDelegate(getReaderContext(), root, parent);
//判断这个根节点是否是默认的命名空间，底层就是判断这个根节点的nameSpaceUrl=="http://www.springframework.org/schema/beans"
if (this.delegate.isDefaultNamespace(root)) {
//获取这个profile属性的值，表示剖面，在springBoot中用于设置环境
String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
//如果profileSpec有值
if (StringUtils.hasText(profileSpec)) {
//根据分隔符换换成数组
String[] specifiedProfiles = StringUtils.tokenizeToStringArray(
profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
//判断这个切面是否是激活的环境，如果不是直接返回，表示这个配置文件不是当前运行环境的配置文件
if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {
if (logger.isInfoEnabled()) {
logger.info("Skipped XML bean definition file due to specified profiles [" + profileSpec +
"] not matching: " + getReaderContext().getResource());
}
return;
}
}
}
//在解析xml之前做的准备工作，其实什么也没做
preProcessXml(root);
//调用这个方法，解析
parseBeanDefinitions(root, this.delegate);
//后续处理的
postProcessXml(root);
this.delegate = parent;
}
//解析BeanDefiniton
protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
//如果是默认的命名空间
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)) {
//递归调用解析这个节点
parseDefaultElement(ele, delegate);
}
else {
//解析自定义元素
delegate.parseCustomElement(ele);
}
}
}
}
else {
//解析自定义元素
delegate.parseCustomElement(root);
}
}
BeanDefinitionDocumentReader
1、这个类的主要作用就是从Document（相当于DOM树，其中包含了XML文件中的全部信息）读取信息转换成BeanDefiniton，并且将读取到的BeanDefiniton注册到注册表中
2、这个接口只有一个方法，如下：
//注册BeanDefiniton
void registerBeanDefinitions(Document doc, XmlReaderContext readerContext)
throws BeanDefinitionStoreException;
}
总结
1、BeanDefinitonReader主要就是加载配置文件转换成BeanDefiniton的形式。其中还结合了一些类，如下：
1、EncodeResource : 编码形式的Resoruce
2、SAX ： 解析XML文件的类
3、BeanDefinitionDocumentReader ： 从给定的Document中读取信息到BeanDefiniton中，并且注册到注册表中，最主要的一个方法就是void registerBeanDefinitions(Document doc, XmlReaderContext readerContext)
参考文章
1、https://www.2cto.com/kf/201609/551189.html
2、https://www.cnblogs.com/jason0529/p/5239139.html
3、SAX解析XML文档https://blog.csdn.net/ydxlt/article/details/50183693
