谈一谈，Spring Boot 中的 starter 到底是什么 ?

喜欢ヅ旅行 2023-10-13 19:33 52阅读 0赞

1. 为什么要用Starter?

*  现在我们就来回忆一下，在还没有Spring-boot框架的时候，我们使用Spring 开发项目，如果需要某一个框架，例如mybatis，我们的步骤一般都是：
 *  到maven仓库去找需要引入的mybatis jar包，选取合适的版本
 *  到maven仓库去找mybatis-spring整合的jar包，选取合适的版本
 *  在spring的applicationContext.xml文件中配置dataSource和mybatis相关信息
 *  假如所有工作都到位，一般可以完成；但很多时候都会花一堆时间解决jar冲突，配置项缺失，导致怎么都启动不起来等等问题。

所以在2012 年 10 月，一个叫 Mike Youngstrom 的人在 Spring Jira 中创建了一个功能请求，要求在 Spring Framework 中支持无容器 Web 应用程序体系结构，提出了在主容器引导 Spring 容器内配置 Web 容器服务；这件事情对 SpringBoot 的诞生应该说是起到了一定的推动作用。

所以SpringBoot 设计的目标就是简化繁琐配置，快速建立Spring 应用。

*  然后在开发Spring-boot 应用的时候， 经常可以看到我们的pom 文件中引入了spring-boot-starter-web、spring-boot-starter-data-redis、mybatis-spring-boot-starter 这样的依赖，然后几乎不用任何配置就可以使用这些依赖的功能。
 *  下面我们就先来尝试自己开发一个Starter。

### 2. 命名规范 ###

在使用spring-boot-starter，会发现，有的[项目名称][Link 1]是 XX-spring-boot-starter，有的是spring-boot-starter-XX，这个项目的名称有什么讲究呢？从springboot官方文档摘录:

![format_png][]

这段话的大概意思就是，麻烦大家遵守这个命名规范：

**Srping官方命名格式为：spring-boot-starter-\{name\}**

**非Spring官方建议命名格式：\{name\}-spring-boot-starter**

### 3. 开发示例 ###

下面我就以记录日志的一个组件为示例来讲述开发一个starter 的过程。

### 3.1 新建工程 ###

首先新建一个maven 工程,名称定义为jd-log-spring-boot-starter

![4d2e741be39d204834f1e59fb00b0b22.png][]

### 3.2 Pom 引入依赖 ###

<?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.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.13</version>
        <relativePath/> 
      </parent>
      <groupId>com.jd</groupId>
      <artifactId>jd-log-spring-boot-starter</artifactId>
      <version>1.0-SNAPSHOT</version>
      <name>jd-log-spring-boot-starter</name>
      <url>http://www.example.com</url>
      <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
      </properties>
    
    
      <dependencies>
        
        <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-autoconfigure</artifactId>
        </dependency>
        
        <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-configuration-processor</artifactId>
        </dependency>
        
        <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
        <dependency>
          <groupId>org.projectlombok</groupId>
          <artifactId>lombok</artifactId>
        </dependency>
      </dependencies>
      <build>
        <plugins>
          <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-source-plugin</artifactId>
            <version>2.2.1</version>
            <executions>
              <execution>
                <id>attach-sources</id>
                <goals>
                  <goal>jar-no-fork</goal>
                </goals>
              </execution>
            </executions>
          </plugin>
        </plugins>
      </build>
    </project>

这边稍微解释一下这几个依赖:

spring-boot-autoconfigure :提供自动化装配功能，是为了Spring Boot 应用在各个模块提供自动化配置的作用；即加入对应 pom，就会有对应配置其作用；所以我们想要自动装配功能，就需要引入这个依赖。

spring-boot-configuration-processor：将自定义的配置类生成配置[元数据][Link 2]，所以在引用自定义STARTER的工程的YML文件中，给自定义配置初始化时，会有属性名的提示；确保在使用@ConfigurationProperties注解时，可以优雅的读取配置信息，引入该依赖后，IDEA不会出现“spring boot configuration annotation processor not configured”的错误；编译之后会在META-INF 下生成一个spring-configuration-metadata.json 文件，大概内容就是定义的配置的元数据；效果如下截图。

