public interface Coin {

    String getDescription();

}

public class GoldCoin  implements Coin {

    static final String DESCRIPTION = "这是金硬币！";

    @Override
    public String getDescription() {
        return DESCRIPTION;
    }

}

public class SliverCoin implements Coin {

    static final String DESCRIPTION = "这是银硬币！";

    @Override
    public String getDescription() {
        return DESCRIPTION;
    }

}

public enum CoinType {

    GOLD(GoldCoin::new),
    SLIVER(SliverCoin::new);

    private final Supplier<Coin> constructor;

    CoinType(Supplier<Coin> constructor) {
        this.constructor = constructor;
    }

    public Supplier<Coin> getConstructor() {
        return constructor;
    }

}

public class CoinFactory {

    public static Coin getCoin(CoinType coinType) {
        return coinType.getConstructor().get();
    }

}

public static void main(String[] args) {
    Coin goldCoin = CoinFactory.getCoin(CoinType.GOLD);
    Coin sliverCoin = CoinFactory.getCoin(CoinType.SLIVER);
    System.out.println(goldCoin.getDescription());
    System.out.println(sliverCoin.getDescription());
}

public class CopperCoin implements Coin {
   
  static final String DESCRIPTION = "这是铜硬币!";

  @Override
  public String getDescription() {
    return DESCRIPTION;
  }
}

public enum CoinType {

    GOLD(GoldCoin::new),
    SLIVER(SliverCoin::new),
    COPPER(copperCoin::new);

    private final Supplier<Coin> constructor;

    CoinType(Supplier<Coin> constructor) {
        this.constructor = constructor;
    }

    public Supplier<Coin> getConstructor() {
        return constructor;
    }

}

public static void main(String[] args) {
    Coin copperCoin = CoinFactory.getCoin(CoinType.COPPER);
    System.out.println(copperCoin.getDescription());
}

public interface Chair {
  String getDescription();
}

public interface Sofa {
  String getDescription();
}

public interface CoffeeTable {
  String getDescription();
}

// Modern implementations ->
public class ModernChair implements Chair {
  static final String DESCRIPTION = "这是现代风格的椅子!";
  @Override
  public String getDescription() {
    return DESCRIPTION;
  }
}
public class ModernSofa implements Sofa {
  static final String DESCRIPTION = "这是现代风格的沙发!";
  @Override
  public String getDescription() {
    return DESCRIPTION;
  }
}
public class ModernCoffeeTable implements CoffeeTable {
  static final String DESCRIPTION = "这是现代风格的咖啡桌!";
  @Override
  public String getDescription() {
    return DESCRIPTION;
  }
}

// Victorian implementations similarly -> ...

public interface FurnitureFactory {
  Chair createChair();
  Sofa createSofa();
  CoffeeTable createCoffeeTable();
}

public class ModernFurnitureFactory implements KingdomFactory {
  public Chair createChair() {
    return new ModernChair();
  }
  public Sofa createSofa() {
    return new ModernSofa();
  }
  public CoffeeTable createCoffeeTable() {
    return new ModernCoffeeTable();
  }
}

public class VictorianFurnitureFactory implements KingdomFactory {
  public Chair createChair() {
    return new VictorianChair();
  }
  public Sofa createSofa() {
    return new VictorianSofa();
  }
  public CoffeeTable createCoffeeTable() {
    return new VictorianCoffeeTable();
  }
}

@Getter
@Setter
public class CoffeeStore {

    private Chair chair;

    private Sofa sofa;

    private CoffeeTable coffeeTable;

    public static class FactoryMaker {

        public enum CoffeeStoreStyle {
            Victorian, Modern
        }

        public static FurnitureFactory makeFactory(CoffeeStoreStyle style) {
            FurnitureFactory factory;
            switch (style) {
                case Victorian:
                    factory = new VictorianFurnitureFactory();
                    break;
                case Modern:
                    factory = new ModernFurnitureFactory();
                    break;
                default: throw new IllegalArgumentException("FurnitureType not supported.");
            };
            return factory;
        }

    }

}

