Spring源码分析：applicationContext.xml文件解析与NamespaceHandler

最新推荐文章于 2024-09-16 19:59:11 发布

北纬@叶枫

最新推荐文章于 2024-09-16 19:59:11 发布

阅读量314

点赞数

分类专栏： spring 文章标签： spring

原文链接：https://blog.csdn.net/u010013573/article/details/86674990

版权

spring 专栏收录该内容

21 篇文章 1 订阅

订阅专栏

applicationContext.xml文件解析

Spring容器启动，在创建BeanFactory时，需要加载和解析当前ApplicationContext对应的配置文件applicationContext.xml，从而获取bean相关的配置信息。
在内部实现的调用关系为：ApplicationContext通过XmlBeanDefinitionReader来完成从applicationContext.xml获取应用配置的bean信息，并注册到关联的BeanFactory中。XmlBeanDefinitionReader的主要工作为解析xml文件的标签，包括从bean标签直接创建BeanDefinition，以及创建用于处理context:component-scan标签的BeanFactoryPostProcessor，然后间接创建BeanDefinitions。
整个解析过程如下：
- XmlBeanDefinitionReader创建DefaultBeanDefinitionDocumentReader对象实例，读取XML文件并封装成Document对象，然后将该Document对象作为参数，调用DefaultBeanDefinitionDocumentReader的registerBeanDefinitions，在registerBeanDefinitions中解析XML文件的内容，从中获取并生成beanDefinitions；
- registerBeanDefinitions方法：从XML文件对应的Document对象获取root Element，从root Element一直往下解析所有的xml标签Element；
- 针对每个xml标签Element，解析过程为：新增一个与该Element对应的BeanDefinitionParserDelegate，根据该Element的命名空间nameSpaceUri，从NamespaceHandlerResolver获取该nameSpaceUri对应的NamespaceHandler；
- 其中NamespaceHandler内部维护了xml标签和xml标签解析器BeanDefinitionParser的映射，所以由NamespaceHandler获取当前正在处理的xml标签Element对应的标签处理器BeanDefinitionParser（如< bean …>标签处理器则直接创建BeanDefinition对象，而< component-scan …>标签则是创建一个BeanFactoryPostProcessor，之后由该BeanFactory后置处理器通过扫描指定包获取类并生成BeanDefinition注册到BeanFactory），由该BeanDefinitionParser从xml标签Element生成注册到BeanFactory的BeanDefinition，或者生成BeanFactoryPostProcessor。
所以这里就需要定义每个标签对应一个特定的标签解析器了，在spring内部是通过BeanDefinitionParser接口来定义的。

NamespaceHandler

在Spring的设计当中，通常每个标签都属于一个特定的名称空间来避免名称冲突，如context名称空间，mvc名称空间等，每个名称空间内部可定义多个标签。
使用NamespaceHandler接口来维护每个名称空间内部的标签和标签处理器之间的映射关系。这样XmlBeanDefinitionReader在解析applicationContext.xml文件时，遇到某个名称空间，则获取这名称空间对应的NamespaceHandler，然后通过NamespaceHandler进一步获取内部标签对应的标签处理器。

Spring内部的使用和源码实现

在spring-context，spring-webmvc，spring-beans等spring框架子项目的META-INF/spring.handlers文件中，定义标签命名空间与NamespaceHandler实现类之间的映射关系。

如下为spring-webmvc子项目的META-INF/spring.handlers文件内容：

http\://www.springframework.org/schema/mvc=org.springframework.web.servlet.config.MvcNamespaceHandler

对应的NamespaceHandler的实现类为：

package org.springframework.web.servlet.config;
/**
 * {@link NamespaceHandler} for Spring MVC configuration namespace.
 *
 * @author Keith Donald
 * @author Jeremy Grelle
 * @author Sebastien Deleuze
 * @since 3.0
 */
public class MvcNamespaceHandler extends NamespaceHandlerSupport {

