上一篇以bean标签为例，介绍了属于defaultNamesapce标签的解析流程，但是defaultNamespace中默认的标签只有bean、beans、alias、import这四个，而我们平时在xml中配置的标签有很多。那其余的标签是如何解析？
在这篇文章会详细介绍定制化标签的解析流程。
注：除defaultNamesapce所属的4个标签外，其余所见标签都为定制化标签，包括自已根据业务定义的。
在看解析定制化标签流程的具体逻辑之前，先回顾一下registerBeanDefinitions方法中的流程。
配置文件
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:util="http://www.springframework.org/schema/util"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd>
<context:property-placeholder location="classpath:db.properties" ></context:property-placeholder>
<util:list></util:list>
<bean id="person" class="com.test.Person" scope="prototype">
<property name="id" value="1"></property>
<property name="name" value="zhangsan"></property>
</bean>
</beans>registerBeanDefinitions
这段代码一定不陌生，在上一篇中，根据EncodingResource创建了Doc对象后执行的方法就是这个，创建了BeanDefinitionDocumentReader 对象。但在创建完BDDR对象后，具体解析之前。
执行registerBeanDefinitions()方法传入的方法参数中还执行了createReaderContext()方法。
public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
// 对xml的beanDefinition进行解析
BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
int countBefore = getRegistry().getBeanDefinitionCount();
// 完成具体的解析过程
documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
return getRegistry().getBeanDefinitionCount() - countBefore;
}createReaderContext
createReaderContext方法中会执行getNamespaceHandlerResolver()方法。getNamespaceHandlerResolver()会返回一个DefaultNamespaceHandlerResolver对象封装进XmlReaderContext中。
而DefaultNamespaceHandlerResolver中有一个类变量是handlerMappingLocation，这个变量的值是类中的常量DEFAULT_HANDLER_MAPPINGS_LOCATION 。
public XmlReaderContext createReaderContext(Resource resource) {
return new XmlReaderContext(resource, this.problemReporter, this.eventListener,
this.sourceExtractor, this, getNamespaceHandlerResolver());
}public static final String DEFAULT_HANDLER_MAPPINGS_LOCATION = "META-INF/spring.handlers";public NamespaceHandlerResolver getNamespaceHandlerResolver() {
if (this.namespaceHandlerResolver == null) {
this.namespaceHandlerResolver = createDefaultNamespaceHandlerResolver();
}
return this.namespaceHandlerResolver;
}
protected NamespaceHandlerResolver createDefaultNamespaceHandlerResolver() {
ClassLoader cl = (getResourceLoader() != null ? getResourceLoader().getClassLoader() : getBeanClassLoader());
return new DefaultNamespaceHandlerResolver(cl);
}因为Spring框架在底层中说不定什么地方会进行类的加载，和父类构造器属性的一些赋值。用的时候就直接拿出来，所以有一些知识点不串起来会非常的突兀。不知道类、值都是哪来的。
前置的知识点已经介绍完，接下来让我们来看定制化标签的解析过程。
parseBeanDefinitions
如果是defaultNamespace会走bean、beans、import、alias中的一个。定制化的标签会走下面。
protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
if (delegate.isDefaultNamespace(root)) {
//上一篇已经介绍过，代码省略
}
else {
//执行定制化标签解析的具体逻辑
delegate.parseCustomElement(root);
}
}parseCustomElement
依然是获取对应的命名空间，并且根据namespaceUri，在readerContext中进行解析，找到对应的handler。
@Nullable
public BeanDefinition parseCustomElement(Element ele, @Nullable BeanDefinition containingBd) {
// 获取对应的命名空间
String namespaceUri = getNamespaceURI(ele);
if (namespaceUri == null) {
return null;
}
// 根据命名空间找到对应的NamespaceHandlerspring
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进行解析
return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
}resolve
resolve方法中，就是在上面提到的xmlReaderContext中获取defaultResolve来进行对应的处理。在通过mapping找到具体Handler处理类后，调用handler的init()方法，像parsers中注册，并且根据标签下，属性的不同，具体的parsers解析类实现也不同。
public NamespaceHandler resolve(String namespaceUri) {
// 获取所有已经配置好的handler映射
Map<String, Object> handlerMappings = getHandlerMappings();
// 根据命名空间找到对应的信息
Object handlerOrClassName = handlerMappings.get(namespaceUri);
if (handlerOrClassName == null) {
return null;
}
else if (handlerOrClassName instanceof NamespaceHandler) {
// 如果已经做过解析，直接从缓存中读取
return (NamespaceHandler) handlerOrClassName;
}
else {
// 没有做过解析，则返回的是类路径
String className = (String) handlerOrClassName;
try {
// 通过反射将类路径转化为类
Class<?> handlerClass = ClassUtils.forName(className, this.classLoader);
if (!NamespaceHandler.class.isAssignableFrom(handlerClass)) {
//省略异常..
}
// 实例化类
NamespaceHandler namespaceHandler = (NamespaceHandler) BeanUtils.instantiateClass(handlerClass);
// 调用自定义的namespaceHandler的初始化方法
namespaceHandler.init();
// 讲结果记录在缓存中
handlerMappings.put(namespaceUri, namespaceHandler);
return namespaceHandler;
}
}
}getHandlerMappings
在这个方法中，会找到配置文件中的handler映射。
这个方法比较有意思，如果是debug进来的话，那handlerMappings是有默认值的。因为idea编译器为了查看类的变量属性，会调用toString方法，而toString方法中就会显式调用getHandlerMappings。
如果handlerMappings 是null的话，则会通过loadAllProperties方法获取mapping，通过方法的参数中handlerMappingsLocation（固定常量），来进行对应META-INF/spring.handlers的加载。
private Map<String, Object> getHandlerMappings() {
Map<String, Object> handlerMappings = this.handlerMappings;
// 如果没有被缓存，则开始进行缓存
if (handlerMappings == null) {
synchronized (this) {
handlerMappings = this.handlerMappings;
if (handlerMappings == null) {
try {
// this.handlerMappingsLocation在构造函数中已经被初始化为META-INF/Spring.handlers
Properties mappings =
PropertiesLoaderUtils.loadAllProperties(this.handlerMappingsLocation, this.classLoader);
handlerMappings = new ConcurrentHashMap<>(mappings.size());
// 将properties格式文件合并到map格式的handlerMapping中
CollectionUtils.mergePropertiesIntoMap(mappings, handlerMappings);
this.handlerMappings = handlerMappings;
}
}
}
}
return handlerMappings;
}让我们来看一下spring.handlers是什么样。
spring.handlers就是key，value形式的文件格式，value就是对应标签的处理器，比如文章开头的context标签和util标签。在< beans xmls >中配置对应的属性后，xml文件即可引用对应标签及其属性，就可以获取到对应的namespaceUri来找到对应的handlerMapping。就可以进行具体handler类的一个加载。
UtilNamespaceHandler
这就是具体的handler类，在根据mapping找到具体的handler类后，会进行init方法的初始化操作，像util标签中list属性，会调用registerBeanDefinitionParser方法向parsers（Map<String, BeanDefinitionParser>）中进行注册，并且每个属性都有具体BeanDefinitionParser解析类来进行属性的解析。
public class UtilNamespaceHandler extends NamespaceHandlerSupport {
private static final String SCOPE_ATTRIBUTE = "scope";
@Override
public void init() {
registerBeanDefinitionParser("constant", new ConstantBeanDefinitionParser());
registerBeanDefinitionParser("property-path", new PropertyPathBeanDefinitionParser());
registerBeanDefinitionParser("list", new ListBeanDefinitionParser());
registerBeanDefinitionParser("set", new SetBeanDefinitionParser());
registerBeanDefinitionParser("map", new MapBeanDefinitionParser());
registerBeanDefinitionParser("properties", new PropertiesBeanDefinitionParser());
}
private static class ListBeanDefinitionParser extends AbstractSingleBeanDefinitionParser {
@Override
protected Class<?> getBeanClass(Element element) {
return ListFactoryBean.class;
}
@Override
protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
List<Object> parsedList = parserContext.getDelegate().parseListElement(element, builder.getRawBeanDefinition());
builder.addPropertyValue("sourceList", parsedList);
String listClass = element.getAttribute("list-class");
if (StringUtils.hasText(listClass)) {
builder.addPropertyValue("targetListClass", listClass);
}
String scope = element.getAttribute(SCOPE_ATTRIBUTE);
if (StringUtils.hasLength(scope)) {
builder.setScope(scope);
}
}
}
//省略部分代码
}parseCustomElement
获取到具体handler并且执行完init()后，再回到parseCustomElement，此时resolve方法已经执行完成，往下走，调用具体的handler.parse来进行属性的解析。
public BeanDefinition parseCustomElement(Element ele, @Nullable BeanDefinition containingBd) {
// 获取对应的命名空间
String namespaceUri = getNamespaceURI(ele);
if (namespaceUri == null) {
return null;
}
// 根据命名空间找到对应的NamespaceHandlerspring
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进行解析
return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
}findParserForElement
parse方法会调用NamespaceHandlerSupport类中的findParserForElement，首先会获取元素名称"list"，而我们在handler中执行init方式时，已经将标签对应属性全部放入了parser中，此时从parser获取具体Parser对象并返回。执行parser.parser方法。
public BeanDefinition parse(Element element, ParserContext parserContext) {
// 获取元素的解析器
BeanDefinitionParser parser = findParserForElement(element, parserContext);
return (parser != null ? parser.parse(element, parserContext) : null);
}
private BeanDefinitionParser findParserForElement(Element element, ParserContext parserContext) {
// 获取元素名称
String localName = parserContext.getDelegate().getLocalName(element);
// 根据元素名称找到对应的解析器
BeanDefinitionParser parser = this.parsers.get(localName);
if (parser == null) {
}
return parser;
}parse
此时会调用AbstractBeanDefinitionParser类中的parse方法，根据parseInternal()底层调用的具体doParse方法对标签属性进行具体的解析后，将Definition封装成BeanDefinitionHolder ，调用registerBeanDefinition方法注册到BeanFactory中。
public final BeanDefinition parse(Element element, ParserContext parserContext) {
AbstractBeanDefinition definition = parseInternal(element, parserContext);
if (definition != null && !parserContext.isNested()) {
try {
String id = resolveId(element, definition, parserContext);
if (!StringUtils.hasText(id)) {
}
String[] aliases = null;
if (shouldParseNameAsAliases()) {
String name = element.getAttribute(NAME_ATTRIBUTE);
if (StringUtils.hasLength(name)) {
aliases = StringUtils.trimArrayElements(StringUtils.commaDelimitedListToStringArray(name));
}
}
// 将AbstractBeanDefinition转换为BeanDefinitionHolder并注册
BeanDefinitionHolder holder = new BeanDefinitionHolder(definition, id, aliases);
registerBeanDefinition(holder, parserContext.getRegistry());
if (shouldFireEvents()) {
// 通知监听器进行处理
BeanComponentDefinition componentDefinition = new BeanComponentDefinition(holder);
postProcessComponentDefinition(componentDefinition);
parserContext.registerComponent(componentDefinition);
}
}
catch (BeanDefinitionStoreException ex) {
String msg = ex.getMessage();
parserContext.getReaderContext().error((msg != null ? msg : ex.toString()), element);
return null;
}
}
return definition;
}parseInternal
创建BeanDefinitionBuilder，调用doParse方法进行属性的具体解析，并将值放到builder对象中。
protected final AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {
BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition();
String parentName = getParentName(element);
if (parentName != null) {
builder.getRawBeanDefinition().setParentName(parentName);
}
// 获取自定义标签中的class，此时会调用自定义解析器
Class<?> beanClass = getBeanClass(element);
if (beanClass != null) {
builder.getRawBeanDefinition().setBeanClass(beanClass);
}
else {
// 若子类没有重写getBeanClass方法则尝试检查子类是否重写getBeanClassName方法
String beanClassName = getBeanClassName(element);
if (beanClassName != null) {
builder.getRawBeanDefinition().setBeanClassName(beanClassName);
}
}
builder.getRawBeanDefinition().setSource(parserContext.extractSource(element));
BeanDefinition containingBd = parserContext.getContainingBeanDefinition();
if (containingBd != null) {
// Inner bean definition must receive same scope as containing bean.
// 若存在父类则使用父类的scope属性
builder.setScope(containingBd.getScope());
}
if (parserContext.isDefaultLazyInit()) {
// Default-lazy-init applies to custom bean definitions as well.
// 配置延迟加载
builder.setLazyInit(true);
}
// 调用子类重写的doParse方法进行解析
doParse(element, parserContext, builder);
return builder.getBeanDefinition();
}doParse
具体的解析方法。以< util:list >为例，就是将list元素获取后，添加到builder中。每个属性的实现逻辑不同，如果想要自己自定义，也可遵循Spring的相关步骤来实现。
private static class ListBeanDefinitionParser extends AbstractSingleBeanDefinitionParser {
@Override
protected Class<?> getBeanClass(Element element) {
return ListFactoryBean.class;
}
@Override
protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
List<Object> parsedList = parserContext.getDelegate().parseListElement(element, builder.getRawBeanDefinition());
builder.addPropertyValue("sourceList", parsedList);
String listClass = element.getAttribute("list-class");
if (StringUtils.hasText(listClass)) {
builder.addPropertyValue("targetListClass", listClass);
}
String scope = element.getAttribute(SCOPE_ATTRIBUTE);
if (StringUtils.hasLength(scope)) {
builder.setScope(scope);
}
}
}
至此，默认的命名空间标签解析和定制化的标签解析流程全部完成。最后都是将解析到的BeanDefinition注册到BeanFactory中。
