自定义 Spring Boot Starter 开发指南

原创 已于 2026-01-23 11:50:34 修改 · 522 阅读 · 15 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
标签
#spring boot #后端 #java
于 2026-01-23 11:45:52 首次发布

自定义 Spring Boot Starter 面试要点

1. 什么是 Spring Boot Starter？

Spring Boot Starter 是一组方便的依赖描述符，你可以在项目中包含这些描述符，
从而获得所需的所有依赖项。它们简化了依赖管理和配置，使得开发者能够快速启动和运行
Spring Boot 应用程序。

2. 为什么需要自定义 Starter？

  1. 代码复用：将常用的功能封装成可重用的组件
  2. 简化配置：减少重复配置工作
  3. 统一管理：集中管理特定功能的实现
  4. 团队协作：提供标准化的解决方案

3. 自定义 Starter 的核心组件

3.1 配置属性类 (@ConfigurationProperties)

@ConfigurationProperties(prefix = "my.starter")
public class MyProperties {
    private String prefix = "Hello";
    private String suffix = "!";
    private boolean enabled = true;
    private int repeat = 1;
    // getter/setter...
}

3.2 业务服务类

public class MyService {
    private final MyProperties properties;
    
    public MyService(MyProperties properties) {
        this.properties = properties;
    }
    
    // 实现业务逻辑...
}

3.3 自动配置类

@Configuration
@ConditionalOnClass(MyService.class)
@ConditionalOnProperty(prefix = "my.starter", name = "enabled", 
                       havingValue = "true", matchIfMissing = true)
@EnableConfigurationProperties(MyProperties.class)
public class MyAutoConfiguration {
    
    @Bean
    @ConditionalOnMissingBean(MyService.class)
    public MyService myService(MyProperties properties) {
        return new MyService(properties);
    }
}

3.4 配置文件 (META-INF/spring.factories)

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.std.mystarter.MyAutoConfiguration

4. 关键注解说明

  • @ConfigurationProperties：用于绑定配置文件中的属性到 Java 对象
  • @ConditionalOnClass：当类路径下存在指定类时才进行配置
  • @ConditionalOnProperty：根据配置属性的值决定是否进行配置
  • @ConditionalOnMissingBean：当容器中不存在指定类型的 Bean 时才创建
  • @EnableConfigurationProperties：启用配置属性绑定功能

5. 实现步骤总结

  1. 创建业务类：实现核心功能
  2. 创建配置属性类：定义可配置的参数
  3. 创建自动配置类：定义 Bean 并使用条件注解控制加载时机
  4. 注册自动配置：在 spring.factories 文件中注册配置类
  5. 添加配置元数据：提供 IDE 提示支持

6. 条件注解的使用场景

  • @ConditionalOnClass：依赖的类存在时才配置
  • @ConditionalOnMissingBean：避免重复创建 Bean
  • @ConditionalOnProperty：根据配置开关决定是否启用
  • @ConditionalOnResource：资源存在时才配置
  • @ConditionalOnWebApplication：Web 环境下才配置

7. 最佳实践

  1. 命名规范：使用 xxx-spring-boot-starter 的命名方式
  2. 依赖传递：确保 Starter 包含所有必要依赖
  3. 配置验证：对配置参数进行有效性校验
  4. 文档完善：提供清晰的使用说明
  5. 版本管理：合理管理依赖版本

8. 注意事项

  • 避免循环依赖
  • 合理使用条件注解
  • 提供合理的默认值
  • 考虑线程安全问题
  • 做好异常处理

9. 实际应用场景

  • 数据库连接池配置
  • 缓存集成
  • 消息队列集成
  • 监控和健康检查
  • 日志框架集成
  • 第三方 API 集成

1. 项目概述

本项目演示了如何开发一个自定义的 Spring Boot Starter - service-zstarter，以及如何在另一个模块 my-bootstarter-test 中使用它。

2. 项目结构

spring-cloud-alibaba-demo/
├── service-zstarter/           # 自定义 Starter 模块
│   ├── src/main/java/com/std/mystarter/
│   │   ├── MyAutoConfiguration.java    # 自动配置类
│   │   ├── MyProperties.java           # 配置属性类
│   │   ├── MyService.java              # 业务服务类
│   │   └── MyCondition.java            # 条件判断类
│   ├── src/main/resources/META-INF/
│   │   └── additional-spring-configuration-metadata.json  # 配置元数据
│   └── pom.xml
└── my-bootstarter-test/        # 测试模块
    ├── src/main/java/com/std/DemoApplication.java
    ├── src/main/resources/application.yml
    └── pom.xml