	@Override
	public void init() {
		registerBeanDefinitionParser("annotation-driven", new AnnotationDrivenBeanDefinitionParser());
		registerBeanDefinitionParser("default-servlet-handler", new DefaultServletHandlerBeanDefinitionParser());
		registerBeanDefinitionParser("interceptors", new InterceptorsBeanDefinitionParser());
		registerBeanDefinitionParser("resources", new ResourcesBeanDefinitionParser());
		registerBeanDefinitionParser("view-controller", new ViewControllerBeanDefinitionParser());
		registerBeanDefinitionParser("redirect-view-controller", new ViewControllerBeanDefinitionParser());
		registerBeanDefinitionParser("status-controller", new ViewControllerBeanDefinitionParser());
		registerBeanDefinitionParser("view-resolvers", new ViewResolversBeanDefinitionParser());
		registerBeanDefinitionParser("tiles-configurer", new TilesConfigurerBeanDefinitionParser());
		registerBeanDefinitionParser("freemarker-configurer", new FreeMarkerConfigurerBeanDefinitionParser());
		registerBeanDefinitionParser("groovy-configurer", new GroovyMarkupConfigurerBeanDefinitionParser());
		registerBeanDefinitionParser("script-template-configurer", new ScriptTemplateConfigurerBeanDefinitionParser());
		registerBeanDefinitionParser("cors", new CorsBeanDefinitionParser());
	}

}

XmlBeanDefinitionReader主要是从applicationContext.xml创建一个Document对象，交给子组件BeanDefinitionDocumentReader处理这个Document对象。而NamespaceHandler的实现类主要是在BeanDefinitionDocumentReader中在解析Document对象的Element元素时调用，如下：

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;
	}
	
	// 通过这个NamespaceHandler
	// 在它里面维护的parser集合中找到
	// 与该标签对应的parser，由该parser来执行解析
	
	return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
}

以上已经说明了通过XmlBeanDefinitionReader的NamespaceHandlerResolver维护：名称空间和NamespaceHandler的映射；通过NamespaceHandler来维护标签和Parser的映射，那么两者是什么时候初始化注册的呢？

其实NamespaceHandler和Parser的初始化，使用的是懒加载机制，即当调用了NamespaceHandlerResolver的resolve方法时，才进行加载，加载之后进行缓存。如下：

NamespaceHandler的初始化：在DefaultNamespaceHandlerResolver的getHandlerMappings方法实现。在resolve方法中调用getHandlerMappings方法。

/**
 * Load the specified NamespaceHandler mappings lazily.
 */
private Map<String, Object> getHandlerMappings() {
	Map<String, Object> handlerMappings = this.handlerMappings;
	if (handlerMappings == null) {
		synchronized (this) {
			handlerMappings = this.handlerMappings;
			if (handlerMappings == null) {
				if (logger.isTraceEnabled()) {
					logger.trace("Loading NamespaceHandler mappings from [" + this.handlerMappingsLocation + "]");
				}
				try {
					Properties mappings =
							PropertiesLoaderUtils.loadAllProperties(this.handlerMappingsLocation, this.classLoader);
					if (logger.isTraceEnabled()) {
						logger.trace("Loaded NamespaceHandler mappings: " + mappings);
					}
					handlerMappings = new ConcurrentHashMap<>(mappings.size());
					CollectionUtils.mergePropertiesIntoMap(mappings, handlerMappings);
					this.handlerMappings = handlerMappings;
				}
				catch (IOException ex) {
					throw new IllegalStateException(
							"Unable to load NamespaceHandler mappings from location [" + this.handlerMappingsLocation + "]", ex);
				}
			}
		}
	}
	return handlerMappings;
}

从META-INF/spring.handlers文件加载键值对，并缓存在类型为ConcurrentHashMap的handlerMappings中；
注意这里并没有初始化NamespaceHandler，即handlerMappings的value还是String类型。

