【小家Spring】Spring IOC容器启动流程 AbstractApplicationContext#refresh()方法源码分析（二），Spring容器启动/刷新的完整总结（中）

  protected void registerListeners() {
    // 这一步和手动注册BeanDefinitionRegistryPostProcessor一样，可以自己通过set手动注册监听器  然后是最新执行的（显然此处我们无自己set）
    for (ApplicationListener<?> listener : getApplicationListeners()) {
      // 把手动注册的监听器绑定到广播器
      getApplicationEventMulticaster().addApplicationListener(listener);
    }
    // Do not initialize FactoryBeans here: We need to leave all regular beans
    // uninitialized to let post-processors apply to them!
    // 取到容器里面的所有的监听器的名称，绑定到广播器  后面会广播出去这些事件的
    // 同时提醒大伙注意：此处并没有说到ApplicationListenerDetector这个东东，下文会分解
    String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
    for (String listenerBeanName : listenerBeanNames) {
      getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
    }
    // Publish early application events now that we finally have a multicaster...
    // 这一步需要注意了：如果存在早期应用事件，这里就直接发布了(同时就把earlyApplicationEvents该字段置为null)
    // 
    Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
    this.earlyApplicationEvents = null;
    if (earlyEventsToProcess != null) {
      for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
        getApplicationEventMulticaster().multicastEvent(earlyEvent);
      }
    }
  }

  protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
    // Initialize conversion service for this context.
    // 初始化上下文的转换服务，ConversionService是一个类型转换接口
    if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) && beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
      beanFactory.setConversionService( beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
    }
    // Register a default embedded value resolver if no bean post-processor
    // (such as a PropertyPlaceholderConfigurer bean) registered any before:
    // at this point, primarily for resolution in annotation attribute values.
    // 设置一个内置的值处理器（若没有的话），该处理器作用有点像一个PropertyPlaceholderConfigurer bean
    if (!beanFactory.hasEmbeddedValueResolver()) {
      beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
    }
    // Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
    // 注意此处已经调用了getBean方法，初始化LoadTimeWeaverAware Bean
    // getBean()方法的详细，下面会详细分解
    // LoadTimeWeaverAware是类加载时织入的意思
    String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
    for (String weaverAwareName : weaverAwareNames) {
      getBean(weaverAwareName);
    }
    // Stop using the temporary ClassLoader for type matching.
    // 停止使用临时的类加载器
    beanFactory.setTempClassLoader(null);
    // Allow for caching all bean definition metadata, not expecting further changes.
    // 缓存（冻结）所有的bean definition数据，不期望以后会改变
    beanFactory.freezeConfiguration();
    // Instantiate all remaining (non-lazy-init) singletons.
    // 这个就是最重要的方法：会把留下来的Bean们  不是lazy懒加载的bean都实例化掉
    //  bean真正实例化的时刻到了
    beanFactory.preInstantiateSingletons();
  }
  @Override
  public void freezeConfiguration() {
    this.configurationFrozen = true;
    this.frozenBeanDefinitionNames = StringUtils.toStringArray(this.beanDefinitionNames);
  }

  @Override
  public void preInstantiateSingletons() throws BeansException {
    // Iterate over a copy to allow for init methods which in turn register new bean definitions.
    // While this may not be part of the regular factory bootstrap, it does otherwise work fine.
    // 此处目的，把所有的bean定义信息名称，赋值到一个新的集合中
    List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
    // Trigger initialization of all non-lazy singleton beans...
    for (String beanName : beanNames) {
      //getMergedLocalBeanDefinition：见下~
      RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
      // 不是抽象类&&是单例&&不是懒加载
      if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
        // 这是Spring提供的对工程bean模式的支持：比如第三方框架的继承经常采用这种方式
        // 如果是工厂Bean，那就会此工厂Bean放进去
        if (isFactoryBean(beanName)) {
          // 拿到工厂Bean本省，注意有前缀为：FACTORY_BEAN_PREFIX 
          Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
          if (bean instanceof FactoryBean) {
            final FactoryBean<?> factory = (FactoryBean<?>) bean;
            boolean isEagerInit;
            if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
              isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
                      ((SmartFactoryBean<?>) factory)::isEagerInit,
                  getAccessControlContext());
            } else {
              isEagerInit = (factory instanceof SmartFactoryBean &&
                  ((SmartFactoryBean<?>) factory).isEagerInit());
            }
            // true：表示渴望马上被初始化的，那就拿上执行初始化~
            if (isEagerInit) {
              getBean(beanName);
            }
          }
        } else { // 这里，就是普通单例Bean正式初始化了~  核心逻辑在方法：doGetBean 
          // 关于doGetBean方法的详解：下面有贴出博文，专文讲解
          getBean(beanName);
        }
      }
    }
    // Trigger post-initialization callback for all applicable beans...
    // SmartInitializingSingleton：所有非lazy单例Bean实例化完成后的回调方法 Spring4.1才提供
    //SmartInitializingSingleton的afterSingletonsInstantiated方法是在所有单例bean都已经被创建后执行的
    //InitializingBean#afterPropertiesSet 是在仅仅自己被创建好了执行的
    // 比如EventListenerMethodProcessor它在afterSingletonsInstantiated方法里就去处理所有的Bean的方法
    // 看看哪些被标注了@EventListener注解，提取处理也作为一个Listener放到容器addApplicationListener里面去
    for (String beanName : beanNames) {
      Object singletonInstance = getSingleton(beanName);
      if (singletonInstance instanceof SmartInitializingSingleton) {
        final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
        if (System.getSecurityManager() != null) {
          AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
            smartSingleton.afterSingletonsInstantiated();
            return null;
          }, getAccessControlContext());
        }
        else {
          // 比如：ScheduledAnnotationBeanPostProcessor CacheAspectSupport  MBeanExporter等等
          smartSingleton.afterSingletonsInstantiated();
        }
      }
    }
  }

