SpringBoot自定义Starter开发全指南

1. 为什么需要自定义Starter

在SpringBoot生态中，Starter是一种约定俗成的依赖管理方式。官方提供的Starter如spring-boot-starter-web已经为我们封装了Web开发所需的全部依赖。但当我们开发一些可复用的组件时，自定义Starter就变得尤为重要。

我曾在多个微服务项目中遇到这样的场景：每个服务都需要集成相同的功能模块（比如分布式锁、日志收集等）。如果每个项目都重复配置相同的Bean和依赖，不仅效率低下，而且难以保证一致性。这时，自定义Starter就能完美解决这个问题。

提示：自定义Starter的核心价值在于"开箱即用"的体验。用户只需引入你的依赖，相关功能就能自动配置好，无需关心底层实现细节。

2. 自定义Starter的核心组件

2.1 项目结构规范

一个标准的SpringBoot Starter项目通常包含以下模块：

code复制my-spring-boot-starter
├── my-spring-boot-autoconfigure  # 自动配置核心逻辑
├── my-spring-boot-starter        # 空模块，仅包含对autoconfigure的依赖
└── pom.xml                       # 父POM管理版本

这种分离设计的好处是：

1. 用户可以选择只引入autoconfigure模块进行深度定制
2. Starter模块保持简洁，只做依赖转发
3. 符合SpringBoot官方Starter的设计哲学

2.2 自动配置原理

自动配置的核心是@Conditional系列注解和META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports文件。以下是一个典型的自动配置类：

java复制@AutoConfiguration
@ConditionalOnClass(MyService.class)
@EnableConfigurationProperties(MyProperties.class)
public class MyAutoConfiguration {
    
    @Bean
    @ConditionalOnMissingBean
    public MyService myService(MyProperties properties) {
        return new MyService(properties);
    }
}

关键点解析：

• @AutoConfiguration：标识这是一个自动配置类（SpringBoot 2.7+推荐使用）
• @ConditionalOnClass：当类路径存在指定类时才生效
• @EnableConfigurationProperties：启用配置属性绑定
• @ConditionalOnMissingBean：当容器中不存在该Bean时才创建

2.3 属性配置设计

良好的属性配置能让Starter更灵活。建议采用嵌套属性的方式：

java复制@ConfigurationProperties("my.starter")
public class MyProperties {
    private boolean enabled = true;
    private String endpoint;
    private Cache cache = new Cache();

    // getters/setters...
    
    public static class Cache {
        private int size = 100;
        private Duration timeout = Duration.ofSeconds(30);
        // getters/setters...
    }
}

对应的application.yml配置示例：

yaml复制my:
  starter:
    enabled: true
    endpoint: https://api.example.com
    cache:
      size: 200
      timeout: 60s

3. 开发实战：构建一个缓存Starter

3.1 初始化项目

使用Spring Initializr创建项目，选择：

• Packaging: Jar
• Java Version: 17
• Dependencies:
  • Configuration Processor (用于属性提示)
  • Lombok (可选)

pom.xml关键配置：

xml复制<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-configuration-processor</artifactId>
    <optional>true</optional>
</dependency>

3.2 实现核心逻辑

首先定义缓存接口：

java复制public interface MyCache {
    void put(String key, Object value);
    Object get(String key);
    void evict(String key);
}

然后提供默认实现（基于Caffeine）：

java复制public class DefaultMyCache implements MyCache {
    private final Cache<String, Object> cache;

    public DefaultMyCache(MyCacheProperties properties) {
        this.cache = Caffeine.newBuilder()
                .maximumSize(properties.getMaxSize())
                .expireAfterWrite(properties.getTtl())
                .build();
    }

    // 实现接口方法...
}

3.3 自动配置类

java复制@AutoConfiguration
@ConditionalOnClass(Caffeine.class)
@EnableConfigurationProperties(MyCacheProperties.class)
public class MyCacheAutoConfiguration {

    @Bean
    @ConditionalOnMissingBean
    public MyCache myCache(MyCacheProperties properties) {
        return new DefaultMyCache(properties);
    }
    
