目录
//TODO 解析Document 填充BeanDefintion对象源码分析未完成
前言：通过写了两篇博文Spring源码分析之一BeanFactory相关和spring源码分析之BeanDefinition相关两篇博文后，我们真正要探究的主题才要开始了。接下来让我们以一个常见的业务场景为例子 以XML的形式一步一步揭开spring容器的使用的神秘面纱。
一、spring容器使用的业务场景
1、xml配置
-
<?xml version="1.0" encoding="UTF-8"?>
-
<!-- 从 xsi:schemaLocation中值得后缀可以看出次xml验证模式是xsd模式 -->
-
<beans xmlns="http://www.springframework.org/schema/beans"
-
xmlns:xsi=
"http://www.w3.org/2001/XMLSchema-instance"
-
xsi:schemaLocation=
"http://www.springframework.org/schema/beans
-
http://www.springframework.org/schema/beans/spring-beans.xsd">
-
-
<!-- xml的形式声明一个需要spring容器帮我们管理的bean实例 -->
-
<bean id="worker" class="com.xiu.bean.Worker" >
-
<property name="name" value="索隆" />
-
</bean>
-
</beans>
-
2、java类
-
//需要spring管理的bean
-
public
class Worker {
-
private String name;
-
-
public Worker(){
-
System.out.println(
"the worker object is finish");
-
}
-
-
public void setName(String name) {
-
this.name = name;
-
}
-
-
public String getName() {
-
return name;
-
}
-
}
-
-
//测试类
-
@Test
-
public void testGetBean(){
-
//创建beanFactory对象工厂
-
XmlBeanFactory beanFactory =
new XmlBeanFactory(
new ClassPathResource(
"spring-beans.xml"));
-
//从工厂中获取对应的bean实例
-
Worker worker = beanFactory.getBean(
"worker", Worker.class);
-
}
3、输出结果
4、总结
总的来说我么需要分析测试方法中的两行代码，看似简单的两行但是分析起来代码很庞大，这大概就是源码分析让人又爱又恨的魔力吧。鉴于篇幅较长，两行代码一行代码一篇博文来介绍
- XmlBeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("spring-beans.xml"));
- Worker worker = beanFactory.getBean("worker", Worker.class);
第一行代码到底做了那些功能呢？让我们一起来探究一下吧。
二、spring容器获取bean实例的流程
1、功能分析
抛开复杂细节基于我们使用spring以及测试结果，大致分析一下上面做了那些工作。
1、首先资源文件xml的加载和解析（需要把bean标签的一些属性和子标签解析的相关数据信息解析出来）
2、实例化bean这样我们才可以拿出使用
2、容器获取bean实例流程概览
- 初始对应的BeanFactory
- 将对应的资源包装成便于spring统一管理的Resource
- 将Resource实例根据不同的验证方式（DTD或者XSD） 转换为对应的Document
- 解析Docuemnt的标签元素 包含两种解析方式 默认标签解析和自定义标签解析。
3、初始对应的BeanFactory
-
//XmlBeanFactory类
-
//调用XmlBeanFactory构造器
-
public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException {
-
//调用父类DefaultListableBeanFactory构造器 该类继续调用其父类AbstractAutowireCapableBeanFactory构造器
-
super(parentBeanFactory);
-
//将xml对应的resource 转换为BeanDefiniion并装载在Spring容器中
-
this.reader.loadBeanDefinitions(resource);
-
}
-
-
//----------------------------------------------------------------------------------------------------//
-
-
-
//AbstractAutowireCapableBeanFactory类
-
//最终调用其爷爷类的AbstractAutowireCapableBeanFactory
-
public AbstractAutowireCapableBeanFactory(@Nullable BeanFactory parentBeanFactory) {
-
//执行相关的接口忽略注入
-
this();
-
//如果该工厂对象有父BeanFactory 则设置其父BeanFactory
-
setParentBeanFactory(parentBeanFactory);
-
}
-
-
//this()方法
-
public AbstractAutowireCapableBeanFactory() {
-
//调用其父类AbstractBeanFactory 空构造器
-
super();
-
//设置需要忽略依赖注入的接口
-
//正常情况下如果如果一个类实例 beanA依赖 另一个实例beanB 则在初始化beanA的时候 需要先初始化beanB
-
//但是ignoreDependencyInterface声明忽略其对应的beanB的时候 则beanA初始化的时候不会初始化beanB
-
//如果实例bean 实现了如下的BeanNameAware（设置BeanName）、BeanFactoryAware（设置BeanFactory）、BeanClassLoaderAware（设置BeanClassLoader）三个接口
-
//则bean 依赖的beanName、BeanFactory、BeanClassLoader属性不会去初始化 而是spring根据bean的生命周期内将对应的属性设置进去
-
//https://blog.csdn.net/wubai250/article/details/8255918 挺不错的
-
ignoreDependencyInterface(BeanNameAware.class);
-
ignoreDependencyInterface(BeanFactoryAware.class);
-
ignoreDependencyInterface(BeanClassLoaderAware.class);
-
}
-
-
4、resource转换Document
-
//XmlBeanFactory
-
//使用XmlBeanDefinitionReader 来实现如下功能
-
//将xml对应的resource 转换为BeanDefiniion并装载在Spring容器中
-
this.reader.loadBeanDefinitions(resource);
-
-
-
//---------------------------------------------------------------------------------------------//
-
-
-
//XmlBeanDefinitionReader
-
//真正的资源加载并转换为BeanDefinition
-
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);
-
}
-
//获取到存在的资源列表 并添加其新加载的资源 重复加载会抛出响应异常
-
Set<EncodedResource> currentResources =
this.resourcesCurrentlyBeingLoaded.get();
-
if (currentResources ==
null) {
-
currentResources =
new HashSet<>(
4);
-
this.resourcesCurrentlyBeingLoaded.set(currentResources);
-
}
-
if (!currentResources.add(encodedResource)) {
-
throw
new BeanDefinitionStoreException(
-
"Detected cyclic loading of " + encodedResource +
" - check your import definitions!");
-
}
-
try {
-
//获取inputStrem 流对象 将其包装成适合进行xml解析的InputSource
-
InputStream inputStream = encodedResource.getResource().getInputStream();
-
try {
-
InputSource inputSource =
new InputSource(inputStream);
-
if (encodedResource.getEncoding() !=
null) {
-
inputSource.setEncoding(encodedResource.getEncoding());
-
}
-
//执行真正的转换xml为document 解析document 转换为BeanDefinition
-
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);
-
//解析doc中的属性转换为BeanDefinition对象 并注册在spring容器中 该部分功能我们放后面讲解
-
return registerBeanDefinitions(doc, resource);
-
}
-
-
//省略一些异常捕获处理代码
-
catch (BeanDefinitionStoreException ex) {
-
throw ex;
-
}
-
}
-
-
//执行将resource资源文件转换为Document的操作
-
protected Document doLoadDocument(InputSource inputSource, Resource resource) throws Exception {
-
//转换document功能不由该类本身完成 而是委托给了DoucmentLoader(其实真正实现转换Doc功能的
-
是其子类DefaultDoucmentLoader)
-
//参数本身有符合xml解析的InputSource类
-
//EntityResolver 作用提供一个解析xml的DTD/XSD声明的方法 来避免从网络上寻找声明出现的问题
-
//对于解析XMl sax需要先读取xml文档声明 以便对其xml文档进行验证。
-
//errorHandler错误处理类
-
//ValidationMode xml验证模式 XSD 或者DTD
-
//NamespaceAware 是否感知xml的命名空间
-
//这里需要着重介绍一下其
-
return
this.documentLoader.loadDocument(inputSource, getEntityResolver(),
-
this.errorHandler,
-
getValidationModeForResource(resource), isNamespaceAware());
-
}
-
-
//---------------------------------------------------------------------------------------------//
-
-
//DefaultDoucmentLoader类
-
//很简单一般的解析XML的方式 获取DocumentBuilderFactory 工厂创建DocumentBuilder 调用其parse（）方法 将资源Resource转换为Document。
-
public Document loadDocument(InputSource inputSource, EntityResolver entityResolver,
-
ErrorHandler errorHandler, int validationMode, boolean namespaceAware)
throws Exception {
-
-
DocumentBuilderFactory factory = createDocumentBuilderFactory(validationMode, namespaceAware);
-
if (logger.isDebugEnabled()) {
-
logger.debug(
"Using JAXP provider [" + factory.getClass().getName() +
"]");
-
}
-
DocumentBuilder builder = createDocumentBuilder(factory, entityResolver, errorHandler);
-
return builder.parse(inputSource);
-
}
-
-
5、解析Docuemnt转换为BeanDefinition
在4中我们介绍了资源转换为Document的流程 在XmlBeanDefinitionReader 类的doLoadBeanDefinitions()方法
-
//将对应资源转换为Document对象
-
Document doc = doLoadDocument(inputSource, resource);
-
//解析doc中的属性转换为BeanDefinition对象 并注册在spring容器中
-
return registerBeanDefinitions(doc, resource);
registerBeanDefinitions(doc,resource)则对应接下来的主题解析document对象 并将其转换为BeanDefinitions()
-
//XmlBeanDefinitionReader
-
public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
-
//BeanDefinitionDocumentReader 主要的作用是读取Document 并注册BeanDefinition对象
-
BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
-
int countBefore = getRegistry().getBeanDefinitionCount();
-
//执行读取Document转换为BeanDefinition注册spring 委托给BeanDefinitionDocumentReader 来进行处理()真正实现是DefaultBeanDefinitionDocumentReader
-
documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
-
//返回BeanDefinition成功的个数
-
return getRegistry().getBeanDefinitionCount() - countBefore;
-
}
-
-
//-------------------------------------------------------------------------------------------------------//
-
-
//DefaultBeanDefinitionDocumentReader
-
//调用DefaultBeanDefinitionDocumentReader实现类的registerBeanDefinitions
-
@Override
-
public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
-
this.readerContext = readerContext;
-
logger.debug(
"Loading bean definitions");
-
Element root = doc.getDocumentElement();
-
//执行真正的核心的解析document注册BeanDefinition
-
doRegisterBeanDefinitions(root);
-
}
-
-
-
protected void doRegisterBeanDefinitions(Element root) {
-
//具体的解析document 还是委托给了BeanDefinitionParserDelegate 来进行处理
-
BeanDefinitionParserDelegate parent =
this.delegate;
-
this.delegate = createDelegate(getReaderContext(), root, parent);
-
-
if (
this.delegate.isDefaultNamespace(root)) {
-
//获取对应的profile 从而应用profile对应环境
-
String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
-
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;
-
}
-
}
-
}
-
//document解析之前的处理 空实现 如果想要在document解析之前做一些特定操作
-
// 可以使用子类继承该类并重写该方法
-
preProcessXml(root);
-
//执行document解析
-
parseBeanDefinitions(root,
this.delegate);
-
//document解析之后的处理 空实现 如果想要在document解析之后做一些特定操作
-
//可以使用子类继承该类并重写该方法
-
postProcessXml(root);
-
-
this.delegate = parent;
-
}
-
-
-
protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
-
//如果是xml默认的命名空间则说明xml配置的标签是类似于<bean id="" cals="" />等
-
//如果是xml不是默认的命名空间则说明xml配置的标签是类似于<tx:annotation-driven />
-
//等自定义标签
-
//两者标签解析差别很对 默认的配置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)) {
-
//默认标签元素解析 beans 默认字标签<import> <bean> <property>等
-
parseDefaultElement(ele, delegate);
-
}
-
else {
-
//自定义标签解析 需要结合用户实现的相关接口配合解析
-
delegate.parseCustomElement(ele);
-
}
-
}
-
}
-
}
-
else {
-
//自定义标签解析 需要结合用户实现的相关接口配合解析
-
delegate.parseCustomElement(root);
-
}
-
}
三、spring默认标签的解析
在上面的逻辑中 我们大致分析了如何将xml转换为Document,对应的document转换为BeanDefinition并注册的解析逻辑，但是关于标签的详细解析留在这个环节去讲解，首先根据上面的代码分析我们可以清楚的知道有关spring标签的解析分为两类，
- 默认标签的解析，例如：
<bean id="son" class="" >
<alias />
- 自定义标签的解析
<tx:advice />
<aop:config/>
1、默认标签解析分析
默认标签分为四种import标签，alias标签，bean标签，beans标签 四种类似，spring源码中分别对于这四种默认标签提供了对应的四个方法分别进行解析对应的标签。
-
//对Spring beans xml 配置的默认标签进行解析 默认标签 包含几个大类
-
// 1、import导入别的xml配置
-
// 2、alias显示注册别名
-
// 3、bean 对应配置的实例bean解析 是我们最常用同时也是最重要的解析方法（主要探究点）
-
// 4、beans 即<beans /> 标签下包含一个内部的<beans /> (本地使用递归)
-
private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
-
//如果对应的doc节点是import 走import标签解析逻辑
-
if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
-
importBeanDefinitionResource(ele);
-
}
-
//如果对应的doc节点是alias 走注册别名的逻辑
-
else
if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
-
processAliasRegistration(ele);
-
}
-
//如果对应的doc节点是bean 走注册解析bean标签并转换为BeanDefinition对象的逻辑
-
else
if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
-
processBeanDefinition(ele, delegate);
-
}
-
//内部beans 标签解析 再次调用该类的doRegisterBeanDefinitions()
-
//把其当做一个新的beans.xml直接进行解析
-
else
if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
-
// recurse 递归执行
-
doRegisterBeanDefinitions(ele);
-
}
-
}
1、import标签解析
import标签可以使我们的spring配置结构清晰 对于比较有着庞大配置的项目，我们可以将具体的某个相似的功能bean配置 分模块的配置在单独的xml配置文件中，比如数据源相关的配置spring-datasource.xml、缓存相关的配置 spring-cache.xml ，在最终的配置xml文件中使用import的方式将其引入 条理清晰 可读性也好。
-
//import标签解析的具体逻辑
-
protected void importBeanDefinitionResource(Element ele) {
-
//获取import标签的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值
-
location = getReaderContext().getEnvironment().
-
resolveRequiredPlaceholders(location);
-
-
Set<Resource> actualResources =
new LinkedHashSet<>(
4);
-
// Discover whether the location is an absolute or relative URI
-
boolean absoluteLocation =
false;
-
try {
-
//如果location是URL或者绝对的uri
-
//（意思是表明该资源绝对路径可以被识别能访问到真实的资源）
-
absoluteLocation = ResourcePatternUtils.isUrl(location) ||
-
//ResourceUtils.toURI(location).isAbsolute();
-
}
-
catch (URISyntaxException ex) {
-
// cannot convert to an URI, considering the location relative
-
// unless it is the well-known Spring prefix "classpath*:"
-
}
-
//资源是绝对路径
-
if (absoluteLocation) {
-
try {
-
//最终还是调用我们前面追踪到的XmlBeanDefintion的loadBeanDefinitions()方法（）
-
int importCount = getReaderContext().getReader()
-
.loadBeanDefinitions(location, actualResources);
-
if (logger.isDebugEnabled()) {
-
logger.debug(
"Imported " + importCount +
" bean definitions
-
from URL location [" + location +
"]");
-
}
-
}
-
catch (BeanDefinitionStoreException ex) {
-
getReaderContext().error(
-
"Failed to import bean definitions from URL location
-
[" + location +
"]", ele, ex);
-
}
-
}
-
else {
-
// 没有绝对路径 则根据location获取相对资源 如果资源存在直接调用如上相同的方法
-
// 资源不存在 获取其根路径+location(相对路径)得到一个相对路径资源同样调用如上相同的方法
-
//其他情况 抛出异常信息
-
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) {
-
getReaderContext().error(
"Failed to resolve current resource location",
-
ele, ex);
-
}
-
catch (BeanDefinitionStoreException ex) {
-
getReaderContext().error(
"Failed to import bean definitions from
-
relative location [" + location +
"]",ele, ex);
-
}
-
}
-
Resource[] actResArray = actualResources.toArray(
new Resource[
0]);
-
//触发事件监听器 通知import解析完成
-
getReaderContext().fireImportProcessed(location, actResArray, extractSource(ele));
-
}
2、alias标签解析
alias标签可以让我们显式为我们所定义的bean添加别名
-
//别名标签注册 在进行bean定义的时候 除了使用id name定义名字外 还可以使用<alias />指定别名
-
protected void processAliasRegistration(Element ele) {
-
//获取alias标签的name属性 beanName
-
//（该属性值和配置中的某个bean的id或者name有直接或者间接的联系
-
//即beanName最终会指向配置中的某个bean）
-
String name = ele.getAttribute(NAME_ATTRIBUTE);
-
//获取alias标签的alias属性别名
-
String alias = ele.getAttribute(ALIAS_ATTRIBUTE);
-
boolean valid =
true;
-
if (!StringUtils.hasText(name)) {
-
getReaderContext().error(
"Name must not be empty", ele);
-
valid =
false;
-
}
-
if (!StringUtils.hasText(alias)) {
-
getReaderContext().error(
"Alias must not be empty", ele);
-
valid =
false;
-
}
-
// name属性 和alias属性存在
-
if (valid) {
-
try {
-
//获取注册别名的类进行别名注册 默认实现类SimpleAliasRegistry
-
//使用map来存储name和alias的关联关系
-
getReaderContext().getRegistry().registerAlias(name, alias);
-
}
-
catch (Exception ex) {
-
getReaderContext().error(
"Failed to register alias '" + alias +
-
"' for bean with name '" + name +
"'", ele, ex);
-
}
-
//触发事件监听器 通知alias解析完成
-
getReaderContext().fireAliasRegistered(name, alias, extractSource(ele));
-
}
-
}
3、beans标签的解析
beans.xml中嵌入式的beans标签，一般很少使用，但是非常类似于import标签的功能，本质上是将其当做beans标签递归调用解析beans的方法进行解析。此处不再进行描述。
4、bean标签的解析
beans标签是我们最常用同时也是spring最核心的解析逻辑，spring用了大量的篇幅来解析相关的bean标签，接下来让我们一步一步分析一下bean标签的解析流程
4.1、processBeanDefinition方法
-
//最常见的最核心最终的bean标签的解析
-
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
-
//解析bean标签 将其转换为BeanDefinition 保存在BeanDefinitionHolder中
-
//（BeanDefinitionHolder中 持有一个BeanDefinition对象）
-
BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
-
if (bdHolder !=
null) {
-
//当对应的BeanDefinitionHolder存在的时候 如果bean标签中有我们自定义的属性
-
//或者自定义的子节点标签
-
//对其自定义标签或者属性进行解析
-
bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
-
try {
-
//注册最终解析并修饰后的BeanDefinition实例
-
//经过上面两部的操作得到的BeanDefinition对象 已经满足后续的使用要求了
-
// 接下来剩下的工作是注册对应的bean
-
BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder,
-
getReaderContext().getRegistry());
-
}
-
catch (BeanDefinitionStoreException ex) {
-
getReaderContext().error(
"Failed to register bean definition with name '"
-
bdHolder.getBeanName() +
"'", ele, ex);
-
}
-
//发送注册bean的事件监听 通知该对应的bean定义已经注册成功
-
getReaderContext().fireComponentRegistered(
-
new BeanComponentDefinition(bdHolder));
-
}
-
}
下面我们分析一下这个方法主要逻辑：
- 委托BeanDefinitionParserDelegate 调用其parseBeanDefinitionElement()方法对bean的标签进行解析
- BeanDefinitionHolder如果存在且其中我们自定义的属性 或者自定义的子节点标签 再次对自定义标签进行解析
- 经过上面两部的操作得到的BeanDefinition对象 已经满足后续的使用要求了 接下来剩下的工作是注册BeanDefinition对象
- 最后触发响应事件，通知相关的监视器告知其对应的beanDefinition对象加载完成
4.2、parseBeanDefinitionElement方法
该方法主要是将bean的相关属性比如 id,class parent等进行解析填充到BeanDefintion实例并将其放BeanDefinitionHolder中。
-
//解析Bean
-
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
-
//获取bean标签的id 和name属性 name属性根据",;"将其转换为数组存放在list中
-
//如果没有id 则别名的一个座位其唯一标识beanName(也是bean的原始名字)
-
String id = ele.getAttribute(ID_ATTRIBUTE);
-
String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);
-
List<String> aliases =
new ArrayList<>();
-
if (StringUtils.hasLength(nameAttr)) {
-
String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
-
aliases.addAll(Arrays.asList(nameArr));
-
}
-
String beanName = id;
-
if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
-
beanName = aliases.remove(
0);
-
if (logger.isDebugEnabled()) {
-
logger.debug(
"No XML 'id' specified - using '" + beanName +
-
"' as bean name and " + aliases +
" as aliases");
-
}
-
}
-
if (containingBean ==
null) {
-
//检查beanName是否已经被使用 没有被使用 将beanName和aliases 存放到usedNames列表中
-
checkNameUniqueness(beanName, aliases, ele);
-
}
-
//前面只是针对id和name属性进行解析获取别名的处理 该行代码对bean标签的其他属性进行解析并初始化BeanDefinition
-
AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
-
if (beanDefinition !=
null) {
-
//如果beanName不存在则使用spring中提供的命名规则生成对应的beanName
-
if (!StringUtils.hasText(beanName)) {
-
try {
-
if (containingBean !=
null) {
-
beanName = BeanDefinitionReaderUtils.generateBeanName(
-
beanDefinition,
this.readerContext.getRegistry(),
true);
-
}
-
else {
-
beanName =
this.readerContext.generateBeanName(beanDefinition);
-
//如果有可能的话为该beanDefinition再注册一个别名 别名为beanClassName
-
String beanClassName = beanDefinition.getBeanClassName();
-
if (beanClassName !=
null &&
-
beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&
-
!
this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {
-
aliases.add(beanClassName);
-
}
-
}
-
if (logger.isDebugEnabled()) {
-
logger.debug(
"Neither XML 'id' nor 'name' specified - " +
-
"using generated bean name [" + beanName +
"]");
-
}
-
}
-
catch (Exception ex) {
-
error(ex.getMessage(), ele);
-
return
null;
-
}
-
}
-
// 根据beanDefintion对象、beanName,别名列表 创建BeanDefinitionHolder 并返回
-
String[] aliasesArray = StringUtils.toStringArray(aliases);
-
return
new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
-
}
-
return
null;
-
}
下面我们分析一下这个方法主要逻辑：
- 解析bean的id，name属性转换为对应的beanName属性和别名alias列表
- 调用parseBeanDefinitionElement()方法对除了已经解析的id,name属性其他属性进行解析并填充BeanDefinition对象
- 如果beanName不存在则根据不同的规则生成对应的beanName
- 将对应的beanDefintion属性、beanName、alias作为参数创建BeanDefintionHolder对象并返回。
4.3、parseBeanDefinitionElement()方法
该方法对bean标签的除了id,name的其他属性进行解析，并将对应的属性值填充到BeanDefintion对象中。
-
//对处理别名（bean标签的id属性和name属性）之外的其他标签进行解析处理
-
@Nullable
-
public AbstractBeanDefinition parseBeanDefinitionElement(
-
Element ele, String beanName, @Nullable BeanDefinition containingBean) {
-
//在parseState中存放一个beanName对应的BenEntry对象 表明该bean实例正在被解析为BeanDefinition
-
//解析完成后该beanName对应的BenEntry对象应该会被移除
-
this.parseState.push(
new BeanEntry(beanName));
-
-
//获取class属性
-
String className =
null;
-
if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
-
className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
-
}
-
//获取该实例需要继承的父类对象的bean（父类Bean的id 或者beanName）
-
String parent =
null;
-
if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
-
parent = ele.getAttribute(PARENT_ATTRIBUTE);
-
}
-
-
try {
-
//初始化一个AbstractBeanDefinition对象并设置属性beanClass 和parentName
-
AbstractBeanDefinition bd = createBeanDefinition(className, parent);
-
//设置Scope Abstract lazyInit、autowire、depends-on、autowire-candidate
-
// primary、init-method、destroy-method、factory-method、factory-bean等属性
-
parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
-
//设置beanDefinition的描述信息
-
bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
-
//解析bean标签的子<meta />标签
-
parseMetaElements(ele, bd);
-
//解析bean标签的lookup-method子标签
-
//将其转换为LookUpMethodOverride属性添加到BeanDefinition
-
parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
-
//解析bean标签的replaced-method子标签
-
//将其转换为ReplaceOverride属性添加到BeanDefinition
-
parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
-
//解析bean标签的constructor-arg子标签
-
parseConstructorArgElements(ele, bd);
-
//解析bean标签的property子标签
-
parsePropertyElements(ele, bd);
-
//解析bean标签的Qualifier子标签
-
parseQualifierElements(ele, bd);
-
-
bd.setResource(
this.readerContext.getResource());
-
bd.setSource(extractSource(ele));
-
-
return bd;
-
}
-
catch (ClassNotFoundException ex) {
-
error(
"Bean class [" + className +
"] not found", ele, ex);
-
}
-
catch (NoClassDefFoundError err) {
-
error(
"Class that bean class [" + className +
"] depends on not found", ele, err);
-
}
-
catch (Throwable ex) {
-
error(
"Unexpected failure during bean definition parsing", ele, ex);
-
}
-
finally {
-
//移除解析标记
-
this.parseState.pop();
-
}
-
return
null;
-
}
至此通过xml配置一个普通的bean 并交由spring管理 然后XmlBeanFactory 获取的第一部分(处理具体的解析document初始阿化BeanDefinition对象)总结完成。笔者才疏学浅，在本篇博文的分析中如果有理解不到的地方，欢迎大家批评指正。
转载：https://blog.csdn.net/liushangzaibeijing/article/details/105173989
查看评论