SpringBoot的starter到底是什麼?

2022-10-03 06:03:27

前言

我們都知道,Spring的功能非常強大,但也有些弊端。比如:我們需要手動去設定大量的引數,沒有預設值,需要我們管理大量的jar包和它們的依賴。

為了提升Spring專案的開發效率,簡化一些設定,Spring官方引入了SpringBoot。

當然,引入SpringBoot還有其他原因,在這裡就不過多描述了。

本文重點跟大家一起聊聊SpringBootstarter機制,因為它太重要了。

1 為什麼要用starter?

SpringBoot還沒有出來之前,我們使用Spring開發專案。如果程式需要連線資料庫,我們一般會使用HibernateMybatisORM框架,這裡我以Mybatis為例,具體的操作步驟如下:

  1. 到maven倉庫去找需要引入的mybatis jar包,選取合適的版本。
  2. 到maven倉庫去找mybatis-spring整合的jar包,選取合適的版本。
  3. 在spring的applicationContext.xml檔案中設定dataSource和mybatis相關資訊。

當然有些朋友可能會指正,不是還需要引入資料庫驅動包嗎?

確實需要引入,但資料庫驅動有很多,比如:mysql、oracle、sqlserver,這不屬於mybatis的範疇,使用者可以根據專案的實際情況單獨引入。

如果程式只是需要連線資料庫這一個功能還好,按上面的步驟做基本可以滿足需求。但是,連線資料庫可能只是龐大的專案體系中一個環節,實際專案中往往更復雜,需要引入更多的功能,比如:連線redis、連線mongodb、使用rocketmq、使用excel功能等等。

引入這些功能的話,需要再把上面的步驟再重複一次,工作量無形當中增加了不少,而且有很多重複的工作

另外,還是有個問題,每次到要到maven中找合適的版本,如果哪次找的mybatis.jar包 和 mybatis-spring.jar包版本不相容,程式不是會出現問題?

SpringBoot為了解決以上兩個問題引入了starter機制

2 starter有哪些要素?

我們首先一起看看mybatis-spring-boot-starter.jar是如何定義的。


可以看到它的META-INF目錄下只包含了:

  • pom.protperties 設定maven所需的專案version、groupId和artifactId。
  • pom.xml 設定所依賴的jar包。
  • MANIFEST.MF 這個檔案描述了該Jar檔案的很多資訊。
  • spring.provides 設定所依賴的artifactId,給IDE使用的,沒有其他的作用。

注意一下,沒有一行程式碼。

我們重點看一下pom.xml,因為這個jar包裡面除了這個沒有啥重要的資訊

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <parent>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot</artifactId>
    <version>1.3.1</version>
  </parent>
  <artifactId>mybatis-spring-boot-starter</artifactId>
  <name>mybatis-spring-boot-starter</name>
  <dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter</artifactId>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-jdbc</artifactId>
    </dependency>
    <dependency>
      <groupId>org.mybatis.spring.boot</groupId>
      <artifactId>mybatis-spring-boot-autoconfigure</artifactId>
    </dependency>
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
    </dependency>
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
    </dependency>
  </dependencies>
</project>

從上面可以看出,pom.xml檔案中會引入一些jar包,其中除了引入spring-boot-starter,之外重點看一下:mybatis-spring-boot-autoconfigure

我們找到mybatis-spring-boot-autoconfigure.jar檔案,開啟這個檔案。

裡面包含如下檔案:

  • pom.properties 設定maven所需的專案version、groupId和artifactId
  • pom.xml 設定所依賴的jar包
  • additional-spring-configuration-metadata.json 手動新增IDE提示功能
  • MANIFEST.MF 這個檔案描述了該Jar檔案的很多資訊
  • spring.factories SPI會讀取的檔案
  • spring-configuration-metadata.json 系統自動生成的IDE提示功能
  • ConfigurationCustomizer 自定義Configuration回撥介面
  • MybatisAutoConfiguration mybatis設定類
  • MybatisProperties mybatis屬性類
  • SpringBootVFS 掃描巢狀的jar包中的類

spring-configuration-metadata.jsonadditional-spring-configuration-metadata.json的功能差不多,我們在applicationContext.properties檔案中輸入spring時,會自動出現下面的設定資訊可供選擇,就是這個功能了。

