【springboot 之自定义starter】_springboot自定义starter

1. starter是什么?

在Spring Boot中，Starter是一种用于简化依赖管理和配置的方式。它是一个预定义的依赖关系集合，
包含了一组常用的依赖和配置，以便于快速启动和构建特定类型的应用程序。
Starter通常包含一下组件：
1.自动配置（Auto-configuration）：包含了一组自动配置类，用于根据classpath中的依赖和配置，
自动配置和初始化相关的Bean和组件。
2.条件化配置（Conditional configuration）：通过条件注解（例如@ConditionalOnClass、
@ConditionalOnProperty等）来控制自动配置类的生效条件。
3.配置属性（Configuration properties）：用于定义应用程序的配置属性，可以通过application.properties
或application.yml文件进行配置。
4.启动器依赖（Starter dependencies）：包含了一组常用的依赖，可以通过在项目中引入Starter依赖，自动
导入所需的依赖。

使用Starter可以大大简化项目的依赖管理和配置工作，提供了一种快速启动和构建特定类型应用程序的方式。
例如，Spring Boot提供了spring-boot-starter-web用于快速构建Web应用程序，它包含了常用的Web依赖（如
Spring MVC、Tomcat等）和相关的自动配置。

开发者也可以自定义自己的Starter，将常用的依赖和配置打包为一个Starter，方便在复用和共享。自定义
Starter可以提供一组特定领域的依赖和配置，以满足开发需求。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

2. 为什么使用starter

这就不用说了，引入starter，简单配置就可以使用，方便开箱即用！
1

3. SpringBoot自动配置原理

开发者在pom.xml文件中依赖需要的starter，springboot在启动的时候，会扫描jar包下的spring.factories文件，找到自动配置类信息，加载相应的bean信息并启动相应的默认配置。

3.1 首先看一下springboot特点

• 提供了固定的配置简化配置，即约定大于配置
• 尽可能自动装配库，即能自动装配
• 内嵌容器，创建独立的spring应用
• 内嵌Junit、Springboot Test多种测试框架，方便测试
• 不需要xml配置

3.2 从启动类分析装配原理

@SpringBootApplication
public class SpringbootWorkApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringbootWorkApplication.class, args);
    }
}
1
2
3
4
5
6

@SpringBootApplication

这是一个组合注解，主要包含了
	@SpringBootConfiguration(里面就是@Configuration)
	@EnableAutoConfiguration(开启自动配置)
	@ComponentScan(包扫描)
1
2
3
4

点 @SpringBootConfiguration

里面主要包含了@Configuration注解，表明这是一个配置类，可以向容器中注入组件
1

点@ComponentScan进去

可以`basePackeageClasses` 或`basePackages`来定义要扫描的特定包。如果没有定义特定的包，将从声明该
注解的类的包开始扫描(包含子包)
1
2

点@EnableAutoConfiguration

@EnableAutoConfiguration说人话 就是：开启自动导入配置
这个注解是重点，下面继续讨论
1
2

3.3 @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 {};
}
1
2
3
4
5
6
7
8
9
10
11
12
13

3.3.1 @AutoConfigurationPackage

自动导入配置包
点进去查看
1
2

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Import({Registrar.class})
public @interface AutoConfigurationPackage {
    String[] basePackages() default {};

    Class<?>[] basePackageClasses() default {};
}
1
2
3
4
5
6
7
8
9
10

@Import为spring的注解，导入一个配置文件，在springboot中为容器导入一个组件，而导入的组件由AutoConfigurationPackages.class的内部类Registrar.class执行逻辑来决定是如何导入的。

@Import({Registrar.class})

点Registrar.class进去查看源码如下

