ClassPathXmlApplicationContext源码解析一:准备工作

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

其实在web环境中 用到的上下文环境是 XmlWebApplicationContext 但其实对于我们要讲解的内容来说 核心逻辑是一样的 在后面讲解到web环境加载的时候 会讲到XmlWebApplicationContext类的解析 下面几篇博客的内容我们会介绍Spring是怎么构建上下文环境的 也就是ClassPathXmlApplicationContext的源码的过程
ClassPathXmlApplicationContext类的测试类是ClassPathXmlApplicationContextTests 如果读者能好好利用这个测试类的话 能节省不少阅读源码的时间
构造函数

    //接收配置文件的地址 默认刷新 父容器为null 讲解web环境加载的时候 会讲到父容器的概念
    public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)
            throws BeansException {
        super(parent);
        setConfigLocations(configLocations);
        if (refresh) {
            refresh();
        }
    }

以后讲解web环境加载的时候我们会讲到父子容器的概念 这里只考虑父容器为null的情况 如果路径中含有如${user.dir}的变量 会被处理替换掉 对替换这部分感兴趣的读者可以深入阅读 然后就进入最重要的一个方法refresh()
refresh()
refresh()方法从总体上看 还算比较清晰 用几个大的方法高度概括了refresh()要完成的工作

    public void refresh() throws BeansException, IllegalStateException {
        synchronized (this.startupShutdownMonitor) {
            // Prepare this context for refreshing.
            // 加载前的准备工作:active标记为true；资源必要性验证等 
            prepareRefresh();

            // 创建DefaultListableBeanFactory 并加载配置文件 转化为BeanDefinition保存
            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

            prepareBeanFactory(beanFactory);

            try {
                //empty
                postProcessBeanFactory(beanFactory);

                // spring扩展的实现(容器级别) BeanFactoryPostProcessor 在实例化任何用户定义的bean之前 会首先调用BFPP的接口方法
                // 常见的BFPP:PropertyPlaceholderConfigurer
                invokeBeanFactoryPostProcessors(beanFactory);

                // spring可扩展的另一个实现:BeanPostProcessor 在调用bean的init-method方法的前后会调用接口方法
                // 较常见的硬编码的BPP:ApplicationContextAwareProcessor,ApplicationListenerDetector
                registerBeanPostProcessors(beanFactory);

                //国际化
                initMessageSource();

                // Initialize event multicaster for this context.
                initApplicationEventMulticaster();

                // Initialize other special beans in specific context subclasses.
                //empty
                onRefresh();

                // Check for listener beans and register them.
                // 注册listener
                registerListeners();

                // Instantiate all remaining (non-lazy-init) singletons.
                // 实例化所有的非懒惰加载的单例
                finishBeanFactoryInitialization(beanFactory);

                // Last step: publish corresponding event.
                finishRefresh();
            }

            catch (BeansException ex) {
                logger.warn("Exception encountered during context initialization - cancelling refresh attempt", ex);

                // Destroy already created singletons to avoid dangling resources.
                destroyBeans();

                // Reset 'active' flag.
                cancelRefresh(ex);

                // Propagate exception to caller.
                throw ex;
            }
        }
    }

下面我们看obtainFreshBeanFactory()#AbstractRefreshableApplicationContext.refreshBeanFactory()方法(obtainFreshBeanFactory()方法中主要逻辑是在refreshBeanFactory()方法 我们就不再列出完整的obtainFreshBeanFactory()方法 以后这样的格式我们用#区分)
再此感叹spring代码的优秀 每个方法都是那么的简短清晰 一层一层的深入

    protected final void refreshBeanFactory() throws BeansException {
    // 如果已经加载过的话 先销毁再重新加载
        if (hasBeanFactory()) {
            destroyBeans();
            closeBeanFactory();
        }
        try {
        //实例化一个DefaultListableBeanFactory 这是一个很重要的类
            DefaultListableBeanFactory beanFactory = createBeanFactory();
            //设置id
            beanFactory.setSerializationId(getId());

            customizeBeanFactory(beanFactory);
            loadBeanDefinitions(beanFactory);
            synchronized (this.beanFactoryMonitor) {
                this.beanFactory = beanFactory;
            }
        }
        catch (IOException ex) {
            throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
        }
    }

