一、什么是SpringBoot Starter

在SpringBoot生态中，starter是一种特殊的依赖，它能够自动装配相关组件，简化项目配置。

官方提供了众多starter，如spring-boot-starter-web、spring-boot-starter-data-jpa等，但在实际业务中，我们常常需要开发自己的starter来封装通用功能，实现一次开发，多处复用。

自定义starter的核心价值在于：

• 封装复杂的配置逻辑，实现开箱即用 • 统一技术组件的使用规范，避免”轮子”泛滥 • 提高开发效率，减少重复代码 本文将详细介绍6种不同的自定义starter开发方法。

二、方法一：基础配置类方式

这是最简单的starter开发方法，通过创建一个包含@Configuration注解的配置类，使用@Bean方法定义需要注入的组件。

实现步骤 1. 创建Maven项目：命名遵循xxx-spring-boot-starter格式 2. 添加依赖：

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
</dependencies>

1. 创建配置类：

   @Configuration
   public class SimpleServiceAutoConfiguration {
       
   @Bean
   public SimpleService simpleService() {
       return new SimpleServiceImpl();
   }
   }
   

2. 创建自动配置文件：在resources/META-INF/spring.factories中添加：

   org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
   com.example.SimpleServiceAutoConfiguration
   

使用方式

使用时只需要在项目中添加依赖：

<dependency>
    <groupId>com.example</groupId>
    <artifactId>simple-spring-boot-starter</artifactId>
    <version>1.0.0</version>
</dependency>

优缺点分析

优点：

• 实现简单，上手容易 • 适合封装简单的功能组件

缺点：

• 不支持定制化配置 • 无法根据条件选择性装配 • 功能过于简单，适用场景有限

适用场景：适合封装简单的工具类或无需外部配置的功能组件。

三、方法二：条件装配方式

通过SpringBoot的条件装配机制，实现根据特定条件决定是否启用配置的starter。

实现步骤

1. 创建Maven项目同上

2. 创建配置类，添加条件注解：

   @Configuration
   @ConditionalOnClass(RedisTemplate.class)
   public class RedisServiceAutoConfiguration {
       
   @Bean
   @ConditionalOnMissingBean
   public RedisService redisService() {
       return new RedisServiceImpl();
   }
       
   @Bean
   @ConditionalOnProperty(prefix = "redis.cache", name = "enabled", havingValue = "true")
   public RedisCacheManager redisCacheManager() {
       return new RedisCacheManager();
   }
   }
   

3. 配置自动装配文件同上

条件注解说明

SpringBoot提供了丰富的条件注解：

• @ConditionalOnClass：当类路径下有指定类时 • @ConditionalOnMissingBean：当容器中没有指定Bean时 • @ConditionalOnProperty：当配置文件中有指定属性时 • @ConditionalOnWebApplication：当应用是Web应用时 • @ConditionalOnExpression：基于SpEL表达式的条件

优缺点分析

优点：

• 智能装配，避免无用组件加载 • 可以根据环境条件决定是否启用功能 • 防止与已有Bean冲突

缺点：

• 配置逻辑较复杂 • 调试排错难度增加 • 需要考虑条件之间的优先级和冲突

适用场景：适合需要根据环境条件选择性启用的功能组件，如根据是否是Web环境决定是否启用Web相关功能。

四、方法三：属性绑定方式

通过@ConfigurationProperties实现自定义配置的starter，支持从配置文件中读取参数。

实现步骤

1. 创建属性类：

   @ConfigurationProperties(prefix = "example.service")
   @Data
   public class ServiceProperties {
   /**
    * 是否启用服务
    */
   private boolean enabled = true;
       
   /**
    * 服务URL
    */
   private String url = "http://localhost:8080";
       
   /**
    * 连接超时时间
    */
   private int timeout = 3000;
   }
   

2. 创建自动配置类：

   @Configuration
   @EnableConfigurationProperties(ServiceProperties.class)
   @ConditionalOnProperty(prefix = "example.service", name = "enabled", havingValue = "true", matchIfMissing = true)
   public class ExampleServiceAutoConfiguration {
       
   @Autowired
   private ServiceProperties properties;
       
   @Bean
   @ConditionalOnMissingBean
   public ExampleService exampleService() {
       return new ExampleServiceImpl(properties.getUrl(), properties.getTimeout());
   }
   }
   

