@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {}

@Import(AutoConfigurationPackages.Registrar.class)
public @interface AutoConfigurationPackage {}

@Override
public String[] selectImports(AnnotationMetadata annotationMetadata) {
    //判断自动装配开关是否打开
    if (!isEnabled(annotationMetadata)) {
        return NO_IMPORTS;
    }
    //获取所有需要装配的bean
    AutoConfigurationEntry autoConfigurationEntry =
        getAutoConfigurationEntry(annotationMetadata);
    return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
}

protected AutoConfigurationEntry getAutoConfigurationEntry(
    AnnotationMetadata annotationMetadata) {
    //1.判断自动装配开关是否打开
    if (!isEnabled(annotationMetadata)) {
        return EMPTY_ENTRY;
    }
    //2.
    AnnotationAttributes attributes = getAttributes(annotationMetadata);
    //3.扫描spring.factories下需要自动装配的所有类
    List<String> configurations = getCandidateConfigurations(annotationMetadata,
                                                             attributes);
    //4.下面是过滤出真正需要加载的类。
    configurations = removeDuplicates(configurations);
    Set<String> exclusions = getExclusions(annotationMetadata, attributes);
    checkExcludedClasses(configurations, exclusions);
    configurations.removeAll(exclusions);
    configurations = getConfigurationClassFilter().filter(configurations);
    fireAutoConfigurationImportEvents(configurations, exclusions);
    return new AutoConfigurationEntry(configurations, exclusions);
}

@Component
@ConfigurationProperties("person")
public interface Person {}

//这个类只在prod环境下注册
@Profile("prod")  
@Component
public class Boss implements Person{
    private String name;
    private Integer age;

    public String getName() {return name;}
    public void setName(String name) {this.name = name;}
    public Integer getAge() {return age;}
    public void setAge(Integer age) {this.age = age;}
}

//这个类只在test环境下注册
@Profile("test")
@Component
public class Worker implements Person{
    private String name;
    private Integer age;

    public String getName() {return name;}
    public void setName(String name) {this.name = name;}
    public Integer getAge() {return age;}
    public void setAge(Integer age) {this.age = age;}
}

@RestController
public class HelloController {
    @Autowired
    Person person;

    @GetMapping("/")
    public String  hello(){
        return person.getClass().getName();
    }
}

@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(CacheManager.class)
@ConditionalOnBean(CacheAspectSupport.class)
@ConditionalOnMissingBean(value = CacheManager.class, name = "cacheResolver")
@EnableConfigurationProperties(CacheProperties.class)
@AutoConfigureAfter({ CouchbaseDataAutoConfiguration.class, 
                     HazelcastAutoConfiguration.class,
                     HibernateJpaAutoConfiguration.class,
                     RedisAutoConfiguration.class })
@Import({ CacheConfigurationImportSelector.class, CacheManagerEntityManagerFactoryDependsOnPostProcessor.class })
public class CacheAutoConfiguration {...}

@ConfigurationProperties(prefix = "spring.cache")
public class CacheProperties {...}

//绑定配置文件中的前缀
@ConfigurationProperties(prefix = "kang.hello")
public class HelloProperties {
    private String prefix;
    private String suffix;

    public String getPrefix() {return prefix;}
    public void setPrefix(String prefix) {this.prefix = prefix;}
    public String getSuffix() {return suffix;}
    public void setSuffix(String suffix) {this.suffix = suffix;}
}

@Configuration
@EnableConfigurationProperties(HelloProperties.class)
public class HelloServiceAutoConfiguration {
    
    @Bean
    @ConditionalOnMissingBean(HelloService.class)
    public HelloService helloService(){
        return new HelloService();
    }
}

/*
默认不要放在容器中
 */
public class HelloService {
    @Autowired  //自动装配配置类
    HelloProperties helloProperties;
    
    //定义一个方法，在输入参数中添加前缀和后缀
    public String sayHello(String userName){
        String prefix = helloProperties.getPrefix();
        String suffix = helloProperties.getSuffix();
        return prefix+","+userName+","+suffix;
    }
}

@RestController
public class HelloController {
    //引入了自定义的启动器，可以使用其提供的方法。
    @Autowired
    HelloService helloService;

    @GetMapping("/hello")
    public String sayHello(){
        String str = helloService.sayHello("KANG");
        return str;
    }
}

@Configuration
public class MyConfig {
    @Bean
    public HelloService helloService(){
        HelloService helloService = new HelloService();
        //对helloService进行自定义的操作，比如setXxx()
        return helloService;
    }
}

public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
    //加载一些信息
    this.resourceLoader = resourceLoader;
    //判断是否有主配置类信息
    Assert.notNull(primarySources, "PrimarySources must not be null");
    //保存主配置类信息  class com.kang.boot.Springboot09HelloTestApplication
    this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
    //判断应用类型   Servlet
    this.webApplicationType = WebApplicationType.deduceFromClasspath();
    //去spring.factories查找初始启动引导器  null
    this.bootstrapRegistryInitializers = getBootstrapRegistryInitializersFromSpringFactories();
    //去spring.factories查找ApplicationContextInitializer  找到n个
    setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
    //去spring.factories查找监听器  找到n个
    setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
    //查找主程序  class com.kang.boot.Springboot09HelloTestApplication
    this.mainApplicationClass = deduceMainApplicationClass();
}