    @Bean
    public MyCacheManager cacheManager(MyCache myCache) {
        return new MyCacheManager(myCache);
    }
}

3.4 注册自动配置

在resources/META-INF下创建：

1. spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports

code复制com.example.mycache.MyCacheAutoConfiguration

2. additional-spring-configuration-metadata.json (用于IDE提示)

json复制{
  "properties": [
    {
      "name": "my.cache.enabled",
      "type": "java.lang.Boolean",
      "defaultValue": true,
      "description": "是否启用缓存功能"
    },
    {
      "name": "my.cache.max-size",
      "type": "java.lang.Integer",
      "defaultValue": 1000,
      "description": "缓存最大条目数"
    }
  ]
}

4. 高级技巧与避坑指南

4.1 条件装配的进阶用法

除了基本的@Conditional注解，还有一些特殊场景下的条件判断：

1. 基于环境变量的条件装配：

java复制@Bean
@ConditionalOnExpression("${my.starter.feature.enabled:false}")
public FeatureService featureService() {
    return new FeatureService();
}

2. 多条件组合：

java复制@Bean
@ConditionalOnProperty(name = "my.starter.cache.type", havingValue = "redis")
@ConditionalOnClass(RedisTemplate.class)
public RedisCacheService redisCacheService() {
    return new RedisCacheService();
}

4.2 自动配置的顺序控制

当多个自动配置类存在依赖关系时，可以使用@AutoConfigureAfter或@AutoConfigureBefore：

java复制@AutoConfiguration
@AutoConfigureAfter(DataSourceAutoConfiguration.class)
public class MyRepositoryAutoConfiguration {
    // 确保数据源先初始化
}

4.3 常见问题排查

1. 自动配置不生效

   • 检查META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports文件是否存在且路径正确
   • 确认配置类没有被@ComponentScan扫描到（应该放在单独的包中）
   • 使用--debug启动参数查看自动配置报告

2. 属性绑定失败

   • 确保@ConfigurationProperties类有setter方法
   • 检查属性前缀是否匹配
   • 在IDE中确认spring-boot-configuration-processor是否正常工作

3. Bean冲突

   • 使用@ConditionalOnMissingBean避免重复创建
   • 通过@Bean(name = "...")指定唯一名称

4.4 性能优化建议

1. 延迟初始化：

java复制@Bean
@Lazy
public ExpensiveService expensiveService() {
    return new ExpensiveService();
}

2. 使用@Configuration(proxyBeanMethods = false)提高启动速度：

java复制@Configuration(proxyBeanMethods = false)
public class MyFastConfiguration {
    // 配置项...
}

5. 测试与发布

5.1 单元测试

SpringBoot提供了专门的测试支持：

java复制@SpringBootTest
class MyStarterAutoConfigurationTests {

    @Autowired(required = false)
    private MyService myService;

    @Test
    void serviceNotLoadedWhenPropertyDisabled() {
        assertThat(myService).isNull();
    }

    @Test
    @EnableAutoConfiguration
    void serviceLoadedWhenPropertyEnabled() {
        assertThat(myService).isNotNull();
    }
}

5.2 集成测试

建议使用Testcontainers进行真实环境测试：

java复制@Testcontainers
@SpringBootTest
class MyStarterIntegrationTests {

    @Container
    static RedisContainer redis = new RedisContainer(DockerImageName.parse("redis:alpine"));

    @DynamicPropertySource
    static void redisProperties(DynamicPropertyRegistry registry) {
        registry.add("my.starter.cache.host", redis::getHost);
        registry.add("my.starter.cache.port", redis::getFirstMappedPort);
    }

    @Test
    void testCacheWithRealRedis() {
        // 测试逻辑...
    }
}

5.3 发布到Maven仓库

1. 配置settings.xml：

xml复制<servers>
    <server>
        <id>ossrh</id>
        <username>your-jira-id</username>
        <password>your-token</password>
    </server>
</servers>

2. 执行发布命令：

bash复制mvn clean deploy -P release

6. 真实案例：邮件Starter开发

6.1 需求分析

我们需要开发一个邮件发送Starter，支持：