來自靈魂的一問:這兩個檔案有什麼區別?

答:如果pom.xml中引入了spring-boot-configuration-processor包,則會自動生成spring-configuration-metadata.json

如果需要手動修改裡面的後設資料,則可以在additional-spring-configuration-metadata.json中編輯,最終兩個檔案中的後設資料會合併到一起。

MybatisProperties類是屬性實體類:

@ConfigurationProperties(prefix = MybatisProperties.MYBATIS_PREFIX)
public class MybatisProperties {

  public static final String MYBATIS_PREFIX = "mybatis";
  private String configLocation;
  private String[] mapperLocations;
  private String typeAliasesPackage;
  private String typeHandlersPackage;
  private boolean checkConfigLocation = false;
  private ExecutorType executorType;
  private Properties configurationProperties;
  @NestedConfigurationProperty
  private Configuration configuration;

  public String getConfigLocation() {
    return this.configLocation;
  }

  public void setConfigLocation(String configLocation) {
    this.configLocation = configLocation;
  }

  @Deprecated
  public String getConfig() {
    return this.configLocation;
  }

  @Deprecated
  public void setConfig(String config) {
    this.configLocation = config;
  }

  public String[] getMapperLocations() {
    return this.mapperLocations;
  }

  public void setMapperLocations(String[] mapperLocations) {
    this.mapperLocations = mapperLocations;
  }
  
  public String getTypeHandlersPackage() {
    return this.typeHandlersPackage;
  }

  public void setTypeHandlersPackage(String typeHandlersPackage) {
    this.typeHandlersPackage = typeHandlersPackage;
  }

  public String getTypeAliasesPackage() {
    return this.typeAliasesPackage;
  }

  public void setTypeAliasesPackage(String typeAliasesPackage) {
    this.typeAliasesPackage = typeAliasesPackage;
  }

  public boolean isCheckConfigLocation() {
    return this.checkConfigLocation;
  }

  public void setCheckConfigLocation(boolean checkConfigLocation) {
    this.checkConfigLocation = checkConfigLocation;
  }

  public ExecutorType getExecutorType() {
    return this.executorType;
  }

  public void setExecutorType(ExecutorType executorType) {
    this.executorType = executorType;
  }

  public Properties getConfigurationProperties() {
    return configurationProperties;
  }

  public void setConfigurationProperties(Properties configurationProperties) {
    this.configurationProperties = configurationProperties;
  }

  public Configuration getConfiguration() {
    return configuration;
  }

  public void setConfiguration(Configuration configuration) {
    this.configuration = configuration;
  }

  public Resource[] resolveMapperLocations() {
    ResourcePatternResolver resourceResolver = new PathMatchingResourcePatternResolver();
    List<Resource> resources = new ArrayList<Resource>();
    if (this.mapperLocations != null) {
      for (String mapperLocation : this.mapperLocations) {
        try {
          Resource[] mappers = resourceResolver.getResources(mapperLocation);
          resources.addAll(Arrays.asList(mappers));
        } catch (IOException e) {
          // ignore
        }
      }
    }
    return resources.toArray(new Resource[resources.size()]);
  }
}

可以看到Mybatis初始化所需要的很多屬性都在這裡,相當於一個JavaBean

下面重點看一下MybatisAutoConfiguration的程式碼:

@org.springframework.context.annotation.Configuration
@ConditionalOnClass({ SqlSessionFactory.class, SqlSessionFactoryBean.class })
@ConditionalOnBean(DataSource.class)
@EnableConfigurationProperties(MybatisProperties.class)
@AutoConfigureAfter(DataSourceAutoConfiguration.class)
public class MybatisAutoConfiguration {

