659 lines
22 KiB
Markdown
659 lines
22 KiB
Markdown
# Spring 自定义标签解析
|
||
- Author: [HuiFer](https://github.com/huifer)
|
||
- 源码阅读仓库: [SourceHot-Spring](https://github.com/SourceHot/spring-framework-read)
|
||
- 与自定义标签解析相关的类
|
||
1. `org.springframework.beans.factory.xml.AbstractSingleBeanDefinitionParser`
|
||
2. `org.springframework.beans.factory.xml.NamespaceHandlerSupport`
|
||
|
||
- 开始源码之前先搭建一个环境
|
||
|
||
|
||
## 环境搭建
|
||
- 创建对象
|
||
```java
|
||
public class UserXtd {
|
||
private String userName;
|
||
private String emailAddress;
|
||
|
||
public String getUserName() {
|
||
return userName;
|
||
}
|
||
|
||
public void setUserName(String userName) {
|
||
this.userName = userName;
|
||
}
|
||
|
||
public String getEmailAddress() {
|
||
return emailAddress;
|
||
}
|
||
|
||
public void setEmailAddress(String emailAddress) {
|
||
this.emailAddress = emailAddress;
|
||
}
|
||
}
|
||
```
|
||
- 创建 xsd 文件
|
||
```xml
|
||
<?xml version="1.0" encoding="UTF-8" ?>
|
||
<schema xmlns="http://www.w3.org/2001/XMLSchema"
|
||
targetNamespace="http://www.huifer.com/schema/user"
|
||
elementFormDefault="qualified">
|
||
|
||
<element name="myUser">
|
||
<complexType>
|
||
<attribute name="id" type="string"/>
|
||
<attribute name="userName" type="string"/>
|
||
<attribute name="emailAddress" type="string"/>
|
||
</complexType>
|
||
</element>
|
||
</schema>
|
||
```
|
||
- 创建 namespaceHandler
|
||
```java
|
||
public class UserNamespaceHandler extends NamespaceHandlerSupport {
|
||
@Override
|
||
public void init() {
|
||
registerBeanDefinitionParser("myUser", new UserBeanDefinitionParser());
|
||
}
|
||
}
|
||
```
|
||
- 创建 beanDefinitionParser
|
||
```java
|
||
public class UserBeanDefinitionParser extends AbstractSingleBeanDefinitionParser {
|
||
/**
|
||
* 标签对应class
|
||
* @param element the {@code Element} that is being parsed
|
||
* @return
|
||
*/
|
||
@Override
|
||
protected Class<?> getBeanClass(Element element) {
|
||
return UserXtd.class;
|
||
}
|
||
|
||
|
||
@Override
|
||
protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
|
||
// 获取 userName 标签属性值
|
||
String name = element.getAttribute("userName");
|
||
// 获取 emailAddress 标签属性值
|
||
String address = element.getAttribute("emailAddress");
|
||
|
||
if (StringUtils.hasText(name)) {
|
||
builder.addPropertyValue("userName", name);
|
||
}
|
||
if (StringUtils.hasText(address)) {
|
||
builder.addPropertyValue("emailAddress", address);
|
||
}
|
||
}
|
||
}
|
||
|
||
```
|
||
- 创建 resource/META-INF/spring.handlers
|
||
```text
|
||
http\://www.huifer.com/schema/user=com.huifer.source.spring.parser.UserNamespaceHandler
|
||
```
|
||
- 创建 resource/META-INF/spring.schemas
|
||
```text
|
||
http\://www.huifer.com/schema/user.xsd=META-INF/spring-test.xsd
|
||
```
|
||
- 创建测试用例xml
|
||
```xml
|
||
<?xml version="1.0" encoding="UTF-8"?>
|
||
<beans xmlns="http://www.springframework.org/schema/beans"
|
||
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
|
||
xmlns:myname="http://www.huifer.com/schema/user"
|
||
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
|
||
http://www.huifer.com/schema/user http://www.huifer.com/schema/user.xsd
|
||
">
|
||
|
||
<myname:myUser id="testUserBean" userName="huifer" emailAddress="huifer97@163.com"/>
|
||
|
||
</beans>
|
||
```
|
||
- 创建 Java 运行方法
|
||
```java
|
||
/**
|
||
* 自定义标签测试用例
|
||
*/
|
||
public class XSDDemo {
|
||
public static void main(String[] args) {
|
||
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("XTD-xml.xml");
|
||
UserXtd user = (UserXtd) applicationContext.getBean("testUserBean");
|
||
System.out.println(user.getEmailAddress());
|
||
}
|
||
}
|
||
```
|
||
- 这里我们希望输出结果是`huifer97@163.com`,运行后结果也确实是`huifer97@163.com`
|
||
|
||
## 解析 DefaultNamespaceHandlerResolver
|
||
- 入口方法`org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader.parseBeanDefinitions`
|
||
```java
|
||
protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
|
||
if (delegate.isDefaultNamespace(root)) {
|
||
NodeList nl = root.getChildNodes();
|
||
for (int i = 0; i < nl.getLength(); i++) {
|
||
Node node = nl.item(i);
|
||
if (node instanceof Element) {
|
||
Element ele = (Element) node;
|
||
if (delegate.isDefaultNamespace(ele)) {
|
||
// 不同标签的解析
|
||
parseDefaultElement(ele, delegate);
|
||
}
|
||
else {
|
||
// 非spring 默认标签解析
|
||
delegate.parseCustomElement(ele);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else {
|
||
delegate.parseCustomElement(root);
|
||
}
|
||
}
|
||
|
||
```
|
||
- 调用链路
|
||
- `org.springframework.beans.factory.xml.BeanDefinitionParserDelegate.parseCustomElement(org.w3c.dom.Element)`
|
||
- `org.springframework.beans.factory.xml.BeanDefinitionParserDelegate.parseCustomElement(org.w3c.dom.Element, org.springframework.beans.factory.config.BeanDefinition)`
|
||
|
||
```java
|
||
/**
|
||
* Parse a custom element (outside of the default namespace).
|
||
* <p>
|
||
* 自定义标签解析
|
||
*
|
||
* @param ele the element to parse
|
||
* @param containingBd the containing bean definition (if any)
|
||
* @return the resulting bean definition
|
||
*/
|
||
@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));
|
||
}
|
||
|
||
```
|
||
|
||
|
||
|
||
- `http://www.huifer.com/schema/user`和我们定义的xsd文件中的url相同，如何找到对应的NamespaceHandler,在`META-INF/spring.handlers`中有定义,
|
||
|
||
`http\://www.huifer.com/schema/user=com.huifer.source.spring.parser.UserNamespaceHandler`
|
||
|
||
`NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);`这行代码就是获取`spring.handlers`中的定义
|
||
|
||
- 处理方法`org.springframework.beans.factory.xml.DefaultNamespaceHandlerResolver.resolve`
|
||
|
||
|
||
|
||
```java
|
||
/**
|
||
* Locate the {@link NamespaceHandler} for the supplied namespace URI
|
||
* from the configured mappings.
|
||
*
|
||
* 根据 namespaceUri 获取对应的 {@link NamespaceHandler}
|
||
* @param namespaceUri the relevant namespace URI
|
||
* @return the located {@link NamespaceHandler}, or {@code null} if none found
|
||
*/
|
||
@Override
|
||
@Nullable
|
||
public NamespaceHandler resolve(String namespaceUri) {
|
||
// 获取handlerMapping
|
||
Map<String, Object> handlerMappings = getHandlerMappings();
|
||
// 从 handlerMapping 中获取类名
|
||
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);
|
||
// 调用init()方法,自定义类中实现
|
||
namespaceHandler.init();
|
||
// 放入缓存
|
||
handlerMappings.put(namespaceUri, namespaceHandler);
|
||
// 返回自定义的 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);
|
||
}
|
||
}
|
||
}
|
||
|
||
```
|
||
|
||
|
||
|
||
- `org.springframework.beans.factory.xml.DefaultNamespaceHandlerResolver#getHandlerMappings`跟踪这个方法
|
||
|
||
```JAVA
|
||
/**
|
||
* Load the specified NamespaceHandler mappings lazily.
|
||
*
|
||
* 获取handlerMappings
|
||
*/
|
||
private Map<String, Object> getHandlerMappings() {
|
||
Map<String, Object> handlerMappings = this.handlerMappings;
|
||
}
|
||
```
|
||
|
||
|
||
|
||
|
||
|
||
- 这里直接存在数据了,他是从什么时候加载的?
|
||
|
||
- `org.springframework.beans.factory.xml.XmlBeanDefinitionReader#registerBeanDefinitions`
|
||
|
||
这个方法在注册bean定义的时候调用
|
||
|
||
```java
|
||
public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
|
||
BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
|
||
int countBefore = getRegistry().getBeanDefinitionCount();
|
||
// 注册方法
|
||
// createReaderContext 初始化HandlerMapping
|
||
documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
|
||
return getRegistry().getBeanDefinitionCount() - countBefore;
|
||
}
|
||
|
||
```
|
||
|
||
- 继续跟踪`createReaderContext`
|
||
|
||
```java
|
||
org.springframework.beans.factory.xml.XmlBeanDefinitionReader#createReaderContext
|
||
```
|
||
|
||
```java
|
||
public XmlReaderContext createReaderContext(Resource resource) {
|
||
return new XmlReaderContext(resource, this.problemReporter, this.eventListener,
|
||
this.sourceExtractor, this, getNamespaceHandlerResolver());
|
||
}
|
||
|
||
```
|
||
|
||
- 继续跟踪`getNamespaceHandlerResolver`
|
||
|
||
`org.springframework.beans.factory.xml.XmlBeanDefinitionReader#getNamespaceHandlerResolver`
|
||
|
||
```java
|
||
public NamespaceHandlerResolver getNamespaceHandlerResolver() {
|
||
if (this.namespaceHandlerResolver == null) {
|
||
this.namespaceHandlerResolver = createDefaultNamespaceHandlerResolver();
|
||
}
|
||
return this.namespaceHandlerResolver;
|
||
}
|
||
|
||
```
|
||
|
||
- 继续跟踪`createDefaultNamespaceHandlerResolver`
|
||
|
||
`org.springframework.beans.factory.xml.XmlBeanDefinitionReader#createDefaultNamespaceHandlerResolver`
|
||
|
||
```java
|
||
protected NamespaceHandlerResolver createDefaultNamespaceHandlerResolver() {
|
||
ClassLoader cl = (getResourceLoader() != null ? getResourceLoader().getClassLoader() : getBeanClassLoader());
|
||
return new DefaultNamespaceHandlerResolver(cl);
|
||
}
|
||
```
|
||
|
||
|
||
|
||
- 继续跟踪`DefaultNamespaceHandlerResolver`
|
||
|
||
`org.springframework.beans.factory.xml.DefaultNamespaceHandlerResolver`
|
||
|
||
```java
|
||
public DefaultNamespaceHandlerResolver(@Nullable ClassLoader classLoader) {
|
||
this(classLoader, DEFAULT_HANDLER_MAPPINGS_LOCATION);
|
||
}
|
||
|
||
```
|
||
|
||
他回到了我们之前疑问的地方 `handlerMappings` 如何出现的
|
||
|
||
断点
|
||
|
||
|
||
|
||
```JAVA
|
||
public DefaultNamespaceHandlerResolver(@Nullable ClassLoader classLoader) {
|
||
this(classLoader, DEFAULT_HANDLER_MAPPINGS_LOCATION);
|
||
}
|
||
```
|
||
|
||
`public static final String DEFAULT_HANDLER_MAPPINGS_LOCATION = "META-INF/spring.handlers";`
|
||
|
||
|
||
|
||
此时还是空
|
||
|
||
走完
|
||
|
||
|
||
|
||
```java
|
||
@Override
|
||
public String toString() {
|
||
return "NamespaceHandlerResolver using mappings " + getHandlerMappings();
|
||
}
|
||
|
||
```
|
||
|
||
|
||
|
||
```JAVA
|
||
/**
|
||
* Load the specified NamespaceHandler mappings lazily.
|
||
*
|
||
* 获取handlerMappings
|
||
*/
|
||
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());
|
||
// 转换成map结构
|
||
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;
|
||
}
|
||
|
||
```
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
## org.springframework.beans.factory.xml.DefaultNamespaceHandlerResolver#resolve
|
||
|
||
```java
|
||
@Override
|
||
@Nullable
|
||
public NamespaceHandler resolve(String namespaceUri) {
|
||
// 获取handlerMapping
|
||
Map<String, Object> handlerMappings = getHandlerMappings();
|
||
// 从 handlerMapping 中获取类名
|
||
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);
|
||
// 调用init()方法,自定义类中实现
|
||
namespaceHandler.init();
|
||
// 放入缓存
|
||
handlerMappings.put(namespaceUri, namespaceHandler);
|
||
// 返回自定义的 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);
|
||
}
|
||
}
|
||
}
|
||
|
||
```
|
||
|
||
执行`init`方法
|
||
|
||
```java
|
||
public class UserNamespaceHandler extends NamespaceHandlerSupport {
|
||
@Override
|
||
public void init() {
|
||
registerBeanDefinitionParser("myUser", new UserBeanDefinitionParser());
|
||
}
|
||
}
|
||
```
|
||
|
||
```java
|
||
/**
|
||
* Subclasses can call this to register the supplied {@link BeanDefinitionParser} to
|
||
* handle the specified element. The element name is the local (non-namespace qualified)
|
||
* name.
|
||
*
|
||
* 将标签名称,标签解析类放入
|
||
*/
|
||
protected final void registerBeanDefinitionParser(String elementName, BeanDefinitionParser parser) {
|
||
this.parsers.put(elementName, parser);
|
||
}
|
||
|
||
```
|
||
|
||
|
||
|
||
- 方法走完，回到开始的方法
|
||
|
||
```java
|
||
/**
|
||
* Parse a custom element (outside of the default namespace).
|
||
* <p>
|
||
* 自定义标签解析
|
||
*
|
||
* @param ele the element to parse
|
||
* @param containingBd the containing bean definition (if any)
|
||
* @return the resulting bean definition
|
||
*/
|
||
@Nullable
|
||
public BeanDefinition parseCustomElement(Element ele, @Nullable BeanDefinition containingBd) {
|
||
// 自定义标签解析
|
||
String namespaceUri = getNamespaceURI(ele);
|
||
if (namespaceUri == null) {
|
||
return null;
|
||
}
|
||
// 根据命名空间获取处理类
|
||
// org.springframework.beans.factory.xml.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;
|
||
}
|
||
// 自定义处理器
|
||
return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
|
||
}
|
||
|
||
```
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
## org.springframework.beans.factory.xml.NamespaceHandler#parse
|
||
|
||
- `org.springframework.beans.factory.xml.NamespaceHandlerSupport.parse`
|
||
|
||
```java
|
||
@Override
|
||
@Nullable
|
||
public BeanDefinition parse(Element element, ParserContext parserContext) {
|
||
BeanDefinitionParser parser = findParserForElement(element, parserContext);
|
||
return (parser != null ? parser.parse(element, parserContext) : null);
|
||
}
|
||
|
||
```
|
||
|
||
### org.springframework.beans.factory.xml.NamespaceHandlerSupport#findParserForElement
|
||
|
||
```java
|
||
@Nullable
|
||
private BeanDefinitionParser findParserForElement(Element element, ParserContext parserContext) {
|
||
// 获取标签名称
|
||
String localName = parserContext.getDelegate().getLocalName(element);
|
||
// 在map中获取对应的标签解析类
|
||
BeanDefinitionParser parser = this.parsers.get(localName);
|
||
// 空报错
|
||
if (parser == null) {
|
||
parserContext.getReaderContext().fatal(
|
||
"Cannot locate BeanDefinitionParser for element [" + localName + "]", element);
|
||
}
|
||
// 不为空返回
|
||
return parser;
|
||
}
|
||
|
||
```
|
||
|
||
|
||
|
||
### org.springframework.beans.factory.xml.BeanDefinitionParser#parse
|
||
|
||
- `org.springframework.beans.factory.xml.AbstractBeanDefinitionParser#parse`
|
||
|
||
```java
|
||
public final BeanDefinition parse(Element element, ParserContext parserContext) {
|
||
/**
|
||
* {@link AbstractSingleBeanDefinitionParser#parseInternal(org.w3c.dom.Element, org.springframework.beans.factory.xml.ParserContext)}
|
||
*/
|
||
AbstractBeanDefinition definition = parseInternal(element, parserContext);
|
||
|
||
|
||
}
|
||
```
|
||
|
||
### org.springframework.beans.factory.xml.AbstractSingleBeanDefinitionParser#parseInternal
|
||
|
||
```java
|
||
@Override
|
||
protected final AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {
|
||
BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition();
|
||
String parentName = getParentName(element);
|
||
if (parentName != null) {
|
||
builder.getRawBeanDefinition().setParentName(parentName);
|
||
}
|
||
// 调用自己实现的方法 com.huifer.source.spring.parser.UserBeanDefinitionParser.getBeanClass
|
||
Class<?> beanClass = getBeanClass(element);
|
||
if (beanClass != null) {
|
||
builder.getRawBeanDefinition().setBeanClass(beanClass);
|
||
}
|
||
else {
|
||
// 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.
|
||
// 设置 lazy-init
|
||
builder.setLazyInit(true);
|
||
}
|
||
|
||
// 执行解析方法,在自定义解析类中存在com.huifer.source.spring.parser.UserBeanDefinitionParser.doParse
|
||
doParse(element, parserContext, builder);
|
||
return builder.getBeanDefinition();
|
||
}
|
||
```
|
||
|
||
|
||
|
||
|
||
|
||
执行`com.huifer.source.spring.parser.UserBeanDefinitionParser#doParse`
|
||
|
||
```JAVA
|
||
@Override
|
||
protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
|
||
// 获取 userName 标签属性值
|
||
String name = element.getAttribute("userName");
|
||
// 获取 emailAddress 标签属性值
|
||
String address = element.getAttribute("emailAddress");
|
||
|
||
if (StringUtils.hasText(name)) {
|
||
builder.addPropertyValue("userName", name);
|
||
}
|
||
if (StringUtils.hasText(address)) {
|
||
builder.addPropertyValue("emailAddress", address);
|
||
}
|
||
}
|
||
```
|
||
|
||
|
||
|
||
|
||
|