• 多种邮件服务商（SMTP、Mailgun、SendGrid）
• 模板邮件发送
• 附件支持
• 发送指标监控

6.2 核心实现

1. 定义发送接口：

java复制public interface EmailSender {
    void send(EmailMessage message);
}

2. 多实现选择：

java复制@AutoConfiguration
@ConditionalOnClass(SendGrid.class)
@ConditionalOnProperty(name = "mail.provider", havingValue = "sendgrid")
public class SendGridAutoConfiguration {
    @Bean
    public EmailSender emailSender(SendGridProperties properties) {
        return new SendGridEmailSender(properties);
    }
}

3. 模板支持：

java复制public class ThymeleafEmailTemplateRenderer implements EmailTemplateRenderer {
    private final SpringTemplateEngine templateEngine;

    public String render(String templateName, Map<String, Object> context) {
        Context thymeleafContext = new Context();
        thymeleafContext.setVariables(context);
        return templateEngine.process(templateName, thymeleafContext);
    }
}

6.3 使用示例

引入依赖后，直接注入使用：

java复制@Service
@RequiredArgsConstructor
public class OrderService {
    private final EmailSender emailSender;

    public void confirmOrder(Order order) {
        EmailMessage message = EmailMessage.builder()
                .to(order.getCustomerEmail())
                .subject("订单确认")
                .template("order-confirmation")
                .variable("order", order)
                .build();
        
        emailSender.send(message);
    }
}

7. Starter的版本兼容性

7.1 版本管理策略

建议遵循以下规则：

1. 主版本号：不兼容的API修改
2. 次版本号：向下兼容的功能新增
3. 修订号：向下兼容的问题修正

在父POM中定义依赖管理：

