Spring源码学习(二)默认bean标签学习记录

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 } 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 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的解析大概流程就是这样，感觉记录的比较凌乱，先记录下吧，等下又忘记了。