BeanDefinitions加载流程

[zyllt]

Spring在创建完BeanFactory之后就会进行加载BeanDefinitions，如果是用的XML形式来启动的Spring，首先要做的就是解析XML文件。如果是注解式配置，在初始化AnnotationConfigApplication的时候就已经根本配置的scan path来加载和注册BeanDefinitions了

ApplicationContext context = new ClassPathXmlApplicationContext("application-context.xml")

1. 解析XML文件

此处主要用到的核心类是XmlBeanDefinitionReader

1.1 定位文件

根据传入的XML文件路径，解析成Resource数组:

//定位获取 Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);

1.2 读取XML文件

在获取到XML文件的resource时候就可以进行读取工作，此项工作是交给DefaultDocumentLoader来完 成，默认使用DocumentBuilder来解析xml文件。

protected Document doLoadDocument(InputSource inputSource, Resource resource) throws Exception {
        return this.documentLoader.loadDocument(inputSource, getEntityResolver(), this.errorHandler,
                getValidationModeForResource(resource), isNamespaceAware());
    }

1.3 解析注册

1.2中返回的Document，就可以交给DefaultBeanDefinitionDocumentReader来循环处理Element了。

public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
    /**
     * 实例化 {@link DefaultBeanDefinitionDocumentReader}
     */
    BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
    /**
     * 获取之前已经注册的beanDefinition的数量
     * {@link DefaultListableBeanFactory#getBeanDefinitionCount()}
     */
    int countBefore = getRegistry().getBeanDefinitionCount();
    /**
     * 委托给 {@link DefaultBeanDefinitionDocumentReader}进行实际的解析和注册
     */
    documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
    return getRegistry().getBeanDefinitionCount() - countBefore;
}

@Override
public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
    this.readerContext = readerContext;
    logger.debug("Loading bean definitions");
    Element root = doc.getDocumentElement();
    /**
     * 真正的解析注册逻辑
     */
    doRegisterBeanDefinitions(root);
}
protected void doRegisterBeanDefinitions(Element root) {
    // Any nested <beans> elements will cause recursion in this method. In
    // order to propagate and preserve <beans> default-* attributes correctly,
    // keep track of the current (parent) delegate, which may be null. Create
    // the new (child) delegate with a reference to the parent for fallback purposes,
    // then ultimately reset this.delegate back to its original (parent) reference.
    // this behavior emulates a stack of delegates without actually necessitating one.
    BeanDefinitionParserDelegate parent = this.delegate;
    /**
     * 创建一个 {@link BeanDefinitionParserDelegate}，把解析任务委托给它
     * 如果有多个beans标签会导致此解析递归调用，为防止出现错误，需要创建新的并且传递parent
     */
    this.delegate = createDelegate(getReaderContext(), root, parent);

    /**
     * 判断是否默认的spring nameSpace {@link BeanDefinitionParserDelegate#BEANS_NAMESPACE_URI}
     * 如果uri为空也返回true
     */
    if (this.delegate.isDefaultNamespace(root)) {
        String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
        if (StringUtils.hasText(profileSpec)) {
            String[] specifiedProfiles = StringUtils.tokenizeToStringArray(
                    profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
            if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {
                return;
            }
        }
    }

    /**
     * 准备方法，可以被重写
     */
    preProcessXml(root);
    /**
     * 解析 element、注册bean definitions
     */
    parseBeanDefinitions(root, this.delegate);
    postProcessXml(root);

    this.delegate = parent;
}

[zyllt]

在轮询element的childNodes过程中，可能会有很多自定义的标签。Spring的默认xml标签只有bean、import、alias、beans,其中beans和import都会因为解析过程的递归调用。 当碰到一些特殊的或者自定义的标签时，spring是怎么判断和解析的，先看源码：

Element ele = (Element) node;
/**
 * 此处分为默认的解析器和自定义的解析器，根据NameSpaceUri获取NameSpaceHandler
 * 自定义namespaceuri解析扩展需要实现{@link NamespaceHandlerSupport#init()}和{@link BeanDefinitionParser}
 * 并且需要在META-INF文件中创建spring.handles文件，类似于http://code.alibabatech.com/schema/dubbo=com.alibaba.dubbo.config.spring.schema.DubboNamespaceHandler
 * 配置会被{@link DefaultNamespaceHandlerResolver#getHandlerMappings()}加载
 */
if (delegate.isDefaultNamespace(ele)) {
    parseDefaultElement(ele, delegate);
}
else {
    delegate.parseCustomElement(ele);
}

从上面可以看到主要是delegate.isDefaultNamespace来判断是否默认的标签。如果element的namespaceUri是空或者等于http://www.springframework.org/schema/beans，则返回true

public boolean nodeNameEquals(Node node, String desiredName) {
    return desiredName.equals(node.getNodeName()) || desiredName.equals(getLocalName(node));
}

public boolean isDefaultNamespace(String namespaceUri) {
    return (!StringUtils.hasLength(namespaceUri) || BEANS_NAMESPACE_URI.equals(namespaceUri));
}

下面看一下怎么解析默认的element:

private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
    if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
        //解析import节点，会触发import的xml文件解析
        importBeanDefinitionResource(ele);
    }
    else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
        //解析alias节点
        processAliasRegistration(ele);
    }
    else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
        //解析bean节点，注册到beanDefinitionMaps
        /**
         * {@link BeanDefinitionReaderUtils}工具类
         */
        processBeanDefinition(ele, delegate);
    }
    else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
        // recurse
        /**
         * beans下面包含beans，递归调用
         */
        doRegisterBeanDefinitions(ele);
    }
}