3. 配置元数据提示：创建META-INF/spring-configuration-metadata.json

   {
   "properties": [
   {
     "name": "example.service.enabled",
     "type": "java.lang.Boolean",
     "description": "Whether to enable example service.",
     "defaultValue": true
   },
   {
     "name": "example.service.url",
     "type": "java.lang.String",
     "description": "Service URL.",
     "defaultValue": "http://localhost:8080"
   },
   {
     "name": "example.service.timeout",
     "type": "java.lang.Integer",
     "description": "Connection timeout in milliseconds.",
     "defaultValue": 3000
   }
   ]
   }
   

优缺点分析

优点：

• 支持从配置文件读取参数，实现灵活配置 • 配置项有元数据提示，用户体验好 • 支持配置校验和默认值

缺点：

• 开发工作量增加 • 需要维护配置元数据 • 配置项过多时管理复杂

适用场景：适合需要通过外部配置定制化的功能组件，如各种客户端和连接池配置。

五、方法四：完全自动配置方式

结合前面方法，实现一个完整的自动配置starter，包含条件装配、属性绑定和多组件配置。

实现步骤

1. 创建多个组件：

   // 核心服务接口
   public interface ComplexService {
   String process(String input);
   }
   
   // 实现类
   public class ComplexServiceImpl implements ComplexService {
   private final String endpoint;
   private final int timeout;
       
   public ComplexServiceImpl(String endpoint, int timeout) {
       this.endpoint = endpoint;
       this.timeout = timeout;
   }
       
   @Override
   public String process(String input) {
       // 实现逻辑
       return "Processed: " + input;
   }
   }
   // 辅助组件
   public class ServiceHelper {
   public void assist() {
       // 辅助功能实现
   }
   }
   

2. 创建属性类：

   @ConfigurationProperties(prefix = "complex.service")
   @Data
   public class ComplexServiceProperties {
   private boolean enabled = true;
   private String endpoint = "http://api.example.com";
   private int timeout = 5000;
   private AdvancedConfig advanced = new AdvancedConfig();
       
   @Data
   public static class AdvancedConfig {
       private boolean cacheEnabled = false;
       private int cacheSize = 100;
   }
   }
   

3. 创建自动配置类：

   @Configuration
   @EnableConfigurationProperties(ComplexServiceProperties.class)
   @ConditionalOnProperty(prefix = "complex.service", name = "enabled", havingValue = "true", matchIfMissing = true)
   public class ComplexServiceAutoConfiguration {
       
   @Autowired
   private ComplexServiceProperties properties;
       
   @Bean
   @ConditionalOnMissingBean
   public ComplexService complexService() {
       return new ComplexServiceImpl(
           properties.getEndpoint(), 
           properties.getTimeout()
       );
   }
       
   @Bean
   @ConditionalOnProperty(prefix = "complex.service.advanced", name = "cache-enabled", havingValue = "true")
   public CacheManager cacheManager() {
       return new SimpleCacheManager(properties.getAdvanced().getCacheSize());
   }
       
   @Bean
   public ServiceHelper serviceHelper() {
       return new ServiceHelper();
   }
   }
   

4. 添加自动装配文件：在META-INF/spring.factories中添加配置 优缺点分析

优点：

• 功能完整，支持复杂场景 • 组件化设计，支持条件装配 • 灵活的配置选项

缺点：

• 实现复杂度高 • 需要考虑多组件间的依赖关系

适用场景：适合复杂的企业级功能组件，如分布式事务、安全认证等需要多组件协同工作的场景。

六、方法五：Enable模式方式

通过自定义@Enable注解，允许用户主动启用特定功能。

实现步骤

1. 创建功能接口和实现类：

   public interface FeatureService {
   void execute();
   }
   
   public class FeatureServiceImpl implements FeatureService {
   @Override
   public void execute() {
       // 实现逻辑
   }
   }
   

2. 创建@Enable注解：

   @Retention(RetentionPolicy.RUNTIME)
   @Target(ElementType.TYPE)
   @Import(FeatureConfiguration.class)
   public @interface EnableFeature {
   /**
    * 模式设置
    */
   Mode mode() default Mode.SIMPLE;
       
   enum Mode {
       SIMPLE, ADVANCED
   }
   }
   

3. 创建配置类：

   @Configuration
   public class FeatureConfiguration implements ImportAware {
       
   private EnableFeature.Mode mode;
       
   @Override
   public void setImportMetadata(AnnotationMetadata importMetadata) {
       Map<String, Object> attributes = importMetadata.getAnnotationAttributes(
               EnableFeature.class.getName());
       this.mode = (EnableFeature.Mode) attributes.get("mode");
   }
       
   @Bean
   public FeatureService featureService() {
       if (mode == EnableFeature.Mode.SIMPLE) {
           return new SimpleFeatureServiceImpl();
       } else {
           return new AdvancedFeatureServiceImpl();
       }
   }
   }
   