static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {
    Registrar() {
    }

    public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) 
    {
        //断点
        AutoConfigurationPackages.register(registry, 
        (String[])(new AutoConfigurationPackages.PackageImports(metadata))
        .getPackageNames().toArray(new String[0]));
    }

    public Set<Object> determineImports(AnnotationMetadata metadata) {
        return Collections.singleton(new AutoConfigurationPackages.PackageImports(metadata));
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

说明：

ImportBeanDefinitionRegistrar是Spring框架提供的一个接口，用于动态注册BeanDefinition到Spring容器中
,具体来说，ImportBeanDefinitionRegistrar接口有一个registerBeanDefinitions方法，该方法会在Spring容器
启动时被调用。在该方法中，我们可以通过BeanDefinitionRegistry接口向Spring容器注册BeanDefinition，从
而实现动态注册Bean。
通常情况下，ImportBeanDefinitionRegistrar会与@Import注解一起使用。通过@Import注解引入
ImportBeanDefinitionRegistrar的实现类，从而实现BeanDefinition的动态注册。
1
2
3
4
5
6

总结：
        @AutoConfigurationPackage 就是将主配置类（@SpringBootApplication 标注的类）所在的包下面所有的组件都扫描注冊到 spring 容器中。

3.3.2 @Import({AutoConfigurationImportSelector.class})

作用: AutoConfigurationImportSelector开启自动配置类的导包的选择器，即是带入哪些类，有选择性的导入

点AutoConfigurationSelector.class进入源码
1、selectImports：选择需要导入的组件

public String[] selectImports(AnnotationMetadata annotationMetadata) {
    if (!this.isEnabled(annotationMetadata)) {
        return NO_IMPORTS;
    } else {
        AutoConfigurationImportSelector.AutoConfigurationEntry autoConfigurationEntry = this.getAutoConfigurationEntry(annotationMetadata);
        return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
    }
}
1
2
3
4
5
6
7
8

2、getAutoConfigurationEntry

根据导入的@Configuration类的AnnotationMetadata返回AutoConfigurationImportSelector
.AutoConfigurationEntry
1
2

protected AutoConfigurationImportSelector.AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
    if (!this.isEnabled(annotationMetadata)) {
        return EMPTY_ENTRY;
    } else {
        AnnotationAttributes attributes = this.getAttributes(annotationMetadata);
         // 这打个断点，看看 返回的数据
        List<String> configurations = this.getCandidateConfigurations(annotationMetadata, attributes);
        //删除重复项
        configurations = this.removeDuplicates(configurations);
        Set<String> exclusions = this.getExclusions(annotationMetadata, attributes);
        //检查
        this.checkExcludedClasses(configurations, exclusions);
        //删除需要排除的依赖
        configurations.removeAll(exclusions);
        configurations = this.getConfigurationClassFilter().filter(configurations);
        this.fireAutoConfigurationImportEvents(configurations, exclusions);
        return new AutoConfigurationImportSelector.AutoConfigurationEntry(configurations, exclusions);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

this.getCandidateConfigurations(annotationMetadata, attributes) 这里断点查看

configurations数组长度为133，并且文件后缀名都为 **AutoConfiguration

结论： 这些都是候选的配置类，经过去重，去除需要的排除的依赖，最终的组件才是这个环境需要的所有组件。有了自动配置，就不需要我们自己手写配置的值了，配置类有默##认值的。

继续看如何返回需要配置的组件的

getCandidateConfigurations(annotationMetadata, attributes)

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

这里有句断言： 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.”);
意思是：“在 META-INF/spring.factories 中没有找到自动配置类。如果您使用自定义包装，请确保该文件是正确的。“
结论： 即是要loadFactoryNames() 方法要找到自动的配置类返回才不会报错。

getSpringFactoriesLoaderFactoryClass()

我们点进去发现：this.getSpringFactoriesLoaderFactoryClass()返回的是EnableAutoConfiguration.class这个注解。这个注解和@SpringBootApplication下标识注解是同一个注解。

protected Class<?> getSpringFactoriesLoaderFactoryClass() {
    return EnableAutoConfiguration.class;
}
1
2
3

结论: 获取一个能加载自动配置类的类，即SpringBoot默认自动配置类为EnableAutoConfiguration

SpringFactoriesLoader

SpringFactoriesLoader工厂加载机制是Spring内部提供的一个约定俗成的加载方式，只需要在模块的META-INF/spring.factories文件，这个Properties格式的文件中的key是接口、注解、或抽象类的全名，value是以逗号 “ , “ 分隔的实现类，使用SpringFactoriesLoader来实现相应的实现类注入Spirng容器中。

注：会加载所有jar包下的classpath路径下的META-INF/spring.factories文件，这样文件不止一个。

loadFactoryNames()

public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
   ClassLoader classLoaderToUse = classLoader;
   if (classLoaderToUse == null) {
      classLoaderToUse = SpringFactoriesLoader.class.getClassLoader();
   }
   String factoryTypeName = factoryType.getName();
   return loadSpringFactories(classLoaderToUse).getOrDefault(factoryTypeName, Collections.emptyList());
}
1
2
3
4
5
6
7
8

断点查看factoryTypeName：

先将EnableAutoConfiguration.class传给了factoryType，然后String factoryTypeName = factoryType.getName();所以factoryTypeName 值为 org.springframework.boot.autoconfigure.EnableAutoConfiguration

loadSpringFactories()

接着查看loadSpringFactories方法的引用

