【spring源码分析】IOC容器初始化（一）

前言：spring主要就是对bean进行管理，因此IOC容器的初始化过程非常重要，搞清楚其原理不管在实际生产或面试过程中都十分的有用。在【spring源码分析】准备工作中已经搭建好spring的环境，并利用xml配置形式对类进行了实例化。在test代码中有一个非常关键的类ClassPathXmlApplicationContext，在这个类中实现了IOC容器的初始化，因此我们从ClassPathXmlApplicationContext入手开始研究IOC的初始化过程。

---

1.ClassPathXmlApplicationContext类继承关系

ClassPathXmlApplicationContext类的继承关系非常的庞大，在IOC容器初始化的过程中，经常调用父类的方法进行实现，因此需特别注意类之间的继承关系。通过阅读源码，可粗略的将IOC容器初始化过程分为两步：（1）解析xml文件，导入bean；（2）通过反射生成bean。因此下面将从这两大步对IOC初始化进行分析。

2.解析xml文件，导入bean

首先给出导入bean的调用链：

通过程序调用链可知：

（1）导入bean大致分为三个阶段：①导入bean（loadBeanDefinitions）；②解析bean（parseBeanDefinition）；③注册bean（registerBeanDefinition）。

（2）最终bean是存储在beanDefinitionMap中：键为类名（beanName），值为GenericBeanDefinition（BeanDefinition）。

下面对导入bean的三个阶段进行分析。

 2.1 导入bean阶段

通过上述调用链，先整理出在导入bean过程中所涉及的类和相关方法。

通过上表可以知道，在导入bean阶段主要涉及如下几个类（根据调用顺序）：

①ClassPathXmlApplicationContext；②AbstractApplicationContext；

③AbstractRefreshableApplicationContext；④AbstractXmlApplicationContext；

⑤AbstractBeanDefinitionReader；⑥XmlBeanDefinitionReader。

根据类名就可以猜测出①②③④为继承关系，事实的确如此。其继承关系通过ClassPathXmlApplicationContext继承关系图可知：

⑤⑥也为继承关系，其继承关系如下：

2.2 bean导入阶段源码分析

通过上面对bean导入阶段大致流程的梳理，应该对bean导入阶段有了大体的认识，下面对该阶段源码进行分析（按上面程序调用链顺序）。

ClassPathXmlApplicationContext构造函数，具体代码如下：

    public ClassPathXmlApplicationContext(
            String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)
            throws BeansException {

        super(parent);
        System.out.println("配置文件:"+configLocations[0]);
        setConfigLocations(configLocations);  //配置xml文件资源
        if (refresh) {
            System.out.println("进入核心函数:AbstractApplicationContext#refresh");
            refresh();
        }
    }

这段代码比较好理解主要就是设置xml文件资源，将xml文件的路径保存下来，供后面使用。

第7行代码调用的是AbstractRefreshableConfigApplicationContext的setConfigLocations函数，该函数功能简单：设置xml文件资源，具体代码如下：

    /**
     * Set the config locations for this application context.
     * <p>If not set, the implementation may use a default as appropriate.
     */
    public void setConfigLocations(@Nullable String... locations) {
        if (locations != null) {
            Assert.noNullElements(locations, "Config locations must not be null");
            this.configLocations = new String[locations.length];
            for (int i = 0; i < locations.length; i++) {
                this.configLocations[i] = resolvePath(locations[i]).trim();  //解析xml路径，并存入configLocations中
            }
        }
        else {
            this.configLocations = null;
        }
    }

第10行代码refresh()为整个IOC流程的入口，这里调用的是AbstractApplicationContext的refresh方法，具体代码如下：