/**
     * 忽略BeanNameAware  BeanFactoryAware  BeanClassLoaderAware的依赖 spring有设置专门调用setXXX方法的地方
     * Create a new AbstractAutowireCapableBeanFactory.
     */
    public AbstractAutowireCapableBeanFactory() {
        super();
        ignoreDependencyInterface(BeanNameAware.class);
        ignoreDependencyInterface(BeanFactoryAware.class);
        ignoreDependencyInterface(BeanClassLoaderAware.class);
    }

对于这样的代码 如果不跟踪进去的话 可能会对有些变量的值感到困惑
createBeanFactory()实例化了一个DefaultListableBeanFactory 在实例化的过程中 其父类 AbstractAutowireCapableBeanFactory的构造函数注册了几个忽略依赖注入的接口 就是说以后对于bean的属性注入的时候 如果在我们注册的忽略接口里面的话 就不再依赖注入

//
    protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory) {
    //是否允许覆盖
        if (this.allowBeanDefinitionOverriding != null) {
            beanFactory.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
        }
        //是否允许循环引用  循环引用是很重要的一个知识点 我们后面会专门讲解
        if (this.allowCircularReferences != null) {
            beanFactory.setAllowCircularReferences(this.allowCircularReferences);
        }
        //设置Qualifier注解解析类
        beanFactory.setAutowireCandidateResolver(new QualifierAnnotationAutowireCandidateResolver());
    }

我们看下beanFactory.setAutowireCandidateResolver(new QualifierAnnotationAutowireCandidateResolver())方法 这个方法就是设置autowireCandidateResolver变量 顺便做了一件事情 就是如果该变量继承了BeanFactoryAware的话 调用setBeanFactory()方法 我们从这里就可以看到sping代码优秀的另一个方面是约定习俗

    public void setAutowireCandidateResolver(final AutowireCandidateResolver autowireCandidateResolver) {
        Assert.notNull(autowireCandidateResolver, "AutowireCandidateResolver must not be null");
        if (autowireCandidateResolver instanceof BeanFactoryAware) {
            if (System.getSecurityManager() != null) {
                final BeanFactory target = this;
                AccessController.doPrivileged(new PrivilegedAction<Object>() {
                    public Object run() {
                        ((BeanFactoryAware) autowireCandidateResolver).setBeanFactory(target);
                        return null;
                    }
                }, getAccessControlContext());
            }
            else {
            // 调用`setBeanFactory()`方法 this作为参数
                ((BeanFactoryAware) autowireCandidateResolver).setBeanFactory(this);
            }
        }
        //设置变量
        this.autowireCandidateResolver = autowireCandidateResolver;
    }

下面就进入很重要的一个方法了AbstractXmlApplicationContext#loadBeanDefinitions(beanFactory); 载入配置文件 就是根据配置文件做相应的处理 例如将<bean>转化为BeanDefinition保存 这跟Tomcat将server.xml转化为StandardServer是一样的 阅读这部分代码并不需要你很了解是怎么解析xml文档的 因为方法包装的很好的 当然如果读者比较了解xml文档解析的话 那么就更好了

    protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
        // Create a new XmlBeanDefinitionReader for the given BeanFactory.
        XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

        // Configure the bean definition reader with this context's
        // resource loading environment.
        beanDefinitionReader.setEnvironment(this.getEnvironment());
        beanDefinitionReader.setResourceLoader(this);
        beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));

        // Allow a subclass to provide custom initialization of the reader,
        // then proceed with actually loading the bean definitions.
        initBeanDefinitionReader(beanDefinitionReader);
        loadBeanDefinitions(beanDefinitionReader);
    }

