public void refresh() throws BeansException, IllegalStateException {
// 获取监视器锁
      synchronized(this.startupShutdownMonitor) {
      
      	// 刷新上下文前的准备，记录状态，验证必要属性
          this.prepareRefresh();
          ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
          
          // 配置标准的 beanFactory，设置 classloader, bean表达解析器，同时注册重要的bean组件
          this.prepareBeanFactory(beanFactory);

          try {
          	// 模板方法，交由子类对 beanFactory 进行后置处理
              this.postProcessBeanFactory(beanFactory);
              
              // 调用 beanFactoryPostPorcessor 
              this.invokeBeanFactoryPostProcessors(beanFactory);
              
              // 注册容器中的 beanPostProcessors
              this.registerBeanPostProcessors(beanFactory);
              
              // 初始化国际工具类 MessageSource
              this.initMessageSource();
              
              // 初始化并注册事件广播器 ApplicationEventMulticaster
              this.initApplicationEventMulticaster();
              
              // 模板方法，根据应用的具体类型交由子类具体处理，如果是web类型，通常是构建webServer
              this.onRefresh();
              
              // 注册容器中的监听器，包括spring.factories 和 自定义 bean listenr
              this.registerListeners();
              
              // 实例化所有的单例 bean （非 Lazy）,beanPostProcessor 开始起作用
              this.finishBeanFactoryInitialization(beanFactory);
              
              // refresh() 后的额外工作，包括清除resource cahce，注册 LifeCycleProcessor及发布上下文已经刷新的事件 ContexntRefreshedEvent
              this.finishRefresh();
          } catch (BeansException var9) {
		
		// 如果刷新上下文的过程中，出现异常，那么销毁所有已经创建的 bean
              this.destroyBeans();
              
              // 重置 context 的刷新状态，即将 active = false
              this.cancelRefresh(var9);
              throw var9;
          } finally {
          	// 无论失败与否，已经不再需要 bean metadata，重置 Spring 的内核缓存
              this.resetCommonCaches();
          }
      }
  }

public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
	    ...
	    // 设置启动的源Class，即启动的SpringBootLearningApplication.class对象，包含了对应的 classLoader
        this.primarySources = new LinkedHashSet(Arrays.asList(primarySources));
        
        // 设置了 webApplication的类型，尚未配置web，所以当前为 NONE （Servlet, Reactive）
        this.webApplicationType = WebApplicationType.deduceFromClasspath();
        
        // 借助 SpringFactoriesLoader 找到 /META-INF/spring.factories 下的所有配置 key 为 ApplicationContextInitializer 
          （所有的应用初始化器），实例化并设置到 setInitializers 这个集合属性中
        this.setInitializers(this.getSpringFactoriesInstances(ApplicationContextInitializer.class));
        
        // 和上面一样， 通过 SpringFactoriesLoader 找到所有配置 key 为 ApplicationListener (所有的应用程序监听器)，
            实例化并设置到 setListeners 集合属性中
        this.setListeners(this.getSpringFactoriesInstances(ApplicationListener.class));
        
       // 找到 StackTrace （方法调用堆栈）中的 main 方法，即入口类的名字，并 Class.forName 得到类对象
        this.mainApplicationClass = this.deduceMainApplicationClass();
    }

// SpringApplication.class
public ConfigurableApplicationContext run(String... args) {
	listeners.starting();
}

// SpringApplicationRunListeners 
public void starting() {
        Iterator var1 = this.listeners.iterator();

        while(var1.hasNext()) {
            SpringApplicationRunListener listener = (SpringApplicationRunListener)var1.next();
            listener.starting();
        }
}

// EventPublishingRunListeners.class
public void starting() {
        this.initialMulticaster.multicastEvent(new ApplicationStartingEvent(this.application, this.args));
}

@SpringBootApplication
public class SpringbootlLearningApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringbootlLearningApplication.class, args);
    }
}

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(
    excludeFilters = {@Filter(
    type = FilterType.CUSTOM,
    classes = {TypeExcludeFilter.class}
), @Filter(
    type = FilterType.CUSTOM,
    classes = {AutoConfigurationExcludeFilter.class}
)}
)
public @interface SpringBootApplication {
	...
}

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration
public @interface SpringBootConfiguration {
}

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import({AutoConfigurationImportSelector.class})
public @interface EnableAutoConfiguration {
    String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";

    Class<?>[] exclude() default {};

    String[] excludeName() default {};
}