下面是上下文初始化的核心方法

public void refresh() throws BeansException, IllegalStateException {
    Object var1 = this.startupShutdownMonitor;
    synchronized(this.startupShutdownMonitor) {

        // 准备工作
        this.prepareRefresh();

        // 获取beanFactory,此方法会读取解析application.xml,得到Bean的定义,注册到beanFactory
        ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();

        // 配置beanFactory
        this.prepareBeanFactory(beanFactory);

        try {

            //提供扩展，配置beanFactory
            this.postProcessBeanFactory(beanFactory);

            //执行beanFactoryPostProcessors

            this.invokeBeanFactoryPostProcessors(beanFactory);

            //注册beanPostProcessors
            this.registerBeanPostProcessors(beanFactory);
            this.initMessageSource();
            this.initApplicationEventMulticaster();
            this.onRefresh();
            this.registerListeners();

            //bean的实例化和初始化
            this.finishBeanFactoryInitialization(beanFactory);
            this.finishRefresh();
        } catch (BeansException var5) {
            this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt", var5);
            this.destroyBeans();
            this.cancelRefresh(var5);
            throw var5;
        }

    }
}

spring配置解析：

https://www.cnblogs.com/leftthen/p/5615066.html

我们来详细说明一下核心方法

invokeBeanFactoryPostProcessors

从beanDefinitionNames得到实现了BeanFactoryPostProcessor的类,实例化之后执行其核心方法，

这个操作发生在业务bean的实例化之前，这是一个容器级别的processor,主要是为了在bean实例化之前进行一些处理,目前项目中有两处有两处用到，一个是替换配置文件中的变量,我们在spring的配置文件中配置一个bean,实现BeanFactoryPostProcessor,从zk上读取一些值。另一个是配置了一个扫描mapper的bean,这个也实现了BeanFactoryPostProcessor,负责将mapper托管给bean工厂

registerBeanPostProcessors

从beanDefinitionNames得到实现了BeanPostProcessor的类,实例化之后注册到beanFactory,关于beanPostProcessor的作用不做赘述(网上的资料已经把这个讲烂了)

finishBeanFactoryInitialization

这个方法的核心是对bean的实例化

protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
    if(this.logger.isDebugEnabled()) {
        this.logger.debug("Creating instance of bean \'" + beanName + "\'");
    }

    this.resolveBeanClass(mbd, beanName, new Class[0]);

    try {
        mbd.prepareMethodOverrides();
    } catch (BeanDefinitionValidationException var5) {
        throw new BeanDefinitionStoreException(mbd.getResourceDescription(), beanName, "Validation of method overrides failed", var5);
    }

    Object beanInstance;
    try {
        beanInstance = this.resolveBeforeInstantiation(beanName, mbd);
        if(beanInstance != null) {
            return beanInstance;
        }
    } catch (Throwable var6) {
        throw new BeanCreationException(mbd.getResourceDescription(), beanName, "BeanPostProcessor before instantiation of bean failed", var6);
    }

    beanInstance = this.doCreateBean(beanName, mbd, args);
    if(this.logger.isDebugEnabled()) {
        this.logger.debug("Finished creating instance of bean \'" + beanName + "\'");
    }

    return beanInstance;
}

resolveBeforeInstantiation:这步操作会判断是否需要执行 InstantiationAwareBeanPostProcessor,这是一种非常特殊的BeanPostProcessor,通常的BeanPostProcessor都是发生在bean实例化之后，对bean的初始化进行前后干预，而这个InstantiationAwareBeanPostProcessor是对bean的实例化前后干预

doCreateBean:创建bean的实例，然后初始化bean，初始化bean前后执行对应的postProcessor

下图描述了bean的实例化和初始化过程

依赖注入：

实例化后

this.populateBean(beanName, mbd, instanceWrapper);

使用AutowiredAnnotationBeanPostProcessor进行依赖注入,具体是里面的

AutowiredFieldElement中的inject方法