本文共 14929 字，大约阅读时间需要 49 分钟。

接上文spring源码阅读 四

解析默认标签中的自定义标签元素

上文我们知道了默认标签解析函数的起始函数

/**	 * Process the given bean element, parsing the bean definition	 * and registering it with the registry.	 * 1 委托BeanDefinitionDelegate类的parseBeanDefinitionElement方法进行元素解析，此时bdHolder已经包含配置文件	 * 中的属性，如class,name,id	 * 2 当bdHolder不为空时，如存在默认标签的子节点下在有自定义属性，还需要再次解析	 * 3 解析完成，进行bdHolder进行注册	 * 4 响应事件，通知监听器，完成bean加载	 */	protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
   		BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);		if (bdHolder != null) {
   			bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);			try {
   				// Register the final decorated instance.				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));		}	}

BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);这个函数我们已经分析过了，下面我们来分析当bdHolder不为空的情况，也就是用户自定义标签的解析bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);

如下代码，myname2是自定义标签元素

这种自定义类型是针对于属性的，我们解析一下decorateBeanDefinitionIfRequired

/**	 * Decorate the given bean definition through a namespace handler, if applicable.	 * @param ele the current element	 * @param originalDef the current bean definition	 * @return the decorated bean definition	 */	public BeanDefinitionHolder decorateBeanDefinitionIfRequired(Element ele, BeanDefinitionHolder originalDef) {
   		return decorateBeanDefinitionIfRequired(ele, originalDef, null);	}

发现他调用的是decorateBeanDefinitionIfRequired(ele, originalDef, null);点击查看详细情况

/**	 * 完成自定义标签元素的解析	 * @param ele the current element	 * @param originalDef the current bean definition	 * @param containingBd the containing bean definition (if any)	 * @return the decorated bean definition	 */	public BeanDefinitionHolder decorateBeanDefinitionIfRequired(			Element ele, BeanDefinitionHolder originalDef, @Nullable BeanDefinition containingBd) {
   		BeanDefinitionHolder finalDefinition = originalDef;		// Decorate based on custom attributes first.		NamedNodeMap attributes = ele.getAttributes();		for (int i = 0; i < attributes.getLength(); i++) {
   			// NamedNodeMap.item(i)返回指定索引处的属性节点（Attr），或者，当索引超出或等于属性节点的数量时，返回 null。			Node node = attributes.item(i);			finalDefinition = decorateIfRequired(node, finalDefinition, containingBd);		}		// Decorate based on custom nested elements.		NodeList children = ele.getChildNodes();		// 遍历所有的子节点，看看是否有适用于修饰的子元素		for (int i = 0; i < children.getLength(); i++) {
   			Node node = children.item(i);			if (node.getNodeType() == Node.ELEMENT_NODE) {
   				finalDefinition = decorateIfRequired(node, finalDefinition, containingBd);			}		}		return finalDefinition;	}

上面我们可以看到所有的我们都用到了decorateIfRequired函数

/**	 * Decorate the given bean definition through a namespace handler,	 * if applicable.	 * @param node the current child node	 * @param originalDef the current bean definition	 * @param containingBd the containing bean definition (if any)	 * @return the decorated bean definition	 */	public BeanDefinitionHolder decorateIfRequired(			Node node, BeanDefinitionHolder originalDef, @Nullable BeanDefinition containingBd) {
           // 获取命名空间		String namespaceUri = getNamespaceURI(node);		// 如果 命名空间不为空 并且指定了默认命名空间		if (namespaceUri != null && !isDefaultNamespace(namespaceUri)) {
   			NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);			if (handler != null) {
   				BeanDefinitionHolder decorated =						handler.decorate(node, originalDef, new ParserContext(this.readerContext, this, containingBd));				if (decorated != null) {
   					return decorated;				}			}			else if (namespaceUri.startsWith("http://www.springframework.org/schema/")) {
   				error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", node);			}			else {
   				// A custom namespace, not to be handled by Spring - maybe "xml:...".				if (logger.isDebugEnabled()) {
   					logger.debug("No Spring NamespaceHandler found for XML schema namespace [" + namespaceUri + "]");				}			}		}		return originalDef;	}

即使，我们程序的逻辑大致是这样子的，首先获取属性或者元素的命名空间，以此来判断该元素或者属性是否适应于自定义标签的解析条件，找出自定义类型对应的NamespaceHandle并进行进一步解析，解析完成之后的工作就是进行bean的注册

也就是processBeanDefinittion函数里的BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());