private static Map<String, List<String>> loadSpringFactories(ClassLoader classLoader) {
    //断点查看
   Map<String, List<String>> result = cache.get(classLoader);
   if (result != null) {
      return result;
   }

   result = new HashMap<>();
   try {
      //注意这里：META-INF/spring.factories
      Enumeration<URL> urls = classLoader.getResources(FACTORIES_RESOURCE_LOCATION);
      while (urls.hasMoreElements()) {
         URL url = urls.nextElement();
         UrlResource resource = new UrlResource(url);
         Properties properties = PropertiesLoaderUtils.loadProperties(resource);
         for (Map.Entry<?, ?> entry : properties.entrySet()) {
            String factoryTypeName = ((String) entry.getKey()).trim();
            String[] factoryImplementationNames =
                  StringUtils.commaDelimitedListToStringArray((String) entry.getValue());
            for (String factoryImplementationName : factoryImplementationNames) {
            //断点
               result.computeIfAbsent(factoryTypeName, key -> new ArrayList<>())
                     .add(factoryImplementationName.trim());
            }
         }
      }

      // Replace all lists with unmodifiable lists containing unique elements
      //去重，断点查看result值
      result.replaceAll((factoryType, implementations) -> implementations.stream().distinct()
            .collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList)));
      cache.put(classLoader, result);
   }
   catch (IOException ex) {
      throw new IllegalArgumentException("Unable to load factories from location [" +
            FACTORIES_RESOURCE_LOCATION + "]", ex);
   }
   return result;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

这里的 FACTORIES_RESOURCE_LOCATION 在上面有定义：META-INF/spring.factories

public final class SpringFactoriesLoader {

   /**
    * The location to look for factories.
    * <p>Can be present in multiple JAR files.
    */
   public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";
1
2
3
4
5
6
7

META-INF/spring.factories文件在哪里？？ 在所有引入的java包的当前类路径下的META-INF/spring.factories文件都会被读取，如：

断点查看result值如下：

该方法作用是加载所有依赖的路径META-INF/spring.factories文件，通过map结构保存，key为文件中定义的一些标识工厂类，value就是能自动配置的一些工厂实现的类，value用list保存并去重。

在回看 loadSpringFactories(classLoaderToUse).getOrDefault(factoryTypeName, Collections.emptyList());
因为 loadFactoryNames 方法携带过来的第一个参数为 EnableAutoConfiguration.class，所以 factoryType 值也为 EnableAutoConfiguration.class，那么 factoryTypeName 值为 EnableAutoConfiguration。拿到的值就是META-INF/spring.factories文件下的key为
org.springframework.boot.autoconfigure.EnableAutoConfiguration的值

getOrDefault 当 Map 集合中有这个 key 时，就使用这个 key值，如果没有就使用默认值空数组.
结论:

• loadSpringFactories()该方法就是从“META-INF/spring.factories”中加载给定类型的工厂实现的完全限定类名放到map中
• loadFactoryNames()是根据SpringBoot的启动生命流程，当需要加载自动配置类时，就会传入org.springframework.boot.autoconfigure.EnableAutoConfiguration参数，从map中查找key为org.springframework.boot.autoconfigure.EnableAutoConfiguration的值，这些值通过反射加到容器中，之后的作用就是用它们来做自动配置，这就是Springboot自动配置开始的地方
• 只有这些自动配置类进入到容器中以后，接下来这个自动配置类才开始进行启动
• 当需要其他的配置时如监听相关配置：listenter，就传不同的参数，获取相关的listenter配置

3.4 流程图总结：

3.5 常用的Condition注解

• 在加载自动配置类的时候，并不是将spring.factories的配置全部加载进来，而是通过@Conditional等注解的判断进行动态加载
• @Conditional其实是spring底层注解，意思就是根据不同的条件，来进行自己不同的条件判断，如果满足指定的条件，那么配置类里边的配置才会生效。
• 常用的Conditional注解：
  • @ConditionalOnClass ： classp ath中存在该类时起效
  • @ConditionalOnMissingClass ： classpath中不存在该类时起效
  • @ConditionalOnBean ： DI容器中存在该类型Bean时起效
  • @ConditionalOnMissingBean ： DI容器中不存在该类型Bean时起效
  • @ConditionalOnSingleCandidate ： DI容器中该类型Bean只有一个或 @Primary的只有一个时起效
  • @ConditionalOnExpression ： SpEL表达式结果为true时
  • @ConditionalOnProperty ： 参数设置或者值一致时起效
  • @ConditionalOnResource ： 指定的文件存在时起效
  • @ConditionalOnJndi ： 指定的JNDI存在时起效
  • @ConditionalOnJava ： 指定的Java版本存在时起效
  • @ConditionalOnWebApplication ： Web应用环境下起效
  • @ConditionalOnNotWebApplication ： 非Web应用环境下起效

3.6 @Import支持导入的三种方式

1. 带有@Configuration的配置类
2. ImportSelector 的实现
3. ImportBeanDefinitionRegistrar 的实现

4. spring.factories

Spring Boot会默认扫描跟启动类平级的包，如果我们的Starter跟启动类不在同一个主包下，需要通过配置spring.factories文件来配置生效，SpringBoot默认加载各个jar包下classpath路径的spring.factories文件，配置的key为org.springframework.boot.autoconfigure.EnableAutoConfiguration

5.starter开发常用注解

注解配置大大简化了开发，我们不在用写xml配置文件了，SpringBoot经过查找spring.factories文件，加载自动配置类，而自动配置类中定义了各种运行时判断条件，如@ConditionOnMissingBean(A.class)等，只要ioc容器中没有指定的A类型的bean信息，该配置文件才会生效。
@Condition是Spring4新提供的注解，它的作用是按照一定的条件进行判断，满足条件给容器注册bean。

• 属性映射注解：
  • @ConfigurationProperties: 配置文件属性值和实体类的映射
  • @EnableConfigurationProperties： 和@ConfigurationProperties配合使用，把@ConfigurtionProperties修饰的类加入ioc容器
• 配置bean注解
  • @Configuration: 标识该类为配置类，并把该类注入ioc容器
  • @Bean: 一般放在方法上，声明一个bean，bean名称默认是方法名称，类型为返回值
• 条件注解
  • @Conditional: 根据条件类创建特定的Bean，条件类需要实现Condition接口，并重写matches接口来构造判断条件
  • @ConditionalOnBean: 容器中存在指定bean，才会实例化一个Bean
  • @ConditionalOnMissingBean：容器中不存在指定bean，才会实例化一个Bean
  • @ConditionalOnClass：系统中有指定类，才会实例化一个Bean
  • @ConditionalOnMissingClass：系统中没有指定类，才会实例化一个Bean
  • @ConditionalOnExpression：当SpEl表达式为true的时候，才会实例化一个Bean
  • @AutoConfigureAfter ：在某个bean完成自动配置后实例化这个bean
  • @AutoConfigureBefore ：在某个bean完成自动配置前实例化这个bean
  • @ConditionalOnJava ：系统中版本是否符合要求
  • @ConditionalOnSingleCandidate：当指定的Bean在容器中只有一个，或者有多个但是指定了首选的Bean时触发实例化
  • @ConditionalOnResource：类路径下是否存在指定资源文件
  • @ConditionalOnWebApplication：是web应用
  • @ConditionalOnNotWebApplication：不是web应用
  • @ConditionalOnJndi：JNDI指定存在项
  • @ConditionalOnProperty： 配置Configuration的加载规则
    • prefix ：配置属性名称的前缀
    • value ：数组，获取对应property名称的值，与name不可同时使用
    • name ：数组，可与prefix组合使用，组成完整的配置属性名称，与value不可同时使用
    • havingValue ：比较获取到的属性值与havingValue给定的值是否相同，相同才加载配置
    • matchIfMissing ：缺少该配置属性时是否可以加载。如果为true，没有该配置属性时也会正常加 载；反之则不会生效

6.Full模式和Lite模式

当Configuration参数proxyBeanMethods分为如下两种情况:
Full模式：@Configuration(proxyBeanMethods = true)
Lite模式: @Configuration(proxyBeanMethods = false)

@Configuration(proxyBeanMethods = false)
public class AppConfig {
    
