/**
 * @author :breakpoint/赵立刚
 * @date : 2020/08/03
 */
@EnableAsync // 开启是否支持异步的操作
@SpringBootApplication // 声明当前的应用是SpringBoot的应用
public class StartMain {
    public static void main(String[] args) {
        SpringApplication.run(StartMain.class, args);
    }
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration // SpringBoot的配置 与 @Configuration的作用类似，都是可以自动发现配置的
@EnableAutoConfiguration // 开启自动的装配的功能个
@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
    @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
// 上面的 @ComponentScan 是包扫描方案，扫描哪些包
public @interface SpringBootApplication {

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage //
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Import(AutoConfigurationPackages.Registrar.class)
public @interface AutoConfigurationPackage {
}

// org.springframework.boot.autoconfigure.AutoConfigurationImportSelector#selectImports
@Override
  public String[] selectImports(AnnotationMetadata annotationMetadata) {
    if (!isEnabled(annotationMetadata)) {
      return NO_IMPORTS;
    }
    // 家在自动配置的属性
    AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader
        .loadMetadata(this.beanClassLoader);
    // 获取到自己配置的相关信息，这里面也返回了我们需要自动配置的类的信息
    AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(autoConfigurationMetadata,
        annotationMetadata);
    return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
  }

protected AutoConfigurationEntry getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata,
      AnnotationMetadata annotationMetadata) {
    if (!isEnabled(annotationMetadata)) {
      return EMPTY_ENTRY;
    }
  // 获取到注解的属性信息
    AnnotationAttributes attributes = getAttributes(annotationMetadata);
  // 获取到候选的配置信息，这一步也就是加载了所有的自动配置的信息，一会主要分析的就是这个方法
    List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
  // 去除掉重复的配置信息
    configurations = removeDuplicates(configurations);
  // 根据以前的配置，获取到所有需要排除的信息
    Set<String> exclusions = getExclusions(annotationMetadata, attributes);
  // 校验需要排除的配置类的信息
    checkExcludedClasses(configurations, exclusions);
  // 执行移除的操作
    configurations.removeAll(exclusions);
  // 过滤一下配置的信息与获取到的后信息是否有问题
    configurations = filter(configurations, autoConfigurationMetadata);
  // 首先获取到所有的配置的监听器，之后配置listener.onAutoConfigurationImportEvent(event);
    fireAutoConfigurationImportEvents(configurations, exclusions);
  //返回操作的对象
    return new AutoConfigurationEntry(configurations, exclusions);
  }

protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
  // 显然，和我们以前分析的一样，都是从META-INF/spring.factories获取到所有的EnableAutoConfiguration的组件并且进行返回。
    List<String> configurations = SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(),
        getBeanClassLoader());
  // 判断是否为空，默认肯定不是空的，因为spring-boot-autoconfigure-2.2.2.RELEASE.jar已经为我们配置了一些主要的的自动配置类。
    Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories. If you "
        + "are using a custom packaging, make sure that file is correct.");
    return configurations;
  }

# Auto Configure
# 可以看到一些自动配置的信息
# 全类名=自动配置类的集合
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration,\
org.springframework.boot.autoconfigure.batch.BatchAutoConfiguration,\
org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration,\
org.springframework.boot.autoconfigure.cassandra.CassandraAutoConfiguration,\
org.springframework.boot.autoconfigure.cloud.CloudServiceConnectorsAutoConfiguration,\
org.springframework.boot.autoconfigure.context.ConfigurationPropertiesAutoConfiguration,\
org.springframework.boot.autoconfigure.context.MessageSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration,\
...

// 说明当前是一个配置类
@Configuration(proxyBeanMethods = false)
// 判断当前是否配置了 spring.aop 的相关的配置
@ConditionalOnProperty(prefix = "spring.aop", name = "auto", havingValue = "true", matchIfMissing = true)
public class AopAutoConfiguration {
  @Configuration(proxyBeanMethods = false)
  // 当 Advice 存在的是欧，这个配置是生效的
  @ConditionalOnClass(Advice.class)
  static class AspectJAutoProxyingConfiguration {
    @Configuration(proxyBeanMethods = false)
    @EnableAspectJAutoProxy(proxyTargetClass = false)
    @ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "false",
        matchIfMissing = false)
    static class JdkDynamicAutoProxyConfiguration {
    }
    @Configuration(proxyBeanMethods = false)
    @EnableAspectJAutoProxy(proxyTargetClass = true)
    @ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "true",
        matchIfMissing = true)
    static class CglibAutoProxyConfiguration {
    }
  }
  @Configuration(proxyBeanMethods = false)
  // 不存在 org.aspectj.weaver.Advice这个类，是生效的
  @ConditionalOnMissingClass("org.aspectj.weaver.Advice")
  @ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "true",
      matchIfMissing = true)
  static class ClassProxyingConfiguration {
    ClassProxyingConfiguration(BeanFactory beanFactory) {
      if (beanFactory instanceof BeanDefinitionRegistry) {
        BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
        AopConfigUtils.registerAutoProxyCreatorIfNecessary(registry);
        AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
      }
    }
  }
}