  private static final Logger logger = LoggerFactory.getLogger(MybatisAutoConfiguration.class);
  private final MybatisProperties properties;
  private final Interceptor[] interceptors;
  private final ResourceLoader resourceLoader;
  private final DatabaseIdProvider databaseIdProvider;
  private final List<ConfigurationCustomizer> configurationCustomizers;
  public MybatisAutoConfiguration(MybatisProperties properties,
                                  ObjectProvider<Interceptor[]> interceptorsProvider,
                                  ResourceLoader resourceLoader,
                                  ObjectProvider<DatabaseIdProvider> databaseIdProvider,
                                  ObjectProvider<List<ConfigurationCustomizer>> configurationCustomizersProvider) {
    this.properties = properties;
    this.interceptors = interceptorsProvider.getIfAvailable();
    this.resourceLoader = resourceLoader;
    this.databaseIdProvider = databaseIdProvider.getIfAvailable();
    this.configurationCustomizers = configurationCustomizersProvider.getIfAvailable();
  }

  @PostConstruct
  public void checkConfigFileExists() {
    if (this.properties.isCheckConfigLocation() && StringUtils.hasText(this.properties.getConfigLocation())) {
      Resource resource = this.resourceLoader.getResource(this.properties.getConfigLocation());
      Assert.state(resource.exists(), "Cannot find config location: " + resource
          + " (please add config file or check your Mybatis configuration)");
    }
  }

  @Bean
  @ConditionalOnMissingBean
  public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception {
    SqlSessionFactoryBean factory = new SqlSessionFactoryBean();
    factory.setDataSource(dataSource);
    factory.setVfs(SpringBootVFS.class);
    if (StringUtils.hasText(this.properties.getConfigLocation())) {
      factory.setConfigLocation(this.resourceLoader.getResource(this.properties.getConfigLocation()));
    }
    Configuration configuration = this.properties.getConfiguration();
    if (configuration == null && !StringUtils.hasText(this.properties.getConfigLocation())) {
      configuration = new Configuration();
    }
    if (configuration != null && !CollectionUtils.isEmpty(this.configurationCustomizers)) {
      for (ConfigurationCustomizer customizer : this.configurationCustomizers) {
        customizer.customize(configuration);
      }
    }
    factory.setConfiguration(configuration);
    if (this.properties.getConfigurationProperties() != null) {
      factory.setConfigurationProperties(this.properties.getConfigurationProperties());
    }
    if (!ObjectUtils.isEmpty(this.interceptors)) {
      factory.setPlugins(this.interceptors);
    }
    if (this.databaseIdProvider != null) {
      factory.setDatabaseIdProvider(this.databaseIdProvider);
    }
    if (StringUtils.hasLength(this.properties.getTypeAliasesPackage())) {
      factory.setTypeAliasesPackage(this.properties.getTypeAliasesPackage());
    }
    if (StringUtils.hasLength(this.properties.getTypeHandlersPackage())) {
      factory.setTypeHandlersPackage(this.properties.getTypeHandlersPackage());
    }
    if (!ObjectUtils.isEmpty(this.properties.resolveMapperLocations())) {
      factory.setMapperLocations(this.properties.resolveMapperLocations());
    }

    return factory.getObject();
  }

  @Bean
  @ConditionalOnMissingBean
  public SqlSessionTemplate sqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {
    ExecutorType executorType = this.properties.getExecutorType();
    if (executorType != null) {
      return new SqlSessionTemplate(sqlSessionFactory, executorType);
    } else {
      return new SqlSessionTemplate(sqlSessionFactory);
    }
  }

  public static class AutoConfiguredMapperScannerRegistrar
      implements BeanFactoryAware, ImportBeanDefinitionRegistrar, ResourceLoaderAware {
    private BeanFactory beanFactory;
    private ResourceLoader resourceLoader;

    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {

      ClassPathMapperScanner scanner = new ClassPathMapperScanner(registry);
      try {
        if (this.resourceLoader != null) {
          scanner.setResourceLoader(this.resourceLoader);
        }

        List<String> packages = AutoConfigurationPackages.get(this.beanFactory);
        if (logger.isDebugEnabled()) {
          for (String pkg : packages) {
            logger.debug("Using auto-configuration base package '{}'", pkg);
          }
        }

        scanner.setAnnotationClass(Mapper.class);
        scanner.registerFilters();
        scanner.doScan(StringUtils.toStringArray(packages));
      } catch (IllegalStateException ex) {
        logger.debug("Could not determine auto-configuration package, automatic mapper scanning disabled.", ex);
      }
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
      this.beanFactory = beanFactory;
    }

    @Override
    public void setResourceLoader(ResourceLoader resourceLoader) {
      this.resourceLoader = resourceLoader;
    }
  }