/**	 * 注册解析的BeanDefinition	 * @param definitionHolder the bean definition including name and aliases	 * @param registry the bean factory to register with	 * @throws BeanDefinitionStoreException if registration failed	 */	public static void registerBeanDefinition(			BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)			throws BeanDefinitionStoreException {
   		// 使用BeanName做唯一标识注册		String beanName = definitionHolder.getBeanName();		registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());		// 注册所有的别名		String[] aliases = definitionHolder.getAliases();		if (aliases != null) {
   			for (String alias : aliases) {
   				registry.registerAlias(beanName, alias);			}		}	}

解析的beanDefinition都会被注册到BeanDefinitionRegister类型的实例中，而对于beanDefiition的注册则分为了两个部分，通过beanNmae的注册以及通过别名的注册

通过beanName注册BeanDefinition

对于beanDefinitin的注册，spring将beanDefinintion直接放进map，使用beanName作为key,真正完成注册功能的是DefaultListableBeanFactory

// DefaultListableBeanFactory.java	@Override	public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)			throws BeanDefinitionStoreException {
   		Assert.hasText(beanName, "Bean name must not be empty");		Assert.notNull(beanDefinition, "BeanDefinition must not be null");		if (beanDefinition instanceof AbstractBeanDefinition) {
   			try {
   				// 注册前的最后一次校验				// 主要是对于AbstractBeanDefinition 属性中的methodOverrides校验				// 校验methodOverrides 是否与工厂方法并存或者methodOverrides对应的方法不存在				((AbstractBeanDefinition) beanDefinition).validate();			}			catch (BeanDefinitionValidationException ex) {
   				throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,						"Validation of bean definition failed", ex);			}		}		BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);	   // 对应的beanName已经被注册并且在配置中配置了不允许被覆盖		if (existingDefinition != null) {
   			if (!isAllowBeanDefinitionOverriding()) {
   				throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);			}			else if (existingDefinition.getRole() < beanDefinition.getRole()) {
   				// e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE				if (logger.isInfoEnabled()) {
   					logger.info("Overriding user-defined bean definition for bean '" + beanName +							"' with a framework-generated bean definition: replacing [" +							existingDefinition + "] with [" + beanDefinition + "]");				}			}			else if (!beanDefinition.equals(existingDefinition)) {
   				if (logger.isDebugEnabled()) {
   					logger.debug("Overriding bean definition for bean '" + beanName +							"' with a different definition: replacing [" + existingDefinition +							"] with [" + beanDefinition + "]");				}			}			else {
   				if (logger.isTraceEnabled()) {
   					logger.trace("Overriding bean definition for bean '" + beanName +							"' with an equivalent definition: replacing [" + existingDefinition +							"] with [" + beanDefinition + "]");				}			}			this.beanDefinitionMap.put(beanName, beanDefinition);		}		else {
   			if (hasBeanCreationStarted()) {
   				// Cannot modify startup-time collection elements anymore (for stable iteration)				synchronized (this.beanDefinitionMap) {
   					this.beanDefinitionMap.put(beanName, beanDefinition);					List
   
     updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);					updatedDefinitions.addAll(this.beanDefinitionNames);					updatedDefinitions.add(beanName);					this.beanDefinitionNames = updatedDefinitions;					removeManualSingletonName(beanName);				}			}			else {
   				// Still in startup registration phase				this.beanDefinitionMap.put(beanName, beanDefinition);				this.beanDefinitionNames.add(beanName);				removeManualSingletonName(beanName);			}			this.frozenBeanDefinitionNames = null;		}		if (existingDefinition != null || containsSingleton(beanName)) {
   			resetBeanDefinition(beanName);		}	}
   

这里我们可以看到有一个方法hasBeanCreationStarted被加锁了，那么hasBeanCreationStarted到底是干什么的，为什么要对他加锁

其实hasBeanCreationStarted主要是判断是不是已经有bean被创建了（这里如果已经存在bean的创建，那么代表我们已经开始进行了业务操作，Spring容器无法保证使用者是在线程安全的情况下调用了，也就是无法保证下面的代码不会出现线程安全问题，所以需要加锁）

上述代码逻辑大概是这样的

1. 对AbstractBeanDefinition的校验，主要针对于AbstractBeanDefinition的methodOverrides属性
2. 对于beanName已经注册的情况的处理，如果设置了不允许覆盖，则需要抛出异常，否则直接覆盖
3. 加入map缓存
4. 清除解析之前留下的对应的beanName缓存

通过别名注册BeanDefinition