public void refresh() throws BeansException, IllegalStateException {
        synchronized (this.startupShutdownMonitor) {
            // Prepare this context for refreshing.
            System.out.println("设置上下文活动标志active（会先将上下文标志设置为true），还有进行一些环境配置。");
            prepareRefresh();

            // Tell the subclass to refresh the internal bean factory.
            System.out.println("核心函数AbstractApplicationContext#obtainFreshBeanFactory，功能解析xml，创建BeanFactory");
            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

            // Prepare the bean factory for use in this context.
            prepareBeanFactory(beanFactory);

            try {
                // Allows post-processing of the bean factory in context subclasses.
                postProcessBeanFactory(beanFactory);

                // Invoke factory processors registered as beans in the context.
                invokeBeanFactoryPostProcessors(beanFactory);

                // Register bean processors that intercept bean creation.
                registerBeanPostProcessors(beanFactory);

                // Initialize message source for this context.
                initMessageSource();

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

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

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

                // Instantiate all remaining (non-lazy-init) singletons.
                //该函数中会对bean进行初始化，利用反射技术。
                finishBeanFactoryInitialization(beanFactory);

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

            catch (BeansException ex) {
                if (logger.isWarnEnabled()) {
                    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;
            }

            finally {
                // Reset common introspection caches in Spring's core, since we
                // might not ever need metadata for singleton beans anymore...
                resetCommonCaches();
            }
        }
    }

注：该方法为同步方法；主要关注：①obtainFreshBeanFactory；②finishBeanFactoryInitialization。①方法会进行bean的注入；②方法会利用反射实例化bean。

第5行prepareRefresh函数功能比较简单：设置相关标志（将active设置为true），初始化一些数据。

重点第9行obtainFreshBeanFactory函数生成beanFactory工厂，具体代码如下：

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
        refreshBeanFactory();
        ConfigurableListableBeanFactory beanFactory = getBeanFactory();
        if (logger.isDebugEnabled()) {
            logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
        }
        return beanFactory;
    }

注意这里执行完refreshBeanFactory后就会返回beanFactory，关键函数refreshBeanFactory刷新beanFactory，这里会调用AbstractRefreshableApplicationContext中的refreshBeanFactory方法，具体代码如下：

protected final void refreshBeanFactory() throws BeansException {
        if (hasBeanFactory()) {
            destroyBeans();
            closeBeanFactory();
        }
        try {
            System.out.println("在AbstractRefreshableApplicationContext#refreshBeanFactory方法中创建beanFactory");
            DefaultListableBeanFactory beanFactory = createBeanFactory();
            beanFactory.setSerializationId(getId());
            customizeBeanFactory(beanFactory);
            System.out.println("AbstractRefreshableApplicationContext#loadBeanDefinitions(beanFactory)关键函数，载入bean定义");
            loadBeanDefinitions(beanFactory);
            synchronized (this.beanFactoryMonitor) {
                this.beanFactory = beanFactory;
            }
        } catch (IOException ex) {
            throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
        }
    }

分析：

①第2行：首先判断是否存在beanFactory，如果存在则销毁bean，并关闭beanfactory。

②第8行：创建beanFactory。

③第12行：导入bean。

关注第8行创建beanFactory，该函数会调用AbstractRefreshableApplicationContext中的createBeanFactory方法，具体代码如下：

protected DefaultListableBeanFactory createBeanFactory() {
        System.out.println("new一个DefaultListableBeanFactory，需先判断是否存在内部的BeanFactory实例");
        return new DefaultListableBeanFactory(getInternalParentBeanFactory());
    }

这里直接new一个DefaultListableBeanFactory实例，这里会先判断是否有父工厂，在DefaultListableBeanFactory的构造函数中会调用其父类AbstractAutowireCapableBeanFactory的构造函数，在其构造函数中需要进行关注下：

public AbstractAutowireCapableBeanFactory() {
        super();
        ignoreDependencyInterface(BeanNameAware.class);
        ignoreDependencyInterface(BeanFactoryAware.class);
        ignoreDependencyInterface(BeanClassLoaderAware.class);
        System.out.println("AbstractAutowireCapableBeanFactory构造函数中，忽略实现接口BeanNameAware.class/BeanFactoryAware.class/BeanClassLoaderAware.class类的自动装配功能");
    }

这里会忽略实现BeanNameAware/BeanFactoryAware/BeanClassLoaderAware接口类的自动装配功能。

在实例化DefaultListableBeanFactory后，会对beanFactory进行一些设置，在customizeBeanFactory函数中：

protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory) {
        if (this.allowBeanDefinitionOverriding != null) {
            beanFactory.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
        }
        if (this.allowCircularReferences != null) {
            beanFactory.setAllowCircularReferences(this.allowCircularReferences);
        }
    }

注：这里设置是否可以对BeanDefinition进行覆盖，是否允许循环依赖属性。

接下来重点函数loadBeanDefinitions，这里转向AbstractXmlApplicationContext中的loadBeanDefinitions函数，具体代码如下：

protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
        // Create a new XmlBeanDefinitionReader for the given BeanFactory.
        System.out.println("通过AbstractBeanDefinitionReader父类创建XmlBeanDefinitionReader,用于解析xml文件的bean");
        XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

        // Configure the bean definition reader with this context's
        // resource loading environment.
        System.out.println("设置环境与ResourceLoader");
        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);
    }

分析：

①第4行创建XmlBeanDefinitionReader，是在AbstractBeanDefinitionReader中创建的，传入beanFactory对象。

