今天跟大家來探討下SpringBoot的核心注解@SpringBootApplication以及run方法，理解下springBoot為什么不需要XML，達到零配置

首先我們先來看段代碼

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

我們點進@SpringBootApplication來看

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

}

上面的元注解我們在這里不在做解釋，相信大家在開發當中肯定知道，我們要來說@SpringBootConfiguration @EnableAutoConfiguration 這兩個注解,到這里我們知道 SpringBootApplication注解里除了元注解，我們可以看到又是@SpringBootConfiguration，@EnableAutoConfiguration，@ComponentScan的組合注解，官網上也有詳細說明，那我們現在把目光投向這三個注解。

首先我們先來看 @SpringBootConfiguration，那我們點進來看

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

}

我們可以看到這個注解除了元注解以外，就只有一個@Configuration，那也就是說這個注解相當于@Configuration，所以這兩個注解作用是一樣的，那他是干嘛的呢，相信很多人都知道，它是讓我們能夠去注冊一些額外的Bean，并且導入一些額外的配置。那@Configuration還有一個作用就是把該類變成一個配置類，不需要額外的XML進行配置。所以@SpringBootConfiguration就相當于@Configuration。

那我們繼續來看下一個@EnableAutoConfiguration，這個注解官網說是 讓Spring自動去進行一些配置，那我們點進來看

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

可以看到它是由 @AutoConfigurationPackage，@Import(EnableAutoConfigurationImportSelector.class)這兩個而組成的，我們先說@AutoConfigurationPackage，他是說：讓包中的類以及子包中的類能夠被自動掃描到spring容器中。 我們來看@Import(EnableAutoConfigurationImportSelector.class)這個是核心，之前我們說自動配置，那他到底幫我們配置了什么，怎么配置的？

就和@Import(EnableAutoConfigurationImportSelector.class)息息相關，程序中默認使用的類就自動幫我們找到。我們來看EnableAutoConfigurationImportSelector.class

public class EnableAutoConfigurationImportSelector
      extends AutoConfigurationImportSelector {

   @Override
   protected boolean isEnabled(AnnotationMetadata metadata) {
      if (getClass().equals(EnableAutoConfigurationImportSelector.class)) {
         return getEnvironment().getProperty(
               EnableAutoConfiguration.ENABLED_OVERRIDE_PROPERTY, Boolean.class,
               true);
      }
      return true;
   }

}

可以看到他繼承了AutoConfigurationImportSelector我們繼續來看AutoConfigurationImportSelector，這個類有一個方法

public String[] selectImports(AnnotationMetadata annotationMetadata) {
   if (!isEnabled(annotationMetadata)) {
      return NO_IMPORTS;
   }
   try {
      AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader
            .loadMetadata(this.beanClassLoader);
      AnnotationAttributes attributes = getAttributes(annotationMetadata);
      List

這個類會幫你掃描那些類自動去添加到程序當中。我們可以看到getCandidateConfigurations()這個方法，他的作用就是引入系統已經加載好的一些類，到底是那些類呢，我們點進去看一下

protected List<String> getCandidateConfigurations(AnnotationMetadata metadata,
      AnnotationAttributes attributes) {
   List<String> configurations = SpringFactoriesLoader.loadFactoryNames(
         getSpringFactoriesLoaderFactoryClass(), getBeanClassLoader());
   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;
}

這個類回去尋找的一個目錄為META-INF/spring.factories，也就是說他幫你加載讓你去使用也就是在這個META-INF/spring.factories目錄裝配的，他在哪里？

我們點進spring.factories來看

我們可以發現幫我們配置了很多類的全路徑，比如你想整合activemq，或者說Servlet

可以看到他都已經幫我們引入了進來，我看隨便拿幾個來看

org.springframework.boot.autoconfigure.security.SecurityAutoConfiguration,\\
org.springframework.boot.autoconfigure.security.SecurityFilterAutoConfiguration,\\
org.springframework.boot.autoconfigure.security.FallbackWebSecurityAutoConfiguration,\\
org.springframework.boot.autoconfigure.security.oauth2.OAuth2AutoConfiguration,\\

比如我們經常用的security，可以看到已經幫你配置好，所以我們的EnableAutoConfiguration主要作用就是讓你自動去配置，但并不是所有都是創建好的，是根據你程序去進行決定。 那我們繼續來看

@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, 
classes = TypeExcludeFilter.class), @Filter(type = FilterType.CUSTOM, 
classes = AutoConfigurationExcludeFilter.class) })

這個注解大家應該都不陌生，掃描包，放入spring容器，那他在springboot當中做了什么策略呢？我們可以點跟煙去思考，幫我們做了一個排除策略，他在這里結合SpringBootConfiguration去使用，為什么是排除，因為不可能一上來全部加載，因為內存有限。

那么我們來總結下@SpringbootApplication：就是說，他已經把很多東西準備好，具體是否使用取決于我們的程序或者說配置，那我們到底用不用？那我們繼續來看一行代碼

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

那們來看下在執行run方法到底有沒有用到哪些自動配置的東西，比如說內置的Tomcat，那我們來找找內置Tomcat，我們點進run

public static ConfigurableApplicationContext run(Object[] sources, String[] args) {
        return new SpringApplication(sources).run(args);
    }

然后他調用又一個run方法，我們點進來看

public ConfigurableApplicationContext run(String... args) {
   //計時器
   StopWatch stopWatch = new StopWatch();
   stopWatch.start();
   ConfigurableApplicationContext context = null;
   FailureAnalyzers analyzers = null;
   configureHeadlessProperty();
   //監聽器
   SpringApplicationRunListeners listeners = getRunListeners(args);
   listeners.starting();
   try {
      ApplicationArguments applicationArguments = new DefaultApplicationArguments(
            args);
      ConfigurableEnvironment environment = prepareEnvironment(listeners,
            applicationArguments);
      Banner printedBanner = printBanner(environment);
      //準備上下文
      context = createApplicationContext();
      analyzers = new FailureAnalyzers(context);
         //預刷新context
      prepareContext(context, environment, listeners, applicationArguments,
            printedBanner);
     //刷新context
      refreshContext(context);
     //刷新之后的context
      afterRefresh(context, applicationArguments);
      listeners.finished(context, null);
      stopWatch.stop();
      if (this.logStartupInfo) {
         new StartupInfoLogger(this.mainApplicationClass)
               .logStarted(getApplicationLog(), stopWatch);
      }
      return context;
   }
   catch (Throwable ex) {
      handleRunFailure(context, listeners, analyzers, ex);
      throw new IllegalStateException(ex);
   }
}

那我們關注的就是 refreshContext(context); 刷新context，我們點進來看

private void refreshContext(ConfigurableApplicationContext context) {
   refresh(context);
   if (this.registerShutdownHook) {
      try {
         context.registerShutdownHook();
      }
      catch (AccessControlException ex) {
         // Not allowed in some environments.
      }
   }
}

我們繼續點進refresh(context);

protected void refresh(ApplicationContext applicationContext) {
   Assert.isInstanceOf(AbstractApplicationContext.class, applicationContext);
   ((AbstractApplicationContext) applicationContext).refresh();
}