通过别名注册的方法是**registry.registerAlias(beanName, alias);**点击发现他的实现类是在SimpleAliasRegistry里面的，我们看一下源码

@Override	public void registerAlias(String name, String alias) {
   		Assert.hasText(name, "'name' must not be empty");		Assert.hasText(alias, "'alias' must not be empty");		synchronized (this.aliasMap) {
   			if (alias.equals(name)) {
   				this.aliasMap.remove(alias);				if (logger.isDebugEnabled()) {
   					logger.debug("Alias definition '" + alias + "' ignored since it points to same name");				}			}			else {
   				String registeredName = this.aliasMap.get(alias);				if (registeredName != null) {
   					if (registeredName.equals(name)) {
   						// An existing alias - no need to re-register						return;					}					if (!allowAliasOverriding()) {
   						throw new IllegalStateException("Cannot define alias '" + alias + "' for name '" +								name + "': It is already registered for name '" + registeredName + "'.");					}					if (logger.isDebugEnabled()) {
   						logger.debug("Overriding alias '" + alias + "' definition for registered name '" +								registeredName + "' with new target name '" + name + "'");					}				}				checkForAliasCircle(name, alias);				this.aliasMap.put(alias, name);				if (logger.isTraceEnabled()) {
   					logger.trace("Alias definition '" + alias + "' registered for name '" + name + "'");				}			}		}	}

1. alias与beanName相同的处理情况，如果相同则不需要处理并删除原来的alias
2. alias覆盖处理，如果aliasName已经使用并已经指向了另一个beanName则需要用户的设置进行处理
3. 循环检查 当A→B存在，如果在出现A→C→B时出现异常
4. 注册

通知监听器解析注册完成 主要留给开发者实现

上文说到了别名，那么我们就来看一下别名的注册与解析

/**	 * Process the given alias element, registering the alias with the registry.	 */	protected void processAliasRegistration(Element ele) {
   		String name = ele.getAttribute(NAME_ATTRIBUTE);		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;		}		if (valid) {
   			try {
   				getReaderContext().getRegistry().registerAlias(name, alias);			}			catch (Exception ex) {
   				getReaderContext().error("Failed to register alias '" + alias +						"' for bean with name '" + name + "'", ele, ex);			}			getReaderContext().fireAliasRegistered(name, alias, extractSource(ele));		}	}

import标签解析

import作用一般是用来引入外部其他配置文件的，以后如果有新的文件就只需要简单的修改这一个文件了，spring对于import是如何解析

spring 解析import的代码在importBeanDefinitionResource里面，我们看一下源码

/**	 * Parse an "import" element and load the bean definitions	 * from the given resource into the bean factory.	 */	protected void importBeanDefinitionResource(Element ele) {
   		String location = ele.getAttribute(RESOURCE_ATTRIBUTE);		if (!StringUtils.hasText(location)) {
   			getReaderContext().error("Resource location must not be empty", ele);			return;		}		// Resolve system properties: e.g. "${user.dir}"		location = getReaderContext().getEnvironment().resolveRequiredPlaceholders(location);		Set
   
     actualResources = new LinkedHashSet<>(4);		// Discover whether the location is an absolute or relative URI		boolean absoluteLocation = false;		try {
   			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*:"		}		// Absolute or relative?		if (absoluteLocation) {
   			try {
   				int importCount = getReaderContext().getReader().loadBeanDefinitions(location, actualResources);				if (logger.isTraceEnabled()) {
   					logger.trace("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 {
   			// No URL -> considering resource location as relative to the current file.			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.isTraceEnabled()) {
   					logger.trace("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]);		getReaderContext().fireImportProcessed(location, actResArray, extractSource(ele));	}
   

主要逻辑

1. 获取resource属性所表示的路径
2. 解析路径中的系统属性，格式“${user,dir}”
3. 判断location是绝对路径还是相对路径
4. 如果是绝对路径就递归调用bean的解析过程，进行另一次解析
5. 如果是相对路径则计算出绝对路径进行解析
6. 通知监听器，解析完成

自定义标签的解析

自定义标签的解析主要是delegate.parseCustomElement(ele);

查看源码

@Nullable	public BeanDefinition parseCustomElement(Element ele, @Nullable BeanDefinition containingBd) {
   		String namespaceUri = getNamespaceURI(ele);		if (namespaceUri == null) {
   			return null;		}		// 根据命名空间找到对应的NamespaceHandler		NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);		if (handler == null) {
   			error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele);			return null;		}		// 调用自定义的NameSpaceHandle进行解析		return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));	}

转载地址：http://onkgn.baihongyu.com/