public static void main(String[] args) {

        CoffeeStore coffeeStore = new CoffeeStore();
        System.out.println("Victorian Style");
        FurnitureFactory victorianFactory = CoffeeStore.FactoryMaker.makeFactory(CoffeeStore.FactoryMaker.CoffeeStoreStyle.Victorian);
        coffeeStore.setChair(victorianFactory.createChair());
        coffeeStore.setSofa(victorianFactory.createSofa());
        coffeeStore.setCoffeeTable(victorianFactory.createCoffeeTable());
        System.out.println(coffeeStore.getChair().getDescription());
        System.out.println(coffeeStore.getSofa().getDescription());
        System.out.println(coffeeStore.getCoffeeTable().getDescription());

        System.out.println("Modern Style");
        FurnitureFactory ModernFactory = CoffeeStore.FactoryMaker.makeFactory(CoffeeStore.FactoryMaker.CoffeeStoreStyle.Modern);
        coffeeStore.setChair(ModernFactory.createChair());
        coffeeStore.setSofa(ModernFactory.createSofa());
        coffeeStore.setCoffeeTable(ModernFactory.createCoffeeTable());
        System.out.println(coffeeStore.getChair().getDescription());
        System.out.println(coffeeStore.getSofa().getDescription());
        System.out.println(coffeeStore.getCoffeeTable().getDescription());

    }

public final class Singleton {

    private Singleton() {

    }

    private static final Singleton INSTANCE = new Singleton();


    public static Singleton getInstance() {
        return INSTANCE;
    }
    
}

public static void main(String[] args) {
    Singleton singleton1 = Singleton.getInstance();
    Singleton singleton2 = Singleton.getInstance();
    System.out.println("singleton1=" + singleton1);
    System.out.println("singleton2=" + singleton2);
}

public class ThreadSafeLazyLoadedSingleton {

    /**
     *  declared as volatile to ensure atomic access by multiple threads.
     */
    private static volatile ThreadSafeLazyLoadedSingleton instance;

    /**
     * Private constructor to prevent instantiation from outside the class.
     */
    private ThreadSafeLazyLoadedSingleton() {
        // Protect against instantiation via reflection
        if (instance != null) {
            throw new IllegalStateException("Already initialized.");
        }
    }

    /**
     * The instance doesn't get created until the method is called for the first time.
     */
    public static synchronized ThreadSafeLazyLoadedSingleton getInstance() {
        if (instance == null) {
            instance = new ThreadSafeLazyLoadedSingleton();
        }
        return instance;
    }

}

ThreadSafeLazyLoadedSingleton instance1 = ThreadSafeLazyLoadedSingleton.getInstance();
ThreadSafeLazyLoadedSingleton instance2 = ThreadSafeLazyLoadedSingleton.getInstance();
System.out.println("instance1=" + instance1);
System.out.println("instance2=" + instance2);

public class ThreadSafeDoubleCheckSingleton {

    /**
     *  declared as volatile to ensure atomic access by multiple threads.
     */
    private static volatile ThreadSafeDoubleCheckSingleton instance;

    /**
     * Private constructor to prevent instantiation from outside the class.
     */
    private ThreadSafeDoubleCheckSingleton() {
        // Protect against instantiation via reflection
        if (instance != null) {
            throw new IllegalStateException("Already initialized.");
        }
    }

    /**
     * To be called by user to obtain instance of the class.
     */
    public static ThreadSafeDoubleCheckSingleton getInstance() {
        // local variable increases performance by 25 percent
        ThreadSafeDoubleCheckSingleton result = instance;
        // Check if singleton instance is initialized.
        if (instance == null) {
            synchronized (ThreadSafeDoubleCheckSingleton.class) {
                result = instance;
                if (result == null) {
                    result = new ThreadSafeDoubleCheckSingleton();
                    instance = result;
                }
            }
        }
        return result;
    }

}

