一、整体流程

1、先创建容器
2、加载配置文件，封装成 BeanDefinition
3、调用执行 BeanFactoryPostProcessor
准备工作：
beanPosytProcessor
准备监听器，事件，广播器
4、实例化（为bean的属性设置值和对其他bean引用）
5、初始化
6、获取到完整对象

二、源码解读

实例代码

    public static void main(String[] args) {
//        获取核心容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml"); //更常用
//        ApplicationContext ac = new FileSystemXmlApplicationContext("/Users/superking/Desktop/bean.xml");
//       根据id获取bean对象( 以下两种方式强转 可以直接强转，也可以获取字节码.class)
        IAccountService as = (IAccountService) ac.getBean("accountService");
        IAccountDao accountDao = ac.getBean("accountDao",IAccountDao.class);
        System.out.println(as);
        System.out.println(accountDao);
    }
}

1、创建容器

1、debug进入 ClassPathXmlApplicationContext
2、首先是初始化一些父类方法（super），然后是设置配置文件路径setConfigLocations
�最后进入 refresh 方法

3、进入 refresh 的obtainFreshBeanFactory

@Override
    public void refresh() throws BeansException, IllegalStateException {
        synchronized (this.startupShutdownMonitor) {
            // Prepare this context for refreshing.
            prepareRefresh();
            // Tell the subclass to refresh the internal bean factory.
            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.
                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();
            }
        }
    }

依次进入

这里的 createBeanFactory 创建的是一个默认容器

2、加载配置文件

经过 loadBeanDefinitions 载入bean之后，beanDefinitionMap的size变为了2。
到这里之后，完成了配置文件 bean.xml 中的bean的加载，但是还没有值。

loadBeanDefinitions 结束之后回到 refresh 方法，进行下一步 prepareBeanFactory ，这里会完成 bean工厂参数的赋值操作

3、调用执行 BeanFactoryPostProcessor

调用各种 beanFactory处理器，例如 PlaceholderConfigurerSupport

4、准备工作

registerBeanPostProcessors 注册 bean 处理器，这里只是注册功能，真正调用的是 getBean 方法。

initMessageSource(); 方法，为上下文初始化 message原，即不同语言的消息体，国际化操作。
initApplicationEventMulticaster()；初始化事件监听多路广播器
onRefresh()；留给子类初始化其他的bean
�registerListeners()；在所有注册的bean中查找listener bean，注册到消息广播器中。

5、实例化

通过方法 finishBeanFactoryInitialization() 初始化所有非懒加载的单例对象。

进入 finishBeanFactoryInitialization() 直接到最后一行（代码太多不细看）看到 preInstantiateSingletons()。

经过层层判断，最后如果beanName对应的bean不是FactoryBean，只是普通的bean，则通过beanName获取bean实例。

进入 getBean—>doGetBean，在 doGetBean 方法中会先获取单例对象，如果获取不到，则会进行创建。

获取单例对象 getSingleton （此处可以联想到单例模式单例模式）

�创建 bean，doGetBean -> createBean -> doCreateBean -> createBeanInstance

在 createBeanInstance 的最后一行（只有无参构造方法，前面的方法都用不了，最后一行创建无参构造器） instantiateBean(beanName, mbd)

继续进去，看到了久违的 constructorToUse = clazz.getDeclaredConstructor()；
到这里可以回顾下
2、反射进行实例化操作

�继续走，看到后面 BeanUtils.instantiateClass(constructorToUse)，最后newInstance()，到这里完成了对象的创建，但是对象还没有值。

对象创建结束之后会到方法 doCreateBean ，在这里调用 populateBean 用于填充值(org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#populateBean)，然后调用方法initializeBean 初始化 bean。

6、初始化

6.1 第一次初始化

在 initializeBean 方法内部，（第一次初始化 aware）执行 invokeAwareMethods（Aware接口处理器，调用 BeanNameAware、BeanClassLoaderAware、beanFactoryAware）

6.2 第二次初始化

接着继续初始化（第二次初始化 aware），调用 applyBeanPostProcessorsBeforeInitialization 方法。

�使用里面的 BeanPostProcessor.postProcessBeforeInitialization

在进入 postProcessBeforeInitialization 的方法 invokeAwareInterfaces
org.springframework.context.support.ApplicationContextAwareProcessor#invokeAwareInterfaces

�结束之后得到完整的bean

6.3 为什么需要初始化两次

因为 beanFactory 和 applicationContext 是两套分支，所以spring会使用 invokeAwareMethods（初始化 beanFactory）和 applyBeanPostProcessorsBeforeInitialization（初始化 applicationContext）各初始化一次。