Spring IOC容器初始化过程

应用场景

spring IOC 提供了一个基本JavaBean容器，通过IOC模式管理依赖关系，并通过依赖注入和AOP切面增强了为JavaBean这样的POJO对象赋予了事务管理，生命周期管理等基本功能

控制反转

对象的依赖关系的管理被反转了，转到了IOC容器中，对象之间的依赖关系由IOC容器进行管理，并由IOC容器完成对象的注入。

IOC 容器系列实现与设计

一个是实现BeanFactory接口简单容器系列，一个是ApplicationContext应用上下文，作为容器的高级形态存在

BeanFactory

如果把IOC容器比作一个水桶，那么BeanFactory就定义了这个水桶的基本功能，例如：能装水，有提手，容器里面装的水，则是BeanDefinition(依赖反转功能都是围绕BeanDefinition)

BenaFactory 容器设计原理

我们以XmlBeanactory的实现为例来说明简单IOC容器的设计原理，其实XmlBeanFactory的功是建立在DefaultListableBeanFactory这个基础上


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);
    }
 
}

使用IOC容器的步骤：
1. 创建配置文件，里面包含了BeanDefinition的定义信息。
2. 创建一个BeanFactory，使用是DefaultListableBeanFactory（纯粹是一个IOC容器）。
3. 创建一个载入BeanDefinition的读取器，使用XmlBeanDefinitionReader来读取XML文件形式的BeanDefinition，通过回调配置给BeanFactory。
4. 完成整个载入和注册Bean之后，需要IOC容器就建立起来了。就可以直接使用IOC容器

ClassPathResource res = new ClassPathResource ("beans.xml");
DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
//创建XmlBeanDefinitionReader ,并通过回调设置到BenFactory中
XmlBeanDefinitionReader reder = new XmlBeanDefinitionReader(factory);
reder.loadBeanDefinitions(res);

ApplicationContext

我们以FileSystemXmlApplicationContext的实现为例来说明ApplicationContext容器的设计原理，其主要功能已经在FileSystemXmlApplicationContext的基类AbstractXmlApplicationContext中实现。通过refresh（）启动IOC容器

初始化IOC容器过程

Resource定位，指BeanDefinition的资源定位，它由ResourceLoader 通过统一的Resource接口完成。
BeanDefinition的载入，把定义好的Bean表示成IOC容器内部的数据结构
IOC容器注册BeanDefinition,这个过程是通过BeanDefinitionRegistry接口实现完成的，在IOC容器内部将BeanDefinition注入到一个hasmap中，IOC容器通过这个Hashmap来持有这些BeanDefinition数据机构

PS: Bean定义的载入和依赖注入是两个独立过程，依赖注入一般发生在应用第一次通过getBean容器索取Bean的时候，如果Bean定义了lazyinit属性，那么这个Bean依赖注入在IOC容器初始化时就预先完成了。

BeanDefinition的Resurce定位丶载入丶注册

定位
FileSystemXmlApplicationContext 继承了 abstractApplicationContext具备了ResourceLoader读入以Resource定义BeanDefinition 的能力，AbstractApplicationContext的基类是DefaultResourceLoader,所以关于IOC容器功能相关实现都是在FileSystemXmlApplicationContext中完成的。
载入
BeanDefinition载入分为两个部分，首先通过调用XML的解析器获取到document对象，但是这个对象没有按照spring bean 规则进行解析，是在documentReader中实现解析的，处理结果有BeanDefinitionHolder对象持有，BeanDefinitionHolder除了持有BeanDefinition对象外，还持有其他与BeanDefinition的使用相关信息，比如Bean名字，别名等。

AbstractApplicationContext.refresh()标志着IoC容器的正式启动

public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
        // Prepare this context for refreshing.
        //准备启动spring容器，设置容器的启动日期和活动标志 
        prepareRefresh();

        // Tell the subclass to refresh the internal bean factory.
        //获得容器ApplicationContext的子类BeanFactory。步骤如下：
        //1.如果已经有了BeanFactory就销毁它里面的单例Bean并关闭这个BeanFactory。
        //2.创建一个新的BeanFactory。
        //3.对这个BeanFactory进行定制（customize),如allowBeanDefinitionOverriding等参数
        //4.转载BeanDefinitions(读取配置文件，将xml转换成对应得BeanDefinition)
        //5.检查是否同时启动了两个BeanFactory。  
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

        // Prepare the bean factory for use in this context.
        //配置BeanFactory（就是将ApplicationContext的一些属性配置到BeanFactory上吧）
　　　　　//如重要的如设置classLoader；将BeanPostProcess注册到BeanFactory里  
        prepareBeanFactory(beanFactory);

        try {
        // Allows post-processing of the bean factory in context subclasses.
        //允许上下文的子类去执行postProcessor  
        postProcessBeanFactory(beanFactory);

        // Invoke factory processors registered as beans in the context.
        // 执行注册到该上下文的BeanFactoryPostProcessors
        invokeBeanFactoryPostProcessors(beanFactory);

        // Register bean processors that intercept bean creation.
        // 开始注册BeanPostProcessor来拦截其他的bean的初始化过程
        registerBeanPostProcessors(beanFactory);

        // Initialize message source for this context.
        // 初始化消息源
        initMessageSource();

        // Initialize event multicaster for this context.
        //注册上下文事件的广播集  
        initApplicationEventMulticaster();

        // Initialize other special beans in specific context subclasses.
        //初始化一些特殊的bean
        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方法如下：

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

在AbstractRefreshableApplicationContext的refreshBeanFactory()方法中创建BeanFactory,在创建前，如果容器已经存在，那么需要把已有的容器销毁与关闭，保证refresh之后使用的是新建立起来的IOC容器。

protected final void refreshBeanFactory() throws BeansException {
        if (hasBeanFactory()) {
            destroyBeans();
            closeBeanFactory();
        }
        try {
            DefaultListableBeanFactory beanFactory = createBeanFactory();
            beanFactory.setSerializationId(getId());
            customizeBeanFactory(beanFactory);
            //第二步BeanDefinition的载入，第三步对载入的BeanDefinition在Ioc上注册
            loadBeanDefinitions(beanFactory);
            synchronized (this.beanFactoryMonitor) {
                this.beanFactory = beanFactory;
            }
        }
        catch (IOException ex) {
            throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
        }
    }

obtainFreshBeanFactory准备容器，refreshBeanFactory产生DefaultListableBeanFactoryro容器，getBeanFactory是对产生的容器校验，避免失败．可以看出其实真正使用的IoC容器是DefaultListableBeanFactory．