public static void main(String[] args) {
    ThreadSafeDoubleCheckSingleton instance1 = ThreadSafeDoubleCheckSingleton.getInstance();
    ThreadSafeDoubleCheckSingleton instance2 = ThreadSafeDoubleCheckSingleton.getInstance();
    System.out.println(instance1);
    System.out.println(instance2);
}

public final class StaticInnerClassSingleton {

    /**
     * Private constructor to prevent instantiation from outside the class.
     */
    private StaticInnerClassSingleton() {

    }

    /**
     * The InstanceHolder is a static inner class, and it holds the Singleton instance.
     * It is not loaded into memory until the getInstance() method is called.
     */
    private static class InstanceHolder {
        private static final StaticInnerClassSingleton INSTANCE = new StaticInnerClassSingleton();
    }

    /**
     * When this method is called, the InstanceHolder is loaded into memory
     * and creates the Singleton instance. This method provides a global access point
     * for the singleton instance.
     */
    public static StaticInnerClassSingleton getInstance() {
        return InstanceHolder.INSTANCE;
    }

}

public enum EnumSingleton {
    INSTANCE;

    @Override
    public String toString() {
        return getDeclaringClass().getCanonicalName() + "@" + hashCode();
    }
}

public static void main(String[] args) {
    EnumSingleton instance1 = EnumSingleton.INSTANCE;
    EnumSingleton instance2 = EnumSingleton.INSTANCE;
    System.out.println(instance1);
    System.out.println(instance2);
}

// 创建一个空的 Optional 对象
Optional<String> empty = Optional.empty();

// 创建一个非空的 Optional 对象
Optional<String> hello = Optional.of("Hello");

// 创建一个可能为空的 Optional 对象
Optional<String> name = Optional.ofNullable("Hello");

Optional<Person> personOptional = daoService.selectOne(person1);
if (personOptional.isPresent()) {
  System.out.println("查询不为空");
} else {
  System.out.println("查询为空");
}

Optional<Person> personOptional = daoService.selectOne(person1);
if (personOptional.isPresent()) {
  Person person = personOptional.get();
  System.out.println(person);
} else {
	System.out.println("查询为空");
}

Optional<Person> personOptional = daoService.selectOne(person1);
personOptional.ifPresent(person -> System.out.println(person.getName()));

Optional<Person> personOptional = daoService.selectOne(person1);
Person person = personOptional.orElse(new Person());

/**
 * Return the value if present, otherwise return {@code other}.
 */
public T orElse(T other) {
    return value != null ? value : other;
}

/**
 * Return the value if present, otherwise invoke {@code other} and return
 * the result of that invocation.
 */
public T orElseGet(Supplier<? extends T> other) {
    return value != null ? value : other.get();
}

Person person1 = new Person();
person1.setName("zhangsan");
Person person2 = null;

String orElse = Optional.ofNullable(person1.getName()).orElse(person2.getName()); // 报错，空指针

String orElseGet = Optional.ofNullable(person1.getName()).orElseGet(() -> person2.getName()); // 不报错

System.out.println(orElseGet);

Person person1 = new Person();
person1.setName("zhangsan");
Optional<Person> person = Optional.ofNullable(person1);
Optional<String> optionalS = person.map(p -> p.getName().toUpperCase());
if (optionalS.isPresent()) {
  String upperName = optionalS.get();
  System.out.println(upperName);
}
// ZHANGSAN

public<U> Optional<U> map(Function<? super T, ? extends U> mapper) {
    Objects.requireNonNull(mapper);
    if (!isPresent())
        return empty();
    else {
        return Optional.ofNullable(mapper.apply(value));//会使用Optional的ofNullable方法包装Function函数返回的值
    }
}

public<U> Optional<U> flatMap(Function<? super T, Optional<U>> mapper) {
    Objects.requireNonNull(mapper);
    if (!isPresent())
        return empty();
    else {
        return Objects.requireNonNull(mapper.apply(value));//直接返回Function执行的结果

    }
}

