[spring源码学习]二、IOC源码——配置文件读取

一、环境准备

　　对于学习源码来讲，拿到一大堆的代码，脑袋里肯定是嗡嗡的，所以从代码实例进行跟踪调试未尝不是一种好的办法，此处，我们准备了一个小例子：

package com.zjl;

public class Person {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void sayHello(){
        System.out.println("hello "+this.name);
    }
}

　　bean的定义：

    <bean id="person" class="com.zjl.Person">
        <property name="name" value="zhangsan"></property>
    </bean>  

　　从很久以前，spring的第一个例子惯性的我们都是用XmlBeanFactory来进行，测试代码如下：

        XmlBeanFactory xmlBeanFactory=new XmlBeanFactory(new ClassPathResource("bean.xml"));
        Person person=(Person)xmlBeanFactory.getBean("person");
        person.sayHello();

　　不过，很可惜，这个类在后来的版本中被删除了，不过没关系，他的源码很简单：

public class XmlBeanFactory extends DefaultListableBeanFactory {

    private final XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(this);

    /**
     * Create a new XmlBeanFactory with the given resource,
     * which must be parsable using DOM.
     * @param resource XML resource to load bean definitions from
     * @throws BeansException in case of loading or parsing errors
     */
    public XmlBeanFactory(Resource resource) throws BeansException {
        this(resource, null);
    }

    /**
     * Create a new XmlBeanFactory with the given input stream,
     * which must be parsable using DOM.
     * @param resource XML resource to load bean definitions from
     * @param parentBeanFactory parent bean factory
     * @throws BeansException in case of loading or parsing errors
     */
    public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException {
        super(parentBeanFactory);
        this.reader.loadBeanDefinitions(resource);
    }

}

　　我们可以看到，只是他继承了DefaultListableBeanFactory ，并持有一个XmlBeanDefinitionReader的引用，然后调用了this.reader.loadBeanDefinitions(resource)方法。所以我们很容易根据这个源码将程序改造一下

        DefaultListableBeanFactory beanFacory=new DefaultListableBeanFactory();
        XmlBeanDefinitionReader reader=new XmlBeanDefinitionReader(beanFacory);
        reader.loadBeanDefinitions(new ClassPathResource("bean.xml"));
        Person person=(Person)beanFacory.getBean("person");
        person.sayHello();

　二、源码解析

　　结合上一节的内容，在本章节，我们只是详细看下针对xml配置的bean的一个加载过程，并不会调用getBean方法具体生成bean的对象，入口程序我们锁定为reader.loadBeanDefinitions(new ClassPathResource("bean.xml"))

　　1、对resource进行了再次包装，添加编码和字符集

    public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
        return loadBeanDefinitions(new EncodedResource(resource));
    }

　　2、读取配置文件，将inputStream转化为sax的inputSource，并设置字符集

try {
            InputStream inputStream = encodedResource.getResource().getInputStream();
            try {
                InputSource inputSource = new InputSource(inputStream);
                if (encodedResource.getEncoding() != null) {
                    inputSource.setEncoding(encodedResource.getEncoding());
                }
　　　　　　　　　//入口程序
                return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
            }
            finally {
                inputStream.close();
            }
        }

　　3、进入doLoadBeanDefinitions方法，将inputSource转化为Dom解析的Document

            Document doc = doLoadDocument(inputSource, resource);
            return registerBeanDefinitions(doc, resource);

　　4、创建dom的读取方法DefaultBeanDefinitionDocumentReader的实例，，并获取bean的数量，使用registerBeanDefinitions加载bean，解析完成后，返回此次加载bean的数量，注：此处对resource再次做了封装，疑似注入一些监听函数，但是暂时不管他们

    public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
        BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
        int countBefore = getRegistry().getBeanDefinitionCount();
        documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
        return getRegistry().getBeanDefinitionCount() - countBefore;
    }

　　5、进入DefaultBeanDefinitionDocumentReader的registerBeanDefinitions方法，获取到配置文件的根节点beans，针对根节点开始遍历

    public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
        this.readerContext = readerContext;
        logger.debug("Loading bean definitions");
        Element root = doc.getDocumentElement();
        doRegisterBeanDefinitions(root);
    }

　　6、创建了一个delegate，并判断节点是否为NameSpaceURI-http://www.springframework.org/schema/beans

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

　　7、如果是默认的，获取profile属性，此处资料上可以配置开发、生产或者测试环境，暂不深究

        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)) {
                    if (logger.isInfoEnabled()) {
                        logger.info("Skipped XML bean definition file due to specified profiles [" + profileSpec +
                                "] not matching: " + getReaderContext().getResource());
                    }
                    return;
                }
            }
        }

　　8、继续解析，在真正解析前后，可以使用pre和post方法对xml进行处理，此处均为空，只看parseBeanDefinitions方法即可

        preProcessXml(root);
　　　　 //入口
        parseBeanDefinitions(root, this.delegate);
        postProcessXml(root);

　　9、此处再次判断，root是否为默认的namespace，如果是，获取所有子节点，进行遍历子节点，并解析。如果根节点或者子节点不是默认的namespace，将使用delegate.parseCustomElement进行解析，由此可以看出，spring为我们预留了一个自定义配置文件解析的入口(此部分作为下一个章节重点分析)

　　此次我们只有默认的namespace的应用，所以进行解析他的Element的子节点，我们知道唯一一个子节点为“bean”

protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
        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);
        }
    }

