spring的标签解析是从DefaultBeanDefinitionDocumentReader这个类的parseBeanDefinitions这个方法开始解析的，就是解析我们定义在xml里面的标签，标签分为自定义标签和默认标签，这里记录一下默认标签的解析过程。
parseBeanDefinitions
DefaultBeanDefinitionDocumentReader类中的这个方法就是解析标签的，这个方法的两个参数Element就是xml解析的节点，BeanDefinitionParserDelegate是用来判断标签解析的，比如说判断标签是bean标签，还是import标签，还是alias标签等等。
这个方法比较简单就是循环变量Element的节点，然后判断是否有子节点，然后判断是否是默认标签，和自定义标签的不同解析方法，默认标签一般就是我们所说的bean标签，import标签之类的。自定义的标签就可以随意定义了，最常见的就是事物和切面了。
/**
* Parse the elements at the root level in the document:
* "import", "alias", "bean".
* @param root the DOM root element of the document
*/
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);
}
}
我们先看parseDefaultElement方法里面都干了什么，一共有四个标签，
下面就开始看看bean标签是怎么解析的，我们看到默认标签一共是从这四个方面去进行拆分的，我们就直接看bean的标签吧，这个我们用的最多。
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)) {
//这个就是bean标签的处理逻辑，先看这个。
processBeanDefinition(ele, delegate);
}
else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
// recurse
doRegisterBeanDefinitions(ele);
}
}
解析bean标签的方法是processBeanDefinition，这个方法的注释写的就是处理bean节点，解析bean的定义信息，并进行注册。
/**
* Process the given bean element, parsing the bean definition
* and registering it with the registry.
*/
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
//这行代码是关键，就是把ele转换成BeanDefinition，那这个方法做了什么事情呢，我们点进去看一下。
// 这里就获取到了bean定义信息的持有对象了
BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
if (bdHolder != null) {
// 这个方法理解过来的意思就是说如果有需要就对Definition进行装饰
// 这里就是判断一下默认标签里面是否包含自定义标签，如果包含自定义标签就出来一下，其实到这里为止，对标签的解析就已经结束了。
bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
try {
//到这里为止，解析、装饰都完成了，就差注册了，那到了这里就可以开始注册了，
BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
}
catch (BeanDefinitionStoreException ex) {
getReaderContext().error("Failed to register bean definition with name '" +
bdHolder.getBeanName() + "'", ele, ex);
}
// //注册完成之后就行注册监听事件分发
getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
}
}
delegate.parseBeanDefinitionElement(ele);
这个方法比较长，大概看一下，就是解析ele元素，然后返回BeanDefinitionHolder 对象，那解析ele的哪些元素呢，点击进去看一下。
/**
* Parses the supplied {@code <bean>} element. May return {@code null}
* if there were errors during parse. Errors are reported to the
* {@link org.springframework.beans.factory.parsing.ProblemReporter}.
*/
@Nullable
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
//id属性
String id = ele.getAttribute(ID_ATTRIBUTE);
//name属性
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));
}
//把id设置为beanName
String beanName = id;
if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
//别名优先级高，覆盖id的值。
beanName = aliases.remove(0);
if (logger.isDebugEnabled()) {
logger.debug("No XML 'id' specified - using '" + beanName +
"' as bean name and " + aliases + " as aliases");
}
}
//检查beanName是否有重复
if (containingBean == null) {
checkNameUniqueness(beanName, aliases, ele);
}
//这里就是执行解析的方法了，最后返回的就是一个beanDefinition 对象了。
AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
============================================
parseBeanDefinitionElement(ele, beanName, containingBean);这方法主要代码功能就是下面这个，里面做了具体的解析操作。
//创建beanDefinition 对象
AbstractBeanDefinition bd = createBeanDefinition(className, parent);
/***
* 解析下面这些标签属性 singleton scope abstract lazy-init autowire depends-on
* autowire-candidate primary init-method destroy-method factory-method
* factory-bean
*/
parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
// 解析description属性
bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
// 解析meta属性
parseMetaElements(ele, bd);
// 解析lookup-method属性
parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
// 解析replaced-method
parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
// 解析constructor-arg节点属性
parseConstructorArgElements(ele, bd);
// 解析property属性
parsePropertyElements(ele, bd);
// 解析qualifier属性
parseQualifierElements(ele, bd);
bd.setResource(this.readerContext.getResource());
bd.setSource(extractSource(ele));
// 属性解析完之后放到BeanDefinition的实现类里面去
============================================
if (beanDefinition != null) {
//这个判断就是判断beanName是否存在，不存在就使用默认生成的。
if (!StringUtils.hasText(beanName)) {
try {
if (containingBean != null) {
beanName = BeanDefinitionReaderUtils.generateBeanName(
beanDefinition, this.readerContext.getRegistry(), true);
}
else {
beanName = this.readerContext.generateBeanName(beanDefinition);
// Register an alias for the plain bean class name, if still possible,
// if the generator returned the class name plus a suffix.
// This is expected for Spring 1.2/2.0 backwards compatibility.
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;
}
}
String[] aliasesArray = StringUtils.toStringArray(aliases);
// 最后把获取到的信息封装成BeanDefinitionHolder对象
return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
}
return null;
}
关于bean的定义主要涉及类是BeanDefinition，这个是一个接口，具体实现类有AbstractBeanDefinition，AbstractBeanDefinition类有三个子类，ChildBeanDefinition，GenericBeanDefinition，RootBeanDefinition，这三个类基本就能完成所有bean定义信息了。
bean的解析大概流程就是这样，感觉记录的比较凌乱，先记录下吧，等下又忘记了。