Springboot之starter

已于 2023-12-08 21:32:06 修改
阅读量160 收藏
点赞数
分类专栏： spring 文章标签： spring boot java spring
于 2023-11-19 00:11:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cxbtdd/article/details/134485353
版权

springboot之starter

Spring的功能非常强大，但也有些弊端。比如：我们需要手动去配置大量的参数，没有默认值，需要我们管理大量的jar包和它们的依赖。为了提升Spring项目的开发效率，简化一些配置，Spring官方引入了SpringBoot。

1、为什么要用starter？

在SpringBoot还没有出来之前，我们使用Spring开发项目。如果程序需要连接数据库，我们一般会使用Hibernate或Mybatis等ORM框架，这里我以Mybatis为例，具体的操作步骤如下：

到maven仓库去找需要引入的mybatis jar包，选取合适的版本。

到maven仓库去找mybatis-spring整合的jar包，选取合适的版本。

在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目录下只包含了：

1.pom.protperties：配置maven所需的项目version、groupId和artifactId。

2.pom.xml：配置所依赖的jar包。

3.MANIFEST.MF：这个文件描述了该Jar文件的很多信息。

注意一下，没有一行代码。

重点看一下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>2.1.4</version>
  </parent>
  <artifactId>mybatis-spring-boot-starter</artifactId>
  <name>mybatis-spring-boot-starter</name>
  <properties>
    <module.name>org.mybatis.spring.boot.starter</module.name>
  </properties>
  <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.json和additional-spring-configuration-metadata.json的功能差不多，我们在applicationContext.properties文件中输入spring时，会自动出现下面的配置信息可供选择，就是这个功能了。

这两个json文件有什么区别?

答：如果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;

  //省略了getter、setter方法

  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

里面只有一行配置，即key为EnableAutoConfiguration，value为MybatisAutoConfiguration。

总结一下starter的几个要素，如下图所示：

那么，编写starter需要哪些步骤?

1. 创建xxx-spring-boot-autoconfigure项目，其中包含了名称为xxxAutoConfiguration的类，该类可以定义一些bean实例。当然，Configuration类上可以加一些如：ConditionalOnClass、ConditionalOnBean、EnableConfigurationProperties等注解。另外，需要在spring.factories文件中增加key为EnableAutoConfiguration，value为xxxAutoConfiguration的配置。

2. 创建一个名称为xxx-spring-boot-starter的空项目，里面不包含任何代码，可以有pom.xml和pom.properties文件。pom.xml文件中引入名称为xxx-spring-boot-autoconfigure的项目。

3.在需要使用xxx-spring-boot-autoconfigure中代码的项目中通过pom.xml文件引入xxx-spring-boot-starter即可。

按照以上三步编写一个starter看看能否成功，验证一下总结的内容是否正确。

3、如何自定义starter？

3.1、创建autoconfigure模块

创建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.2、创建starter模块

创建一个空项目，该项目名称为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.3、创建依赖模块

创建需要依赖上面autoconfigure模块的其他模块，例如下面的id-generate-test，这个项目主要用于测试。

在该项目的pom.xml文件中引入上面定义的id-generate-spring-boot-starter。

该项目里面包含：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);
    }
}

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包核心内容是：IdGenerateAutoConfiguration，这个配置类中创建了IdGenerateService对象，IdGenerateService是我们所需要自动配置的具体功能。

接下来一个最重要的问题：IdGenerateAutoConfiguration为什么会自动加载的呢？

还记得我们定义的spring.factories文件不？

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

它里面只有一行配置，key是EnableAutoConfiguration，value是IdGenerateAutoConfiguration。

要搞明白这个过程，要从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的值，即IdGenerateAutoConfiguration等类。
    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的原则是约定优于配置。springboot的约定是要把xxx-spring-boot-starter.jar和xxx-spring-boot-autoconfigure.jar区分开的，而alibaba定义的druid-spring-boot-starter只有xxx-spring-boot-starter.jar文件，没有xxx-spring-boot-autoconfigure.jar文件，没有遵照springboot的约定。

下面是springboot定义的spring-boot-starter-jdbc：

springboot自己定义的spring-boot-starter-jdbc为什么连pom.xml文件也没有呢？它不需要依赖xxx-spring-boot-autoconfigure.jar文件吗？

因为springboot把所有的自动配置的类都统一放到spring-boot-autoconfigure.jar下面了：

spring.factories文件内容如下：

SpringBoot这样集中管理自动配置，而不需要从各个子包中遍历，我个人认为是为了查找效率。

最后再看看spring-cloud-starter-openfegin：

明显看到，它是遵循了我们说的原则的。

除此之外，还有一个原则顺便提一下。

SpringBoot和SpringCloud系列定义jar包的名称是:

spring-boot-starter-xxx.jar

spring-cloud-starter-xxx.jar

而我们自己的项目定义的jar应该是：

xxx-spring-boot-starter.jar