  @org.springframework.context.annotation.Configuration
  @Import({ AutoConfiguredMapperScannerRegistrar.class })
  @ConditionalOnMissingBean(MapperFactoryBean.class)
  public static class MapperScannerRegistrarNotFoundConfiguration {
  
    @PostConstruct
    public void afterPropertiesSet() {
      logger.debug("No {} found.", MapperFactoryBean.class.getName());
    }
  }
}

這個類就是一個Configuration(設定類),它裡面定義很多bean,其中最重要的就是SqlSessionFactory的bean範例,該範例是Mybatis的核心功能,用它建立SqlSession,對資料庫進行CRUD操作。

除此之外,MybatisAutoConfiguration類還包含了:

  • @ConditionalOnClass 設定了只有包含SqlSessionFactory.class和SqlSessionFactoryBean.class,該設定類才生效。
  • @ConditionalOnBean 設定了只有包含dataSource範例時,該設定類才生效。
  • @EnableConfigurationProperties 該註解會自動填充MybatisProperties範例中的屬性。
  • AutoConfigureAfter 設定了該設定類在DataSourceAutoConfiguration類之後自動設定。

這些註解都是一些輔助功能,決定Configuration是否生效,當然這些註解不是必須的。

接下來,重點看看spring.factories檔案有啥內容:

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.mybatis.spring.boot.autoconfigure.MybatisAutoConfiguration

裡面只有一行設定,即keyEnableAutoConfigurationvalueMybatisAutoConfiguration

好了,介紹了這麼多東西,現在我們來總結一下,

starter幾個要素如下圖所示:

那麼,編寫starter需要哪些步驟?

  • 1.需要定義一個名稱為xxx-spring-boot-starter的空專案,裡面不包含任何程式碼,可以有pom.xml和pom.properties檔案。
  • 2.pom.xml檔案中包含了名稱為xxx-spring-boot-autoconfigure的專案。
  • 3.xxx-spring-boot-autoconfigure專案中包含了名稱為xxxAutoConfiguration的類,該類可以定義一些bean範例。當然,Configuration類上可以打一些如:ConditionalOnClass、ConditionalOnBean、EnableConfigurationProperties等註解。
  • 4.需要在spring.factories檔案中增加key為EnableAutoConfiguration,value為xxxAutoConfiguration。

我們試著按照這四步,自己編寫一個starter看看能否成功,驗證一下總結的內容是否正確。

3 如何定義自己的starter?

3.1 先建立一個空專案

該專案名稱為id-generate-starter,注意為了方便我把專案重新命名了,原本應該是叫id-generate-spring-boot-starter的,如下圖所示:

pom.xml檔案定義如下:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <version>1.3.1</version>
    <groupId>com.sue</groupId>
    <artifactId>id-generate-spring-boot-starter</artifactId>
    <name>id-generate-spring-boot-starter</name>
    <dependencies>
        <dependency>
            <groupId>com.sue</groupId>
            <artifactId>id-generate-spring-boot-autoconfigure</artifactId>
            <version>1.3.1</version>
        </dependency>
    </dependencies>
</project>

我們看到,它只引入了id-generate-spring-boot-autoconfigure。當然如果有需要這裡還可以引入多個autoconfigure或者多個其他jar包或者。

3.2 建立id-generate-autoconfigure

同樣為了方便我把專案重新命名了,原本是叫id-generate-spring-boot-autoconfigure,如下圖所示:

該專案當中包含:pom.xml、spring.factories、IdGenerateAutoConfiguration、IdGenerateService 和 IdProperties 這5個關鍵檔案,下面我們逐一看看。

先從pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.4.RELEASE</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <version>1.3.1</version>
    <groupId>com.sue</groupId>
    <artifactId>id-generate-spring-boot-autoconfigure</artifactId>
    <name>id-generate-spring-boot-autoconfigure</name>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-autoconfigure</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

我們可以看到,這個檔案比較簡單就引入了:

  • spring-boot-starter:springboot的相關jar包。
  • spring-boot-autoconfigure:springboot自動設定相關jar包。
  • spring-boot-configuration-processor:springboot生成IDE提示功能相關jar包。

