刷新容器前的预处理

prepareRefresh();

1. initPropertySources();
   初始化一些属性设置

2. getEnvironment().validateRequiredProperties();
   校验属性的合法性

3. this.earlyApplicationEvents = new LinkedHashSet<ApplicationEvent>();
   保存容器中的早期事件的容器 Set 集合

获取 beanFactory

ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

1. this.beanFactory = new DefaultListableBeanFactory();
   构造一个 beanFactory

2. ConfigurableListableBeanFactory beanFactory = getBeanFactory();
   获取 BeanFactory 返回的上一步构 GenericApplicationContext 类构造器创建的 beanFactory

3. return beanFactory;
   返回 beanFactory 【ConfigurableListableBeanFactory 的实例实例对象】

beanFactory 的预准备工作

prepareBeanFactory(beanFactory);

1. 设置 beanFactory 的类加载器

beanFactory.setBeanClassLoader(getClassLoader());
beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

2. 添加 BeanPostProcessor 后置处理器

beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));

3. 设置忽略的自动装配的接口

beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAwarelass);
beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAre.class);
beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
beanFactory.ignoreDependencyInterface(ApplicationContextAware.cls);

4. 注解可以自动装配的 Bean, 我们可以直接进行注入

beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
beanFactory.registerResolvableDependency(ResourceLoader.class, this);
beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
beanFactory.registerResolvableDependency(ApplicationContext.class, this);

5. 添加 BeanPostProcessor ApplicationListenerDetector

beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

6. 给 beanFactory 注册一些包含的组件

if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
  beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
}
if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
  beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
}
if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
  beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
}

beanFactory 准备完成的后置处理工作

postProcessBeanFactory(beanFactory);

1. 空方法，子类通过重写这个方法来在 BeanFactory 创建并预准备完成以后做进一步的设置

protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
}

执行 beanFactoryPostProcessors 方法

invokeBeanFactoryPostProcessors(beanFactory);

1. 执行 invokeBeanFactoryPostProcessors 的方法
   1. BeanFactoryPostProcessor 和 BeanDefinitionRegistryPostProcessor
      先执行 BeanDefinitionRegistryPostProcessor 的方法
      再执行 BeanFactoryPostProcessors 的方法

注册 BeanPostProcessors 【 Bean 的后置处理器 】

registerBeanPostProcessors(beanFactory);

优先级接口PriorityOrdered 和 Ordered

初始化 MessageSource 组件

initMessageSource();

初始化事件派发器

initApplicationEventMulticaster();

留给子容器（子类）

onRefresh();

给容器中将所有项目里面的ApplicationListener注册进来

registerListeners();

1. 获取所有的事件，并添加到事件派发器中

for (ApplicationListener<?> listener : getApplicationListeners()) {
    getApplicationEventMulticaster().addApplicationListener(listener);
}

2. 派发事件

getApplicationEventMulticaster().multicastEvent(earlyEvent);

初始化所有剩下的单实例 Bean(没有配置赖加载的 lazy!=true)

finishBeanFactoryInitialization(beanFactory);

1. 初始化所有剩下的单实例bean

beanFactory.preInstantiateSingletons();

2. 将容器中所有的 bean 加入到 List中

List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);

3. 遍历该 List

for (String beanName : beanNames) {
  ...
}

4. 获取 bean 定义信息

RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);

5. bean 不是抽象的、是单例的、非懒加载的

if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
  ...
}

6. 是否为 FactoryBean ,是则调用 FactoryBean 的创建方法，否则执行 getBean() 方法

if (isFactoryBean(beanName)) {
        ...     
}

7. 调用 getBean() 方法 -> 内部再调用 doGetBean() 方法

   1. 尝试从从缓存中获取 bean

    Object sharedInstance = getSingleton(beanName);
   

   2. 获取 bean 定义信息

    RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
   

   3. 判断是否有其他依赖，如果有其他依赖，注册依赖的 bean 并调用 getBean() 方法创建

   String[] dependsOn = mbd.getDependsOn();
   if (dependsOn != null) {
            for (String dep : dependsOn) {
                if (isDependent(beanName, dep)) {
                    throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                            "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
                }
                registerDependentBean(dep, beanName);
                getBean(dep);
            }
        }
   

   4. 进入单实例 bean 的创建流程

   return createBean(beanName, mbd, args);
   

   单实例 bean 的创建流程很复杂，单独进行说明

完成BeanFactory的初始化创建工作；IOC容器就创建完成

finishRefresh();

1. 从 beanFactory 中获取 LifecycleProcessor 组件，如果没有获取到，则创建。

if(xxx){
  this.lifecycleProcessor = beanFactory.getBean(LIFECYCLE_PROCESSOR_BEAN_NAME, LifecycleProcessor.class);
  ...
} else{
  DefaultLifecycleProcessor defaultProcessor = new DefaultLifecycleProcessor();
  ...
}

2. 调用 onRefresh() 方法，在上一步中，已经有 LifecycleProcessor 组件了

getLifecycleProcessor().onRefresh();

3. 发布容器刷新完成事件

publishEvent(new ContextRefreshedEvent(this));

4. LiveBeansView.registerApplicationContext(this);