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的解析大概流程就是這樣，感覺記錄的比較凌亂，先記錄下吧，等下又忘記了。