重點看看spring.factories檔案:

org.springframework.boot.autoconfigure.EnableAutoConfiguration=com.sue.IdGenerateAutoConfiguration

它裡面只包含一行設定,其中key是EnableAutoConfiguration,value是IdGenerateAutoConfiguration。

再重點看一下IdGenerateAutoConfiguration

@ConditionalOnClass(IdProperties.class)
@EnableConfigurationProperties(IdProperties.class)
@Configuration
public class IdGenerateAutoConfiguration {
    @Autowired
    private IdProperties properties;
    @Bean
    public IdGenerateService idGenerateService() {
        return new IdGenerateService(properties.getWorkId());
    }
}

該類是一個使用了@Configuration註解標記為了設定類,生效的條件是@ConditionalOnClass註解中檢測到包含IdProperties.class。並且使用@EnableConfigurationProperties註解會自動注入IdProperties的範例。

此外,最關鍵的點是該類裡面建立了idGenerateService的bean範例,這是自動設定的精髓。

再看看IdGenerateService

public class IdGenerateService {
    private Long workId;
    public IdGenerateService(Long workId) {
        this.workId = workId;
    }

    public Long generate() {
        return new Random().nextInt(100) + this.workId;
    }
}

我們可以看到它是一個普通的類,甚至都沒有使用@Service註解,裡面有個generate方法,根據workId的值和亂數動態生成id。

最後看看IdProperties

@ConfigurationProperties(prefix = IdProperties.PREFIX)
public class IdProperties {
    public static final String PREFIX = "sue";
    private Long workId;
    public Long getWorkId() {
        return workId;
    }
    public void setWorkId(Long workId) {
        this.workId = workId;
    }
}

它是一個設定實體類,裡面包含了相關的組態檔。使用@ConfigurationProperties註解,會自動把application.properties檔案中以sue開通的,引數名稱跟IdProperties中一樣的引數值,自動注入到IdProperties物件中。

3.3 建立id-generate-test

這個專案主要用於測試。

該專案裡面包含:pom.xml、application.properties、Application 和 TestRunner 檔案。

先看看pom.xml檔案

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

    <modelVersion>4.0.0</modelVersion>
    <version>1.3.1</version>
    <groupId>com.sue</groupId>
    <artifactId>spring-boot-id-generate-test</artifactId>
    <name>spring-boot-id-generate-test</name>
    <dependencies>
        <dependency>
            <groupId>com.sue</groupId>
            <artifactId>id-generate-spring-boot-starter</artifactId>
            <version>1.3.1</version>
        </dependency>
    </dependencies>
</project>

由於只測試剛剛定義的id生成功能,所以只引入的id-generate-spring-boot-starter jar包。

application.properties設定資原始檔

sue.workId=123

只有一行設定,因為我們的IdProperties中目前只需要這一個引數。

Application是測試程式啟動類

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

很簡單,就是一個普通的springboot啟動類

TestRunner是我們的測試類

@Component
public class TestRunner implements ApplicationRunner {
    @Autowired
    private IdGenerateService idGenerateService;
    public void run(ApplicationArguments args) throws Exception {
        Long sysNo = idGenerateService.generate();
        System.out.println(sysNo);
    }
}

它實現了ApplicationRunner介面,所以在springboot啟動的時候會呼叫該類的run方法。

好了,所有自定義starter的程式碼和測試程式碼都已經就緒。接下,執行一下Application類的main方法。

執行結果:

176

完美,驗證成功了。

接下來,我們分析一下starter的底層實現原理。

4 starter的底層原理是什麼?

通過上面編寫自己的starter的例子,相信大家對starter的認識更進一步了,現在跟大家一起看看starter的底層是如何實現的。

id-generate-starter.jar其實是一個空專案,依賴於id-generate-autoconfiguration.jar。

id-generate-starter.jar是一個入口,我們給他取一個更優雅的名字:門面模式,其他業務系統想引入相應的功能,必須要通過這個門面。

我們重點分析一下 id-generate-autoconfiguration.jar

該jar包核心內容是:IdGenerateConfiguration,這個設定類中建立了IdGenerateService物件,IdGenerateService是我們所需要自動設定的具體功能。

