public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
        return (new SpringApplication(primarySources)).run(args);
    }

　　public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
        this.sources = new LinkedHashSet();
        // 獲取banner打印模式
        this.bannerMode = Mode.CONSOLE;
        this.logStartupInfo = true;
        // 添加命令行系統屬性
        this.addCommandLineProperties = true;
        this.addConversionService = true;
        this.headless = true;
        this.registerShutdownHook = true;
        this.additionalProfiles = Collections.emptySet();
        this.isCustomEnvironment = false;
         // 是否懶加載
        this.lazyInitialization = false;
        // 默認賦值 applicationContextFactory 工廠對象
        this.applicationContextFactory = ApplicationContextFactory.DEFAULT;
        this.applicationStartup = ApplicationStartup.DEFAULT;
        this.resourceLoader = resourceLoader;
        Assert.notNull(primarySources, "PrimarySources must not be null");
        this.primarySources = new LinkedHashSet(Arrays.asList(primarySources));
         // 根據類加載路徑推斷webApplicaitonType類型：SERVLET；REACTIVE
        this.webApplicationType = WebApplicationType.deduceFromClasspath();
        // 進行Spring的自動裝配，主要用來SpringFactoriesLoader類進行裝載工廠
        this.bootstrappers = new ArrayList(this.getSpringFactoriesInstances(Bootstrapper.class));
        this.setInitializers(this.getSpringFactoriesInstances(ApplicationContextInitializer.class));
         // 設置監聽器
        this.setListeners(this.getSpringFactoriesInstances(ApplicationListener.class));
        this.mainApplicationClass = this.deduceMainApplicationClass();
    }

 　　public ConfigurableApplicationContext run(String... args) {
        // 應用啟動計時器
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        DefaultBootstrapContext bootstrapContext = this.createBootstrapContext();
        // 初始化應用上下文
        ConfigurableApplicationContext context = null;
        this.configureHeadlessProperty();
        // 獲取啟動監聽器
        SpringApplicationRunListeners listeners = this.getRunListeners(args);
        //監聽器使用類似於生產-消費模式進行消息監聽
        listeners.starting(bootstrapContext, this.mainApplicationClass);

        try {
            //構建應用參數
            ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
            //準備應用環境
            ConfigurableEnvironment environment = this.prepareEnvironment(listeners, bootstrapContext, applicationArguments);
            this.configureIgnoreBeanInfo(environment);
            //打印banner
            Banner printedBanner = this.printBanner(environment);
            //創建ApplicationContext
            context = this.createApplicationContext();
            context.setApplicationStartup(this.applicationStartup);
            //準備context
            this.prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
            //重點：刷新context:實現IOC容器啟動的整個過程
            this.refreshContext(context);
            //後置工作
            this.afterRefresh(context, applicationArguments);
            stopWatch.stop();
            if (this.logStartupInfo) {
                (new StartupInfoLogger(this.mainApplicationClass)).logStarted(this.getApplicationLog(), stopWatch);
            }

            listeners.started(context);
            this.callRunners(context, applicationArguments);
        } catch (Throwable var10) {
            this.handleRunFailure(context, var10, listeners);
            throw new IllegalStateException(var10);
        }
        
    }

private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners, DefaultBootstrapContext bootstrapContext, ApplicationArguments applicationArguments) {
        // 根據前面推斷的web環境類型創建推Environment對象
        ConfigurableEnvironment environment = this.getOrCreateEnvironment();
        // 進行環境配置
        this.configureEnvironment((ConfigurableEnvironment)environment, applicationArguments.getSourceArgs());
        ConfigurationPropertySources.attach((Environment)environment);
        listeners.environmentPrepared(bootstrapContext, (ConfigurableEnvironment)environment);
        DefaultPropertiesPropertySource.moveToEnd((ConfigurableEnvironment)environment);
        this.configureAdditionalProfiles((ConfigurableEnvironment)environment);
        this.bindToSpringApplication((ConfigurableEnvironment)environment);
        if (!this.isCustomEnvironment) {
            environment = (new EnvironmentConverter(this.getClassLoader())).convertEnvironmentIfNecessary((ConfigurableEnvironment)environment, this.deduceEnvironmentClass());
        }

        ConfigurationPropertySources.attach((Environment)environment);
        return (ConfigurableEnvironment)environment;
    }