public static String getStudentName(School school){
        return Optional.ofNullable(school)
                .map(School::getTearch)
                .map(Tearch::getStudent)
                .map(Student::getName)
                .orElse("false");
}

public static String getStudentName(School school){
        return Optional.ofNullable(school)
                .flatMap(School::getTearch)
                .flatMap(Tearch::getStudent)
                .map(Student::getName).orElse("false");
}

Person person1 = new Person();
person1.setName("zhangsan");
Optional<Person> optionalPerson = Optional.of(person1);
Optional<Person> optional = optionalPerson.filter(person -> "ZHANGSAN".equals(person.getName()));)
if (optional.isPresent()){
	System.out.println(optional);
} else {
	System.out.println("optional为空");
}

@SpringBootApplication
public class Application {

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

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

public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
  this.resourceLoader = resourceLoader;
  Assert.notNull(primarySources, "PrimarySources must not be null");
  this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
  // 根据classpath的类推断并设置webApplicationType
  this.webApplicationType = WebApplicationType.deduceFromClasspath();
  this.bootstrapRegistryInitializers = new ArrayList<>(getSpringFactoriesInstances(BootstrapRegistryInitializer.class));
  setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
  setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
  this.mainApplicationClass = deduceMainApplicationClass();
}

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

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

public ConfigurableApplicationContext run(String... args) {
  long startTime = System.nanoTime();
  DefaultBootstrapContext bootstrapContext = createBootstrapContext();
  ConfigurableApplicationContext context = null;
  configureHeadlessProperty();
  // 查找并加载所有的SpringApplicationRunListener
  SpringApplicationRunListeners listeners = getRunListeners(args);
  // 通知所有的listeners程序启动
  listeners.starting(bootstrapContext, this.mainApplicationClass);
  try {
    ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
    ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);
    Banner printedBanner = printBanner(environment);
    context = createApplicationContext();
    context.setApplicationStartup(this.applicationStartup);
    prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
    refreshContext(context);
    afterRefresh(context, applicationArguments);
    Duration timeTakenToStartup = Duration.ofNanos(System.nanoTime() - startTime);
    if (this.logStartupInfo) {
      new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), timeTakenToStartup);
    }
    listeners.started(context, timeTakenToStartup);
    callRunners(context, applicationArguments);
  }
  catch (Throwable ex) {
    if (ex instanceof AbandonedRunException) {
      throw ex;
    }
    handleRunFailure(context, ex, listeners);
    throw new IllegalStateException(ex);
  }
  try {
    if (context.isRunning()) {
      Duration timeTakenToReady = Duration.ofNanos(System.nanoTime() - startTime);
      listeners.ready(context, timeTakenToReady);
    }
  }
  catch (Throwable ex) {
    if (ex instanceof AbandonedRunException) {
      throw ex;
    }
    handleRunFailure(context, ex, null);
    throw new IllegalStateException(ex);
  }
  return context;
}

private SpringApplicationRunListeners getRunListeners(String[] args) {
  ArgumentResolver argumentResolver = ArgumentResolver.of(SpringApplication.class, this);
  argumentResolver = argumentResolver.and(String[].class, args);
  List<SpringApplicationRunListener> listeners = getSpringFactoriesInstances(SpringApplicationRunListener.class,
  argumentResolver);
  SpringApplicationHook hook = applicationHook.get();
  SpringApplicationRunListener hookListener = (hook != null) ? hook.getRunListener(this) : null;
  if (hookListener != null) {
  listeners = new ArrayList<>(listeners);
  listeners.add(hookListener);
  }
  return new SpringApplicationRunListeners(logger, listeners, this.applicationStartup);
}


private <T> List<T> getSpringFactoriesInstances(Class<T> type, ArgumentResolver argumentResolver) {
  return SpringFactoriesLoader.forDefaultResourceLocation(getClassLoader()).load(type, argumentResolver);
}

public static SpringFactoriesLoader forDefaultResourceLocation(@Nullable ClassLoader classLoader) {
	return forResourceLocation("META-INF/spring.factories", classLoader);
}