接下來一個最重要的問題:
IdGenerateConfiguration為什麼會自動載入的呢?

還記得我們定義的spring.factories檔案不?

org.springframework.boot.autoconfigure.EnableAutoConfiguration=com.sue.IdGenerateAutoConfiguration

它裡面只包含一行設定,其中keyEnableAutoConfigurationvalueIdGenerateAutoConfiguration

要搞明白這個過程,要從Application類的@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 {

  @AliasFor(annotation = EnableAutoConfiguration.class)
  Class<?>[] exclude() default {};

  @AliasFor(annotation = EnableAutoConfiguration.class)
  String[] excludeName() default {};

  @AliasFor(annotation = ComponentScan.class, attribute = "basePackages")
  String[] scanBasePackages() default {};
  
  @AliasFor(annotation = ComponentScan.class, attribute = "basePackageClasses")
  Class<?>[] scanBasePackageClasses() default {};
}

從上面可以看出該註解裡面包含了@EnableAutoConfiguration註解。

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

@EnableAutoConfiguration註解會引入AutoConfigurationImportSelector類。

該類的selectImports方法一個關鍵方法:

@Override
  public String[] selectImports(AnnotationMetadata annotationMetadata) {
    //設定有沒有設定spring.boot.enableautoconfiguration開關,預設為true
    //如果為false,則不執行自動設定的功能,直接返回
    if (!isEnabled(annotationMetadata)) {
      return NO_IMPORTS;
    }
    //找spring-autoconfigure-metadata.properties中的元素
    AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader
        .loadMetadata(this.beanClassLoader);
    //獲取EnableAutoConfiguration註解中的屬性 
    AnnotationAttributes attributes = getAttributes(annotationMetadata);
    //獲取工程下所有設定key為EnableAutoConfiguration的值,即IdGenerateConfiguration等類。
    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);
    fireAutoConfigurationImportEvents(configurations, exclusions);
    return StringUtils.toStringArray(configurations);
  }

這裡就是starter能夠自動設定的祕密

此外,有些朋友看其他人定義的springboot starter可能會有疑惑。

先看看druid-spring-boot-starter

alibaba定義的druid-spring-boot-starter只有xxx-spring-boot-starter.jar檔案,而沒有xxx-spring-boot-autoconfigure.jar檔案。

再看看spring-boot-starter-jdbc

更神奇的是這個檔案中連pom.xml都沒有,一臉懵逼。。。。。。。

是不是我講錯了?

答:其實沒有。

SpringBoot的原則是約定優於設定

從spring-boot-starter-jdbc內部空實現來看,它的約定是要把xxx-spring-boot-starter.jar和xxx-spring-boot-autoconfigure.jar區分開的。個人認為,alibaba定義得並不好,沒有遵照springboot的約定,雖然功能不受影響。(這個地方歡迎一起探討一下)

而springboot自己定義的spring-boot-starter-jdbc為什麼連pom.xml檔案也沒有呢?

它不需要依賴xxx-spring-boot-autoconfigure.jar檔案嗎?

因為springboot把所有的自動設定的類都統一放到spring-boot-autoconfigure.jar下面了:

spring.factories檔案內容如下:

SpringBoot這樣集中管理自動設定,而不需要從各個子包中遍歷,我個人認為是為了查詢效率。

我們最後再看看spring-cloud-starter-openfegin

明顯看到,它是遵循了我們說的原則的。

除此之外,還有一個原則一順便提一下。

SpringBootSpringCloud系列定義jar包的名稱是:

  • spring-boot-starter-xxx.jar
  • spring-cloud-starter-xxx.jar

而我們自己的專案定義的jar應該是:

  • xxx-spring-boot-starter.jar

最後說一句(求關注,別白嫖我)

如果這篇文章對您有所幫助,或者有所啟發的話,幫忙掃描下發二維條碼關注一下,您的支援是我堅持寫作最大的動力。

求一鍵三連:點贊、轉發、在看。

關注公眾號:【蘇三說技術】,在公眾號中回覆:面試、程式碼神器、開發手冊、時間管理有超讚的粉絲福利,另外回覆:加群,可以跟很多BAT大廠的前輩交流和學習。