②9-11行对beanDefinitionReader设置环境、资源导入器、实体解析器。

③第15行注释已经写得很清楚了，允许子类自定义实现beanDefinitionReader方法。

④继续调用loadBeanDefinitions，传入beanDefinitionReader。

此时loadBeanDefinitions函数仍然调用的是AbstractXmlApplicationContext中的方法：

protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
        Resource[] configResources = getConfigResources();
        if (configResources != null) {
            reader.loadBeanDefinitions(configResources);
        }
        String[] configLocations = getConfigLocations();
        if (configLocations != null) {
            System.out.println("AbstractXmlApplicationContext的loadBeanDefinitions(XmlBeanDefinitionReader reader)，导入xml资源");
            reader.loadBeanDefinitions(configLocations);
        }
    }

分析：

这里根据资源类型走不同分支，由于我们前面已经设置了configLocation，所以这里走到第9行处。

由于创建beanDefinitionReader是在AbstractBeanDefinitionReader中实现，因此转向AbstractBeanDefinitionReader的loadBeanDefinitions：

    @Override
    public int loadBeanDefinitions(String... locations) throws BeanDefinitionStoreException {
        Assert.notNull(locations, "Location array must not be null");
        int counter = 0;
        for (String location : locations) {
            counter += loadBeanDefinitions(location);
        }
        return counter;
    }

循环资源文件进行导入（这里会多次调用loadBeanDefinitions方法，注意方法入参），继续其loadBeanDefinitions方法，注意方法入参不同，最终转向的loadBeanDefinitions方法代码如下：

public int loadBeanDefinitions(String location, @Nullable Set<Resource> actualResources) throws BeanDefinitionStoreException {
        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 {
                System.out.println("在AbstractBeanDefinitionReader中将xml资源转换成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;
        }
    }

分析：

①第2行：取出资源导入器，为下面将xml配置文件转换成Resource数组做准备。

②第13行：由于将xml配置文件转换成了Resource数组，这里继续调用AbstractBeanDefinitionReader的loadBeanDefinitions方法（注意入参）：

public int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException {
        System.out.println("在AbstractBeanDefinitionReader#loadBeanDefinitions方法中（参数为Resource）得到" +
                "加载资源文件的个数，也就是beanxml文件的个数");
        Assert.notNull(resources, "Resource array must not be null");
        int counter = 0;
        for (Resource resource : resources) {
            counter += loadBeanDefinitions(resource);
        }
        return counter;
    }

注意在第7行处，这里要调用子类的方法了，具体调用XmlBeanDefinitionReader的loadBeanDefinitions方法：

    /**
     * Load bean definitions from the specified XML file.
     * @param resource the resource descriptor for the XML file
     * @return the number of bean definitions found
     * @throws BeanDefinitionStoreException in case of loading or parsing errors
     */
    @Override
    public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
        return loadBeanDefinitions(new EncodedResource(resource));
    }

    /**
     * Load bean definitions from the specified XML file.
     * @param encodedResource the resource descriptor for the XML file,
     * allowing to specify an encoding to use for parsing the file
     * @return the number of bean definitions found
     * @throws BeanDefinitionStoreException in case of loading or parsing errors
     */
    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<>(4);
            this.resourcesCurrentlyBeingLoaded.set(currentResources);
        }
        if (!currentResources.add(encodedResource)) {
            throw new BeanDefinitionStoreException(
                    "Detected cyclic loading of " + encodedResource + " - check your import definitions!");
        }
        try {
            System.out.println("XmlBeanDefinitionReader的loadBeanDefinitions(EncodedResource encodedResource)中间Resource转化成InputStream流，进行读取操作");
            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();
            }
        }
    }

分析：

①这里将Resource对象包装成了EncodedResource对象，注意第25行使用了ThreadLocal来避免线程安全问题。

②第36行：获取了一个输入流，对xml文件进行操作，接下来开始导入bean，转向XmlBeanDefinitionReader的doLoadBeanDefinitions方法：

protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
            throws BeanDefinitionStoreException {
        try {
            Document doc = doLoadDocument(inputSource, resource);
            return registerBeanDefinitions(doc, resource);
        }
        catch (...)
    }

至此，导入bean阶段完成，通过这么长的调用链其实主要就是将xml配置文件转换成流，为下一步解析和注册bean做准备。

下面给出bean导入阶段的大致时序图：

至此导入bean阶段大致分析完成，该阶段总的来说还是比较简单，下面将对解析bean阶段进行分析。

---

by Shawn Chen，2018.11.24日，晚。