spring xml的bean提取 源码学习

上篇Spring xml解析 源码学习已经细说了spring是如何解析xml文件的，现在就来学习下如何把xml的元素转换为beandefinition甚至于我们需要的bean。

从DefaultBeanDefinitionDocumentReader的parseBeanDefinitions函数开始解析得出具体的bean，重点分析是默认的命名空间。
从root根节点出发，循环遍历其下的所有子节点，针对每个子节点进行判断和处理。

protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
    if (delegate.isDefaultNamespace(root)) {
       // 这里进去的是root元素，一般都会是默认的beans的命名空间
        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 {
                    delegate.parseCustomElement(ele);
                }
            }
        }
    }
    else {
       // 存在用户完全自定义的配置，使用自定义解析
        delegate.parseCustomElement(root);
    }
}

那么问题来了，delegate.isDefaultNamespace(ele)是如何判断当前元素是否属于默认命名空间的呢？

public static final String BEANS_NAMESPACE_URI = "http://www.springframework.org/schema/beans";

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

public boolean isDefaultNamespace(Node node) {
    return isDefaultNamespace(getNamespaceURI(node));
}   

在xml中以<bean>标识的肯定被系统默认为命名空间，如果是类似于<context>呢,只能是使用自定义的命名空间去解析了

image.png

如图圈住的地方，生成了具体解析的上下文XmlReaderContext。

XmlBeanDefinitionReader 文件

public XmlReaderContext createReaderContext(Resource resource) {
    return new XmlReaderContext(resource, this.problemReporter, this.eventListener,
            this.sourceExtractor, this, getNamespaceHandlerResolver());
            // 生成具体的XmlReaderContext对象
}

public NamespaceHandlerResolver getNamespaceHandlerResolver() {
    if (this.namespaceHandlerResolver == null) {
        this.namespaceHandlerResolver = createDefaultNamespaceHandlerResolver();
    }
    return this.namespaceHandlerResolver;
    // 生成了具体的namespace处理器
}

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

解决了命名空间的问题，开始具体解析了

public BeanDefinition parseCustomElement(Element ele, 
            BeanDefinition containingBd) {
    String namespaceUri = getNamespaceURI(ele);
    NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
    // 这里的handlerResolver就是上面所说的命名空间处理器DefaultNamespaceHandlerResolver
    // 然后选择出具体的handler解析器去解析
    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));
}

上面说的resolve方法的细节在DefaultNamespaceHandlerResolver 类

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 {
       // 初次生成的map都是<String, String>结构的，需要替换value为NamespaceHandler类
        String className = (String) handlerOrClassName;
        try {
            Class<?> handlerClass = ClassUtils.forName(className, this.classLoader);
            // value指明的类实例化
            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();
            // 这个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);
        }
    }
}

// 延迟加载获取具体的命名空间详情信息，生成一个map结构是<String, String>
private Map<String, Object> getHandlerMappings() {
    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());
                    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;
}

如下图，可以确认初始化获取的map的键值对具体情况

image.png

这是dubbo的命名空间配置

image.png

ContextNamespaceHandler 文件 初始化init注册进去的解析器

public class ContextNamespaceHandler extends NamespaceHandlerSupport {

    @Override
    public void init() {
        registerBeanDefinitionParser("property-placeholder", new PropertyPlaceholderBeanDefinitionParser());
        registerBeanDefinitionParser("property-override", new PropertyOverrideBeanDefinitionParser());
        registerBeanDefinitionParser("annotation-config", new AnnotationConfigBeanDefinitionParser());
        registerBeanDefinitionParser("component-scan", new ComponentScanBeanDefinitionParser());
        registerBeanDefinitionParser("load-time-weaver", new LoadTimeWeaverBeanDefinitionParser());
        registerBeanDefinitionParser("spring-configured", new SpringConfiguredBeanDefinitionParser());
        registerBeanDefinitionParser("mbean-export", new MBeanExportBeanDefinitionParser());
        registerBeanDefinitionParser("mbean-server", new MBeanServerBeanDefinitionParser());
    }

}

同理，也可以看看dubbo的

public class DubboNamespaceHandler extends NamespaceHandlerSupport {

    static {
        Version.checkDuplicate(DubboNamespaceHandler.class);
        // 检查是否重复了
    }