try {
  ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
  ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);

private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners,
      DefaultBootstrapContext bootstrapContext, ApplicationArguments applicationArguments) {
   // Create and configure the environment
   // 创建并配置environment
   ConfigurableEnvironment environment = getOrCreateEnvironment();
   // 配置 property sources 和 profiles
   configureEnvironment(environment, applicationArguments.getSourceArgs());
   // 将environment.getPropertySources()放在第一个位置
   ConfigurationPropertySources.attach(environment);
   // 运行监听器通知所有监听器环境准备完成
   listeners.environmentPrepared(bootstrapContext, environment);
   // 将'defaultProperties' property source移到最后
   DefaultPropertiesPropertySource.moveToEnd(environment);
   Assert.state(!environment.containsProperty("spring.main.environment-prefix"),
         "Environment prefix cannot be set via properties.");
  	// 将 environment 绑定到 {@link SpringApplication}
   bindToSpringApplication(environment);
  	// 环境转换成StandardEnvironment
   if (!this.isCustomEnvironment) {
      EnvironmentConverter environmentConverter = new EnvironmentConverter(getClassLoader());
      environment = environmentConverter.convertEnvironmentIfNecessary(environment, deduceEnvironmentClass());
   }
   ConfigurationPropertySources.attach(environment);
  // 返回环境配置对象ConfigurableEnvironment
   return environment;
}

private ConfigurableEnvironment getOrCreateEnvironment() {
   if (this.environment != null) {
      return this.environment;
   }
   ConfigurableEnvironment environment = this.applicationContextFactory.createEnvironment(this.webApplicationType);
   if (environment == null && this.applicationContextFactory != ApplicationContextFactory.DEFAULT) {
      environment = ApplicationContextFactory.DEFAULT.createEnvironment(this.webApplicationType);
   }
   return (environment != null) ? environment : new ApplicationEnvironment();
}

try {
  ......
  Banner printedBanner = printBanner(environment);
  context = createApplicationContext();
  context.setApplicationStartup(this.applicationStartup);
  prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
  refreshContext(context);
  afterRefresh(context, applicationArguments);
  Duration timeTakenToStartup = Duration.ofNanos(System.nanoTime() - startTime);
  if (this.logStartupInfo) {
    new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), timeTakenToStartup);
  }
  listeners.started(context, timeTakenToStartup);
  callRunners(context, applicationArguments);
}

private Banner printBanner(ConfigurableEnvironment environment) {
  if (this.bannerMode == Mode.OFF) {
    return null;
  } else {
    ResourceLoader resourceLoader = this.resourceLoader != null ? this.resourceLoader : new DefaultResourceLoader((ClassLoader)null);
    SpringApplicationBannerPrinter bannerPrinter = new SpringApplicationBannerPrinter((ResourceLoader)resourceLoader, this.banner);
    return this.bannerMode == Mode.LOG ? bannerPrinter.print(environment, this.mainApplicationClass, logger) : bannerPrinter.print(environment, this.mainApplicationClass, System.out);
  }
}

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

try {
  ......
  // 创建应用程序上下文对象
  context = createApplicationContext();
  // 设置下上下文对象的应用程序启动器
  context.setApplicationStartup(this.applicationStartup);
  // 准备上下文，配置容器的基本信息
  prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
  refreshContext(context);
  afterRefresh(context, applicationArguments);
  Duration timeTakenToStartup = Duration.ofNanos(System.nanoTime() - startTime);
  if (this.logStartupInfo) {
    new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), timeTakenToStartup);
  }
  listeners.started(context, timeTakenToStartup);
  callRunners(context, applicationArguments);
}

