Spring 源码学习(三)-自定义标签

public class Product {

	private Integer productId;

	private String unit;

	private String name;
}

<xsd:schema targetNamespace="http://vip-augus.github.io/schema/product"
			xmlns:xsd="http://www.w3.org/2001/XMLSchema"
			elementFormDefault="qualified">
	<!-- 注释 3.4 自定义元素  -->
	<xsd:element name="product">
		<xsd:complexType>
            <!-- 这个是类注册时的名字，组件中请不要占用该字段~ -->
			<xsd:attribute name="id" type="xsd:string"/>
			<!-- 属性定义列表，名字和类型 -->
			<xsd:attribute name="productId" type="xsd:integer"/>
			<xsd:attribute name="unit" type="xsd:string"/>
			<xsd:attribute name="name" type="xsd:string"/>
		</xsd:complexType>
	</xsd:element>
</xsd:schema>

public class ProductBeanDefinitionParser extends AbstractSingleBeanDefinitionParser {

	@Override
	protected Class getBeanClass(Element element) {
		// 返回对应的类型
		return Product.class;
	}

	// 从 element 中解析并提取对应的元素
	@Override
	protected void doParse(Element element, BeanDefinitionBuilder builder) {

		String productId = element.getAttribute("productId");
		String productName = element.getAttribute("name");
		String productUnit = element.getAttribute("unit");
		// 将提取到的数据放入 BeanDefinitionBuilder 中，等到完成所有 bean 的解析之后统一注册到 beanFactory 中
		if (productId != null) {
			// element.getAttribute("") 方法取出来的都是 string 类型，使用时记得手动转换
			builder.addPropertyValue("productId", Integer.valueOf(productId));
		}
		if (StringUtils.hasText(productName)) {
			builder.addPropertyValue("name", productName);
		}
		if (StringUtils.hasText(productUnit)) {
			builder.addPropertyValue("unit", productUnit);
		}
	}
}

public class ProductBeanHandler extends NamespaceHandlerSupport {

	@Override
	public void init() {
		// 将组件解析器进行注册到 `Spring` 容器
		registerBeanDefinitionParser("product", new ProductBeanDefinitionParser());
	}
}

spring.handlers

http/://vip-augus.github.io/schema/product=base.label.custom.ProductBeanHandler

spring.schemas

http/://vip-augus.github.io/schema/product.xsd=custom/custom-product.xsd

<?xml version="1.0" encoding="UTF-8"?>
<!-- 注意 schema 位置，最后两行是我新增的自定义配置  -->
<beans xmlns="http://www.springframework.org/schema/beans"
	   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	   xmlns:myname="http://vip-augus.github.io/schema/product"
	   xsi:schemaLocation="http://www.springframework.org/schema/beans
	   http://vip-augus.github.io/schema/product
	   http://vip-augus.github.io/schema/product.xsd">

	<!-- 自定义标签使用 -->
	<myname:product id="product" productId="1" name="Apple" unit="台"/>
</beans>

public class ProductBootstrap {
	public static void main(String[] args) {
		ApplicationContext context = new ClassPathXmlApplicationContext("custom/custom-label.xml");
		Product product = (Product) context.getBean("product");
		// 输出 Product{, productId ='1', unit='台', name='Apple'}
		System.out.println(product.toString());
	}
}

public BeanDefinition parseCustomElement(Element ele, @Nullable BeanDefinition containingBd) {
		// 注释 3.8 ① 找到命名空间
		String namespaceUri = getNamespaceURI(ele);
		// ② 根据命名空间找到对应的 NamespaceHandler
		NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
		// ③ 调用自定义的 NamespaceHandler 进行解析
		return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
	}

public String getNamespaceURI(Node node) {
		return node.getNamespaceURI();
	}

public NamespaceHandler resolve(String namespaceUri) {
	// 注释 3.9 获取所有已经配置的 handler 映射
	Map<String, Object> handlerMappings = getHandlerMappings();
	// 从 map 中取出命名空间对应的 NamespaceHandler 的 className
	// 这个映射 map 值，没有的话，会进行实例化类，然后放入 map，等下次同样命名空间进来就能直接使用了
	Object handlerOrClassName = handlerMappings.get(namespaceUri);
	if (handlerOrClassName == null) {
		return null;
	}
	else if (handlerOrClassName instanceof NamespaceHandler) {
		return (NamespaceHandler) handlerOrClassName;
	}
	else {
		String className = (String) handlerOrClassName;
		
		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);
		// 调用 handler 的 init() 方法
		namespaceHandler.init();
		// 放入 handler 映射中
		handlerMappings.put(namespaceUri, namespaceHandler);
		return namespaceHandler;
	}
}

private Map<String, Object> getHandlerMappings() {
	Map<String, Object> handlerMappings = this.handlerMappings;
	// 如果没有缓存，进行缓存加载，公共变量，加锁进行操作，细节好评:+1:
	if (handlerMappings == null) {
		synchronized (this) {
			handlerMappings = this.handlerMappings;
			if (handlerMappings == null) {
				Properties mappings =
						PropertiesLoaderUtils.loadAllProperties(this.handlerMappingsLocation, this.classLoader);
				handlerMappings = new ConcurrentHashMap<>(mappings.size());
				CollectionUtils.mergePropertiesIntoMap(mappings, handlerMappings);
				this.handlerMappings = handlerMappings;
			}
		}
	}
	return handlerMappings;
}

public BeanDefinition parse(Element element, ParserContext parserContext) {
		// 寻找解析器并进行解析操作
		BeanDefinitionParser parser = findParserForElement(element, parserContext);
		// 真正解析调用调用的方法
		return (parser != null ? parser.parse(element, parserContext) : null);
	}

public final BeanDefinition parse(Element element, ParserContext parserContext) {
		// 注释 3.10 实际自定义标签解析器调用的方法，在 parseInternal 方法中，调用了我们重载的方法
		AbstractBeanDefinition definition = parseInternal(element, parserContext);
    ...
    return definition;
}

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);
	}
	// 注释 3.11 在这里调用了我们写的解析方法
	doParse(element, parserContext, builder);
	return builder.getBeanDefinition();
}