spring源码解析2--容器的基本实现

spring的主要特性是IOC，实现IOC的关键是bean，而更关键的是如何bean的管理容器，也就是BeanFactory，本文的目标是弄清楚BeanFactory具体是怎么样的存在。

先看下最简单的获取bean的案例，代码如下：

public static void main(String[] args){
        BeanFactory factory = new XmlBeanFactory(new ClassPathResource("spring-beans.xml"));
        User user = (User) factory.getBean("user");
        System.out.println(JSON.toJSON(user).toString());
    }

首先是读取spring的配置文件，创建BeanFactory实例，如何直接从BeanFactory实例中获取指定名称的bean。接下来就从这几行简单的代码入手，分析下BeanFactory。

BeanFactory实例是通过XmlBeanFactory来创建的，很明显XmlBeanFactory是BeanFactory的子类，继承关系图如下：

那么先就从XmlBeanFactory的构造方法开始，源码如下：

public class XmlBeanFactory extends DefaultListableBeanFactory {

    private final XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(this);

    public XmlBeanFactory(Resource resource) throws BeansException {
        this(resource, null);
    }

    public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException {
        super(parentBeanFactory);
        this.reader.loadBeanDefinitions(resource);
    }

}

第5行的构造方法调用第9行的构造方法，首先是执行父类的构造方法，然后执行XmlBeanFefinitionReader的loadBeanFefinitions(resource)方法，这个方法显然就是加载bean配置文件的方法。接下来跟踪查看，源码如下：

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

通过EncodeResource来封装Resource，在调用重载的方法

public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
        Assert.notNull(encodedResource, "EncodedResource must not be null");
        //校验Resource参数
        if (logger.isInfoEnabled()) {
            logger.info("Loading XML bean definitions from " + encodedResource.getResource());
        }

        Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();
        if (currentResources == null) {
            currentResources = new HashSet<>(4);
            this.resourcesCurrentlyBeingLoaded.set(currentResources);
        }
        if (!currentResources.add(encodedResource)) {
            throw new BeanDefinitionStoreException(
                    "Detected cyclic loading of " + encodedResource + " - check your import definitions!");
        }
        try {
            //获取Resource的InputSteam流
            InputStream inputStream = encodedResource.getResource().getInputStream();
            try {
                //通过InputSteam构造InputSource
                InputSource inputSource = new InputSource(inputStream);
                if (encodedResource.getEncoding() != null) {
                    inputSource.setEncoding(encodedResource.getEncoding());
                }
                //最终执行doLoadBeanDefinitions方法
                return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
            }
            finally {
                inputStream.close();
            }
        }
        catch (IOException ex) {
            throw new BeanDefinitionStoreException(
                    "IOException parsing XML document from " + encodedResource.getResource(), ex);
        }
        finally {
            currentResources.remove(encodedResource);
            if (currentResources.isEmpty()) {
                this.resourcesCurrentlyBeingLoaded.remove();
            }
        }
    }

这次封装的EncodedResource作用主要是对XML配置文件的编码格式进行处理，然后最终执行了doLoadBeanDefinitions方法

    protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
            throws BeanDefinitionStoreException {
        try {
            //通过InputSource和Resource得到一个Document对象,然后执行注册bean的方法
            Document doc = doLoadDocument(inputSource, resource);
            return registerBeanDefinitions(doc, resource);
        }
        catch (BeanDefinitionStoreException ex) {
            throw ex;
        }
        catch (SAXParseException ex) {
            throw new XmlBeanDefinitionStoreException(resource.getDescription(),
                    "Line " + ex.getLineNumber() + " in XML document from " + resource + " is invalid", ex);
        }
        catch (SAXException ex) {
            throw new XmlBeanDefinitionStoreException(resource.getDescription(),
                    "XML document from " + resource + " is invalid", ex);
        }
        catch (ParserConfigurationException ex) {
            throw new BeanDefinitionStoreException(resource.getDescription(),
                    "Parser configuration exception parsing XML from " + resource, ex);
        }
        catch (IOException ex) {
            throw new BeanDefinitionStoreException(resource.getDescription(),
                    "IOException parsing XML document from " + resource, ex);
        }
        catch (Throwable ex) {
            throw new BeanDefinitionStoreException(resource.getDescription(),
                    "Unexpected exception parsing XML document from " + resource, ex);
        }
    }