    //放一份myBean到ioc容器
    @Bean
    public Mybean myBean() {
        return new Mybean();
    }
 
    //放一份yourBean到ioc容器
    @Bean
    public YourBean yourBean() {
        System.out.println("==========");
        //注意：@Configuration(proxyBeanMethods = false)：myBean()方法不代理，直接调用
        //注意：@Configuration(proxyBeanMethods = true)：myBean()方法代理，从ioc容器拿
        return new YourBean(myBean());
    }
}
// 注：proxyBeanMethods 是为了让使用@Bean注解的方法被代理。而不是@Bean的单例多例的设置参数。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

• 什么时候用Full全模式，什么时候用Lite轻量级模式？

1. 当在你的同一个Configuration配置类中，注入到容器中的bean实例之间有依赖关系时，建议使用Full全模式
2. 当在你的同一个Configuration配置类中，注入到容器中的bean实例之间没有依赖关系时，建议使用Lite轻量
级模式，以提高springboot的启动速度和性能
1
2
3

7.starter的命名规范

• Spring官方Starter通常命名为spring-boot-starter-{name}如：spring-boot-starter-web
• Spring官方建议非官方Starter命名应遵循{name}-spring-boot-starter的格式：如mybatis-spring-boot-starter。

8. 自定义自己的starter流程

8.1 创建starter项目

注意：新建项目后，需要删除main启动类。

8.2 添加依赖

8.3 编写属性类

8.4 自定义业务类

8.5 编写自动配置类

8.6 编写spring.factories

8.7 编写配置提示文件(非必须)

9. 测试starter