private void prepareContext(DefaultBootstrapContext bootstrapContext, ConfigurableApplicationContext context, ConfigurableEnvironment environment, SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments, Banner printedBanner) {
  // 设置容器的环境变量
  context.setEnvironment(environment);
  // 设置容器的ResourceLoader、ClassLoader、ConversionService
  this.postProcessApplicationContext(context);
  // 获取所有初始化器调用initialize()初始化
  this.applyInitializers(context);
  // 触发所有 SpringApplicationRunListener监听器的contextPrepared事件方法
  listeners.contextPrepared(context);
  bootstrapContext.close(context);
  // 打印启动日志和启动应用的Profile
  if (this.logStartupInfo) {
    this.logStartupInfo(context.getParent() == null);
    this.logStartupProfileInfo(context);
  }
	// Add boot specific singleton beans 添加启动特定的单例bean
  ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
  // 向beanFactory注册单例bean：命令行参数bean
  beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
  if (printedBanner != null) {
    // 向beanFactory注册单例bean：banner bean
    beanFactory.registerSingleton("springBootBanner", printedBanner);
  }

  if (beanFactory instanceof AbstractAutowireCapableBeanFactory) {
    ((AbstractAutowireCapableBeanFactory)beanFactory).setAllowCircularReferences(this.allowCircularReferences);
    if (beanFactory instanceof DefaultListableBeanFactory) {
      ((DefaultListableBeanFactory)beanFactory).setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
    }
  }

  if (this.lazyInitialization) {
    context.addBeanFactoryPostProcessor(new LazyInitializationBeanFactoryPostProcessor());
  }
  context.addBeanFactoryPostProcessor(new PropertySourceOrderingBeanFactoryPostProcessor(context));
  // Load the sources，加载所有的资源
  Set<Object> sources = this.getAllSources();
  // 断言资源必须非空
  Assert.notEmpty(sources, "Sources must not be empty");
  // 将bean加载到应用上下文中
  this.load(context, sources.toArray(new Object[0]));
  // 触发所有SpringApplicationRunListener监听器contextLoaded方法
  listeners.contextLoaded(context);
}

try {
  ......
  refreshContext(context);
  afterRefresh(context, applicationArguments);
  Duration timeTakenToStartup = Duration.ofNanos(System.nanoTime() - startTime);
  if (this.logStartupInfo) {
    new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), timeTakenToStartup);
  }
  listeners.started(context, timeTakenToStartup);
  callRunners(context, applicationArguments);
}

private void refreshContext(ConfigurableApplicationContext context) {
  if (this.registerShutdownHook) {
    shutdownHook.registerApplicationContext(context);
  }

  this.refresh(context);
}

public final void refresh() throws BeansException, IllegalStateException {
    try {
        super.refresh();
    } catch (RuntimeException var3) {
        WebServer webServer = this.webServer;
        if (webServer != null) {
            webServer.stop();
        }

        throw var3;
    }
}

    
public void refresh() throws BeansException, IllegalStateException {
        
  synchronized(this.startupShutdownMonitor) {
    StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");
    // 上下文准备刷新
    this.prepareRefresh();
    // 刷新bean工厂，并返回bean工厂
    ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
    // 准备bean工厂，以便进行上下文的使用
    this.prepareBeanFactory(beanFactory);
    try {
      // 允许在上下文子类中对 bean 工厂进行后置处理
      this.postProcessBeanFactory(beanFactory);
      StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process"); 
      // 在bean创建之前调用BeanFactoryPostProcessors后置处理方法
      this.invokeBeanFactoryPostProcessors(beanFactory); 
      // 注册BeanPostProcessor
      this.registerBeanPostProcessors(beanFactory);
      beanPostProcess.end();   
      // 注册DelegatingMessageSource
      this.initMessageSource();
      // 注册一个applicationEventMulticaster的广播器
      this.initApplicationEventMulticaster(); 
      // 在特定上下文子类中初始化其他特殊 bean
      this.onRefresh();
      // 注册监听器Listeners
      this.registerListeners(); 
      // 实例化所有剩余的（非懒加载）单例。
      this.finishBeanFactoryInitialization(beanFactory);
      // 发布对应事件
      this.finishRefresh();  
    } catch (BeansException var10) {      
      if (this.logger.isWarnEnabled()) {
        this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var10);         
      }
      this.destroyBeans();
      this.cancelRefresh(var10);
      throw var10;
    } finally {
      this.resetCommonCaches();        
      contextRefresh.end();       
    }     
  } 
}