该方法只有两行有效逻辑代码，首先是加载XML文件得到一个Document对象，然后根据Document对象来注册Bean信息，一步步来看，先看如何生成Document对象。

private DocumentLoader documentLoader = new DefaultDocumentLoader();

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

调用了DocumentLoader的实例来进行加载，DocumentLoader接口的loadDocument方法

public Document loadDocument(InputSource inputSource, EntityResolver entityResolver,
                                 ErrorHandler errorHandler, int validationMode, boolean namespaceAware) throws Exception {

        //这里显然是工厂模式+建造者模式，先创建DocumentBuilder工厂，如何得到DocumentBuilder，最终执行parse方法解析xml配置文件得到Document对象
        DocumentBuilderFactory factory = createDocumentBuilderFactory(validationMode, namespaceAware);
        if (logger.isDebugEnabled()) {
            logger.debug("Using JAXP provider [" + factory.getClass().getName() + "]");
        }
        DocumentBuilder builder = createDocumentBuilder(factory, entityResolver, errorHandler);
        return builder.parse(inputSource);
    }

public Document parse(InputSource is) throws SAXException, IOException {
        if (is == null) {
            throw new IllegalArgumentException(
                    DOMMessageFormatter.formatMessage(DOMMessageFormatter.DOM_DOMAIN,
                            "jaxp-null-input-source", null));
        }
        if (fSchemaValidator != null) {
            if (fSchemaValidationManager != null) {
                fSchemaValidationManager.reset();
                fUnparsedEntityHandler.reset();
            }
            resetSchemaValidator();
        }
        //上面的代码都是校验，核心是下面的三行，通过DomParser来获取Document对象
        domParser.parse(is);
        Document doc = domParser.getDocument();
        domParser.dropDocumentReferences();
        return doc;
    }

解析配置文件得到了Document对象，接下来就是通过Document来注册beanl了。回到XmlBeanDefinitionReader的RegisterBeanDefinitions方法

public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
        //创建BeanDefinitionDocumentReader实例
        BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
        //统计当前已经加载过的BeanDefinition个数
        int countBefore = getRegistry().getBeanDefinitionCount();
        //加载及注册bean
        documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
        //得到本次加载的BeanFinition个数
        return getRegistry().getBeanDefinitionCount() - countBefore;
    }

核心是BeanDefinitionDocumentReader接口的registerBeanDefinitions方法，代码如下：

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

首先是获取Document的root，然后将root元素传递给下面的方法继续执行，这里的root元素就是配置文件中的<beans>标签

protected void doRegisterBeanDefinitions(Element root) {
        //专门处理解析
        BeanDefinitionParserDelegate parent = this.delegate;
        this.delegate = createDelegate(getReaderContext(), root, parent);

        if (this.delegate.isDefaultNamespace(root)) {
            //处理<beans>标签中的profile属性
            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;
                }
            }
        }

        preProcessXml(root);//代码为空（模板方法设计模式：提供给子类实现，如果需要在bean的解析前后做一些处理的话）
        parseBeanDefinitions(root, this.delegate);//Bean的解析
        postProcessXml(root);//代码为空

        this.delegate = parent;
    }

发现bean的注册方法应该是parseBeanDefinitions方法，继续往下

 protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
        if (delegate.isDefaultNamespace(root)) {
            //获取<beans>标签的子节点也就是所有的<bean>标签
            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)) {
                        //如果是默认命名空间的bean
                        parseDefaultElement(ele, delegate);
                    }
                    else {
                        //如果是自定义命名空间的bean
                        delegate.parseCustomElement(ele);
                    }
                }
            }
        }
        else {
            //自定义命名空间的bean
            delegate.parseCustomElement(root);
        }
    }

这里是逻辑很清楚，获取root下的子节点遍历，判断是否是默认命名空间的元素来分别处理。判断是否是默认命名空间的方式是取Node的namespanceUrl来和默认命名空间的地址进行比较，默认地址为：

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

像<bean id="userService" class="com.test.UserService">这种写法就是默认标签，而如<tx:annotation-driven>这种就是自定义的写法。

总结：本文从BeanFactory的初始化开始，解析XML配置文件，生成Docuemnt对象，解析Document中的标签，按标签的类型来进行区分解析，而两种的解析方式截然不同，接下来就分别解析。