【死磕 Spring】—– IOC 之解析自定義標簽

首先呼叫 getHandlerMappings() 獲取所有配置檔案中的對映關係 handlerMappings ，該關係為 ，然後根據名稱空間 namespaceUri 從對映關係中獲取相應的資訊，如果為空或者已經初始化了就直接傳回，否則根據反射對其進行初始化，同時呼叫其 init() 方法，最後將該 Handler 物件快取。

init() 方法主要是將自定義標簽解析器進行註冊，如我們自定義的 init() ：

    @Override
    public void init() {
        registerBeanDefinitionParser("user",new UserDefinitionParser());
    }

直接呼叫父類的 registerBeanDefinitionParser() 方法進行註冊：

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

其實就是將對映關係放在一個 Map 結構的 parsers 物件中： privatefinalMapparsers 。

完成後傳回 NamespaceHandler 物件，然後呼叫其 parse() 方法開始自定義標簽的解析，如下：

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

呼叫 findParserForElement() 方法獲取 BeanDefinitionParser 實體，其實就是獲取在 init() 方法裡面註冊的實體物件。如下：

    private BeanDefinitionParser findParserForElement(Element element, ParserContext parserContext) {
        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;
    }

獲取 localName，在上面的例子中就是 ： user，然後從 Map 實體 parsers 中獲取 BeanDefinitionParser 物件。傳回 BeanDefinitionParser 物件後，呼叫其 parse()，該方法在 AbstractBeanDefinitionParser 中實現：

    public final BeanDefinition parse(Element element, ParserContext parserContext) {
        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);
                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;
    }

核心在方法 parseInternal() 為什麼這麼說，以為該方法傳回的是 AbstractBeanDefinition 物件，從前面預設標簽的解析工作中我們就可以判斷該方法就是將標簽解析為 AbstractBeanDefinition ，且後續程式碼都是將 AbstractBeanDefinition 轉換為 BeanDefinitionHolder，所以真正的解析工作都交由 parseInternal() 實現，如下：

    protected final AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {
        // 獲取
        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 {
            // beanClass 為 null，意味著子類並沒有重寫 getBeanClass() 方法，則嘗試去判斷是否重寫了 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.
            builder.setScope(containingBd.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();
    }

在該方法中我們主要關註兩個方法： getBeanClass() 、 doParse()。對於 getBeanClass() 方法，AbstractSingleBeanDefinitionParser 類並沒有提供具體實現，而是直接傳回 null，意味著它希望子類能夠重寫該方法，當然如果沒有重寫該方法，這會去呼叫 getBeanClassName() ，判斷子類是否已經重寫了該方法。對於 doParse() 則是直接空實現。所以對於 parseInternal() 而言它總是期待它的子類能夠實現 getBeanClass()、 doParse()，其中 doParse() 尤為重要，如果你不提供實現，怎麼來解析自定義標簽呢？最後將自定義的解析器：UserDefinitionParser 再次回觀。

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

至此，自定義標簽的解析過程已經分析完成了。其實整個過程還是較為簡單：首先會載入 handlers 檔案，將其中內容進行一個解析，形成這樣的一個對映，然後根據獲取的 namespaceUri 就可以得到相應的類路徑，對其進行初始化等到相應的 Handler 物件，呼叫 parse() 方法，在該方法中根據標簽的 localName 得到相應的 BeanDefinitionParser 實體物件，呼叫 parse() ，該方法定義在 AbstractBeanDefinitionParser 抽象類中，核心邏輯封裝在其 parseInternal() 中，該方法傳回一個 AbstractBeanDefinition 實體物件，其主要是在 AbstractSingleBeanDefinitionParser 中實現，對於自定義的 Parser 類，其需要實現 getBeanClass() 或者 getBeanClassName() 和 doParse()。

往

期

精

彩

【死磕 Spring】----- IOC 之 IOC 初始化總結

【死磕 Spring】----- IOC 之 獲取 Document 物件

【死磕 Spring】----- IOC 之 註冊 BeanDefinition

【死磕 Spring】----- IOC 之 獲取驗證模型

【死磕 Spring】----- IOC 之 Spring 統一資源載入策略

【死磕 Spring】----- IOC 之深入理解 Spring IoC

END

>>>>>> 加群交流技術 <<<<<<

長按二維碼向我轉賬

受蘋果公司新規定影響，微信 iOS 版的贊賞功能被關閉，可透過二維碼轉賬支援公眾號。

閱讀原文


微信掃一掃
使用小程式
即將開啟""小程式
取消
開啟