spring源码解析（自定义解析器）

继上篇文章，开始分析默认解析器
[https://blog.csdn.net/jkdcoach/article/details/92403616]

自定义标签使用

定义xsd文件，描述一个自定义的targetNamespace

<?xml version="1.0" encoding="UTF-8"?>
<schema xmlns="http://www.w3.org/2001/XMLSchema"
        targetNamespace="http://www.sunrui.com/schema/srDefine"
        xmlns:tns="http://www.sunrui.com/schema/srDefine"
        elementFormDefault="qualified">
    <element name="user">
        <complexType>
            <attribute name="id" type="string"/>
            <attribute name="userName" type="string"/>
            <attribute name="email" type="string"/>
        </complexType>
    </element>
</schema>   

创建Parser类

import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.xml.AbstractSingleBeanDefinitionParser;
import org.springframework.util.StringUtils;
import org.w3c.dom.Element;

/**
 * Created by Administrator on 2019/6/16.
 */
public class UserBeanDefinitionParser extends AbstractSingleBeanDefinitionParser {
    @Override
    protected Class getBeanClass(Element element){
        return User.class;
    }

    @Override
    protected void doParse(Element element, BeanDefinitionBuilder beanDefinitionBuilder){
        String userName = element.getAttribute("userName");
        String email = element.getAttribute("email");
        if (StringUtils.hasText(userName)){
            beanDefinitionBuilder.addPropertyValue("name", userName);
        }

        if (StringUtils.hasText(email)){
            beanDefinitionBuilder.addPropertyValue("email", email);
        }
    }
}

创建Handler文件，将Parser注册

import org.springframework.beans.factory.xml.NamespaceHandlerSupport;

/**
 * Created by Administrator on 2019/6/16.
 */
public class MyNamespaceHandler extends NamespaceHandlerSupport {
    public void init() {
        registerBeanDefinitionParser("user", new UserBeanDefinitionParser());
    }
}

创建配置文件，使用自定义标签

<beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:myname="http://www.sunrui.com/schema/srDefine"
        xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
        http://www.sunrui.com/schema/srDefine
        http://www.sunrui.com/schema/srDefine.xsd">
    <myname:user id="srId" email="rui@qq.com" userName="sunrui"/>

</beans>

在META-INF下加两个文件：
META-INF/Spring.handlers

http\://www.sunrui.com/schema/srDefine=com.sr.spring.beans.define.MyNamespaceHandler

META-INF/Spring.schemas

http\://www.sunrui.com/schema/srDefine.xsd=xsds/srDefine.xsd

测试类

        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("myselfDefine.xml");
        User user = (User) applicationContext.getBean("srId");
        System.out.println(user.getEmail());

这里简单说明下ClassPathXmlApplicationContext，主要按原来的delegate.parseCustomElement(ele);流程分析
在refresh(）中开始准备xml的解析，然后在obtainFreshBeanFactory()->refreshBeanFactory->loadBeanDefinitions->reader.loadBeanDefinitions(configLocations);
接下来就与原来分析的一样了

	@Nullable
	public BeanDefinition parseCustomElement(Element ele, @Nullable BeanDefinition containingBd) {
		String namespaceUri = getNamespaceURI(ele);
		if (namespaceUri == null) {
			return null;
		}
		NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
		if (handler == null) {
			error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele);
			return null;
		}
		return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
	}

先获取元素的命名空间，根据命名空间获取NamespaceHandler，其实获取到的就应该是前面写的MyNamespaceHandler

public NamespaceHandler resolve(String namespaceUri) {
		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)) {
					throw new FatalBeanException("Class [" + className + "] for namespace [" + namespaceUri +
							"] does not implement the [" + NamespaceHandler.class.getName() + "] interface");
				}
				NamespaceHandler namespaceHandler = (NamespaceHandler) BeanUtils.instantiateClass(handlerClass);
				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);
			}
		}
	}

getHandlerMappings()即获取的是META-INF/spring.handlers中的map，然后根据
namespaceUri获取对应的Handler名，如果初始化过直接返回对象，如果没初始化过则返回字符串并反射，调用init方法，即MyNamespaceHandler 中的init方法，在解析器map中加入自定义的parser
回到前面代码，找到handler.parse，即NamespaceHandler的默认实现

	public BeanDefinition parse(Element element, ParserContext parserContext) {
		BeanDefinitionParser parser = findParserForElement(element, parserContext);
		return (parser != null ? parser.parse(element, parserContext) : null);
	}

在findParserForElement根据定义的元素的名称（也就是user）获取对应的解析器
然后执行解析parser.parse(element, parserContext)

@Override
	@Nullable
	public final BeanDefinition parse(Element element, ParserContext parserContext) {
		//通过自定义解析器构建beanDefinition
		AbstractBeanDefinition definition = parseInternal(element, parserContext);
		if (definition != null && !parserContext.isNested()) {
			try {
				String id = resolveId(element, definition, parserContext);
				if (!StringUtils.hasText(id)) {
					parserContext.getReaderContext().error(
							"Id is required for element '" + parserContext.getDelegate().getLocalName(element)
									+ "' when used as a top-level tag", element);
				}
				String[] aliases = null;
				if (shouldParseNameAsAliases()) {
					String name = element.getAttribute(NAME_ATTRIBUTE);
					if (StringUtils.hasLength(name)) {
						aliases = StringUtils.trimArrayElements(StringUtils.commaDelimitedListToStringArray(name));
					}
				}
				BeanDefinitionHolder holder = new BeanDefinitionHolder(definition, id, aliases);
				//注册BeanDefinition，与默认解析一样
				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;
	}

这段逻辑主要为构建beanDefinition及注册BeanDefinition，先分析构建流程，注册与默认解析器一直

@Override
	protected final AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {
		BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition();
		String parentName = getParentName(element);
		if (parentName != null) {
			builder.getRawBeanDefinition().setParentName(parentName);
		}
		Class<?> beanClass = getBeanClass(element);
		if (beanClass != null) {
			builder.getRawBeanDefinition().setBeanClass(beanClass);
		}
		else {
			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.
			builder.setScope(containingBd.getScope());
		}
		if (parserContext.isDefaultLazyInit()) {
			// Default-lazy-init applies to custom bean definitions as well.
			builder.setLazyInit(true);
		}
		doParse(element, parserContext, builder);
		return builder.getBeanDefinition();
	}

执行doParse(element, parserContext, builder);调用的是抽象类AbstractSingleBeanDefinitionParser的的doParse,然后执行自定义的doParse(element, builder);
至此自定义标签分析完成