ClassPathXmlApplicationContext源码解析二:默认空间元素解析

本文引自我的个人博客: sunmingshuai.coding.me

写在前面
在 ClassPathXmlApplicationContext源码解析一 中 我们用了很长的篇幅 介绍了加载上下文环境前的各种准备工作 spring是个世界级的项目框架 由精英团队打造 全世界的测试人员测试 即使如果读者感觉有点吃力 对突然冒出来的代码有点不习惯的话 也不要气馁 继续往下读 刚阅读源代码的时候 最怕纠结于一些琐碎单却不重要的事情

下面我们看一下parseBeanDefinitions(root, this.delegate)方法

//对于`delegate`  我们暂时只要知道这个类中含有我们需要的一些environment,beanfactory等信息就可以了 当然他还提供一些解析方法    protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {        /**         * 如果是默认命名空间 也就是"http://www.springframework.org/schema/beans"这个空间下的元素 调用parseDefaultElement         * 否则调用parseCustomElement 例如aop context tx等标签的解析         * 也就是parseDefaultElement 解析import alias bean beans标签元素         * parseCustomElement 解析aop context tx 或者是用户自定义命名空间的元素         */        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 {                        delegate.parseCustomElement(ele);                    }                }            }        }        else {            delegate.parseCustomElement(root);        }    }

