一、自定義XML標籤

先新建一個類

public class User {
    private String userName;
    private String email;
    ...省略setter、getter
}

新建一個BeanDefinitionParser

public class UserBeanDefinitionParser extends AbstractSingleBeanDefinitionParser {
    @Override
    protected Class<?> getBeanClass(Element element) {
        return
 
 User.class;
    }
    @Override
    protected void doParse(Element element, BeanDefinitionBuilder builder) {
        String name = element.getAttribute("userName");
        String email = element.getAttribute("email");
        if (StringUtils.hasText(name))
            builder.addPropertyValue("userName"
 
, name);
        if (StringUtils.hasText(email))
            builder.addPropertyValue("email", email);
    }
}

新建一個NameSpaceHandler

public class UserNameSpaceHandler extends NamespaceHandlerSupport {
   @Override
    public void init() {
        registerBeanDefinitionParser("user",new UserBeanDefinitionParser());
    }
}
 

在resources/META-INF目錄下建一個spring-test.xsd檔案（用於XML檢驗）

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

在resources/META-INF目錄下新建spring.handlers檔案寫上

http\://www.season.com/schema/user=com.season.meta.UserNameSpaceHandler

在resources/META-INF目錄下新建spring.schemas檔案寫上

http://www.season.com/schema/user.xsd=META-INF/spring-test.xsd

在resources目錄下建一個beans.xml

<beans xmlns="http://www.springframework.org/schema/beans"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xmlns:myname="http://www.season.com/schema/user"
      xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
       http://www.season.com/schema/user
       http://www.season.com/schema/user.xsd">

    <myname:user id="user" email="[email protected]" userName="season"/>
</beans>

測試：

@Test
public void testNameSpaceHandler(){
    ApplicationContext actx = new ClassPathXmlApplicationContext("beans.xml");
    User user = (User) actx.getBean("user");
    System.out.println(user);
}

二、原理分析

取XML配置的是XmlBeanDefinitionReader，它會先用SAX技術把XML配置檔案讀取成一個Document物件，然後利用BeanDefinitionDocumentReader對Document物件的節點進行解析，最後把bean封裝成BeanDefinition儲存在BeanRegistry中（參見：Spring IOC實現原理筆記（二） – 載入XML配置）,如下：

XmlBeanDefinitionReader類

public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
    //實際建立的是DefaultBeanDefinitionDocumentReader類
     BeanDefinitionDocumentReader documentReader = this.createBeanDefinitionDocumentReader();
     int countBefore = this.getRegistry().getBeanDefinitionCount();
    //【標記1】用BeanDefinitionDocumentReader對Document物件的節點進行解析
     documentReader.registerBeanDefinitions(doc, this.createReaderContext(resource));
     return this.getRegistry().getBeanDefinitionCount() - countBefore;
}

上面【標記1】出就是解析節點的開始，節點分預設節點和自定義節點兩種情況。其中解析自定義節點的原始碼如下：

DefaultBeanDefinitionDocumentReader類

    //解析自定義節點
    public BeanDefinition parseCustomElement(Element ele, BeanDefinition containingBd) {
        String namespaceUri = this.getNamespaceURI(ele);
        NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
        if(handler == null) {
            ...
            return null;
        } else {
            return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
        }
    }

上面程式碼中，首先會拿到節點的中的名稱空間URI，（在上面的例子中是：http://www.season.com/schema/user），接著從NamespaceHandlerResolver中拿到對應該名稱空間URI解析的NamespaceHandler，然後呼叫NamespaceHandler的parse進行解析。

關鍵程式碼是this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri)，其中readerContext是上面【標記1】處的createReaderContext(resource)創建出來的，如下:

XmlBeanDefinitionReader類

public XmlReaderContext createReaderContext(Resource resource) {
    return new XmlReaderContext(resource, this.problemReporter, this.eventListener, this.sourceExtractor,
this, this.getNamespaceHandlerResolver());
}

//上面呼叫了getNamespaceHandlerResolver方法
public NamespaceHandlerResolver getNamespaceHandlerResolver() {
    if(this.namespaceHandlerResolver == null) {
        this.namespaceHandlerResolver = this.createDefaultNamespaceHandlerResolver();
    }
    return this.namespaceHandlerResolver;
}

protected NamespaceHandlerResolver createDefaultNamespaceHandlerResolver() {
    return new DefaultNamespaceHandlerResolver(this.getResourceLoader().getClassLoader());
}