NamespaceHandler包含的parsers的初始化：在resolve方法中进行懒加载初始化。

  /**
   * Locate the {@link NamespaceHandler} for the supplied namespace URI
   * from the configured mappings.
   * @param namespaceUri the relevant namespace URI
   * @return the located {@link NamespaceHandler}, or {@code null} if none found
   */
  @Override
  @Nullable
  public NamespaceHandler resolve(String namespaceUri) {
  
      // 懒加载NamespaceHandler的handlerMappings
      
  	Map<String, Object> handlerMappings = getHandlerMappings();
  	Object handlerOrClassName = handlerMappings.get(namespaceUri);
  	if (handlerOrClassName == null) {
  		return null;
  	}
  	
  	// 不是第一次调用，则已经是NamespaceHandler类型了，可以直接返回
  	
  	else if (handlerOrClassName instanceof NamespaceHandler) {
  		return (NamespaceHandler) handlerOrClassName;
  	}
  	
  	// 第一次调用，由上面分析可知：
  	// 刚开始从META-INF/spring.handlers
  	// 读出时，handlerMappings的value是字符串
  	
  	else {
  		String className = (String) handlerOrClassName;
  		try {
  		
  		// 加载NamespaceHandler
  		
  			Class<?> handlerClass = ClassUtils.forName(className, this.classLoader);
  			if (!NamespaceHandler.class.isAssignableFrom(handlerClass)) {
  				throw new FatalBeanException("Class [" + className + "] for namespace [" + namespaceUri +
  						"] does not implement the [" + NamespaceHandler.class.getName() + "] interface");
  			}
  			NamespaceHandler namespaceHandler = (NamespaceHandler) BeanUtils.instantiateClass(handlerClass);
  			
  			// 调用init方法完成parsers的初始化
  			
  			namespaceHandler.init();
  			handlerMappings.put(namespaceUri, namespaceHandler);
  			return namespaceHandler;
  		}
  		catch (ClassNotFoundException ex) {
  			throw new FatalBeanException("Could not find NamespaceHandler class [" + className +
  					"] for namespace [" + namespaceUri + "]", ex);
  		}
  		catch (LinkageError err) {
  			throw new FatalBeanException("Unresolvable class definition for NamespaceHandler class [" +
  					className + "] for namespace [" + namespaceUri + "]", err);
  		}
  	}
  }
  
  protected final void registerBeanDefinitionParser(String elementName, BeanDefinitionParser parser) {
    this.parsers.put(elementName, parser);
  }

NamespaceHandler的init方法实现：各个NamespaceHandler接口实现类，在init方法中注册xml的标签和Parser之间的映射关系：如下为context标签的名称空间处理器ContextNamespaceHandler：

/**
 * {@link org.springframework.beans.factory.xml.NamespaceHandler}
 * for the '{@code context}' namespace.
 *
 * @author Mark Fisher
 * @author Juergen Hoeller
 * @since 2.5
 */
public class ContextNamespaceHandler extends NamespaceHandlerSupport {

	@Override
	public void init() {
		registerBeanDefinitionParser("property-placeholder", new PropertyPlaceholderBeanDefinitionParser());
		registerBeanDefinitionParser("property-override", new PropertyOverrideBeanDefinitionParser());
		registerBeanDefinitionParser("annotation-config", new AnnotationConfigBeanDefinitionParser());
		
		// <context:component-scan />
	
    	registerBeanDefinitionParser("component-scan", new ComponentScanBeanDefinitionParser());
		registerBeanDefinitionParser("load-time-weaver", new LoadTimeWeaverBeanDefinitionParser());
		registerBeanDefinitionParser("spring-configured", new SpringConfiguredBeanDefinitionParser());
		registerBeanDefinitionParser("mbean-export", new MBeanExportBeanDefinitionParser());
		registerBeanDefinitionParser("mbean-server", new MBeanServerBeanDefinitionParser());
	}

}

插件机制拓展支持

如果需要开发一个插件并自定义标签，然后融入到Spring容器中，则可以在自身插件项目中，基于NamespaceHandler来实现，如在Dubbo项目中，就是利用了Spring的这个机制来容器到Spring框架的，具体可以看我的另外一篇文章：Dubbo源码分析：全透明接入spring和ServiceBean和Referencebean的接口设计与实现
基本步骤包括：
1. 自定义xsd标签定义，并添加到插件项目的META-INF目录中，路径类似于一个普通pacakage下面的一个类；
2. 实现BeanDefinitionParser接口，定义标签的处理逻辑；
3. 实现NamespaceHandler接口，一般继承Spring的NamespaceHandlerSupport即可。在init方法中，使用registerBeanDefinitionParser方法配置标签名称和BeanDefinitionParser实现类的映射关系。
4. 在META-INF/spring.schemas文件中，定义xsd文件全限定名与一个在applicationContext.xml文件中可以配置的命名空间url的映射；
5. 在META-INF/spring.handlers文件中，定义以上命名空间url和该NamespaceHandler实现类的映射。