　　private ConfigurableEnvironment getOrCreateEnvironment() {
        if (this.environment != null) {
            return this.environment;
        } else {
            switch(this.webApplicationType) {
            case SERVLET:
                return new StandardServletEnvironment();
            case REACTIVE:
                return new StandardReactiveWebEnvironment();
            default:
                return new StandardEnvironment();
            }
        }
    }

　　protected void configureEnvironment(ConfigurableEnvironment environment, String[] args) {
        if (this.addConversionService) {
            ConversionService conversionService = ApplicationConversionService.getSharedInstance();
            environment.setConversionService((ConfigurableConversionService)conversionService);
        }
        // 配置屬性源
        this.configurePropertySources(environment, args);
        //獲取激活的 profile
        this.configureProfiles(environment, args);
    }

　　protected ConfigurableApplicationContext createApplicationContext() {
        return this.applicationContextFactory.create(this.webApplicationType);
    }

@FunctionalInterface
public interface ApplicationContextFactory {
    // 根據webApplicationType返回指定的容器實例
    applicationContextFactoryApplicationContextFactory DEFAULT = (webApplicationType) -> {
        try {
            switch(webApplicationType) {
            case SERVLET:
                return new AnnotationConfigServletWebServerApplicationContext();
            case REACTIVE:
                return new AnnotationConfigReactiveWebServerApplicationContext();
            default:
                return new AnnotationConfigApplicationContext();
            }
        } catch (Exception var2) {
            throw new IllegalStateException("Unable create a default ApplicationContext instance, you may need a custom ApplicationContextFactory", var2);
        }
    };
      ConfigurableApplicationContext create(WebApplicationType webApplicationType);
}

public AnnotationConfigApplicationContext() {
        // 啟動上面獲取的容器類型實例
        StartupStep createAnnotatedBeanDefReader = this.getApplicationStartup().start("spring.context.annotated-bean-reader.create");
        // 構建AnnotatedBeanDefinitionReader對象
        this.reader = new AnnotatedBeanDefinitionReader(this);
        createAnnotatedBeanDefReader.end();
          // 構建 ClassPathBeanDefinitionScanner對象
        this.scanner = new ClassPathBeanDefinitionScanner(this);
    }

private void prepareContext(DefaultBootstrapContext bootstrapContext, ConfigurableApplicationContext context, ConfigurableEnvironment environment, SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments, Banner printedBanner) {
        // 使context持有應用環境的引用，同時將應用環境的引用賦給reader和scanner
        context.setEnvironment(environment);
        // 實現應用上下文的後置處理：主要是註冊BeanNameGenerator類型的bean並設置應用上下文的資源加載器和類加載器
        this.postProcessApplicationContext(context);
        // 應用初始化器--添加監聽器、logger、warnning、以及spring啟動加解密等組件
        this.applyInitializers(context);
        listeners.contextPrepared(context);
        bootstrapContext.close(context);
        if (this.logStartupInfo) {
            this.logStartupInfo(context.getParent() == null);
            this.logStartupProfileInfo(context);
        }

        ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
        // 添加啟動相關的bean
        beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
        // 註冊打印banner的bean
        if (printedBanner != null) {
            beanFactory.registerSingleton("springBootBanner", printedBanner);
        }
        // 註冊可定義重寫的bean
        if (beanFactory instanceof DefaultListableBeanFactory) {
            ((DefaultListableBeanFactory)beanFactory).setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
        }
        // 添加懶加載的bean工廠後置處理器
        if (this.lazyInitialization) {
            context.addBeanFactoryPostProcessor(new LazyInitializationBeanFactoryPostProcessor());
        }
        // Load the sources
        Set<Object> sources = this.getAllSources();
        Assert.notEmpty(sources, "Sources must not be empty");
        // 重點：將source bean裝載到應用上下文
        this.load(context, sources.toArray(new Object[0]));
        // 日誌配置
        listeners.contextLoaded(context);
    }