xml复制<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>${spring-boot.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

7.2 多SpringBoot版本支持

可以通过条件判断支持不同版本：

java复制@AutoConfiguration
@ConditionalOnClass(name = {
    "org.springframework.boot.context.properties.ConfigurationPropertiesBindingPostProcessor"
})
public class MyAutoConfiguration {
    // 兼容SpringBoot 2.x和3.x的配置
}

8. 监控与可观测性

8.1 指标暴露

集成Micrometer暴露指标：

java复制@Bean
public MyStarterMetrics myStarterMetrics(MeterRegistry registry) {
    return new MyStarterMetrics(registry);
}

public class MyStarterMetrics {
    private final Counter requestCounter;

    public MyStarterMetrics(MeterRegistry registry) {
        this.requestCounter = Counter.builder("my.starter.requests")
                .description("Total service requests")
                .register(registry);
    }
}

8.2 健康检查

实现健康指示器：

java复制@Bean
public MyStarterHealthIndicator myStarterHealthIndicator() {
    return new MyStarterHealthIndicator();
}

public class MyStarterHealthIndicator implements HealthIndicator {
    @Override
    public Health health() {
        // 检查组件健康状态
        return Health.up().build();
    }
}

9. 安全注意事项

9.1 敏感信息处理

对于密码等敏感信息：

1. 使用@ConfigurationProperties的secret属性标记：

java复制@ConfigurationProperties("my.starter")
public class MyProperties {
    @Secret
    private String apiKey;
}

2. 支持从环境变量或Vault读取：

yaml复制my:
  starter:
    api-key: ${VAULT_API_KEY}

9.2 权限控制

如果Starter涉及敏感操作，应该：

1. 提供权限校验接口
2. 支持通过属性禁用危险功能
3. 记录详细的操作日志

java复制@Bean
@ConditionalOnProperty(name = "my.starter.security.enabled", havingValue = "true")
public SecurityInterceptor securityInterceptor() {
    return new SecurityInterceptor();
}

10. 文档与示例

10.1 README规范

一个好的Starter README应包含：

1. 快速开始指南
2. 配置项说明
3. 常见问题
4. 版本兼容性说明
5. 贡献指南

示例结构：

code复制# My Spring Boot Starter

## Features
- Feature 1
- Feature 2

## Quick Start
1. Add dependency:
```xml
<dependency>
    <groupId>com.example</groupId>
    <artifactId>my-spring-boot-starter</artifactId>
    <version>1.0.0</version>
</dependency>

2. 配置示例：

yaml复制my:
  starter:
    enabled: true

Configuration

code复制
### 10.2 示例项目

建议提供完整的示例项目，展示：
1. 基础用法
2. 高级配置
3. 异常处理
4. 测试用例

项目结构示例：

examples/
├── simple-demo # 基础使用示例
├── advanced-config # 高级配置示例
└── integration-test # 集成测试示例

code复制
## 11. 持续维护建议

### 11.1 版本更新策略

1. 定期同步SpringBoot主版本
2. 及时修复安全漏洞
3. 保持CHANGELOG更新

### 11.2 社区支持

建议：
1. 提供GitHub Issues模板
2. 维护FAQ文档
3. 建立社区交流渠道（如Slack或钉钉群）

### 11.3 兼容性测试

建立自动化测试矩阵，覆盖：
- 不同SpringBoot版本
- 不同Java版本
- 不同应用服务器

示例GitHub Actions配置：
```yaml
jobs:
  test:
    strategy:
      matrix:
        java: ['17', '21']
        spring-boot: ['2.7.0', '3.0.0']
    steps:
      - uses: actions/checkout@v3
      - name: Set up JDK ${{ matrix.java }}
        uses: actions/setup-java@v3
        with:
          java-version: ${{ matrix.java }}
      - name: Test with Spring Boot ${{ matrix.spring-boot }}
        run: mvn test -Dspring-boot.version=${{ matrix.spring-boot }}

12. 企业级Starter设计

12.1 多租户支持

对于SaaS类Starter，需要考虑：

1. 租户隔离
2. 配置覆盖
3. 资源池化

实现示例：

java复制public class TenantAwareService {
    private final ThreadLocal<String> currentTenant = new ThreadLocal<>();

    public void setTenant(String tenant) {
        currentTenant.set(tenant);
    }

    public void doOperation() {
        String tenant = currentTenant.get();
        // 租户特定操作
    }
}

12.2 灰度发布支持

通过配置实现功能开关：

java复制@Bean
@ConditionalOnProperty(name = "my.starter.new-feature.enabled", havingValue = "true")
public NewFeatureService newFeatureService() {
    return new NewFeatureService();
}

12.3 配置动态刷新

集成Spring Cloud Config实现热更新：

java复制@RefreshScope
@Bean
public DynamicConfigService dynamicConfigService() {
    return new DynamicConfigService();
}

13. 性能优化实践

13.1 启动速度优化

1. 使用@Indexed加速组件扫描：

java复制@Indexed
@Component
public class FastComponent {
    // ...
}

2. 延迟初始化：

properties复制spring.main.lazy-initialization=true

13.2 内存优化

1. 避免过早初始化：

java复制@Bean
@Lazy
public HeavyService heavyService() {
    return new HeavyService();
}

2. 使用轻量级替代方案：

java复制@Bean
@ConditionalOnMissingClass("com.example.HeavyLibrary")
public LightService lightService() {
    return new LightService();
}

14. 跨平台注意事项

14.1 Windows/Linux兼容性

处理路径问题时：

java复制String configPath = Paths.get(configDir)
    .resolve("config.properties")
    .toString()
    .replace('\\', '/');

14.2 云原生适配

1. 支持Kubernetes配置：

yaml复制my:
  starter:
    endpoint: ${SERVICE_HOST:localhost}:${SERVICE_PORT:8080}

2. 健康检查端点：

java复制@Bean
public KubernetesHealthIndicator kubernetesHealthIndicator() {
    return new KubernetesHealthIndicator();
}

15. 异常处理最佳实践

15.1 自定义异常

定义业务异常体系：

java复制public class MyStarterException extends RuntimeException {
    private final ErrorCode errorCode;

    public MyStarterException(ErrorCode errorCode) {
        super(errorCode.getMessage());
        this.errorCode = errorCode;
    }
}

15.2 全局异常处理

提供默认@ControllerAdvice：

java复制@ControllerAdvice
public class MyStarterExceptionHandler {

    @ExceptionHandler(MyStarterException.class)
    public ResponseEntity<ErrorResponse> handleException(MyStarterException ex) {
        return ResponseEntity
                .status(ex.getErrorCode().getStatus())
                .body(new ErrorResponse(ex.getErrorCode()));
    }
}

16. 测试策略深度解析

16.1 单元测试覆盖

1. 条件装配测试：

java复制@Test
void autoConfigurationNotLoadedWhenClassNotPresent() {
    this.contextRunner.withClassLoader(new FilteredClassLoader(MyService.class))
            .run(context -> assertThat(context).doesNotHaveBean(MyService.class));
}

2. 属性绑定测试：

java复制@Test
void propertiesBindingWorks() {
    this.contextRunner.withPropertyValues("my.starter.enabled=false")
            .run(context -> {
                MyProperties properties = context.getBean(MyProperties.class);
                assertThat(properties.isEnabled()).isFalse();
            });
}

16.2 集成测试策略

使用@SpringBootTest结合Testcontainers：

java复制@SpringBootTest(properties = {
    "my.starter.db.url=jdbc:tc:postgresql:15-alpine:///testdb"
})
@Testcontainers
class DatabaseIntegrationTests {
    // 测试代码...
}

17. 依赖管理高级技巧

17.1 可选依赖

标记非必需依赖为optional：

xml复制<dependency>
    <groupId>com.example</groupId>
    <artifactId>optional-support</artifactId>
    <version>1.0.0</version>
    <optional>true</optional>
</dependency>

17.2 依赖排除

在Starter中预先排除冲突依赖：

xml复制<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <exclusions>
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
        </exclusion>
    </exclusions>
</dependency>

18. 国际化支持

18.1 多语言消息

1. 定义消息资源：

properties复制# messages.properties
my.starter.error.not_found=Resource not found

2. 在Starter中使用：

java复制public class ErrorMessageSource {
    private final MessageSource messageSource;

    public String getMessage(String code, Object... args) {
        return messageSource.getMessage(code, args, LocaleContextHolder.getLocale());
    }
}

18.2 区域设置感知

自动根据请求头处理：

java复制@Bean
public LocaleResolver localeResolver() {
    AcceptHeaderLocaleResolver resolver = new AcceptHeaderLocaleResolver();
    resolver.setDefaultLocale(Locale.ENGLISH);
    return resolver;
}

19. 扩展点设计

19.1 SPI机制

定义服务接口：

java复制public interface MyPlugin {
    String process(String input);
}

通过META-INF/services加载实现：

code复制# META-INF/services/com.example.MyPlugin
com.example.plugin.CustomPlugin

19.2 事件监听

发布自定义事件：

java复制public class MyEvent extends ApplicationEvent {
    public MyEvent(Object source) {
        super(source);
    }
}

// 发布事件
applicationContext.publishEvent(new MyEvent(this));

20. 前沿技术整合

20.1 响应式编程支持

提供Reactive版本：

java复制@AutoConfiguration
@ConditionalOnClass(ReactiveMongoTemplate.class)
public class MyReactiveAutoConfiguration {

    @Bean
    public ReactiveMyService reactiveMyService() {
        return new ReactiveMyService();
    }
}

20.2 GraalVM原生镜像

添加native-image支持：

1. 配置native-image.properties：

code复制Args = --initialize-at-build-time=com.example.my.package

2. 添加依赖：

xml复制<dependency>
    <groupId>org.springframework.experimental</groupId>
    <artifactId>spring-native</artifactId>
    <version>0.12.1</version>
</dependency>

21. 维护模式建议

21.1 弃用策略

1. 使用@Deprecated注解标记
2. 在文档中说明替代方案
3. 保持至少两个版本的兼容性

21.2 迁移指南

为重大变更提供：

1. 版本对比表
2. 配置映射关系
3. 自动化迁移脚本示例

22. 安全审计集成

22.1 漏洞扫描

集成OWASP Dependency-Check：

xml复制<plugin>
    <groupId>org.owasp</groupId>
    <artifactId>dependency-check-maven</artifactId>
    <version>8.2.1</version>
    <executions>
        <execution>
            <goals>
                <goal>check</goal>
            </goals>
        </execution>
    </executions>
</plugin>

22.2 权限模型

实现RBAC支持：

java复制public interface PermissionEvaluator {
    boolean hasPermission(String role, String resource);
}

23. 监控告警集成

23.1 Prometheus指标

暴露自定义指标：

java复制@Bean
public MyStarterMetrics myStarterMetrics(MeterRegistry registry) {
    Counter counter = Counter.builder("my.starter.operations")
            .description("Total operations")
            .register(registry);
    return new MyStarterMetrics(counter);
}

23.2 告警规则

提供默认Alertmanager配置：

yaml复制groups:
- name: my-starter
  rules:
  - alert: HighErrorRate
    expr: rate(my_starter_errors_total[5m]) > 0.1
    labels:
      severity: critical
    annotations:
      summary: "High error rate in My Starter"

24. 文档生成自动化

24.1 Asciidoctor集成

生成标准化的文档：

adoc复制= My Starter Documentation

== Configuration
[cols="1,1,2"]
|===
| Property | Default | Description
| my.starter.enabled | true | Enable feature
|===

24.2 Swagger集成

自动生成API文档：

java复制@Bean
public OpenAPI customOpenAPI() {
    return new OpenAPI()
            .info(new Info().title("My Starter API"));
}

25. 社区贡献指南

25.1 开发环境搭建

提供一键配置脚本：

bash复制#!/bin/bash
mvn clean install -DskipTests
cd examples/simple-demo
mvn spring-boot:run

25.2 代码风格检查

集成checkstyle：

xml复制<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-checkstyle-plugin</artifactId>
    <version>3.2.0</version>
    <executions>
        <execution>
            <goals>
                <goal>check</goal>
            </goals>
        </execution>
    </executions>
</plugin>

26. 商业支持策略

26.1 开源协议选择

建议使用MIT或Apache 2.0：

text复制Copyright 2023 The Author

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

   http://www.apache.org/licenses/LICENSE-2.0

26.2 商业扩展

提供企业版功能：

1. 专业支持
2. 高级功能模块
3. 定制开发服务

27. 性能基准测试

27.1 JMH集成

编写基准测试：

java复制@BenchmarkMode(Mode.Throughput)
@OutputTimeUnit(TimeUnit.SECONDS)
public class MyStarterBenchmark {

    @Benchmark
    public void testOperation() {
        // 测试代码...
    }
}

27.2 结果可视化

使用JMH Visualizer生成图表：

bash复制java -jar target/benchmarks.jar -rf json | jmh-visualizer

28. 跨语言支持

28.1 Kotlin扩展

提供Kotlin DSL：

kotlin复制fun myStarter(dsl: MyStarterDsl.() -> Unit) {
    val config = MyStarterDsl().apply(dsl).build()
    // 初始化逻辑
}

28.2 Native Image兼容

确保GraalVM支持：

java复制@NativeHint(options = "--enable-url-protocols=http")
public class MyNativeConfiguration implements NativeConfiguration {
    // 原生镜像配置
}

29. 架构演进路线

29.1 功能规划

建议路线图：

1. v1.0 - 核心功能
2. v1.5 - 监控支持
3. v2.0 - 响应式编程
4. v2.5 - 云原生增强

29.2 技术债务管理

使用CodeClimate跟踪：

yaml复制version: "2"
checks:
  similar-code:
    enabled: true
    config:
      threshold: 50

30. 终极实践建议

经过多年开发SpringBoot Starter的经验，我总结了以下黄金法则：

1. 单一职责原则：一个Starter只解决一个问题
2. 合理默认值：提供开箱即用的配置，但允许覆盖
3. 明确文档：每个配置项都有详细说明
4. 完善测试：覆盖所有条件分支
5. 版本兼容：明确支持的SpringBoot版本范围
6. 性能考量：避免启动时加载重型资源
7. 安全审计：定期检查依赖漏洞
8. 社区支持：及时响应Issue和PR

最后一个小技巧：在Starter中加入spring-boot-starter-actuator依赖可以自动暴露健康检查端点，方便运维监控。但记得标记为optional：

xml复制<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
    <optional>true</optional>
</dependency>