3. 开发步骤详解

3.1 创建自定义 Starter (service-zstarter)

3.1.1 定义业务服务类 (MyService.java)
package com.std.mystarter;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class MyService {
    private static final Logger logger = LoggerFactory.getLogger(MyService.class);
    private final MyProperties properties;

    public MyService(MyProperties properties) {
        this.properties = properties;
        logger.info("MyService initialized with properties: {}", properties);
    }

    public String sayHello(String name) {
        if (!properties.isEnabled()) {
            return "Service is disabled";
        }

        StringBuilder result = new StringBuilder();
        for (int i = 0; i < properties.getRepeat(); i++) {
            result.append(properties.getPrefix())
                    .append(" ")
                    .append(name)
                    .append(properties.getSuffix());
            if (i < properties.getRepeat() - 1) {
                result.append(" ");
            }
        }
        return result.toString();
    }

    public void logConfig() {
        logger.info("MyService Configuration:");
        logger.info("  Prefix: {}", properties.getPrefix());
        logger.info("  Suffix: {}", properties.getSuffix());
        logger.info("  Enabled: {}", properties.isEnabled());
        logger.info("  Repeat: {}", properties.getRepeat());
    }
}
3.1.2 定义配置属性类 (MyProperties.java)
package com.std.mystarter;

import org.springframework.boot.context.properties.ConfigurationProperties;

@ConfigurationProperties(prefix = "my.starter")
public class MyProperties {
    // 默认配置值
    private String prefix = "Hello";
    private String suffix = "!";
    private boolean enabled = true;
    private int repeat = 1;

    // Getter 和 Setter 方法
    public String getPrefix() { return prefix; }
    public void setPrefix(String prefix) { this.prefix = prefix; }
    
    public String getSuffix() { return suffix; }
    public void setSuffix(String suffix) { this.suffix = suffix; }
    
    public boolean isEnabled() { return enabled; }
    public void setEnabled(boolean enabled) { this.enabled = enabled; }
    
    public int getRepeat() { return repeat; }
    public void setRepeat(int repeat) { this.repeat = repeat; }
}
3.1.3 创建自动配置类 (MyAutoConfiguration.java)
package com.std.mystarter;

import org.springframework.context.annotation.Configuration;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;

@Configuration  // Spring Boot 2.x 使用 @Configuration
@ConditionalOnClass(MyService.class)  // 类路径存在 MyService 时才生效
@ConditionalOnProperty(prefix = "my.starter", name = "enabled",
        havingValue = "true", matchIfMissing = true)
@EnableConfigurationProperties(MyProperties.class)  // 使配置属性生效
public class MyAutoConfiguration {

    @Bean
    @ConditionalOnMissingBean(MyService.class)
    public MyService myService(MyProperties properties) {
        return new MyService(properties);
    }

    @Bean
    @ConditionalOnMissingBean(name = "myServiceHelper")
    public MyServiceHelper myServiceHelper(MyService myService) {
        return new MyServiceHelper(myService);
    }
}
3.1.4 添加配置元数据文件 (additional-spring-configuration-metadata.json)
{
  "properties": [
    {
      "name": "my.starter.prefix",
      "type": "java.lang.String",
      "description": "消息前缀",
      "defaultValue": "Hello"
    },
    {
      "name": "my.starter.suffix",
      "type": "java.lang.String",
      "description": "消息后缀",
      "defaultValue": "!"
    },
    {
      "name": "my.starter.enabled",
      "type": "java.lang.Boolean",
      "description": "是否启用服务",
      "defaultValue": true
    },
    {
      "name": "my.starter.repeat",
      "type": "java.lang.Integer",
      "description": "消息重复次数",
      "defaultValue": 1
    }
  ]
}
3.1.5 配置自动装配 (spring.factories)

在 src/main/resources/META-INF/spring.factories 文件中添加：

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.std.mystarter.MyAutoConfiguration
3.1.6 配置 POM 文件 (pom.xml)
<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>com.std</groupId>
        <artifactId>spring-cloud-alibaba-demo</artifactId>
        <version>1.0.0</version>
    </parent>
    <artifactId>service-zstarter</artifactId>
    <packaging>jar</packaging>

    <name>service-zstarter</name>
    <url>http://maven.apache.org</url>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <!-- Spring Boot 自动配置核心依赖 -->
        <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>

        <!-- 条件注解支持 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <!-- 可选：如果需要日志 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-logging</artifactId>
            <optional>true</optional>
        </dependency>
    </dependencies>