    public void init() {
        registerBeanDefinitionParser("application", new DubboBeanDefinitionParser(ApplicationConfig.class, true));
        // 如代码所示，关键字是application,也就是我们配置的**dubbo:application** 字段
        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));
    }
}

到这里我们基本清楚了选择的合适的命名空间去解析数据了，可是上文知道一个命名空间处理器handler有多个具体的parse解析器，那就肯定得选择一个具体的解析器去解析。可看抽象类 NamespaceHandlerSupport

NamespaceHandlerSupport 文件

public BeanDefinition parse(Element element, ParserContext parserContext) {
    return findParserForElement(element, parserContext).parse(element, parserContext);
    // 返回一个解析器之后，进行parse(element, parserContext)
}

// 果然不出我们所料（当然我也是看了源码的），确实存在了findPrase这个方法
private BeanDefinitionParser findParserForElement(Element element, ParserContext parserContext) {
    String localName = parserContext.getDelegate().getLocalName(element);
    
    BeanDefinitionParser parser = this.parsers.get(localName);
    // 通过元素的名称，获取到具体的parse，例如上面的PropertyPlaceholderBeanDefinitionParser parse解析器
    if (parser == null) {
        parserContext.getReaderContext().fatal(
                "Cannot locate BeanDefinitionParser for element [" + localName + "]", element);
    }
    return parser;
}

可以看看dubbo的解析器具体工作, DubboBeanDefinitionParser 文件

// 解析element元素的具体属性，返回一个beandefinition
private static BeanDefinition parse(Element element, ParserContext parserContext,   Class<?> beanClass, boolean required) {
   RootBeanDefinition beanDefinition = new RootBeanDefinition();
   beanDefinition.setBeanClass(beanClass);
   beanDefinition.setLazyInit(false);
   String id = element.getAttribute("id");
   if ((id == null || id.length() == 0) && required) {
    String generatedBeanName = element.getAttribute("name");
    if (generatedBeanName == null || generatedBeanName.length() == 0) {
        if (ProtocolConfig.class.equals(beanClass)) {
            generatedBeanName = "dubbo";
        } else {
            generatedBeanName = element.getAttribute("interface");
        }
   ......

到这里整个的解析过程就全部完成了，本篇学习了解了生成beandefinition的全过程，还有个问题就是spring本身如何持有这些已经解析好的beandefinition呢？（PS：是存储在一个map容器中）

又得回到我们上面的那幅图中虚线指出的位置，在AbstractXmlApplicationContext中就已经生成了一个XmlBeanDefinitionReader对象了，然后在XmlBeanDefinitionReader中又把自身当做一个参数传递到XmlReaderContext中，而XmlReaderContext又被当做一个参数传递给具体的parse。就这样整个的链路就打通了，层层包装继承

    public XmlReaderContext createReaderContext(Resource resource) {
        return new XmlReaderContext(resource, this.problemReporter, this.eventListener,
            // 就这个this！！！！很关键的一步
                this.sourceExtractor, this, getNamespaceHandlerResolver());
    }

• 在系统默认的命名空间获取的方式

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
    BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
    // 已经生成的beandefinition
    if (bdHolder != null) {
        bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
        try {
            // 最关键的一步！！！存储，getReaderContext() 返回的是XmlReaderContext上下文
            // getRegistry() 获取其注册仓库，也就是常说的`DefaultListableBeanFactory`
            // 最关键的那个管理bean的工厂
            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));
    }
}

public static void registerBeanDefinition(
        BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
        throws BeanDefinitionStoreException {
    String beanName = definitionHolder.getBeanName();
    registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
    // 这一步就是一直在找的存储到容器中的步骤

    // Register aliases for bean name, if any.
    String[] aliases = definitionHolder.getAliases();
    if (aliases != null) {
        for (String alias : aliases) {
            registry.registerAlias(beanName, alias);
            // bean配置存在别名的情况，也一并考虑
        }
    }
}

• 在自定义命名空间获取的方式

这个就比较简单了，需要对外提供接口的，持有一个ParserContext类

image.png

就这样通个这个ParserContext类把默认的BeanDefinitionParserDelegate本身以及xmlreadcontext上下文存储了，然后传递给用户自定义的parse进行存储操作。
当然这个BeanDefinitionParserDelegate是不是用就看用户自身了，看了下dubbo是并没有使用

所有的过程都结束了，现在spring容器持有beandefinition类型的所有bean，还有getBean等着我们呢！