[zyllt]

在解析默认的标签Element中，我们重点看一下解析bean标签配置，在此过程中会根据配置生成benaDefinition，并且注册到BeanFactory，其中实际注册是在DefaultListableBeanFactory实现的。 （其实是保存到DefaultListableBeanFactory的beanDefinitionMap中）

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
    /**
     * 解析为{@link org.springframework.beans.factory.support.GenericBeanDefinition},并且有name和别名
     */
    BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
    if (bdHolder != null) {
        /**
         * 根据自定义属性(自定义的标签)修改beanDefinition
         */
        bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
        try {
            // Register the final decorated instance.
            /**
             * 注册beanDefinition,默认通过 {@link org.springframework.beans.factory.support.DefaultListableBeanFactory#registerBeanDefinition}
             */
            BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
        }
        catch (BeanDefinitionStoreException ex) {
            getReaderContext().error("Failed to register bean definition with name '" +
                    bdHolder.getBeanName() + "'", ele, ex);
        }
        // Send registration event.
        /**
         * 发送注册事件
         */
        getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
    }
}

[zyllt]

下面看一下解析自定义的标签，其实在解析bean的时候，如果你为bean标签定义了其他的attribute，也用到自定义的标签解析。

public BeanDefinition parseCustomElement(Element ele, BeanDefinition containingBd) {
    String namespaceUri = getNamespaceURI(ele);
    //根据uri获取对应的NameSpaceHandler
    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));
}

在上面最重要的就是getNamespaceHandlerResolver().resolve(namespaceUri)，其实就是根据不同的namepaceUri来获取不同的NameSpaceHandler来处理。

public NamespaceHandler resolve(String namespaceUri) {
    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.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);
        }
    }
}

/**
 * Load the specified NamespaceHandler mappings lazily.
 */
private Map<String, Object> getHandlerMappings() {
    if (this.handlerMappings == null) {
        synchronized (this) {
            if (this.handlerMappings == null) {
                try {
//加载META-INF/spring.handlers文件，格式类似于http://code.alibabatech.com/schema/dubbo=com.alibaba.dubbo.config.spring.schema.DubboNamespaceHandler
                    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());
                    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;
}

以dubbo的标签为例解答下：

dubbo的DubboNamespaceHandler继承了NamespaceHandlerSupport，实现了init方法，在init方法中注册对应标签的解析器；

public void init() {
    registerBeanDefinitionParser("application", new DubboBeanDefinitionParser(ApplicationConfig.class, true));
    registerBeanDefinitionParser("module", new DubboBeanDefinitionParser(ModuleConfig.class, true));
    registerBeanDefinitionParser("registry", new DubboBeanDefinitionParser(RegistryConfig.class, true));
    registerBeanDefinitionParser("monitor", new DubboBeanDefinitionParser(MonitorConfig.class, true));
    registerBeanDefinitionParser("provider", new DubboBeanDefinitionParser(ProviderConfig.class, true));
    registerBeanDefinitionParser("consumer", new DubboBeanDefinitionParser(ConsumerConfig.class, true));
    registerBeanDefinitionParser("protocol", new DubboBeanDefinitionParser(ProtocolConfig.class, true));
    registerBeanDefinitionParser("service", new DubboBeanDefinitionParser(ServiceBean.class, true));
    registerBeanDefinitionParser("reference", new DubboBeanDefinitionParser(ReferenceBean.class, false));
    registerBeanDefinitionParser("annotation", new DubboBeanDefinitionParser(AnnotationBean.class, true));
}

在解析自定义标签方法中获取到的就是DubboNamespaceHandler，然后从中获取到不同的BeanDefinitionParse，此接口只有一个方法就是把element解析为BeanDefinition，然后注册。