![2912a49a43bb01069af9c5e08ca7056c.png][]

spring-boot-starter-aop ：这个就不用解释了，因为示例是记录日志，我们用到切面的功能，所以需要引入。

### 3.3 定义属性配置 ###

/**
     * @author kongxiangdong2
     * @Title: LogProperties
     * @ProjectName jd-log-spring-boot-starter
     * @Description: TODO
     * @date 2022/9/110:04
     */
    @ConfigurationProperties(prefix = "jd")
    @Data
    public class LogProperties {
    
    
        /**
         * 是否开启日志
         */
        private boolean enable;
    
    
        /**
         * 平台：不同服务使用的区分，默认取 spring.application.name
         */
        @Value("${spring.application.name:#{null}}")
        private String platform;

@ConfigurationProperties：该注解和@Value 注解作用类似，用于获取[配置文件][Link 3]中属性定义并绑定到Java Bean 或者属性中；换句话来说就是将配置文件中的配置封装到JAVA 实体对象，方便使用和管理。

这边我们定义两个属性，一个是是否开启日志的开关，一个是标识平台的名称。

### 3.4 定义自动配置类 ###

/**
     * @author kongxiangdong2
     * @Title: JdLogAutoConfiguration
     * @ProjectName jd-log-spring-boot-starter
     * @Description: TODO
     * @date 2022/9/110:06
     */
    @Configuration
    @ComponentScan("com.jd")
    @ConditionalOnProperty(prefix = "jd",name = "enable",havingValue = "true",matchIfMissing = false)
    @EnableConfigurationProperties({LogProperties.class})
    public class JdLogAutoConfiguration {
    
    
       //
    }

这个类最关键了，它是整个starter 最重要的类，它就是将配置自动装载进spring-boot的；具体是怎么实现的，下面在讲解原理的时候会再详细说说，这里先完成示例。

@Configuration ：这个就是声明这个类是一个配置类

@ConditionalOnProperty：作用是可以指定prefix.name 配置文件中的[属性值][Link 4]来判定configuration是否被注入到Spring,就拿上面代码的来说，会根据配置文件中是否配置jd.enable 来判断是否需要加载JdLogAutoConfiguration 类，如果配置文件中不存在或者配置的是等于false 都不会进行加载，如果配置成true 则会加载；指定了havingValue，要把配置项的值与havingValue对比，一致则加载Bean;配置文件缺少配置，但配置了matchIfMissing = true，加载Bean，否则不加载。

在这里稍微扩展一下经常使用的Condition

<table> 
 <tbody> 
  <tr> 
   <th>注解</th> 
   <th>类型</th> 
   <th>说明</th> 
  </tr> 
  <tr> 
   <td>@ConditionalOnClass</td> 
   <td>Class Conditions类条件注解</td> 
   <td>当前classpath下有指定类才加载</td> 
  </tr> 
  <tr> 
   <td>@ConditionalOnMissingClass</td> 
   <td>Class Conditions类条件注解</td> 
   <td>当前classpath下无指定类才加载</td> 
  </tr> 
  <tr> 
   <td>@ConditionalOnBean</td> 
   <td>Bean ConditionsBean条件注解</td> 
   <td>当期容器内有指定bean才加载</td> 
  </tr> 
  <tr> 
   <td>@ConditionalOnMissingBean</td> 
   <td>Bean ConditionsBean条件注解</td> 
   <td>当期容器内无指定bean才加载</td> 
  </tr> 
  <tr> 
   <td>@ConditionalOnProperty</td> 
   <td>Property Conditions<a href="https://www.zhihu.com/search?q=%E7%8E%AF%E5%A2%83%E5%8F%98%E9%87%8F&amp;search_source=Entity&amp;hybrid_search_source=Entity&amp;hybrid_search_extra=%7B%22sourceType%22%3A%22answer%22%2C%22sourceId%22%3A2827791274%7D" title="环境变量" rel="nofollow">环境变量</a>条件注解（含配置文件）</td> 
   <td>prefix 前缀name 名称havingValue 用于匹配配置项值matchIfMissing 没找指定配置项时的默认值</td> 
  </tr> 
  <tr> 
   <td>@ConditionalOnResource</td> 
   <td>ResourceConditions 资源条件注解</td> 
   <td>有指定资源才加载</td> 
  </tr> 
  <tr> 
   <td>@ConditionalOnWebApplication</td> 
   <td>Web Application Conditionsweb条件注解</td> 
   <td>是web才加载</td> 
  </tr> 
  <tr> 
   <td>@ConditionalOnNotWebApplication</td> 
   <td>Web Application Conditionsweb条件注解</td> 
   <td>不是web才加载</td> 
  </tr> 
  <tr> 
   <td>@ConditionalOnExpression</td> 
   <td>SpEL Expression Conditions</td> 
   <td>符合SpEL 表达式才加载</td> 
  </tr> 
 </tbody> 
</table>

@EnableConfigurationProperties使@ConfigurationProperties 注解的类生效。

### 3.5 配置EnableAutoConfiguration ###

在resources/META-INF/ 目录新建spring.factories 文件，配置内容如下；

org.springframework.boot.autoconfigure.EnableAutoConfiguration=com.jd.JdLogAutoConfiguration

好了，至此自定义Starter 大体框架已经好了，下面就是我们记录日志的功能。

### 3.6 业务功能实现 ###

首先我们先定义一个注解Jdlog

/**
     * @author kongxiangdong2
     * @Title: Jdlog
     * @ProjectName jd-log-spring-boot-starter
     * @Description: TODO
     * @date 2022/9/110:04
     */
    @Target(ElementType.METHOD)
    @Retention(RetentionPolicy.RUNTIME)
    public @interface Jdlog {
    }

定义切面执行逻辑，这边就简单的打印一下配置文件的属性值+目标执行方法+耗时。

import com.jd.annotation.Jdlog;
    import com.jd.config.LogProperties;
    import lombok.AllArgsConstructor;
    import lombok.extern.slf4j.Slf4j;
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.Around;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Pointcut;
    import org.springframework.stereotype.Component;
    
    
    /**
     * @author kongxiangdong2
     * @Title: LogAspectjProcess
     * @ProjectName jd-log-spring-boot-starter
     * @Description: TODO
     * @date 2022/9/111:12
     */
    @Aspect
    @Component
    @Slf4j
    @AllArgsConstructor
    public class LogAspectjProcess {
    
    
        LogProperties logProperties;
    
    
        /**
         * 定义切点
         */
        @Pointcut("@annotation(com.jd.annotation.Jdlog)")
        public void pointCut(){}
    
    
        /**
         * 环绕通知
         *
         * @param thisJoinPoint
         * @param jdlog
         * @return
         */
        @Around("pointCut() && @annotation(jdlog)")
        public Object around(ProceedingJoinPoint thisJoinPoint, Jdlog jdlog){
    
    
            //执行方法名称
            String taskName = thisJoinPoint.getSignature()
                    .toString().substring(
                            thisJoinPoint.getSignature()
                                    .toString().indexOf(" "),
                            thisJoinPoint.getSignature().toString().indexOf("("));
            taskName = taskName.trim();
            long time = System.currentTimeMillis();
            Object result = null;
            try {
                result = thisJoinPoint.proceed();
            } catch (Throwable throwable) {
                throwable.printStackTrace();
            }
            log.info("{} -- method:{} run :{} ms",logProperties.getPlatform(), taskName,
                    (System.currentTimeMillis() - time));
            return result;

整体项目结构就是这样子

![e834b98601d66a53df4a0f8c31ffd8f1.png][]

好了，现在就可以打包编译安装

![format_png 1][]

### 3.7 测试使用 ###

然后就可以在其他项目中引入使用了；下面以一个简单的spring-boot web 项目做个测试，在pom 中引入下面的依赖配置。

<dependency>
          <groupId>com.jd</groupId>
          <artifactId>jd-log-spring-boot-starter</artifactId>
          <version>1.0-SNAPSHOT</version>
        </dependency>

增加一个http 访问的方法，标注上@Jdlog 注解

![97309e187640ba014238a4685943d960.png][]

application.yaml 文件中配置

jd:
      enable: true
      platform: "测试项目"

启动测试

![2f4eae286990ad4d4eda8c9a67e94004.png][]

咋样，自定义的Starter是不是特别的简单啊，快动手试试吧！

上面我们讲的都是怎么去开发一个starter,但是到底为什么要这样，spring-boot 是如何去实现的？是不是还不知道？那下面我们就来说说；

### 4. 原理讲解 ###

我们上面已经看到一个starter,只需要引入到pom 文件中，再配置一下(其实都可以不配置)jd.enable=true，就可以直接使用记录日志的功能了，Spring-boot 是怎么做到的？

在开始的时候说过，Spring-boot 的好处就是可以自动装配。那下面我就来说说自动装配的原理。

相比于传统Spring 应用，我们搭建一个SpringBoot 应用，我们只需要引入一个注解（前提：引入springBoot y依赖）@SpringBootApplication，就可以直接运行；所以我们就从这个注解开始入手，看看这个注解到底做了写什么？

### SpringBootApplication 注解 ###

点开@SpringBootApplication注解可以看到包含了@SpringBootConfiguration,@EnableAutoConfiguration,@ComponentScan三个注解。

![d776451d040ef0c4ae4253740d3ff1a3.png][]

前面的四个注解就不用过多叙述了，是定义注解最基本的，关键在于后面的三个注解:@SpringBootConfiguration，@EnableAutoConfiguration，@ComponentScan,其实也就是说在启动类上如果不使用@SpringBootApplication 这个复合注解，直接使用者三个注解一样可以达到相同的效果。

@SpringBootConfiguration 注解：我们再次点进去看这个注解，其实它就是一个@Configuration 注解。

![1c2dd756cd6aaef2b9ad7587e7ec49f6.png][]

#### @ComponentScan 注解 ####

@ComponentScan 注解：配置包扫描定义的扫描路径，把符合扫描规则的类装配到spring容器

#### @EnableAutoConfiguration 注解 ####

@EnableAutoConfiguration 打开自动装配(自动配置着重来看该注解)

<table> 
 <tbody> 
  <tr> 
   <th>注解</th> 
   <th>作用</th> 
   <th>解释</th> 
  </tr> 
  <tr> 
   <td>@SpringBootConfiguration</td> 
   <td>标记当前类为配置类</td> 
   <td>加上这个注解就是为了让当前类作为一个配置类交由 Spring 的 IOC 容器进行管理，因为前面我们说了，SpringBoot 本质上还是 Spring，所以原属于 Spring 的注解 @Configuration 在 SpringBoot 中也可以直接应用</td> 
  </tr> 
  <tr> 
   <td>@ComponentScan</td> 
   <td>配置包扫描定义的扫描路径，把符合扫描规则的类装配到spring容器</td> 
   <td>用于定义 Spring 的扫描路径，等价于在 xml 文件中配置 context:component-scan，假如不配置扫描路径，那么 Spring 就会默认扫描当前类所在的包及其子包中的所有标注了 @Component，@Service，@Controller 等注解的类。</td> 
  </tr> 
  <tr> 
   <td>@EnableAutoConfiguration</td> 
   <td>打开自动装配</td> 
   <td>下面着重讲解</td> 
  </tr> 
 </tbody> 
</table>

我们再次点击@EnableAutoConfiguration进入查看，它是一个由 @AutoConfigurationPackage 和 @Import 注解组成的复合注解；

![format_png 2][]

首先我们先来看@Import 这个注解，这个是比较关键的一个注解；

在说这个注解之前我们先举个例子，假如我们有一个类Demo,它是一个不在启动配置类目录之下的，也就意味着它不会被扫描到，Spring 也无法感知到它的存在，那么如果需要能将它被扫描到，是不是我们可以通过加@Import 注解来导入Demo 类，类似如下代码

@Configuration
    @Import(Demo.class)
    public class MyConfiguration {
    }

所以，我们可以知道@Import 注解其实就是为了去导入一个类。所以这里@Import(\{AutoConfigurationImportSelector.class\}) 就是为了导入AutoConfigurationImportSelector 类，那我们继续来看这个类，AutoConfigurationImportSelector实现的是`DeferredImportSelector`接口，这是一个延迟导入的类；再细看会有一个方法比较显眼，根据注解元数据来选择导入组件，当注解元数据空，直接返回一个空数组；否则就调用getAutoConfigurationEntry ，方法中会使用AutoConfigurationEntry的getConfigurations(),configurations是一个`List<String>`,那么我们看下AutoConfigurationEntry是怎么生成的。

![5462201f4c0472e0c220894e29343664.png][]

进入到getAutoConfigurationEntry 方法中可以看到主要是getCandidateConfigurations 来获取候选的 Bean，并将其存为一个集合；后续的方法都是在去重，校验等一系列的操作。

![bca94ca0d56bee01d2cb644136f8653e.png][]

我们继续往getCandidateConfigurations 方法里看，最终通过SpringFactoriesLoader.loadFactoryNames来获取最终的configurations，并且可以通过断言发现会使用到META-INF/spring.factories文件，那么我们再进入SpringFactoriesLoader.loadFactoryNames()中来看下最终的实现。

![format_png 3][]

SpringFactoriesLoader.loadFactoryNames()方法会读取META-INF/spring.factories文件下的内容到Map中，再结合传入的factoryType=EnableAutoConfiguration.class,因此会拿到 org.springframework.boot.autoconfigure.EnableAutoConfiguration为key对应的各个XXAutoConfiguration的值，然后springboot在结合各个starter中的代码完成对于XXAutoConfiguration中的Bean的加载动作。

![294178aef8898c232a6aaaea9a9381c2.png][]

![format_png 4][]

这边再扩展一下这个内容，通过 SpringFactoriesLoader 来读取配置文件 spring.factories 中的配置文件的这种方式是一种 SPI 的思想。

#### @AutoConfigurationPackage 注解 ####

进入这个注解看，其实它就是导入了Registrar 这个类

![format_png 5][]

再进入这个类查看，它其实是一个[内部类][Link 5]，看代码的大概意思就是读取到我们在最外层的 @SpringBootApplication 注解中配置的扫描路径（没有配置则默认当前包下），然后把扫描路径下面的Bean注册到容器中；

![format_png 6][]

### 总结 ###

好了，现在我们大概来理一下整个自动装配的流程：

1.  启动类中通过使用@SpringBootApplication实现自动装配的功能；
2.  实际注解@SpringBootApplication是借助注解@EnableAutoConfiguration的功能。
3.  在注解@EnableAutoConfiguration中又有两个注解，@AutoConfigurationPackage，@EnableAutoConfiguration。
4.  通过@AutoConfigurationPackage实现对于当前项目中Bean的进行加载；
5.  @EnableAutoConfiguration通过@Import(\{AutoConfigurationImportSelector.class\})实现对于Pom引入的start中的XXAutoConfiguration的加载；
6.  @AutoConfigurationImportSelector类中通过SpringFactoriesLoader读取 META-INF/spring.factories中key为org.springframework.boot.autoconfigure.EnableAutoConfiguration对应的各个XXAutoConfiguration的值，然后springboot在结合各个start中的代码完成对于XXAutoConfiguration中的Bean的加载动作；

到这里，已经可大致以了解对我们之前开发starter中的定义。

[Link 1]: https://www.zhihu.com/search?q=%E9%A1%B9%E7%9B%AE%E5%90%8D%E7%A7%B0&search_source=Entity&hybrid_search_source=Entity&hybrid_search_extra=%7B%22sourceType%22%3A%22answer%22%2C%22sourceId%22%3A2827791274%7D
[format_png]: https://img-blog.csdnimg.cn/img_convert/c1a944dbe8c0fef334400f9b2b453acb.webp?x-oss-process=image/format,png
[4d2e741be39d204834f1e59fb00b0b22.png]: https://img-blog.csdnimg.cn/img_convert/4d2e741be39d204834f1e59fb00b0b22.png
[Link 2]: https://link.zhihu.com/?target=https%3A//so.csdn.net/so/search%3Fq%3D%25E5%2585%2583%25E6%2595%25B0%25E6%258D%25AE%26spm%3D1001.2101.3001.7020
[2912a49a43bb01069af9c5e08ca7056c.png]: https://img-blog.csdnimg.cn/img_convert/2912a49a43bb01069af9c5e08ca7056c.png
[Link 3]: https://www.zhihu.com/search?q=%E9%85%8D%E7%BD%AE%E6%96%87%E4%BB%B6&search_source=Entity&hybrid_search_source=Entity&hybrid_search_extra=%7B%22sourceType%22%3A%22answer%22%2C%22sourceId%22%3A2827791274%7D
[Link 4]: https://www.zhihu.com/search?q=%E5%B1%9E%E6%80%A7%E5%80%BC&search_source=Entity&hybrid_search_source=Entity&hybrid_search_extra=%7B%22sourceType%22%3A%22answer%22%2C%22sourceId%22%3A2827791274%7D
[e834b98601d66a53df4a0f8c31ffd8f1.png]: https://img-blog.csdnimg.cn/img_convert/e834b98601d66a53df4a0f8c31ffd8f1.png
[format_png 1]: https://img-blog.csdnimg.cn/img_convert/d36704dcc5d74c02246e82109df39913.webp?x-oss-process=image/format,png
[97309e187640ba014238a4685943d960.png]: https://img-blog.csdnimg.cn/img_convert/97309e187640ba014238a4685943d960.png
[2f4eae286990ad4d4eda8c9a67e94004.png]: https://img-blog.csdnimg.cn/img_convert/2f4eae286990ad4d4eda8c9a67e94004.png
[d776451d040ef0c4ae4253740d3ff1a3.png]: https://img-blog.csdnimg.cn/img_convert/d776451d040ef0c4ae4253740d3ff1a3.png
[1c2dd756cd6aaef2b9ad7587e7ec49f6.png]: https://img-blog.csdnimg.cn/img_convert/1c2dd756cd6aaef2b9ad7587e7ec49f6.png
[format_png 2]: https://img-blog.csdnimg.cn/img_convert/ad8edc75893970c3b9d0df3c49c18027.webp?x-oss-process=image/format,png
[5462201f4c0472e0c220894e29343664.png]: https://img-blog.csdnimg.cn/img_convert/5462201f4c0472e0c220894e29343664.png
[bca94ca0d56bee01d2cb644136f8653e.png]: https://img-blog.csdnimg.cn/img_convert/bca94ca0d56bee01d2cb644136f8653e.png
[format_png 3]: https://img-blog.csdnimg.cn/img_convert/b844d428e58ea46c1daa3accfff14304.webp?x-oss-process=image/format,png
[294178aef8898c232a6aaaea9a9381c2.png]: https://img-blog.csdnimg.cn/img_convert/294178aef8898c232a6aaaea9a9381c2.png
[format_png 4]: https://img-blog.csdnimg.cn/img_convert/4e5bc23882fd1f75879002ac7e84da36.webp?x-oss-process=image/format,png
[format_png 5]: https://img-blog.csdnimg.cn/img_convert/aaeea0e84d024eca5f8c7af807925369.webp?x-oss-process=image/format,png
[Link 5]: https://www.zhihu.com/search?q=%E5%86%85%E9%83%A8%E7%B1%BB&search_source=Entity&hybrid_search_source=Entity&hybrid_search_extra=%7B%22sourceType%22%3A%22answer%22%2C%22sourceId%22%3A2827791274%7D
[format_png 6]: https://img-blog.csdnimg.cn/img_convert/a243e901790bddc4d825ab0f4676d9f7.webp?x-oss-process=image/format,png