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

朴灿烈づ我的快乐病毒、 2022-03-30 07:46 221阅读 0赞

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