本文详细讲解了 Spring Boot Starter 的自定义开发流程，旨在构建企业级组件库。内容涵盖 Starter 适用场景判断、命名规范、核心架构及自动装配原理。通过分布式锁案例，演示了从配置属性定义、核心接口设计、具体实现到自动配置类编写的完整过程。此外，还介绍了配置元数据、健康检查、多版本兼容、性能优化、测试策略以及发布治理等企业级特性。文章强调 Starter 开发不仅是编码，更是设计思想的体现，需注重用户体验、兼容性和可维护性。
在企业级微服务架构中，通用组件的配置管理往往面临挑战。每个服务都要重复配置 Redis、MQ、监控等，容易出现版本不一致或配置错误。将通用组件打包成 Starter 后，部署时间大幅缩短，配置错误率降低，新人上手速度显著提升。
本文不仅教你怎么写 Starter，更要教你怎么写出生产级的 Starter。这中间的坑，我都替你踩过了。
Spring Boot Starter 是企业级微服务架构的基石。本文从实战出发，完整解析 Starter 的开发全流程：从 Maven 配置、自动装配原理、条件注解使用，到配置元数据、健康检查、监控集成。通过多个真实企业级 Starter 案例（分布式锁、ID 生成器、审计日志），提供可复用的代码模板和最佳实践。最后分享 Starter 治理、版本兼容、性能优化等高级话题。
不是所有组件都适合做成 Starter。我总结了三个判断标准：
比如：Redis 客户端、消息队列、分布式锁、ID 生成器。这些每个服务都要用。
比如：数据库连接池配置、线程池配置、SSL 证书配置。手动配容易出错。
比如：监控上报、链路追踪、安全组件。需要全公司统一。
反面教材：有人把业务层的 DTO 做成 Starter，这就属于走火入魔了。
命名看起来是小问题，但很重要。Spring 官方有明确的命名规范：
<!-- 好的命名 -->
<artifactId>spring-boot-starter-data-redis</artifactId>
<artifactId>redis-spring-boot-starter</artifactId>
<!-- 第三方可以这样 -->
<!-- 坏的命名 -->
<artifactId>my-redis-starter</artifactId> <!-- 没有 spring-boot 前缀 -->
<artifactId>redis-starter-spring-boot</artifactId> <!-- 顺序不对 -->
企业内部的命名建议：
<!-- 公司级组件 -->
<artifactId>example-spring-boot-starter-distributed-lock</artifactId>
<!-- 团队级组件 -->
<artifactId>payment-spring-boot-starter-audit</artifactId>
<!-- 通用工具 -->
<artifactId>common-spring-boot-starter-id-generator</artifactId>
很多人以为 Starter 就是几个 Java 类，太天真了！一个生产级的 Starter 至少包含：
我知道你肯定看过@EnableAutoConfiguration 的原理，但我今天要说点不一样的。
关键点：Spring Boot 2.7 之后，自动配置的注册方式变了：
// Spring Boot 2.7 之前：用 spring.factories
// META-INF/spring.factories
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.example.MyAutoConfiguration
// Spring Boot 2.7 之后：推荐用@AutoConfiguration
// src/main/resources/META-INF/spring/
// └── org.springframework.boot.autoconfigure.AutoConfiguration.imports
// 文件内容：
com.example.MyAutoConfiguration
// 对应的 Java 代码
@AutoConfiguration
@EnableConfigurationProperties(MyProperties.class)
@ConditionalOnClass(SomeClass.class)
public class MyAutoConfiguration {
// 配置内容
}
代码清单 1：新旧自动配置注册方式对比
为什么这么改？因为 @AutoConfiguration 支持更多特性：
@AutoConfigureBefore、@AutoConfigureAfter）在做技术方案前，先明确需求。我们需要的分布式锁要：
先看 Maven 项目结构：
distributed-lock-spring-boot-starter/
├── pom.xml
├── src/
│ ├── main/
│ │ ├── java/
│ │ │ └── com/
│ │ │ └── example/
│ │ │ └── lock/
│ │ │ ├── LockProperties.java # 配置属性
│ │ │ ├── DistributedLock.java # 核心接口
│ │ │ ├── RedisDistributedLock.java # Redis 实现
│ │ │ ├── ZkDistributedLock.java # ZK 实现
│ │ │ ├── LockAutoConfiguration.java # 自动配置
│ │ │ ├── LockAspect.java # AOP 切面
│ │ │ └── annotation/
│ │ │ └── Lockable.java # 锁注解
│ │ └── resources/
│ │ ├── META-INF/
│ │ │ └── spring/
│ │ │ └── org.springframework.boot.autoconfigure.AutoConfiguration.imports
│ │ └── application-lock.yml # 默认配置
│ └── test/ # 测试代码
└── README.md
@ConfigurationProperties(prefix = "example.lock")
@Validated
public class LockProperties {
/**
* 锁类型：redis、zookeeper、database
*/
@NotEmpty(message = "锁类型不能为空")
private String type = "redis";
/**
* 默认超时时间（毫秒）
*/
@Min(value = 1, message = "超时时间必须大于 0")
private long defaultTimeout = 30000;
/**
* 默认等待时间（毫秒）
*/
@Min(value = 0, message = "等待时间不能小于 0")
private long defaultWaitTime = 10000;
/**
* 重试次数
*/
@Min(value = 0, message = "重试次数不能小于 0")
private int retryTimes = 3;
/**
* Redis 配置（当 type=redis 时生效）
*/
private RedisConfig redis = new RedisConfig();
/**
* Zookeeper 配置（当 type=zookeeper 时生效）
*/
private ZkConfig zookeeper = new ZkConfig();
// 嵌套配置类
@Data
public {
;
String password;
;
;
;
}
{
;
;
;
;
}
}
代码清单 2：分布式锁配置属性类
public interface DistributedLock {
/**
* 获取锁
* @param lockKey 锁的 key
* @param timeout 超时时间（毫秒）
* @param waitTime 等待时间（毫秒）
* @return 是否获取成功
*/
boolean tryLock(String lockKey, long timeout, long waitTime);
/**
* 获取锁（使用默认配置）
*/
default boolean tryLock(String lockKey) {
// 实际项目中这里会从 ThreadLocal 或配置中获取默认值
return tryLock(lockKey, 30000, 10000);
}
/**
* 释放锁
*/
void unlock(String lockKey);
/**
* 续期锁（防止锁过期）
*/
boolean renewLock(String lockKey, long expireTime);
/**
* 锁监控指标
*/
LockStats getStats();
@Data
class LockStats {
private long totalAcquireAttempts; // 总获取尝试次数
private long successfulAcquisitions; // 成功获取次数
private long failedAcquisitions; // 失败获取次数
private long averageAcquireTime; // 平均获取时间 (ms)
private Map<String, Long> keyStats;
}
}
代码清单 3：分布式锁核心接口
@Slf4j
public class RedisDistributedLock implements DistributedLock {
private final RedissonClient redissonClient;
private final LockProperties properties;
private final ConcurrentHashMap<String, RLock> lockCache = new ConcurrentHashMap<>();
private final LockStats stats = new LockStats();
private final AtomicLong totalAcquireAttempts = new AtomicLong();
private final AtomicLong successfulAcquisitions = new AtomicLong();
public RedisDistributedLock(LockProperties properties) {
this.properties = properties;
Config config = new Config();
RedisConfig redisConfig = properties.getRedis();
config.useSingleServer()
.setAddress(redisConfig.getAddress())
.setPassword(redisConfig.getPassword())
.setDatabase(redisConfig.getDatabase())
.setConnectionPoolSize(redisConfig.getConnectionPoolSize())
.setConnectionMinimumIdleSize(redisConfig.getConnectionMinimumIdleSize());
.redissonClient = Redisson.create(config);
}
{
totalAcquireAttempts.incrementAndGet();
System.currentTimeMillis();
{
lockCache.computeIfAbsent(lockKey, key -> redissonClient.getLock(key));
lock.tryLock(waitTime, timeout, TimeUnit.MILLISECONDS);
(acquired) {
successfulAcquisitions.incrementAndGet();
System.currentTimeMillis() - startTime;
(stats) {
stats.setAverageAcquireTime(
(stats.getAverageAcquireTime() * (successfulAcquisitions.get() - ) + costTime) / successfulAcquisitions.get()
);
stats.getKeyStats().merge(lockKey, , Long::sum);
}
log.debug(, lockKey, costTime);
} {
log.warn(, lockKey, waitTime);
}
acquired;
} (InterruptedException e) {
Thread.currentThread().interrupt();
log.error(, lockKey, e);
;
} (Exception e) {
log.error(, lockKey, e);
;
} {
stats.setTotalAcquireAttempts(totalAcquireAttempts.get());
stats.setSuccessfulAcquisitions(successfulAcquisitions.get());
stats.setFailedAcquisitions(totalAcquireAttempts.get() - successfulAcquisitions.get());
}
}
{
{
lockCache.get(lockKey);
(lock != && lock.isHeldByCurrentThread()) {
lock.unlock();
log.debug(, lockKey);
}
} (Exception e) {
log.error(, lockKey, e);
}
}
}
代码清单 4：Redis 分布式锁实现
@AutoConfiguration
@EnableConfigurationProperties(LockProperties.class)
@ConditionalOnClass(RedissonClient.class)
@ConditionalOnProperty(prefix = "example.lock", name = "enabled", havingValue = "true", matchIfMissing = true)
@AutoConfigureAfter(RedisAutoConfiguration.class)
public class LockAutoConfiguration {
private static final Logger log = LoggerFactory.getLogger(LockAutoConfiguration.class);
@Bean
@ConditionalOnMissingBean
@ConditionalOnProperty(prefix = "example.lock", name = "type", havingValue = "redis", matchIfMissing = true)
public DistributedLock redisDistributedLock(LockProperties properties) {
log.info("初始化 Redis 分布式锁，地址：{}", properties.getRedis().getAddress());
return new RedisDistributedLock(properties);
}
@Bean
@ConditionalOnMissingBean
@ConditionalOnProperty(prefix = "example.lock", name = "type", havingValue = "zookeeper")
@ConditionalOnClass(value = {CuratorFramework.class, InterProcessMutex.class})
public DistributedLock zookeeperDistributedLock(LockProperties properties) {
log.info("初始化 Zookeeper 分布式锁，servers: {}", properties.getZookeeper().getServers());
return new ZkDistributedLock(properties);
}
@Bean
@ConditionalOnMissingBean
public LockAspect lockAspect(DistributedLock distributedLock) {
(distributedLock);
}
LockHealthIndicator {
(distributedLock);
}
LockMetrics {
(distributedLock);
}
}
代码清单 5：分布式锁自动配置类
@Aspect
@Component
@ConditionalOnBean(DistributedLock.class)
public class LockAspect {
private final DistributedLock distributedLock;
public LockAspect(DistributedLock distributedLock) {
this.distributedLock = distributedLock;
}
@Around("@annotation(lockable)")
public Object aroundLock(ProceedingJoinPoint joinPoint, Lockable lockable) throws Throwable {
String lockKey = generateLockKey(joinPoint, lockable);
try {
// 尝试获取锁
boolean acquired = distributedLock.tryLock(
lockKey, lockable.timeout(), lockable.waitTime()
);
if (!acquired) {
throw new LockAcquireException("获取锁失败：" + lockKey);
}
// 执行业务方法
return joinPoint.proceed();
} finally {
// 释放锁
distributedLock.unlock(lockKey);
}
}
private String generateLockKey(ProceedingJoinPoint joinPoint, Lockable lockable) {
MethodSignature signature = (MethodSignature) joinPoint.getSignature();
Method method = signature.getMethod();
// 支持 SpEL 表达式
(StringUtils.hasText(lockable.key())) {
evaluateSpel(lockable.key(), joinPoint);
}
method.getDeclaringClass().getSimpleName();
method.getName();
Arrays.hashCode(joinPoint.getArgs()) + ;
String.format(, className, methodName, argsHash);
}
String {
expression;
}
}
代码清单 6：分布式锁 AOP 切面
@Component
public class LockHealthIndicator implements HealthIndicator {
private final DistributedLock distributedLock;
public LockHealthIndicator(DistributedLock distributedLock) {
this.distributedLock = distributedLock;
}
@Override
public Health health() {
DistributedLock.LockStats stats = distributedLock.getStats();
// 计算成功率
double successRate = stats.getTotalAcquireAttempts() > 0 ?
(double) stats.getSuccessfulAcquisitions() / stats.getTotalAcquireAttempts() * 100 : 0;
Map<String, Object> details = new HashMap<>();
details.put("successRate", String.format("%.2f%%", successRate));
details.put("totalAttempts", stats.getTotalAcquireAttempts());
details.put("successCount", stats.getSuccessfulAcquisitions());
details.put("avgAcquireTime", stats.getAverageAcquireTime() + "ms");
if (successRate < 95.0) {
return Health.down()
.withDetail("message", "锁获取成功率过低")
.withDetails(details)
.build();
}
return Health.up()
.withDetails(details)
.build();
}
}
代码清单 7：分布式锁健康检查
在 src/main/resources/META-INF/ 下创建：
// additional-spring-configuration-metadata.json
{
"properties": [
{
"name": "example.lock.enabled",
"type": "java.lang.Boolean",
"description": "是否启用分布式锁",
"defaultValue": true
},
{
"name": "example.lock.type",
"type": "java.lang.String",
"description": "锁类型：redis 或 zookeeper",
"defaultValue": "redis"
},
{
"name": "example.lock.default-timeout",
"type": "java.lang.Long",
"description": "默认锁超时时间（毫秒）",
代码清单 8：配置元数据
在 src/main/resources/ 下创建 application-lock.yml：
# 分布式锁默认配置
example:
lock:
enabled: true
type: redis
default-timeout: 30000
default-wait-time: 10000
retry-times: 3
redis:
address: ${REDIS_HOST:redis://localhost:6379}
password: ${REDIS_PASSWORD:}
database: 0
connection-pool-size: 64
connection-minimum-idle-size: 24
zookeeper:
servers: ${ZK_HOST:localhost:2181}
session-timeout: 30000
connection-timeout: 15000
namespace: example-lock
代码清单 9：默认配置文件
<dependency>
<groupId>com.example</groupId>
<artifactId>distributed-lock-spring-boot-starter</artifactId>
<version>1.0.0</version>
</dependency>
# application.yml
example:
lock:
type: redis
redis:
address: redis://prod-redis:6379
default-timeout: 60000 # 生产环境可以设长一点
@Service
public class OrderService {
@Lockable(key = "'order:' + #orderId", timeout = 30000)
public Order createOrder(String orderId, OrderRequest request) {
// 业务逻辑，自动加锁
return orderRepository.save(convertToOrder(request));
}
@Lockable(key = "'inventory:' + #productId", waitTime = 5000)
public void reduceInventory(String productId, int quantity) {
// 最多等待 5 秒获取锁
inventoryService.reduce(productId, quantity);
}
}
@Service
public class PaymentService {
@Autowired
private DistributedLock distributedLock;
public void processPayment(String paymentId) {
String lockKey = "payment:" + paymentId;
try {
if (distributedLock.tryLock(lockKey)) {
// 执行业务逻辑
paymentProcessor.process(paymentId);
} else {
throw new BusinessException("系统繁忙，请稍后重试");
}
} finally {
distributedLock.unlock(lockKey);
}
}
}
启动应用后，可以访问：
/actuator/health（查看锁的健康状态）/actuator/metrics/example.lock（查看锁的统计指标）/actuator/lock-stats（如果有自定义 Endpoint）Starter 一旦被多个服务使用，版本兼容就是大问题。我的经验：
<!-- 版本号规范 -->
<version>主版本。次版本。修订版本 - 里程碑</version>
<!-- 例如：1.2.3-RELEASE -->
<!-- 实际例子 -->
<version>1.0.0</version> <!-- 第一个稳定版 -->
<version>1.1.0</version> <!-- 新增功能，向后兼容 -->
<version>2.0.0</version> <!-- 破坏性变更 -->
public interface DistributedLock {
// v1.0 的方法
boolean tryLock(String lockKey, long timeout, long waitTime);
// v1.1 新增的方法（默认实现保证兼容）
default boolean tryLock(String lockKey, LockOptions options) {
return tryLock(lockKey, options.getTimeout(), options.getWaitTime());
}
// v1.0 的方法，v2.0 计划删除
@Deprecated(since = "2.0.0", forRemoval = true)
boolean oldMethod(String param);
}
@Bean
@Lazy // 只有实际使用时才初始化
public DistributedLock distributedLock(LockProperties properties) {
// 初始化逻辑
}
@Configuration
public class LockAutoConfiguration {
@Bean
@ConditionalOnMissingBean
public RedissonClient redissonClient(LockProperties properties) {
// 如果应用中已经有 RedissonClient，直接复用
// 避免创建多个连接池
}
}
public class RedisDistributedLock {
// 使用 WeakHashMap，避免内存泄漏
private final Map<String, WeakReference<RLock>> lockCache = Collections.synchronizedMap(new WeakHashMap<>());
}
生产级的 Starter 必须有完整的监控：
@Component
public class LockMetrics implements MeterBinder {
private final DistributedLock distributedLock;
public LockMetrics(DistributedLock distributedLock) {
this.distributedLock = distributedLock;
}
@Override
public void bindTo(MeterRegistry registry) {
Gauge.builder("example.lock.success.rate", () -> calculateSuccessRate())
.description("锁获取成功率")
.baseUnit("percent")
.register(registry);
Timer.builder("example.lock.acquire.time")
.description("锁获取耗时")
.publishPercentiles(0.5, 0.95, 0.99) // 50%, 95%, 99%分位
.register(registry);
}
private double calculateSuccessRate() {
DistributedLock.LockStats stats = distributedLock.getStats();
if (stats.getTotalAcquireAttempts() == 0) {
return 100.0;
}
return (double) stats.getSuccessfulAcquisitions() / stats.getTotalAcquireAttempts() * 100;
}
}
告警规则示例（Prometheus）：
groups:
- name: lock_alerts
rules:
- alert: LockSuccessRateLow
expr: example_lock_success_rate < 95
for: 5m
labels:
severity: warning
annotations:
summary: "锁获取成功率过低"
description: "锁获取成功率低于 95%，当前值：{{ $value }}%"
@ExtendWith(MockitoExtension.class)
class RedisDistributedLockTest {
@Mock
private RedissonClient redissonClient;
@Mock
private RLock rLock;
private RedisDistributedLock distributedLock;
@BeforeEach
void setUp() {
LockProperties properties = new LockProperties();
properties.setType("redis");
when(redissonClient.getLock(anyString())).thenReturn(rLock);
// 通过反射设置 redissonClient
distributedLock = new RedisDistributedLock(properties);
setField(distributedLock, "redissonClient", redissonClient);
}
@Test
void testTryLock_Success() throws InterruptedException {
// given
when(rLock.tryLock(anyLong(), anyLong(), any())).thenReturn(true);
// when
boolean result = distributedLock.tryLock("test-key", 30000, 10000);
// then
assertTrue(result);
verify(rLock).tryLock(10000, 30000, TimeUnit.MILLISECONDS);
}
@Test
void testTryLock_Timeout() throws InterruptedException {
(rLock.tryLock(anyLong(), anyLong(), any())).thenReturn();
distributedLock.tryLock(, , );
assertFalse(result);
}
}
@SpringBootTest
@AutoConfigureMockMvc
@Testcontainers // 使用 Testcontainers 启动真实 Redis
class DistributedLockIntegrationTest {
@Container
static RedisContainer redis = new RedisContainer("redis:6.2")
.withExposedPorts(6379);
@DynamicPropertySource
static void redisProperties(DynamicPropertyRegistry registry) {
registry.add("example.lock.redis.address", () -> String.format("redis://%s:%d", redis.getHost(), redis.getFirstMappedPort()));
}
@Autowired
private DistributedLock distributedLock;
@Test
void testDistributedLockInRealRedis() {
// given
String lockKey = "integration-test-key";
// when
boolean acquired = distributedLock.tryLock(lockKey, 5000, 1000);
// then
assertTrue(acquired);
// 再次获取应该失败
boolean acquiredAgain = distributedLock.tryLock(lockKey, 5000, 1000);
assertFalse(acquiredAgain);
// 释放后可以再次获取
distributedLock.unlock(lockKey);
distributedLock.tryLock(lockKey, , );
assertTrue(acquiredAfterRelease);
}
}
@SpringBootTest
@Tag("performance")
class DistributedLockPerformanceTest {
@Autowired
private DistributedLock distributedLock;
@Test
@RepeatedTest(10) // 重复 10 次
void testLockAcquirePerformance() {
// warm up
IntStream.range(0, 1000).parallel().forEach(i -> {
distributedLock.tryLock("perf-" + i, 1000, 100);
});
// actual test
long startTime = System.nanoTime();
IntStream.range(0, 10000).parallel().forEach(i -> {
distributedLock.tryLock("perf-" + i, 1000, 100);
});
long duration = System.nanoTime() - startTime;
double avgTime = duration / 10000.0 / 1_000_000.0; // 转换为毫秒
System.out.printf("平均获取锁时间：%.3f ms%n", avgTime);
// 断言：平均时间应小于 1ms
assertTrue(avgTime < 1.0, "锁获取时间过长：" + avgTime + "ms");
}
}
<!-- pom.xml 配置 -->
<project>
<modelVersion>4.0.0</modelVersion>
<groupId>com.example</groupId>
<artifactId>distributed-lock-spring-boot-starter</artifactId>
<version>1.0.0</version>
<packaging>jar</packaging>
<name>Example Distributed Lock Starter</name>
<description>Spring Boot Starter for distributed lock</description>
<!-- 许可证信息 -->
<licenses>
<license>
<name>Apache License, Version 2.0</name>
<url>https://www.apache.org/licenses/LICENSE-2.0</url>
</license>
</licenses>
<!-- SCM 信息 -->
<scm>
<url>https://github.com/example/distributed-lock-starter</url>
<connection>scm:git:git://github.com/example/distributed-lock-starter.git
scm:git:ssh://github.com/example/distributed-lock-starter.git
Your Name
[email protected]
Example Inc.
example-releases
https://maven.example.com/repository/releases
example-snapshots
https://maven.example.com/repository/snapshots
我推荐使用语义化版本（Semantic Versioning）：
图 2：语义化版本管理流程
实际例子：
1.0.0：第一个稳定版本1.0.1：修复 bug1.1.0：新增功能，向后兼容2.0.0：破坏性变更Starter 的依赖管理要特别小心：
<dependencyManagement>
<dependencies>
<!-- 统一管理 Spring Boot 版本 -->
<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>
<dependencies>
<!-- 必须的依赖 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
<scope>compile</scope>
<!-- 注意：不要带版本号，由 dependencyManagement 管理 -->
</dependency>
<!-- 可选依赖：用户想用 Redis 锁时才需要 -->
<dependency>
org.redisson
redisson-spring-boot-starter
provided
true
org.springframework.boot
spring-boot-starter-test
test
关键点：可选依赖用 <optional>true</optional>，这样用户的项目不会强制引入这些依赖。
当 Starter 多了之后，就需要考虑架构了。在大型企业中，我们是这样组织的：
example-spring-boot-starters/
# 父项目
├── example-spring-boot-starter-parent # 父 pom，统一管理
├── example-spring-boot-starter-lock # 分布式锁
├── example-spring-boot-starter-id # ID 生成器
├── example-spring-boot-starter-mq # 消息队列
├── example-spring-boot-starter-cache # 缓存
├── example-spring-boot-starter-trace # 链路追踪
└── example-spring-boot-starter-all # 全家桶（可选）
复杂的 Starter 之间可能有依赖关系，需要仔细管理：
<!-- example-spring-boot-starter-cache 的 pom.xml -->
<dependencies>
<!-- 内部依赖：先于其他 Starter 发布 -->
<dependency>
<groupId>com.example</groupId>
<artifactId>example-spring-boot-starter-lock</artifactId>
<version>${project.version}</version>
<optional>true</optional>
</dependency>
</dependencies>
多个 Starter 可能有相同的配置项（比如 Redis 地址），需要统一：
// 公共配置类
@ConfigurationProperties(prefix = "example")
public class ExampleCommonProperties {
/**
* 公共 Redis 配置
*/
private RedisCommonConfig redis = new RedisCommonConfig();
/**
* 公共 Zookeeper 配置
*/
private ZkCommonConfig zookeeper = new ZkCommonConfig();
/**
* 监控配置
*/
private MonitorConfig monitor = new MonitorConfig();
@Data
public static class RedisCommonConfig {
private String address = "redis://localhost:6379";
private String password;
private int database = 0;
}
// 其他配置类...
}
// 在各个 Starter 中引用
@ConfigurationProperties(prefix = "example.lock")
public class LockProperties {
@Autowired
private ExampleCommonProperties commonProperties;
// 优先使用专属配置，没有则用公共配置
String {
StringUtils.hasText(redis.getAddress()) ? redis.getAddress() : commonProperties.getRedis().getAddress();
}
}
我总结了 Starter 开发中最常见的 10 个问题：
排查步骤：
META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports 文件# 启动时加参数查看自动配置报告
java -jar app.jar --debug
# 或者在代码中获取
@Autowired
private List<String> autoConfigurations;
解决方案：
@Bean
@ConditionalOnMissingBean // 关键：用户有自定义时，不用我们的
public SomeBean someBean() {
return new SomeBean();
}
// 或者用@Primary 指定优先级
@Bean
@Primary
public SomeBean defaultSomeBean() {
return new SomeBean();
}
排查：
spring-configuration-metadata.json 格式// 在 Starter 中添加配置验证
@PostConstruct
public void validateConfig() {
if (!isValid(config)) {
throw new IllegalStateException("配置无效：" + config);
}
}
// 在自动配置类中加断点
@AutoConfiguration
public class MyAutoConfiguration {
public MyAutoConfiguration() {
// 这里加断点，可以看到什么时候被加载
System.out.println("MyAutoConfiguration 被加载");
}
}
@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication app = new SpringApplication(Application.class);
// 添加监听器，输出条件评估报告
app.addListeners(new ApplicationListener<ApplicationPreparedEvent>() {
@Override
public void onApplicationEvent(ApplicationPreparedEvent event) {
ConditionEvaluationReport report = ConditionEvaluationReport.get(event.getApplicationContext().getBeanFactory());
// 打印报告到文件
try (PrintWriter writer = new PrintWriter("condition-report.txt")) {
report.getConditionAndOutcomesBySource().forEach((source, outcomes) -> {
writer.println(source);
outcomes.forEach(outcome -> {
writer.println(" " + outcome.getOutcome());
});
});
}
}
});
app.run(args);
}
}
# application.yml
management:
endpoints:
web:
exposure:
include: conditions,beans,configprops
然后访问：
/actuator/conditions：查看条件评估详情/actuator/beans：查看所有 Bean/actuator/configprops：查看配置属性写了这么多年 Starter，我最大的体会是：技术是术，设计思想才是道。
好的 Starter 不是代码堆砌，而是对开发者体验的极致追求。你看 Spring Boot 官方的 Starter，每一个都经过精心设计：
所以，在你动手写 Starter 之前，先问自己几个问题：
记住：你写的不是代码，是生产力工具。好的 Starter 能让团队效率翻倍，坏的 Starter 能让团队陷入泥潭。
最后建议：别光看，动手写一个！从最简单的开始，比如一个 hello-spring-boot-starter，让它根据配置输出不同的问候语。写完了发布到公司的 Maven 仓库，让同事用起来。实战一次，胜过看百篇文章。
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
查找任何按下的键的javascript键代码、代码、位置和修饰符。 在线工具，Keycode 信息在线工具，online
JavaScript 字符串转义/反转义；Java 风格 \uXXXX（Native2Ascii）编码与解码。 在线工具，Escape 与 Native 编解码在线工具，online
使用 Prettier 在浏览器内格式化 JavaScript 或 HTML 片段。 在线工具，JavaScript / HTML 格式化在线工具，online
Terser 压缩、变量名混淆，或 javascript-obfuscator 高强度混淆（体积会增大）。 在线工具，JavaScript 压缩与混淆在线工具，online
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online