try {
  ......
  refreshContext(context);
  afterRefresh(context, applicationArguments);
  Duration timeTakenToStartup = Duration.ofNanos(System.nanoTime() - startTime);
  if (this.logStartupInfo) {
    new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), timeTakenToStartup);
  }
  listeners.started(context, timeTakenToStartup);
  callRunners(context, applicationArguments);
}

void started(ConfigurableApplicationContext context, Duration timeTaken) {
  this.doWithListeners("spring.boot.application.started", (listener) -> {
    listener.started(context, timeTaken);
  });
}

try {
  Duration timeTakenToReady = Duration.ofNanos(System.nanoTime() - startTime);
  // 所有的运行监听器调用running()方法,监听应用上下文
  listeners.ready(context, timeTakenToReady);
  return context;
} catch (Throwable var11) {
  this.handleRunFailure(context, var11, (SpringApplicationRunListeners)null);
  throw new IllegalStateException(var11);
}

@SpringBootApplication
public class Application {
    public static void main(String[] args) throws Exception {
        SpringApplication.run(Application.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
@Indexed
public @interface SpringBootConfiguration {
    @AliasFor(
        annotation = Configuration.class
    )
    boolean proxyBeanMethods() default true;
}

public class MyConfiguration {
    @Bean
    public MyService mockService(){
        return new MyServiceImpl();
    }
}

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
@Documented
@Repeatable(ComponentScans.class)
public @interface ComponentScan {
    @AliasFor("basePackages")
    String[] value() default {};

    @AliasFor("value")
    String[] basePackages() default {};

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

    Class<? extends BeanNameGenerator> nameGenerator() default BeanNameGenerator.class;

    Class<? extends ScopeMetadataResolver> scopeResolver() default AnnotationScopeMetadataResolver.class;

    ScopedProxyMode scopedProxy() default ScopedProxyMode.DEFAULT;

    String resourcePattern() default "**/ *.class";

    boolean useDefaultFilters() default true;

    Filter[] includeFilters() default {};

    Filter[] excludeFilters() default {};

    boolean lazyInit() default false;

    @Retention(RetentionPolicy.RUNTIME)
    @Target({})
    public @interface Filter {
        FilterType type() default FilterType.ANNOTATION;

        @AliasFor("classes")
        Class<?>[] value() default {};

        @AliasFor("value")
        Class<?>[] classes() default {};

        String[] pattern() default {};
    }
}

@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 {};
}

public String[] selectImports(AnnotationMetadata annotationMetadata) {
    if (!this.isEnabled(annotationMetadata)) {
      return NO_IMPORTS;
    } else {
      AutoConfigurationEntry autoConfigurationEntry = this.getAutoConfigurationEntry(annotationMetadata);
      return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
    }
}

protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
    List<String> configurations = new ArrayList(SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(),       this.getBeanClassLoader()));
    ImportCandidates.load(AutoConfiguration.class,  this.getBeanClassLoader()).forEach(configurations::add);
    Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories nor in META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports. If you are using a custom packaging, make sure that file is correct.");
    return configurations;
}

public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
    ClassLoader classLoaderToUse = classLoader;
    if (classLoader == null) {
    classLoaderToUse = SpringFactoriesLoader.class.getClassLoader();
    }

    String factoryTypeName = factoryType.getName();
    return (List)loadSpringFactories(classLoaderToUse).getOrDefault(factoryTypeName, Collections.emptyList());	
}

private static Map<String, List<String>> loadSpringFactories(ClassLoader classLoader) {
        Map<String, List<String>> result = (Map)cache.get(classLoader);
        if (result != null) {
            return result;
        } else {
            Map<String, List<String>> result = new HashMap();

            try {
                Enumeration<URL> urls = classLoader.getResources("META-INF/spring.factories");
......
}