倚-天-照-海
关注
专栏目录
mybatis-spring-boot-starter-2.0.0.jar
02-18
mybatis mybatis-spring-boot-starter-2.0.0.jar下载
spring boot(六)：如何优雅的使用mybatis
weixin_33910137的博客
11-07 2104
这两天启动了一个新项目因为项目组成员一直都使用的是mybatis，虽然个人比较喜欢jpa这种极简的模式，但是为了项目保持统一性技术选型还是定了 mybatis。到网上找了一下关于spring boot和mybatis组合的相关资料，各种各样的形式都有，看的人心累，结合了mybatis的官方demo和文档终于找到了最简的两种模式，花了一天时间总结后分享出来。 orm框架的本质是简化...
进阶SpringBoot之 Mybatis 框架
最新发布
m0_58838332的博客
08-21 424
resources 目录下创建 mybatis 包，包下创建 mapper 包，再创建 UserMapper.xml 文件。加注解后包含有参构造、无参构造、get/set 方法、toString() 方法。@Mapper 注解表示这是一个 mybatis 的 mapper 类：Dao。1. 导入包（整合包：mybatis-spring-boot-starter）pojo 包下创建 User 类，与 user 表字段保持一致。也可以通过扫描包的形式，在主程序上方添加注解。
MyBatis-Spring-Boot-Starter
huofuman960209的博客
08-14 2010
MyBatis-Spring-Boot-Starter 可以帮助你更快地在之上构建 MyBatis 应用。构建单体应用程序将几乎不需要样板配置使用更少的 XML 配置。
Spring-boot-Mybatis-Starter
罗兰娇的博客
12-05 1685
简介spring boot mybatis starter是mybatis在spring boot的嵌入。 入门spring boot mybatis starter
spring-boot-starter：MyBatis与Spring Boot的集成
02-23
MyBatis与Spring Boot集成 MyBatis Spring-Boot-Starter将帮助您将MyBatis与Spring Boot结合使用 要求 master（2.1.x）：MyBatis 3.5 +，MyBatis-Spring 2.0+（推荐2.0.4 +），Java 8+和Spring Boot 2.1+ 2.0.x：MyBatis 3.5 +，MyBatis-Spring 2.0 +，Java 8+和Spring Boot 2.0 / 2.1。 1.3.x：MyBatis 3.4 +，MyBatis-Spring 1.3 +，Java 6+和Spring Boot 1.5 必需品 已发布的文件 快照文档 快速开始 错误报告和功能要求 问题
springboot-starter-gemini 一个基于gemini提供的springboot sdk
02-22
《SpringBoot-Starter-Gemini：开启人工智能新篇章》 在当今快速发展的信息技术领域，SpringBoot以其简洁、高效、易用的特性，已经成为Java开发者构建Web应用的首选框架。而SpringBoot-Starter-Gemini，正是在...
SpringBoot之Starter组件手写和启动原理解析
01-20
starter是一种服务（或者叫插件）——使得使用某个功能的开发者不需要关注各种依赖库的处理，不需要具体的配置信息，只需要导入相关maven坐标，由Spring Boot自动通过classpath路径下的类注入需要的Bean，并织入bean...
SpringBoot自定义starter实例代码
08-26
SpringBoot 的强大功能之一是 把常用的场景抽取成了一个个 Starter（场景启动器），我们通过引入 SpringBoot 为我们提供的这些场景启动器，我们再进行少量的配置就能使用相应的功能。但是，SpringBoot 也不能囊括...
my-springboot-starter.zip
04-07
在本压缩包"my-springboot-starter.zip"中，我们有一个自定义的Spring Boot Starter项目，这个Starter是为了帮助开发者更便捷地整合特定功能而设计的。 自定义Spring Boot Starter是Spring Boot生态系统中的一个...
SpringBoot自定义starter
桐花思雨
03-01 1123
目录前言`SpringBoot` 自定义 `starter`创建多模块项目项目编码`custom-spring-boot-starter` 父模块依赖`hello-spring-boot-starter-autoconfigure` 子模块 前言 今天看到了一道面试题，如何实现一个自定义的 SpringBoot starter，或者说，SpringBoot 如何加载我们自己的 jar 包？其实，仔细想想本质是考察 SpringBoot 的自动配置原理，了解了其自动配置原理即可实现 SpringBoot 自定
mybatis-spring-boot-starter-2.1.4.jar
01-10
mybatis-spring-boot-starter-2.1.4.jarmybatis-spring-boot-starter-2.1.4.jar
mybatis-spring-boot-starter-2.0.1.jar
01-10
mybatis-spring-boot-starter-2.0.1.jarmybatis-spring-boot-starter-2.0.1.jarmybatis-spring-boot-starter-2.0.1.jar
MyBatis-Spring-Boot-Starter学习
m0_67391907的博客
08-22 1632
如果您想自定义LanguageDriver通过自动配置创建的，请注册用户定义的 bean。
第三节 mybatis-spring-boot-starter 案例分析
uzong
05-23 1424
tips：可以利用 docker-desktop 快速搭建 MySQL、Redis 等中间件上一章，我们完成了一个自定义 Starter；这一章，我们来看看 Mybatis 是如何使用 Starter，通过学习进一步学习 Starter。
MyBatis-Spring-Boot-Starter 教程
gitblog_00382的博客
08-10 439
MyBatis-Spring-Boot-Starter 教程 spring-boot-starterMyBatis integration with Spring Boot项目地址:https://gitcode.com/gh_mirrors/sp/spring-boot-starter 1. 项目目录结构及介绍 MyBatis-Spring-Boot-Starter 是一个方便地将 MyBat...
mybatis-spring-boot-starter 原理分析
热门推荐
fendo
08-27 1万+
一、前言 mybatis-spring-boot-starter是什么？ mybatis-spring-boot-starter可以帮助你快速创建基于Spring Boot的MyBatis应用程序。 mybatis-spring-boot-starter可以达到什么效果？ ● 构建独立的MyBatis应用程序 ● 零模板 ● 更少的XML配置文件 引入myb...
MyBatis-Spring-Boot-Starter扫盲
若鱼的专栏
04-03 2075
springboot集成mybatis 非常简单，只需要两部： （1）添加依赖： <dependency> <groupId>org.mybatis.spring.boot</groupId> <artifactId>mybatis-spring-boot-starter</artifactId> <vers...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值