10、对子节点的解析分为4中情况，分别为import，alias，bean，beans，其中

　　beans：之前处理过，再次解析子节点即可

　　import：表示引入另外的配置文件资源进行解析，此处预留其他文件解析入口

　　alias：支持此格式<alias name="doSpring" alias="do"/>，是对一个bean起别名

　　bean:是我们目前解析的重点，进入下一步解析

    private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
        if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
            importBeanDefinitionResource(ele);
        }
        else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
            processAliasRegistration(ele);
        }
        else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
　　　　　　//入口
            processBeanDefinition(ele, delegate);
        }
        else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
            // recurse
            doRegisterBeanDefinitions(ele);
        }
    }

11、根据节点，创建一个BeanDefinitionHolder，

    protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
　　　　　//入口
        BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
        if (bdHolder != null) {
            bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
            try {
                // Register the final decorated instance.
                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));
        }
    }

12、我们具体看下他的源码，可以知道它是根据Element的id，name等两个属性进行生成，如果有id，id作为beanName，如果id不存在，name的第一个作为beanName，其他作为别名，此处不再贴出，然后根据name和元素，创建一个AbstractBeanDefinition

AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);

13、 分别获得className、parent、descriptioString 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);
            }
　　　　　　　//14、初始化GenericBeanDefinition
            AbstractBeanDefinition bd = createBeanDefinition(className, parent);
　　　　　　　//15、设置bean的其他属性，包括单例，抽象，延迟加载、autowire、dependency-check、depends-on、autowire-candidate、primary、init-method、destroy-method、factory-method、factory-bean等属性，
此部分的特点是有一个默认值，但也通过系统默认设置
            parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
            bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
　　　　　　　//解析子标签中的meta标签
            parseMetaElements(ele, bd);
　　　　　　　//解析look-up标签
            parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
　　　　　　　//解析replaced-method标签
            parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
　　　　　　　//constructor-arg标签，为了便于构造函数注入
            parseConstructorArgElements(ele, bd);
　　　　　　//解析Property标签，根据value或者ref标签分别注入TypedStringValue或RuntimeBeanReference到PropertyValue中
            parsePropertyElements(ele, bd);
　　　　　　　//解析qualifier
            parseQualifierElements(ele, bd);

            bd.setResource(this.readerContext.getResource());
            bd.setSource(extractSource(ele));

            return bd;
        }

14、与13一起，根据parentName和className创建GenericBeanDefinition的实例，此处classLoader不为null时候，似乎客户设置复杂的数据格式，暂时跳过

    public static AbstractBeanDefinition createBeanDefinition(
            String parentName, String className, ClassLoader classLoader) throws ClassNotFoundException {

        GenericBeanDefinition bd = new GenericBeanDefinition();
        bd.setParentName(parentName);
        if (className != null) {
            if (classLoader != null) {
                bd.setBeanClass(ClassUtils.forName(className, classLoader));
            }
            else {
                bd.setBeanClassName(className);
            }
        }
        return bd;
    }

15、如果有其他标签，仍按照此方法继续处理。到此部分，我们已经解析完了配置文件中的所有标签

16、根据别名，beanDefinition beanName创建BeanDefinitionHolder

String[] aliasesArray = StringUtils.toStringArray(aliases);
            return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);

17、对holder进行进一步装饰，主要装饰[autowire="default", autowire-candidate="default", class="com.zjl.Person", id="person", lazy-init="default"]等

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
        BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
        if (bdHolder != null) {
            bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
            try {
                // Register the final decorated instance.将最终装饰后的BeanDefinition注入registry,
                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));
        }

18、调用registerBeanDefinition，注入bean时，先做一个父类检测((AbstractBeanDefinition) beanDefinition).validate()

主要检测是否在配置文件中设置了factoryMethodName，

    public void validate() throws BeanDefinitionValidationException {
        if (!getMethodOverrides().isEmpty() && getFactoryMethodName() != null) {
            throw new BeanDefinitionValidationException(
                    "Cannot combine static factory method with method overrides: " +
                    "the static factory method must create the instance");
        }

        if (hasBeanClass()) {
            prepareMethodOverrides();
        }
    }

19、将beanDefinition放入map，beanName放入list，将alias也放到map

this.beanDefinitionMap.put(beanName, beanDefinition);
                this.beanDefinitionNames.add(beanName);
                this.manualSingletonNames.remove(beanName);

20、触发注入的事件，此处触发了第四部分注入的监听事件，由于创建时候使用的XmlBeanDefinitionReader的new XmlReaderContext(resource, this.problemReporter, this.eventListener,this.sourceExtractor, this, getNamespaceHandlerResolver());方法中的EmptyReaderEventListener方法均为空，所以不做任何事情，此处我们也知道了，可以在自定义reader的子类中注入新的监听类，可以得到其他通知

// Send registration event.
            getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));

三、总结

1、到此为止，整个ioc的配置文件读取和解析过程以及完成，此处只有一个bean，如果有多个，会从根继续读取下一个子节点进行解析。，最终我们在DefaultListableBeanFactory里得到了bean的map，beanName的list，alias的map等，通过这些容器就可以得到配置文件中bean的内容，但如何在调用getBean的时候获得到需要的bean，需要我们在以后的学习中进一步阅读源码

2、在源码中我们可以看到除了自己配置的一些简单信息外，spring还有大量的默认配置和全局配置，这些配置的不同，是spring的各种功能的入口和配置，需要我们进行关注

3、学习过程中，还有很多暂时不明白的功能，只能先跳过