@Configuration
public class RootConfig {
    @Bean
    public Person person() {
        System.out.println("this is from @Bean person");
        return new Person();
    }
    @Bean("personFactoryBean")
    public FactoryBean<Person> personFactoryBean() {
        return new FactoryBean<Person>() {
            @Override
            public Person getObject() throws Exception {
                System.out.println("this is from personFactoryBean");
                return new Person();
            }
            @Override
            public Class<?> getObjectType() {
                return Person.class;
            }
        };
    }
}

    @Autowired
    @Qualifier("personFactoryBean")
    private Person person;

  // 该方法功能说明：在map缓存中把Bean的定义拿出来。交给getMergedLocalBeanDefinition处理。最终转换成了RootBeanDefinition类型
  //在转换的过程中如果BeanDefinition的父类不为空，则把父类的属性也合并到RootBeanDefinition中，
  //所以getMergedLocalBeanDefinition方法的作用就是获取缓存的BeanDefinition对象并合并其父类和本身的属性
  //注意如果当前BeanDefinition存在父BeanDefinition，会基于父BeanDefinition生成一个RootBeanDefinition,然后再将调用OverrideFrom子BeanDefinition的相关属性覆写进去
  protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException {
    // Quick check on the concurrent map first, with minimal locking.
    RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName);
    if (mbd != null) {
      return mbd;
    }
    return getMergedBeanDefinition(beanName, getBeanDefinition(beanName));
  }
getBeanDefinition(beanName)：方法如下
  // 这一步说白了：就是把前面已经保存在IOC容器里的BeanDefinition定义信息
  @Override
  public BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException {
    BeanDefinition bd = this.beanDefinitionMap.get(beanName);
    if (bd == null) {
      if (this.logger.isTraceEnabled()) {
        this.logger.trace("No bean named '" + beanName + "' found in " + this);
      }
      throw new NoSuchBeanDefinitionException(beanName);
    }
    return bd;
  }

  protected void finishRefresh() {
    // Clear context-level resource caches (such as ASM metadata from scanning).
    // 这个是Spring5.0之后才有的方法
    // 表示清除一些resourceCaches,如doc说的  清楚context级别的资源缓存，比如ASM的元数据
    clearResourceCaches();
    // Initialize lifecycle processor for this context.
    // 初始化所有的LifecycleProcessor  详见下面
    initLifecycleProcessor();
    // Propagate refresh to lifecycle processor first.
    // 上面注册好的处理器，这里就拿出来，调用它的onRefresh方法了
    getLifecycleProcessor().onRefresh();
    // Publish the final event.
    // 发布容器刷新的事件：
    publishEvent(new ContextRefreshedEvent(this));
    // Participate in LiveBeansView MBean, if active.
    // 和MBeanServer和MBean有关的。相当于把当前容器上下文，注册到MBeanServer里面去。
    // 这样子，MBeanServer持久了容器的引用，就可以拿到容器的所有内容了，也就让Spring支持到了MBean的相关功能
    LiveBeansView.registerApplicationContext(this);
  }

  // 这个初始化逻辑比较简单
  protected void initLifecycleProcessor() {
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    // 如果工厂里已经存在LifecycleProcessor，那就拿出来，把值放上去this.lifecycleProcessor
    if (beanFactory.containsLocalBean(LIFECYCLE_PROCESSOR_BEAN_NAME)) {
      this.lifecycleProcessor = beanFactory.getBean(LIFECYCLE_PROCESSOR_BEAN_NAME, LifecycleProcessor.class);
    }
    // 一般情况下，都会注册上这个默认的处理器DefaultLifecycleProcessor
    else {
      DefaultLifecycleProcessor defaultProcessor = new DefaultLifecycleProcessor();
      defaultProcessor.setBeanFactory(beanFactory);
      this.lifecycleProcessor = defaultProcessor;
      // 直接注册成单例Bean进去容器里
      beanFactory.registerSingleton(LIFECYCLE_PROCESSOR_BEAN_NAME, this.lifecycleProcessor);
    }
  }