SpringApplication.load(ApplicationContext context, Object[] sources)-------->
BeanDefinitionLoader.load()---->BeanDefinitionLoader.load(Object source)--->
BeanDefinitionLoader.load(Class<?> source)----->AnnotatedBeanDefinitionReader.register(Class<?>... componentClasses)--->
AnnotatedBeanDefinitionReader.registerBean(Class<?> beanClass)---->
AnnotatedBeanDefinitionReader.doRegisterBean --->
BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);

private final Map<String, BeanDefinition> beanDefinitionMap;

public void refresh() throws BeansException, IllegalStateException {
  synchronized (this.startupShutdownMonitor) {
    // Prepare this context for refreshing.
    // 為應用上下文的刷新做準備--設置時間、記錄刷新日誌、初始化屬性源中的佔位符和驗證必要的屬性等
    prepareRefresh();

    // Tell the subclass to refresh the internal bean factory.
    // 使用CAS讓子類刷新內部的bean factory
    ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

    // Prepare the bean factory for use in this context.
    // 準備在這個應用上下文中使用的bean factory
    prepareBeanFactory(beanFactory);

    try {
      // Allows post-processing of the bean factory in context subclasses.
      // bean factory 後置處理
      postProcessBeanFactory(beanFactory);

      // Invoke factory processors registered as beans in the context.
      // 調用應用上下文中作為bean註冊的工廠處理器
      invokeBeanFactoryPostProcessors(beanFactory);

      // Register bean processors that intercept bean creation.
      // 註冊攔截創建bean的bean處理器
      registerBeanPostProcessors(beanFactory);

      // Initialize message source for this context.
      // 初始化消息源
      initMessageSource();

      // Initialize event multicaster for this context.
      // 初始化事件廣播
      initApplicationEventMulticaster();

      // Initialize other special beans in specific context subclasses.
      // 初始化特定上下文子類中的其它bean
      onRefresh();

      // Check for listener beans and register them.
      // 註冊監聽器bean
      registerListeners();

      // Instantiate all remaining (non-lazy-init) singletons.
      // 實例化所有的單例bean
      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();
    }
  }
}

protected void prepareRefresh() {
 　　//記錄啟動時間
 　　this.startupDate = System.currentTimeMillis();
 　　//標誌位設置
 　　this.closed.set(false);
 　　this.active.set(true);

 　　//日誌記錄一下
 　　if (logger.isInfoEnabled()) {
   　　　　logger.info("Refreshing " + this);
 　　}

 　　// Initialize any placeholder property sources in the context environment
 　　// 初始化資源佔位符
 　　initPropertySources();

 　　// Validate that all properties marked as required are resolvable
 　　// see ConfigurablePropertyResolver#setRequiredProperties
 　　// 驗證所有必要的屬性能通過getProperty()解析，不能則拋出異常
 　　getEnvironment().validateRequiredProperties();

 　　// Allow for the collection of early ApplicationEvents,
 　　// to be published once the multicaster is available...
 　　this.earlyApplicationEvents = new LinkedHashSet<ApplicationEvent>();
}