tips 前面几行代码一直在做准备工作 刚阅读源码的读者一定会被这错综复杂的关系所困扰 spring中模块众多,继承 组合关系也是错综复杂 第一次阅读的话 读者可不必太在意这些类之间的委托关系 跟着代码走就可以了 以后阅读第二遍第三遍的时候 再好好研究 比如到现在为止我们都是顺着代码走 并没有从代码设计的角度去讲解
loadBeanDefinitions()方法最终会调用AbstractBeanDefinitionReader#loadBeanDefinitions()方法

    public int loadBeanDefinitions(String location, Set<Resource> actualResources) throws BeanDefinitionStoreException {
    //ClassPathXmlApplicationContext
        ResourceLoader resourceLoader = getResourceLoader();
        if (resourceLoader == null) {
            throw new BeanDefinitionStoreException(
                    "Cannot import bean definitions from location [" + location + "]: no ResourceLoader available");
        }

        if (resourceLoader instanceof ResourcePatternResolver) {
            // Resource pattern matching available.
            try {
            // 把String类型的地址封装成Resource类型 方便后续操作
                Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);
                int loadCount = loadBeanDefinitions(resources);
                if (actualResources != null) {
                    for (Resource resource : resources) {
                        actualResources.add(resource);
                    }
                }
                if (logger.isDebugEnabled()) {
                    logger.debug("Loaded " + loadCount + " bean definitions from location pattern [" + location + "]");
                }
                return loadCount;
            }
            catch (IOException ex) {
                throw new BeanDefinitionStoreException(
                        "Could not resolve bean definition resource pattern [" + location + "]", ex);
            }
        }
        else {
            // Can only load single resources by absolute URL.
            Resource resource = resourceLoader.getResource(location);
            int loadCount = loadBeanDefinitions(resource);
            if (actualResources != null) {
                actualResources.add(resource);
            }
            if (logger.isDebugEnabled()) {
                logger.debug("Loaded " + loadCount + " bean definitions from location [" + location + "]");
            }
            return loadCount;
        }
    }

方法调用AbstractBeanDefinitionReader#loadBeanDefinitions(resource)#loadBeanDefinitions(encodedResource) 我们发现方法调来调去的 却一直没有看到我们想看的内容 一直做的都是准备工作 不急 慢慢来 我们继续往下看

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

        Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();
        if (currentResources == null) {
            currentResources = new HashSet<EncodedResource>(4);
            this.resourcesCurrentlyBeingLoaded.set(currentResources);
        }
        if (!currentResources.add(encodedResource)) {
            throw new BeanDefinitionStoreException(
                    "Detected cyclic loading of " + encodedResource + " - check your import definitions!");
        }
        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();
            }
        }
        catch (IOException ex) {
            throw new BeanDefinitionStoreException(
                    "IOException parsing XML document from " + encodedResource.getResource(), ex);
        }
        finally {
            currentResources.remove(encodedResource);
            if (currentResources.isEmpty()) {
                this.resourcesCurrentlyBeingLoaded.remove();
            }
        }
    }

也是做各种准备工作 终于让我们遇到了我们想要看的代码doLoadBeanDefinitions 代码读到后面 读者就会注意到spring中以do开头的方法才是真正的核心逻辑的开始

    protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
            throws BeanDefinitionStoreException {
        try {
            //获取验证模式 dtd or xsd
            int validationMode = getValidationModeForResource(resource);
            //为SAX应用程序提供寻找本地验证文件(dtd/xsd文件) 并将配置文件加载为document保存
            Document doc = this.documentLoader.loadDocument(
                    inputSource, getEntityResolver(), this.errorHandler, validationMode, isNamespaceAware());
            return registerBeanDefinitions(doc, resource);
        }
        ......
    }

当然还是山路十八弯

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

    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) {
        String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);//profile attribute
        if (StringUtils.hasText(profileSpec)) {
            String[] specifiedProfiles = StringUtils.tokenizeToStringArray(
                    profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
            if (!getEnvironment().acceptsProfiles(specifiedProfiles)) {
                return;
            }
        }

        BeanDefinitionParserDelegate parent = this.delegate;
        this.delegate = createDelegate(this.readerContext, root, parent);

        preProcessXml(root);
        parseBeanDefinitions(root, this.delegate);
        postProcessXml(root);

        this.delegate = parent;
    }

在方法createDelegate(this.readerContext, root, parent);中 通过populateDefaults()方法设置了一些例如default-lazy-init default-autowire的值 如果根元素中有设置这些变量的话 将会覆盖默认值 起到全局变量的作用
preProcessXml(root) postProcessXml(root)都被留空 留给子类实现
终于 finally 最终 我们看到了我们一直想看到的代码的影子 parseBeanDefinitions(root, this.delegate)
要知后事如何 且听下回分解