</project>

3.2 测试自定义 Starter (my-bootstarter-test)

3.2.1 创建测试应用 (DemoApplication.java)
package com.std;

import com.std.mystarter.MyService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication implements CommandLineRunner {

    @Autowired
    private MyService myService;

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

    @Override
    public void run(String... args) {
        System.out.println("测试自定义 Starter:");
        System.out.println(myService.sayHello("Spring Boot"));
        myService.logConfig();
    }
}
3.2.2 配置自定义参数 (application.yml)
my:
  starter:
    prefix: "Hi"
    suffix: "!!!"
    enabled: true
    repeat: 3

# 启用调试模式查看自动配置报告
debug: true
3.2.3 配置测试模块依赖 (pom.xml)
<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>com.std</groupId>
        <artifactId>spring-cloud-alibaba-demo</artifactId>
        <version>1.0.0</version>
    </parent>

    <artifactId>my-bootstarter-test</artifactId>
    <packaging>jar</packaging>

    <name>my-bootstarter-test</name>
    <url>http://maven.apache.org</url>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.std</groupId>
            <artifactId>service-zstarter</artifactId>
            <version>1.0.0</version>
        </dependency>
    </dependencies>
</project>

4. 关键概念说明

4.1 自动配置原理

  • 使用 [@ConditionalOnClass](file:///E:/javaWork/std/spring-cloud-alibaba-demo/service-user/src/main/java/com/std/config/RedisConfig.java#L8-L8) 注解确保类路径中有必要的类时才进行配置
  • 使用 [@ConditionalOnProperty](file:///E:/javaWork/std/spring-cloud-alibaba-demo/service-user/src/main/java/com/std/config/RedisConfig.java#L9-L9) 注解根据配置属性决定是否启用配置
  • 使用 [@ConditionalOnMissingBean](file:///E:/javaWork/std/spring-cloud-alibaba-demo/service-user/src/main/java/com/std/config/RedisConfig.java#L10-L10) 注解确保只有在没有相同类型的 Bean 时才创建新 Bean

4.2 配置属性绑定

  • 使用 [@ConfigurationProperties](file:///E:/javaWork/std/spring-cloud-alibaba-demo/common/src/main/java/com/std/config/RedisConfig.java#L10-L10) 注解将配置文件中的属性绑定到 Java 对象
  • 配置前缀使用 my.starter，对应的配置项如 my.starter.prefix

4.3 条件化配置

  • Spring Boot 提供了多种条件注解，可以根据不同条件激活配置
  • 常用的条件注解包括 [@ConditionalOnClass](file:///E:/javaWork/std/spring-cloud-alibaba-demo/service-user/src/main/java/com/std/config/RedisConfig.java#L8-L8)、[@ConditionalOnMissingBean](file:///E:/javaWork/std/spring-cloud-alibaba-demo/service-user/src/main/java/com/std/config/RedisConfig.java#L10-L10)、[@ConditionalOnProperty](file:///E:/javaWork/std/spring-cloud-alibaba-demo/service-user/src/main/java/com/std/config/RedisConfig.java#L9-L9) 等

5. 构建和使用

要构建和使用此自定义 Starter，请执行以下步骤：

  1. 构建整个项目：mvn clean install
  2. 运行测试应用：cd my-bootstarter-test && mvn spring-boot:run
  3. 应用将输出自定义配置的结果

6. 最佳实践

  1. 命名规范：Starter 名称通常以 -spring-boot-starter 结尾
  2. 依赖管理：确保 Starter 包含所有必需的依赖项
  3. 配置元数据：提供配置元数据以支持 IDE 提示
  4. 条件配置：合理使用条件注解避免冲突
  5. 文档说明：提供清晰的使用说明和示例
Zcat1024
关注
Spring Boot 自定义 Starter 开发完整指南
ma451152002的专栏
06-17 114
Spring Boot Starter 是一个依赖描述符，它包含了一系列相关的依赖项和自动配置类。当我们在项目中添加一个 Starter 依赖时，Spring Boot 会自动配置相应的功能。├── my-spring-boot-autoconfigure/ # 自动配置模块├── my-spring-boot-starter/ # Starter 模块└── pom.xml # 父项目 POMfill:#333;color:#333;color:#333;fill:none;是否否是。
自定义Spring Boot Starter开发指南
静水深流
06-15 1282
Spring Boot Starter开发要点 核心需求：开发自定义审计starter解决多项目重复代码问题，需支持事件记录、可配置化输出和持久化存储。 技术实现： 使用@Conditional注解实现条件化配置，包括环境检查、类路径检测等 通过@Enable*自定义注解简化功能激活 采用AOP拦截方法调用，记录包含时间戳、方法名、参数等审计信息 支持TEXT/JSON两种输出格式和BEFORE/AFTER/BOTH三种记录时机 最佳实践： 遵循Spring Boot starter规范，分离autocon
1、Spring Boot 3 自定义 Starter 开发完整指南
python15397的博客
09-27 710
Spring Boot 3 自定义 Starter 开发指南 本文将介绍如何创建一个名为 my-spring-boot-starter-greeting 的 Spring Boot 3 自定义 Starter，提供一个可配置的问候语服务。主要内容包括： 项目目标：创建一个支持 YAML 配置、自动装配的问候语服务 项目结构规划 Maven 项目配置（支持 JDK21） 核心代码实现（服务接口、实现类） 该 Starter 将支持通过 application.yaml 配置问候语格式，并自动提供 Greeti
Spring Boot Starter 自定义开发指南
最新发布
hiszmm_124的博客
06-22 188
自动配置是Starter的灵魂。核心配置类应使用@Configuration注解，并通过spring.factories文件实现自动装配，这是Starter与Spring Boot整合的关键。Spring Boot Starter作为Spring生态中简化依赖管理的核心组件，能够将复杂的配置封装为开箱即用的模块。对于希望深度定制化或扩展功能的开发者而言，掌握Starter的自定义开发至关重要。本文将围绕Starter的设计原理与实现步骤，从关键环节展开详解，帮助开发者快速构建高效、可复用的组件。
Spring Boot自定义Starter开发终极指南：打造企业级组件库的完整教程
gitblog_00036的博客
03-07 738
Spring Boot作为简化Spring应用开发的框架，通过自动配置、独立运行和内置服务器等特性，极大提升了开发效率。本文将带你从零开始构建自定义Starter，掌握企业级组件封装的核心技术，让你的组件像官方Starter一样即插即用。 ## 一、自定义Starter的核心价值与应用场景 🚀 自定义Starter是Spring Boot生态的重要扩展方式，它能将通用功能封装为可复用组件，典
5分钟快速上手Spring Boot自定义Starter开发：完整实战指南
gitblog_00979的博客
04-05 352
Spring Boot自定义Starter开发是提升开发效率、实现代码复用的重要技能。通过自定义Starter，开发者可以将常用功能封装成可复用的模块，简化项目配置，实现"开箱即用"的便捷体验。本文将为您展示如何在5分钟内完成一个完整的自定义Starter开发实战，包含加法服务和条件化减法服务的实现。 ## 🔍 什么是Spring Boot自定义Starter？ Spring Boot St
Spring Boot 自定义 Redis Starter 开发指南（附动态 TTL 实现）
〆、挽风的博客
04-07 698
Data@Validated/*** {@link #redisScanBatchSize} 默认值*//*** redis scan 一次返回数量*/核心作用：配置 Redis 基础组件@AutoConfiguration(before = RedissonAutoConfiguration.class) // 目的：使用自己定义的 RedisTemplate Bean/*** 创建 RedisTemplate Bean，使用 JSON 序列化方式*/@Bean。
Dubbo Spring Boot Starter高级特性：自定义扩展与插件开发完全指南
gitblog_00893的博客
04-29 764
Dubbo Spring Boot Starter是一款能够帮助开发者快速集成Dubbo与Spring Boot的工具，它提供了丰富的高级特性，支持自定义扩展与插件开发，让分布式服务开发更加灵活高效。本文将详细介绍如何利用这些高级特性进行自定义扩展和插件开发，助力开发者更好地应对复杂的业务场景。 ## 一、自定义配置扩展：灵活定制Dubbo属性 ### 1.1 DubboProperties配
自定义Spring Boot Starter的全面指南
静水深流
06-05 1357
本文介绍了自定义Spring Boot Starter的核心优势与实现细节。主要特点包括：1) 通过封装通用依赖提升开发效率，消除样板代码，确保环境一致性；2) 增强代码复用性，采用模块化设计和统一版本控制；3) 优化维护性，支持集中式变更和IDE智能提示。技术实现上详细解析了Gradle构建配置、条件化自动配置机制、数据模型设计、AOP切面实现以及配置元数据管理，展示了如何通过注解驱动和智能装配实现灵活的功能扩展。合理设计的自定义Starter可显著提升企业应用的开发标准化程度。
Spring Boot Starter 作用及原理详解
油墨香^-^的博客
02-06 517
SpringBoot Starter是SpringBoot框架的核心组件，采用"约定优于配置"理念，通过预定义依赖和自动配置简化应用开发。文章详细解析了Starter的核心作用、分类（官方和第三方）、优势（依赖管理简化和自动配置实现），并深入剖析其工作原理，包括自动配置机制、条件注解体系、spring.factories文件机制等。同时提供了自定义Starter的开发实践示例（短信服务Starter），涵盖需求分析、项目结构设计、核心代码实现和使用示例。最后总结了Starter的最佳实践
Spring Boot的启动器Starter大全及自定义Starter
Angus的博客
02-13 803
转载自：https://www.cnblogs.com/shamo89/p/8051966.html 现有启动器Starter目录 Spring Boot应用启动器基本的一共有44种，具体如下： 1）spring-boot-starter 这是Spring Boot的核心启动器，包含了自动配置、日志和YAML。 2）spring-boot-starter-actuator 帮助监控和管理应用。 3...
【亲测免费】 Druid Spring Boot Starter 使用指南
gitblog_01269的博客
10-18 1075
Druid Spring Boot Starter 使用指南 Druid Spring Boot Starter 是一个专为简化 Druid 数据源在 Spring Boot 应用中的集成而设计的库。它提供了一种快捷的方式来配置和管理Druid连接池，同时集成Spring Boot的自动配置特性。下面是使用这个库的详细步骤，包括安装、配置以及API使用的全面指导。 安装指南 要开始使用 Druid...
Spring Boot Starter深度解析：从入门到自定义，一篇搞定！
weixin_42148384的博客
07-06 1460
Spring Boot Starter 是 Spring Boot 生态中​​简化依赖管理和自动配置​​的核心机制，旨在帮助开发者快速集成常用功能，避免手动配置大量依赖和样板代码。本文将从核心概念、工作原理、分类、自定义开发到最佳实践，全面解析 Spring Boot Starter。
Spring Boot深度解析：自动配置、Starter依赖与MyBatis Plus集成指南
qq_57755194的博客
05-30 1940
本文深入解析SpringBoot三大核心特性。首先剖析自动配置原理，包括@EnableAutoConfiguration机制、spring.factories文件及条件注解的运作流程。其次详解Starter依赖的模块化设计，对比官方与第三方Starter差异，并提供自定义Starter开发指南。最后实战演示如何高效集成MyBatisPlus，涵盖基础配置、条件构造器、分页查询等高级特性，并给出性能优化建议。
深入理解Spring Boot自定义Starter：从原理到实战
zuiyuelong的博客
08-20 932
在Spring Boot生态中，Starter机制是框架最精妙的设计之一。截至2025年，这套机制已演进成为企业级应用开发的标准化组件方案，其核心价值在于通过约定优于配置的原则，将传统Spring应用中繁琐的依赖管理和配置工作转化为"开箱即用"的模块化体验。尽管官方提供了丰富的Starter，但在实际企业开发中，自定义Starter已成为中高级开发者的必备技能。业务中间件封装将公司内部的消息队列SDK、分布式锁实现或缓存方案打包成Starter，确保所有团队使用统一且经过验证的实现。
Spring Boot 3.x迁移指南：从2.x升级的完整流程和坑点总结
yp0to1的博客
06-17 576
Spring Boot 3.x迁移工作量不小，但这是必须做的。新项目：直接用Spring Boot 3.2 + Java 21（一步到位）老项目：制定迁移计划，逐步迁移（先迁移不重要的服务）测试优先：迁移完后一定要做充分的测试（单元测试 + 集成测试 + 压测）工具辅助：用Spring Boot Migrator和OpenRewrite自动化迁移，减少手动改代码的工作量迁移虽然麻烦，但迁移后能用上虚拟线程、Native Image这些新特性，还是很值得的。参考资料。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值