protected final void refreshBeanFactory() throws IllegalStateException {
 　　// 只支持刷新一次
 　　if (!this.refreshed.compareAndSet(false, true)) {
   　　　　throw new IllegalStateException("GenericApplicationContext does not support multiple refresh attempts: just call  'refresh' once");
 　　}
 　　// 設置序列號
 　　this.beanFactory.setSerializationId(getId());
}

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
 　　// Tell the internal bean factory to use the context's class loader etc.
 　　// 使用應用上下文的類加載器
 　　beanFactory.setBeanClassLoader(getClassLoader());
 　　// 設置bean表達式解析器
 　　beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
 　　// 添加屬性編輯器註冊器
 　　beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this,getEnvironment()));

 　　// Configure the bean factory with context callbacks.
 　　// 使用上下文回調函數配置bean factory
 　　beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
 　　beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
 　　beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
 　　beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
 　　beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
 　　beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
 　　beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);

 　　// BeanFactory interface not registered as resolvable type in a plain factory.
 　　// MessageSource registered (and found for autowiring) as a bean.
 　　// 註冊依賴
 　　beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
 　　beanFactory.registerResolvableDependency(ResourceLoader.class, this);
 　　beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
 　　beanFactory.registerResolvableDependency(ApplicationContext.class, this);

 　　// Register early post-processor for detecting inner beans as ApplicationListeners.
 　　// 添加一個用於探測實現了ApplicationListener接口的bean的後置處理器
 　　beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

 　　// Detect a LoadTimeWeaver and prepare for weaving, if found.
 　　// 探測LoadTimeWeaver並準備織入，與AOP相關
 　　if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
  　　 　　beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));

   　　// Set a temporary ClassLoader for type matching.
   　　beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
 　　}

 　　// Register default environment beans.
 　　// 將默認環境作為bean註冊
 　　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());
 　　}
}

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
 　　// BeanFactory後置處理器的具體實現
 　　PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

 　　// Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
 　　// (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)
 　　if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
   　　　　beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
   　　　　beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
　　 }
}

public void parse(Set<BeanDefinitionHolder> configCandidates) {
 　　this.deferredImportSelectors = new LinkedList<DeferredImportSelectorHolder>();

 　　for (BeanDefinitionHolder holder : configCandidates) {
   　　　　BeanDefinition bd = holder.getBeanDefinition();
   　　　　try {
     　　　　　　//如果bean是註解的，則解析註解---Spring Boot基於註解配置
     　　　　　　if (bd instanceof AnnotatedBeanDefinition) {
       　　　　　　　　parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());
     　　　　　　}
     　　　　　　// 如果是抽象bean並且有bean類
     　　　　　　else if (bd instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) bd).hasBeanClass()) {
       　　　　　　　　parse(((AbstractBeanDefinition) bd).getBeanClass(), holder.getBeanName());
     　　　　} else {
       　　 　　// 普通解析
       　　　　parse(bd.getBeanClassName(), holder.getBeanName());
     　　　　}
   　　　　}
   　　　　catch (BeanDefinitionStoreException ex) {
     　　　　　　throw ex;
   　　} catch (Throwable ex) {
     　　　　throw new BeanDefinitionStoreException(  "Failed to parse configuration class [" + bd.getBeanClassName() + "]", ex);
   　　}
 　　}
　　　　 // 處理延遲導入的選擇器
 　　　　processDeferredImportSelectors();
}

private void processDeferredImportSelectors() {
 　　List<DeferredImportSelectorHolder> deferredImports = this.deferredImportSelectors;
 　　this.deferredImportSelectors = null;
 　　Collections.sort(deferredImports, DEFERRED_IMPORT_COMPARATOR);

 　　for (DeferredImportSelectorHolder deferredImport : deferredImports) {
   　　　　ConfigurationClass configClass = deferredImport.getConfigurationClass();
   　　　　try {
     　　　　// 獲取importSelector---在自動配置源數據中刪除不符合要求或者無法實例化的對象
     　　　　String[] imports = deferredImport.getImportSelector().selectImports(configClass.getMetadata());
     　　　　//處理import---迭代處理，最終調用processConfigurationClass處理自動配置的類
     　　　　processImports(configClass, asSourceClass(configClass), asSourceClasses(imports), false);
   　　　　} catch (BeanDefinitionStoreException ex) {
     　　　　　　throw ex;
   　　　　} catch (Throwable ex) {
    　　　　　　 throw new BeanDefinitionStoreException("Failed to process import candidates for configuration class [" + configClass.getMetadata().getClassName() + "]", ex);
   　　　　}
 　　}
}

AbstractApplicationContext.finishBeanFactoryInitialization（方法最後一行）-----〉
AbstractBeanFactory.getBean---->AbstractBeanFactory.doGetBean------->
AbstractAutowireCapableBeanFactory.createBean------->
重點：AbstractAutowireCapableBeanFactory.doCreateBean(這個方法進行bean的生命周期)