我们这篇文章只看默认命名空间的解析 也就是http://www.springframework.org/schema/beans这个空间下的定义的元素定义 对于非默认空间下的元素的解析的话 请看component-scan做了些什么 这篇文章讲解了component空间下的元素解析

    private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {        //解析import元素标签 通过调用`loadBeanDefinitions`模块方法完成元素加载<import resource="url"/>        if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {            importBeanDefinitionResource(ele);        }        //解析alias元素标签 <alias name="" alias="" />        else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {            //注册别名 说白点就是把name alias的对应关系加入到一个map中            processAliasRegistration(ele);        }        //解析bean元素标签 最核心 <bean >        else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {            processBeanDefinition(ele, delegate);        }        //解析beans元素标签 又调用了`doRegisterBeanDefinitions(element)`方法去解析<beans>        else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {            // recurse            doRegisterBeanDefinitions(ele);        }    }

到达这个方法的时候 ele代表的就是一个bean标签元素了 例如

<bean id="" class="">

我们不必深入了解xml文档的解析 也是能看的懂的 当然如果了解解析的过程 是更好的了
我们可以很清晰的看到beans空间下的元素标签有import alias bean beans 我们当然是重点讲解bean标签的解析了 继续跟踪代码

    protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {    //继续跟踪        BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);        if (bdHolder != null) {            //处理非默认命名空间的元素 如果有的话 这里不继续跟踪下去了            bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);            try {                // 也就是放到一个map中去 key为beanName value为BeanDefinition                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));        }    }

跟踪进BeanDefinitionParserDelegate.parseBeanDefinitionElement方法

    public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) {        String id = ele.getAttribute(ID_ATTRIBUTE);        String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);        //bean标签中的name其实会被划分成alias        List<String> aliases = new ArrayList<String>();        if (StringUtils.hasLength(nameAttr)) {            String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);            aliases.addAll(Arrays.asList(nameArr));        }        String beanName = id;        if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {            beanName = aliases.remove(0);            if (logger.isDebugEnabled()) {                logger.debug("No XML 'id' specified - using '" + beanName +                        "' as bean name and " + aliases + " as aliases");            }        }        if (containingBean == null) {            //beanName唯一性校验            checkNameUniqueness(beanName, aliases, ele);        }        AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);//GenericBeanDefinition        if (beanDefinition != null) {            // 阅读源代码要做到有的放矢 像下面这样的代码就没有太大的必要去看了            if (!StringUtils.hasText(beanName)) {                try {                    if (containingBean != null) {                        beanName = BeanDefinitionReaderUtils.generateBeanName(                                beanDefinition, this.readerContext.getRegistry(), true);                    }                    else {                        beanName = this.readerContext.generateBeanName(beanDefinition);                        String beanClassName = beanDefinition.getBeanClassName();                        if (beanClassName != null &&                                beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&                                !this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {                            aliases.add(beanClassName);                        }                    }                    if (logger.isDebugEnabled()) {                        logger.debug("Neither XML 'id' nor 'name' specified - " +                                "using generated bean name [" + beanName + "]");                    }                }                catch (Exception ex) {                    error(ex.getMessage(), ele);                    return null;                }            }            //返回BeanDefinitionHolder            String[] aliasesArray = StringUtils.toStringArray(aliases);            return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);        }        return null;    }

id 就是beanName了 必须要唯一才行 其实parseBeanDefinitionElement这个方法的目的就很明确了 就是要把bean的配置读取并保存起来 保存到GenericBeanDefinition中 例如我们常见的property constructor-arg等 无非就是构造合适的结构 然后读取数据并保存起来 供以后使用 虽然目的明确 但过程确实是很繁琐的 因为spring支持多种复杂数据结构 例如list map等
我们就不再深入解读了 读者可以自己找几个解析方法阅读

    /**     * 在这个方法中会遇到我们之前可能没有遇到的标签/属性元素 最好的解决办法就是先搜索这个元素/属性的用法,然后再看解析, 再看他们的应用处理等     * 我们这里不对这些不常用的元素/属性进行详解 这里主要就是解析出来并保存到BeanDefinitiion中     */    public AbstractBeanDefinition parseBeanDefinitionElement(            Element ele, String beanName, BeanDefinition containingBean) {        this.parseState.push(new BeanEntry(beanName));        String className = null;        if (ele.hasAttribute(CLASS_ATTRIBUTE)) {            className = ele.getAttribute(CLASS_ATTRIBUTE).trim();        }        try {            String parent = null;            if (ele.hasAttribute(PARENT_ATTRIBUTE)) {                parent = ele.getAttribute(PARENT_ATTRIBUTE);            }            //GenericBeanDefinition 设置className parentName变量 parent属性目前只是作为一个普通属性放倒BeanDefinition中去了 后面加载单例的时候会用到            AbstractBeanDefinition bd = createBeanDefinition(className, parent);//            //解析元素属性 例如scope lazy-init factory-method等属性的解析            parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);            //解析元素子元素开始            bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));            //<meta key="" value="" /> 作为对bd的额外参数使用            parseMetaElements(ele, bd);            //<lookup-method name="" bean="" /> 插拔式设计 方法根据配置 动态返回不同的bean 感兴趣的可以自行搜索相关使用demo            parseLookupOverrideSubElements(ele, bd.getMethodOverrides());            //<replaced-method name="" replacer=""/> 根据配置 替换/更改原来的方法逻辑 interesting 感兴趣的可以自行搜索相关使用demo            parseReplacedMethodSubElements(ele, bd.getMethodOverrides());            //todo <constructor-arg index="i"></constructor-arg>            parseConstructorArgElements(ele, bd);            //<property name="" value=""/> or more complex property such as list,map 阅读源代码 我们要有的放矢            // 没必要把每一行都看懂 就像下面的解析构造参数 与 property一样 都是很复杂的 但我们没必要都读懂才行            parsePropertyElements(ele, bd);            //<qualifier />            parseQualifierElements(ele, bd);            bd.setResource(this.readerContext.getResource());            bd.setSource(extractSource(ele));            return bd;        }        catch (ClassNotFoundException ex) {            error("Bean class [" + className + "] not found", ele, ex);        }        catch (NoClassDefFoundError err) {            error("Class that bean class [" + className + "] depends on not found", ele, err);        }        catch (Throwable ex) {            error("Unexpected failure during bean definition parsing", ele, ex);        }        finally {            this.parseState.pop();        }        return null;    }

生成beanDefinition后 再用BeanDefinitionHolder封装后返回注册 至此xml配置文件中的设置就转化为了java对象保存
我们在回到refresh()方法 继续往下看prepareBeanFactory()方法

    protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {        // Tell the internal bean factory to use the context's class loader etc.        beanFactory.setBeanClassLoader(getClassLoader());        //        beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver());        // 我们知道xml文档中的都是字符串形式的值 但我们可能需要的是其他的类型 比如Float Date等        // 这里注册一些常用的属性编辑器 去解决类型转化问题        beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));        //BPP 作用是如果bean实现了Aware接口的话 自动调用`setXXX`方法        beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));        //忽略特殊类`ResourceLoaderAware` 等的依赖        beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);        beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);        beanFactory.ignoreDependencyInterface(MessageSourceAware.class);        beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);        beanFactory.ignoreDependencyInterface(EnvironmentAware.class);        // BeanFactory interface not registered as resolvable type in a plain factory.        // MessageSource registered (and found for autowiring) as a bean.        beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);        beanFactory.registerResolvableDependency(ResourceLoader.class, this);        beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);        beanFactory.registerResolvableDependency(ApplicationContext.class, this);        // Detect a LoadTimeWeaver and prepare for weaving, if found.        // @AspectJ相关 不常用 后面会专门讲解Spring AOP        if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {            beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));            // Set a temporary ClassLoader for type matching.            beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));        }        // Register default environment beans.        if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {            beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());        }        if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {            beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());        }        if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {            beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());        }    }

代码里面的注释应该是很详细了 我们来分析一个很有趣的事情
如果我们想在我们自己类中 获取如ApplicationContext的话 我们一般会继承ApplicationContextAware 然后有个回调方法会让我们实现 例如setApplicationContext 那么为什么我们只要实现了这个接口 我们实现的回调方法就会调用呢 奥秘就在这句代码beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this))
BPP(BeanFactoryPostProcessor)是个很重要的知识点 我们这里大概了解一下

不管是单例模式还是原型模式 我们定义的class肯定是要实例化的 如果有定义初始化方法的话 还会调用初始化方法 对于一个类来说 实例化 初始化都是很重要的时间节点 我们的class又是托管给spring进行管理的 那么spring就有能力 有机会在这些时间节点前后添加一些处理方法 spring中代表这一类操作的接口是BeanPostProcessor 简称BPP 中文翻译是后置处理器 当然spring中还有一种PostProcessor是容器级别的 BeanFactoryPostProcessor 就是在容器加载前后做一些特殊的操作

在ApplicationContextAwareProcessor.postProcessBeforeInitialization(final Object bean, String beanName)方法中 会调用invokeAwareInterfaces(bean)方法

    private void invokeAwareInterfaces(Object bean) {        if (bean instanceof Aware) {            if (bean instanceof EnvironmentAware) {                ((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());            }            if (bean instanceof EmbeddedValueResolverAware) {                ((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(                        new EmbeddedValueResolver(this.applicationContext.getBeanFactory()));            }            if (bean instanceof ResourceLoaderAware) {                ((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);            }            if (bean instanceof ApplicationEventPublisherAware) {                ((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);            }            if (bean instanceof MessageSourceAware) {                ((MessageSourceAware) bean).setMessageSource(this.applicationContext);            }            if (bean instanceof ApplicationContextAware) {                ((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);            }        }    }

看起来很神秘的东西 它的实现是不是很一般 而且还感觉有点low 竟然没有魔法