public interface LifecycleProcessor extends Lifecycle {}
public interface SmartLifecycle extends Lifecycle, Phased {
  // 是否伴随这容器的启动而启动  true表示容器refreshed它就会启动了
  // false：必须显示的执行了它的start()才行
  boolean isAutoStartup();
  // 相比于Lifecycle 的stop，增加了回调函数
  void stop(Runnable callback);
}
public interface Phased {
  // 权重值
  int getPhase();
}

// Lifecycle的方法
  @Override
  public void start() {
    // 传false，表示Bean一定会启动
    startBeans(false);
    this.running = true;
  }
  @Override
  public void stop() {
    stopBeans();
    this.running = false;
  }
  @Override
  public boolean isRunning() {
    return this.running;
  }
// LifecycleProcessor的方法
  //getLifecycleProcessor().onRefresh(); 这个方法才是容器启动时候自动会调用的，其余都不是
  // 显然它默认只会执行实现了SmartLifecycle接口并且isAutoStartup = true的Bean的start方法
  @Override
  public void onRefresh() {
    startBeans(true);
    this.running = true;
  }
  // 容器关闭的时候自动会调的
  @Override
  public void onClose() {
    stopBeans();
    this.running = false;
  }
// 而到底bean实现的Lifecyle的start()、stop()方法是否会调用呢？ 请看下文
//======================startBeans和stopBeans  LifecycleGroup#start======================
  // autoStartupOnly:是否仅支持自动启动   
  // true：只支持伴随容器启动 （bean必须实现了`SmartLifecycle`接口且isAutoStartup为true才行）
  // false：表示无所谓。都会执行bean的start方法=======
  private void startBeans(boolean autoStartupOnly) {
    //拿到所有的实现了Lifecycle/SmartLifecycle的  已经在IOC容器里面的单例Bean们（备注：不包括自己this，也就是说处理器自己不包含进去）
    // 这里若我们自己没有定义过实现Lifecycle的Bean，这里就是空的
    Map<String, Lifecycle> lifecycleBeans = getLifecycleBeans();
    // phases 这个Map，表示按照phase 值，吧这个Bean进行分组，最后分组执行
    Map<Integer, LifecycleGroup> phases = new HashMap<>();
    lifecycleBeans.forEach((beanName, bean) -> {
      // 若Bean实现了SmartLifecycle 接口并且标注是AutoStartup  或者  强制要求自动自行的autoStartupOnly = true
      if (!autoStartupOnly || (bean instanceof SmartLifecycle && ((SmartLifecycle) bean).isAutoStartup())) {
        int phase = getPhase(bean);
        LifecycleGroup group = phases.get(phase);
        if (group == null) {
          group = new LifecycleGroup(phase, this.timeoutPerShutdownPhase, lifecycleBeans, autoStartupOnly);
          phases.put(phase, group);
        }
        // 添加到phase 值相同的组  分组嘛
        group.add(beanName, bean);
      }
    });
    if (!phases.isEmpty()) {
      List<Integer> keys = new ArrayList<>(phases.keySet());
      // 此处有个根据key从小到大的排序，然后一个个的调用他们的start方法
      Collections.sort(keys);
      for (Integer key : keys) {
        // 这里调用LifecycleGroup#start() 如下
        phases.get(key).start();
      }
    }
  }
//LifecycleGroup#start()
    public void start() {
      if (this.members.isEmpty()) {
        return;
      }
      if (logger.isInfoEnabled()) {
        logger.info("Starting beans in phase " + this.phase);
      }
      // 按照权重值进行排序  若没有实现Smart接口的  权重值都为0
      Collections.sort(this.members);
      for (LifecycleGroupMember member : this.members) {
        if (this.lifecycleBeans.containsKey(member.name)) {
          // 一次执行这些Bean的start方法（这里面逻辑就没啥好看的，只有一个考虑到getBeanFactory().dependenciesForBean控制Bean的依赖关系的）
          doStart(this.lifecycleBeans, member.name, this.autoStartupOnly);
        }
      }
    }
//stopBeans原理基本同startBeans，只是顺序是倒序的，此处省略

 context = new ClassPathXmlApplicationContext(configPath.split("[,\\s]+"));
 context.start();