Spring源码学习--自定义标签解析

发表于 | 分类于 | | 阅读次数:

bean的解析分为默认标签和用户自定义标签，前面已经讲过了默认标签的解析过程．今天就针对自定义标签的解析进行一个介绍．郝佳在sping源码深度解析书中说自定义标签主要是为了支持系统可配置功能．我个人认为，自定义标签的使用是为了提高spring的灵活性，用户可以根据自己的应用特点来定义标签和解析器．spring除了管理默认标签的bean还可以为客户管理这些bean.

自定义标签的使用

为了讲解自定义标签的解析过程，首先我们先回顾自定义标签的使用，熟悉标签使用对于源码的理解有很大帮助．自定义标签一般分为5个步骤:

  1. 创建一个需要拓展的组件
  2. 为该组件定义一个约束文档XSD文件
  3. 定义组件解析器，实现BeanDefinitionParser接口，用来解析xsd文件中的定义和组件定义
  4. 定义组件处理器,扩展NamespaceHandlerSupport,目的是将组件注册到spring容器中
  5. 编写命名空间与处理器handler的映射文件Spring.handlers，以及xsd的路径文件Spring.schemas用于查找xsd．

1) 创建 POJO
public class User{ private String userName; private String email; }
2) 创建约束模式文件xsd，此步骤省略
3) 定义组件解析器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class UserBeanDefinitionParser extends AstractSingleBeanDefinitionParser{
	//指定该bean的类型
	proctected Class getBeanClass(Element element){
		return User.class;
	}
	proctected void doParser(Element element,BeanDefinitionBuilder bean){
		String userName = element.getAttribute("userName");
		String email = element.getAttribute("email");
		if(StringUtils.hasText(userName){
			bean.addPropertyValue("userName",userName);	
		}
		if(StringUtils.hasText(email){
			bean.addPropertyValue("email",email);	
		}
	}

}

4) 创建处理器，注册解析器

1
2
3
4
5
public class MyNamespaceHandler extends NamespaceHandlerSupport{
	public void init(){
		registerBeanDefinitionParser("user",new UserBeanDefinitionParser());		
	}	
}

5) 编写文件
Spring.handlers
http\://www.lexueba.com/schema/user=MyNamespaceHandler
Spring.schemas
http\://www.lexueba.com/schema/user.xsd=META-INF/Spring-test.xsd

自定义标签的解析

自定义标签的解析首先是使用DOM获取节点的命名空间，然后根据命名空间和Spring.handlers配置文件得到处理器，然后交给处理器处理．

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//containingBd 为父类bean， 默认为null 之类．
public BeanDefinition parseCustomElement(Element ele, BeanDefinition containingBd) {
	//获取对应的命名空间
	String namespaceUri = getNamespaceURI(ele);
	//根据命名空间找到对应的NamespaceHandler
	//DefaultNamespaceHandlerResolver．resolve;
	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进行解析
	//NamespaceHandlerSupport;
	return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
}

获取处理器

spring通过懒加载的方式将Spring.handlers中所有命名空间与处理器的映射保存到CocurrentHashMap中，然后根据命名空间获取处理器．因为第一次保存在缓冲中的处理器只是对应的处理器类名，当用户需要使用时首先创建处理器对象，并进行初始化init()，初始化的目的就是为了将该命名空间中的所有解析器注册到spring中．最后保存这个对象到缓冲中，并返回处理器handler，以后调用同一个命名空间时直接返回处理器对象就不用创建新对象．

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
public NamespaceHandler resolve(String namespaceUri) {
	//获取所有已经配置的handler映射，这里采用了double-check方法进行初始化．
	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的初识化方法
			namespaceHandler.init();
			//记录在缓冲中
			handlerMappings.put(namespaceUri, namespaceHandler);
			return namespaceHandler;
		}
		catch (ClassNotFoundException ex) {
			throw new FatalBeanException("NamespaceHandler class [" + className + "] for namespace [" +
					namespaceUri + "] not found", ex);
		}
		catch (LinkageError err) {
			throw new FatalBeanException("Invalid NamespaceHandler class [" + className + "] for namespace [" +
					namespaceUri + "]: problem with handler class file or dependent class", err);
		}
	}
}
private Map<String, Object> getHandlerMappings() {
	//double-check
	if (this.handlerMappings == null) {
		synchronized (this) {
			if (this.handlerMappings == null) {
				try {
					Properties mappings =
							PropertiesLoaderUtils.loadAllProperties(this.handlerMappingsLocation, this.classLoader);
					if (logger.isDebugEnabled()) {
						logger.debug("Loaded NamespaceHandler mappings: " + mappings);
					}
					Map<String, Object> handlerMappings = new ConcurrentHashMap<String, Object>(mappings.size());
					//将properties格式文件合并到map格式的handlerMappings中
					CollectionUtils.mergePropertiesIntoMap(mappings, handlerMappings);
					this.handlerMappings = handlerMappings;
				}
				catch (IOException ex) {
					throw new IllegalStateException(
							"Unable to load NamespaceHandler mappings from location [" + this.handlerMappingsLocation + "]", ex);
				}
			}
		}
	}
	return this.handlerMappings;
}

标签解析

获取了处理器之后，会根据Element的标签从容器中获取对应的解析器，然后标签进行解析．采用建造者模式解析并构建一个BeanDefinition．最后将BeanDefinition转化为BeanDefinitionHolder并注册到容器中．

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
public BeanDefinition parse(Element element, ParserContext parserContext) {
	//寻找解析器并解析操作
	//AbstractBeanDefinitionParser
	//AbstractSingleBeanDefinitionParser
	return findParserForElement(element, parserContext).parse(element, parserContext);
}

/**
 * Locates the {@link BeanDefinitionParser} from the register implementations using
 * the local name of the supplied {@link Element}.
 */
private BeanDefinitionParser findParserForElement(Element element, ParserContext parserContext) {
	//获取元素名称，＜myname:user ＞中的user,
	String localName = parserContext.getDelegate().getLocalName(element);
	//根据元素名称获取对应的解析器，
	BeanDefinitionParser parser = this.parsers.get(localName);
	if (parser == null) {
		parserContext.getReaderContext().fatal(
				"Cannot locate BeanDefinitionParser for element [" + localName + "]", element);
	}
	return parser;
}
//对于parse方法的处理
public final BeanDefinition parse(Element element, ParserContext parserContext) {
	//AbstractBeanDefinition
	//解析得到AbstractBeanDefinition，具体实现留给子类
	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 并注册　
			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) {
			parserContext.getReaderContext().error(ex.getMessage(), element);
			return null;
		}
	}
	return definition;
}

parse方法大部分都是对解析后的BeanDefinition进行处理．这里的解析主要是由parseInternal()方法执行．该方法是解析和构建BeanDefinition过程，构建该对象采用建造者模式(Builder):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
protected final AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {
	//采用了builder模式
	//获取一个builder
	BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition();
	//一步步创建每个构建
	String parentName = getParentName(element);
	if (parentName != null) {
		builder.getRawBeanDefinition().setParentName(parentName);
	}
	//获取自定义标签中的class,此时会调用自定义解析器中的getBeanClass(多态思想，调用子类的具体实现)
	//子类可覆盖
	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));
	if (parserContext.isNested()) {
		//若存在父类，则是否父类的scope属性
		// Inner bean definition must receive same scope as containing bean.
		builder.setScope(parserContext.getContainingBeanDefinition().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();
}
0%