上面可以看到getNamespaceHandlerResolver()獲取到的是DefaultNamespaceHandlerResolver例項，所以接下來去看該類

public class DefaultNamespaceHandlerResolver implements NamespaceHandlerResolver {
    ...
    //【標記2】
    public DefaultNamespaceHandlerResolver(ClassLoader classLoader) {
        this(classLoader, "META-INF/spring.handlers");
    }

    public NamespaceHandler resolve(String namespaceUri) {
        Map<String, Object> handlerMappings = this.getHandlerMappings();
        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);
               ...
              //【標記3】
               NamespaceHandler namespaceHandler = (NamespaceHandler)BeanUtils.instantiateClass(handlerClass);
               //【標記4】
               namespaceHandler.init();
               handlerMappings.put(namespaceUri, namespaceHandler);
               return namespaceHandler;
            ...
        }
    }

    private Map<String, Object> getHandlerMappings() {
        if(this.handlerMappings == null) {
            synchronized(this) {
                if(this.handlerMappings == null) {
                    try {
                        //【標記4】
                        Properties mappings = PropertiesLoaderUtils.loadAllProperties(this.handlerMappingsLocation, this.classLoader);
                        ...
                        Map<String, Object> handlerMappings = new ConcurrentHashMap(mappings.size());
                        CollectionUtils.mergePropertiesIntoMap(mappings, handlerMappings);
                        this.handlerMappings = handlerMappings;
                    } catch...
                }
            }
        }
        return this.handlerMappings;
    }
    ...
}

DefaultNamespaceHandlerResolver是會把所有NamespaceHandler快取到handlerMappings（ConcurrentHashMap例項）裡，resolve方法就是從handlerMappings獲取相應的NamespaceHandler返回出去。

說說上面的標記的地方：
【標記2】：Spring預設的NamespaceHandler配置檔案路徑為META-INF/spring.handlers
【標記3】：未初始化的NamespaceHandler是通過反射例項出來的
【標記4】：例項化出NamespaceHandler後，第一件事是呼叫其init方法
【標記5】：載入META-INF/spring.handlers配置檔案，並記錄到handlerMappings。

總結

Spring在解析XML的時候，解析到是自定義節點，就會找相對應的NameSpaceHandler去解析；而Spring預設載入寫在META-INF/spring.handlers配置檔案中配置的NameSpaceHandler，通過反射將其例項化

2、NameSpaceHandler解析節點

那NameSpaceHandler如何解析的呢？以上面的例子來分析。首先解析自定義節點的原始碼中，Spring拿到相應的NameSpaceHandler後，會呼叫器parse方法，而上面自定義的UserNameSpaceHandler沒看到有parse方法，那就去父類，如下：

NamespaceHandlerSupport類

public abstract class NamespaceHandlerSupport implements NamespaceHandler {
    public BeanDefinition parse(Element element, ParserContext parserContext) {
        return this.findParserForElement(element, parserContext).parse(element, parserContext);
    }

    private BeanDefinitionParser findParserForElement(Element element, ParserContext parserContext) {
        //拿到標籤名稱（對應上面例子的 user）
        String localName = parserContext.getDelegate().getLocalName(element);
        BeanDefinitionParser parser = (BeanDefinitionParser)this.parsers.get(localName);
        ...
        return parser;
    }

    protected final void registerBeanDefinitionParser(String elementName, BeanDefinitionParser parser) {
        this.parsers.put(elementName, parser);
    }
    ...
}

上面看到parse方法呼叫了findParserForElement拿到BeanDefinitionParser，再調BeanDefinitionParser的parse方法進行解析。要拿到BeanDefinitionParser看這句程式碼this.parsers.get(localName),其中parsers是一個Map,鍵存標籤名稱，值為相對應的BeanDefinitionParser。那我們自定義的BeanDefinitionParser（對應上面的UserBeanDefinitionParser）什麼時候放進這個Map中呢？

回顧下【標記4】處程式碼，發現例項化出NamespaceHandler後，第一件事是呼叫其init方法，我們自定義的UserNameSpaceHandler在init方法中呼叫了registerBeanDefinitionParser方法，該方法在父類中，做的事情就是把我們傳入的鍵值對存入parsers這個Map中，所以可以被找到並取出來進行解析節點的操作了。