public ConfigurableApplicationContext run(String... args) {
    //stopWatch用于监听整个应用程序的启动和停止
    StopWatch stopWatch = new StopWatch();
    //启动stopWatch，记录应用的启动时间
    stopWatch.start();
    //创建引导上下文
    DefaultBootstrapContext bootstrapContext = createBootstrapContext();
    ConfigurableApplicationContext context = null;
    //让当前应用进入Headless模式 java.awt.headless
    configureHeadlessProperty();
    //获取所有的运行监听器
    SpringApplicationRunListeners listeners = getRunListeners(args);
    //starting方法调用了所有监听器的starting方法
    listeners.starting(bootstrapContext, this.mainApplicationClass);
    try {
        //保存命令行参数
        ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
        //准备环境
        ConfigurableEnvironment environment = prepareEnvironment(listeners, 
                                                                 bootstrapContext, 
                                                                 applicationArguments);
        configureIgnoreBeanInfo(environment);
        //打印banner，即运行程序的SPRING的ASCII码图案
        Banner printedBanner = printBanner(environment);
        //创建IOC容器
        context = createApplicationContext();
        //容器保存当前项目的startup信息
        context.setApplicationStartup(this.applicationStartup);
        //准备IOC容器的基本信息
        prepareContext(bootstrapContext, context, environment, listeners, 
                       applicationArguments, printedBanner);
        //刷新IOC容器
        refreshContext(context);
        //刷新之后的工作
        afterRefresh(context, applicationArguments);
        //关闭stopWatch，计算出应用启动花费的时间
        stopWatch.stop();
        if (this.logStartupInfo) {
            new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), 
                                                                        stopWatch);
        }
        //通知所有的监听器的started方法
        listeners.started(context);
        //调用所有runners
        callRunners(context, applicationArguments);
    }
    catch (Throwable ex) {
        //如果有异常，会调用监听器的failed()方法
        handleRunFailure(context, ex, listeners);
        throw new IllegalStateException(ex);
    }

    try {
        //调用监听器的running方法
        listeners.running(context);
    }
    catch (Throwable ex) {
        handleRunFailure(context, ex, null);
        throw new IllegalStateException(ex);
    }
    //最后返回容器
    return context;
}

public class MyApplicationContextInitializer implements ApplicationContextInitializer {
    @Override
    public void initialize(ConfigurableApplicationContext applicationContext) {
        //do something
        System.out.println("MyApplicationContextInitializer...initialize...");
    }
}

public class MyApplicationListener implements ApplicationListener {
    @Override
    public void onApplicationEvent(ApplicationEvent event) {
        //do something
        System.out.println("MyApplicationListener...onApplicationEvent...");
    }
}

public class MySpringApplicationRunListener implements SpringApplicationRunListener {

    private SpringApplication application;
    //注意：这里需要一个有参构造器
    public MySpringApplicationRunListener(SpringApplication application,
                                          String [] args){
        this.application = application;

    }

    @Override
    public void starting(ConfigurableBootstrapContext bootstrapContext) {
        System.out.println("MySpringApplicationRunListener...starting...");
    }

    @Override
    public void environmentPrepared(ConfigurableBootstrapContext bootstrapContext,
                                    ConfigurableEnvironment environment) {
        System.out.println("MySpringApplicationRunListener...environmentPrepared...");
    }

    @Override
    public void contextPrepared(ConfigurableApplicationContext context) {
        System.out.println("MySpringApplicationRunListener...contextPrepared...");
    }

    @Override
    public void contextLoaded(ConfigurableApplicationContext context) {
        System.out.println("MySpringApplicationRunListener...contextLoaded...");
    }

    @Override
    public void started(ConfigurableApplicationContext context) {
        System.out.println("MySpringApplicationRunListener...started...");
    }

    @Override
    public void running(ConfigurableApplicationContext context) {
        System.out.println("MySpringApplicationRunListener...running...");
    }

    @Override
    public void failed(ConfigurableApplicationContext context, Throwable exception) {
        System.out.println("MySpringApplicationRunListener...failed...");
    }
}

@Component
public class MyApplicationRunner implements ApplicationRunner {
    @Override
    public void run(ApplicationArguments args) throws Exception {
        System.out.println("MyApplicationRunner...run");
    }
}

/*
应用一启动，做一个一次性的事情
 */
@Component
public class MyCommandLineRunner implements CommandLineRunner {
    @Override
    public void run(String... args) throws Exception {
        System.out.println("MyCommandLineRunner...run...");
    }
}

MyApplicationListener...onApplicationEvent...
MySpringApplicationRunListener...starting...
MyApplicationListener...onApplicationEvent...
MySpringApplicationRunListener...environmentPrepared...

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::                (v2.5.2)

MyApplicationContextInitializer...initialize...
MyApplicationListener...onApplicationEvent...
MySpringApplicationRunListener...contextPrepared...
Starting Springboot09HelloTestApplication
No active profile set, falling back to default profiles: default
MyApplicationListener...onApplicationEvent...
MySpringApplicationRunListener...contextLoaded...
Tomcat initialized with port(s): 8080 (http)
Starting service [Tomcat]
Starting Servlet engine: [Apache Tomcat/9.0.48]
Initializing Spring embedded WebApplicationContext
Root WebApplicationContext: initialization completed in 2013 ms
Tomcat started on port(s): 8080 (http) with context path ''
MyApplicationListener...onApplicationEvent...
MyApplicationListener...onApplicationEvent...
Started Springboot09HelloTestApplication in 3.645 seconds (JVM running for 7.097)
MyApplicationListener...onApplicationEvent...
MyApplicationListener...onApplicationEvent...
MySpringApplicationRunListener...started...
MyApplicationRunner...run
MyCommandLineRunner...run...
MyApplicationListener...onApplicationEvent...
MyApplicationListener...onApplicationEvent...
MySpringApplicationRunListener...running...