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

妖狐艹你老母 2022-03-22 12:11 224阅读 0赞

### 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方法时，才进行加载，加载之后进行缓存。如下：
    
    1.  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;
            }
        
        1.  从META-INF/spring.handlers文件加载键值对，并缓存在类型为ConcurrentHashMap的handlerMappings中；
        2.  注意这里并没有初始化NamespaceHandler，即handlerMappings的value还是String类型。
    2.  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);
              }
    3.  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的接口设计与实现  
    ][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实现类的映射。

[Dubbo_spring_ServiceBean_Referencebean_]: https://blog.csdn.net/u010013573/article/details/85282790