使用方式

在应用主类中使用@Enable注解启用功能：

@SpringBootApplication
@EnableFeature(mode = EnableFeature.Mode.ADVANCED)
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

优缺点分析

优点：

• 显式启用功能，使用意图明确 • 支持通过注解参数定制功能 • 可以与自动配置结合使用

缺点：

• 需要用户主动添加注解 • 不完全符合SpringBoot开箱即用的理念 • 增加用户的使用负担

适用场景：适合可选功能或有多种使用模式的功能组件，如特定的集成方案或可选功能增强。

七、方法六：模块化与组合式starter

通过拆分功能模块，实现可组合的starter体系，用户可以按需引入所需功能。

实现步骤 1. 创建基础模块：

myproject-spring-boot-starter (父模块)
├── myproject-core-spring-boot-starter (核心功能)
├── myproject-web-spring-boot-starter (Web功能)
├── myproject-cache-spring-boot-starter (缓存功能)
└── myproject-security-spring-boot-starter (安全功能)

1. 核心模块实现：

   // 在core模块中
   @Configuration
   @ConditionalOnClass(CoreService.class)
   public class CoreAutoConfiguration {
       
   @Bean
   @ConditionalOnMissingBean
   public CoreService coreService() {
       return new CoreServiceImpl();
   }
   }
   

2. 功能模块实现：

   // 在web模块中
   @Configuration
   @ConditionalOnWebApplication
   @ConditionalOnClass(CoreService.class)
   public class WebAutoConfiguration {
       
   @Autowired
   private CoreService coreService;
       
   @Bean
   public WebService webService() {
       return new WebServiceImpl(coreService);
   }
   }
   

3. 依赖管理：

   <dependency>
   <groupId>com.example</groupId>
   <artifactId>myproject-core-spring-boot-starter</artifactId>
   <version>${project.version}</version>
   </dependency>
   

优缺点分析

优点：

• 功能模块化，按需引入 • 减少不必要的依赖 • 便于团队协作开发 • 符合单一职责原则

缺点：

• 模块间依赖关系管理复杂 • 版本一致性维护困难 • 开发和测试工作量增加

适用场景：适合大型项目或平台型应用，需要根据不同业务场景选择不同功能组合的情况。

八、各种方法对比与选择建议

方法	实现难度	灵活性	可配置性	适用场景
基础配置类方式	★☆☆☆☆	★★☆☆☆	★☆☆☆☆	简单工具类封装
条件装配方式	★★☆☆☆	★★★☆☆	★★☆☆☆	环境敏感功能
属性绑定方式	★★★☆☆	★★★★☆	★★★★★	可配置组件
完全自动配置方式	★★★★☆	★★★★★	★★★★★	企业级复杂功能
Enable模式方式	★★★☆☆	★★★★☆	★★★☆☆	可选功能组件
模块化组合式方式	★★★★★	★★★★★	★★★★★	大型平台级应用

九、自定义starter开发最佳实践

1. 命名规范 • 非官方starter命名：xxx-spring-boot-starter • 官方starter命名：spring-boot-starter-xxx
2. 依赖管理 • 使用spring-boot-starter作为基础依赖 • 避免引入不必要的传递依赖 • 明确声明版本兼容性范围
3. 配置设计 • 使用合理的配置前缀，避免冲突 • 提供合理的默认值 • 编写完整的配置元数据，提供IDE提示
4. 条件装配 • 合理使用条件注解，避免不必要的组件加载 • 使用@ConditionalOnMissingBean避免覆盖用户自定义Bean • 考虑多种环境条件的组合场景
5. 错误处理 • 提供清晰的错误提示 • 实现合理的降级策略 • 提供诊断和自检功能
6. 文档化 • 编写详细的使用文档 • 提供配置示例 • 说明与其他组件的集成方式 十、总结 自定义starter是SpringBoot生态中重要的扩展机制，开发者可以根据不同的需求场景，选择合适的方式实现自己的starter。

从简单的基础配置类方式，到复杂的模块化组合式方式，每种方法都有其适用场景和优缺点。

开发自定义starter时，应遵循以下原则

1. 遵循约定优于配置的理念
2. 提供合理的默认值
3. 允许用户定制化和覆盖默认行为
4. 做好错误处理和降级策略