Spring Boot Bean定义覆盖警告与@Primary冲突深度解析

Spring Boot Bean定义覆盖警告与@Primary冲突深度解析

一、问题现象与核心原因

1.1 典型警告信息

# 最常见的Bean覆盖警告
***************************
APPLICATION FAILED TO START
***************************

Description:

The bean 'dataSource', defined in class path resource [com/example/DataSourceConfig.class],
could not be registered. A bean with that name has already been defined in class path
resource [org/springframework/boot/autoconfigure/jdbc/DataSourceConfiguration$Hikari.class]
and overriding is disabled.

Action:

Consider renaming one of the beans or enabling overriding by setting
spring.main.allow-bean-definition-overriding=true

# 或者多个@Primary冲突警告
2024-01-20T10:30:00.000Z WARN 12345 — [ main] ConfigServletWebServerApplicationContext :
Overriding bean definition for bean 'myService' with a different definition:
replacing [Generic bean: class [com.example.PrimaryService]; scope=singleton;
abstract=false; lazyInit=null; autowireMode=0; dependencyCheck=0; autowireCandidate=true;
primary=true; factoryBeanName=null; factoryMethodName=null; initMethodName=null;
destroyMethodName=null; defined in file [/path/to/PrimaryService.class]] with
[Generic bean: class [com.example.AnotherPrimaryService]; scope=singleton; abstract=false;
lazyInit=null; autowireMode=0; dependencyCheck=0; autowireCandidate=true; primary=true;
factoryBeanName=null; factoryMethodName=null; initMethodName=null; destroyMethodName=null;
defined in file [/path/to/AnotherPrimaryService.class]]

1.2 根本原因分析

Spring Boot 2.1+默认禁止Bean定义覆盖，原因包括：

二、诊断工具与方法

2.1 启用详细Bean定义日志

# application.yml
logging:
level:
org.springframework.beans.factory.support.DefaultListableBeanFactory: DEBUG
org.springframework.context.annotation.ClassPathBeanDefinitionScanner: DEBUG
org.springframework.boot.autoconfigure: DEBUG
pattern:
console: "%d{ISO8601} [%thread] %-5level %logger{36} – %msg%n"

2.2 使用BeanDefinitionRegistryPostProcessor诊断

@Component
public class BeanConflictDetector implements BeanDefinitionRegistryPostProcessor {

private static final Logger log = LoggerFactory.getLogger(BeanConflictDetector.class);

@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry)
throws BeansException {

String[] beanNames = registry.getBeanDefinitionNames();
Map<String, List<String>> beanNameToSources = new HashMap<>();

for (String beanName : beanNames) {
BeanDefinition beanDef = registry.getBeanDefinition(beanName);
String source = beanDef.getResourceDescription() != null
? beanDef.getResourceDescription()
: "unknown";

beanNameToSources.computeIfAbsent(beanName, k -> new ArrayList<>()).add(source);
}

// 检测冲突
beanNameToSources.forEach((beanName, sources) -> {
if (sources.size() > 1) {
log.warn("⚠️ Bean名称冲突: {} 定义在多个位置:", beanName);
sources.forEach(source -> log.warn(" – {}", source));

// 检查@Primary冲突
checkPrimaryConflict(registry, beanName);
}
});
}

private void checkPrimaryConflict(BeanDefinitionRegistry registry, String beanName) {
BeanDefinition beanDef = registry.getBeanDefinition(beanName);
if (beanDef.isPrimary()) {
log.error("❌ 检测到@Primary冲突: bean '{}' 被标记为primary", beanName);

// 查找同一类型的其他Primary Bean
try {
Class<?> beanType = Class.forName(beanDef.getBeanClassName());
String[] allBeans = registry.getBeanNamesForType(beanType);

long primaryCount = Arrays.stream(allBeans)
.filter(name -> registry.getBeanDefinition(name).isPrimary())
.count();

if (primaryCount > 1) {
log.error("🚨 类型 {} 有多个@Primary Bean", beanType.getName());
}
} catch (Exception e) {
// 忽略类型加载错误
}
}
}

@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)
throws BeansException {
// 可选：BeanFactory级别的检查
}
}

2.3 使用ConditionEvaluationReport

@Component
public class BeanOverrideAnalyzer implements ApplicationRunner {

@Autowired
private ApplicationContext context;

@Override
public void run(ApplicationArguments args) {
analyzeBeanOverrides();
analyzePrimaryConflicts();
}

private void analyzeBeanOverrides() {
ConfigurableListableBeanFactory beanFactory =
(ConfigurableListableBeanFactory) context.getAutowireCapableBeanFactory();

Map<String, BeanDefinition> beanDefinitions = new HashMap<>();

for (String beanName : beanFactory.getBeanDefinitionNames()) {
BeanDefinition beanDef = beanFactory.getBeanDefinition(beanName);
String source = beanDef.getResourceDescription();

if (beanDefinitions.containsKey(beanName)) {
BeanDefinition existingDef = beanDefinitions.get(beanName);
log.error("Bean定义覆盖检测:");
log.error(" Bean名称: {}", beanName);
log.error(" 原始定义: {}", existingDef.getResourceDescription());
log.error(" 新定义: {}", source);
log.error(" 原始类型: {}", existingDef.getBeanClassName());
log.error(" 新类型: {}", beanDef.getBeanClassName());
} else {
beanDefinitions.put(beanName, beanDef);
}
}
}

private void analyzePrimaryConflicts() {
ConfigurableListableBeanFactory beanFactory =
(ConfigurableListableBeanFactory) context.getAutowireCapableBeanFactory();

Map<Class<?>, List<String>> typeToPrimaryBeans = new HashMap<>();

for (String beanName : beanFactory.getBeanDefinitionNames()) {
BeanDefinition beanDef = beanFactory.getBeanDefinition(beanName);

if (beanDef.isPrimary()) {
try {
Class<?> beanType = beanFactory.getType(beanName);
if (beanType != null) {
typeToPrimaryBeans.computeIfAbsent(beanType, k -> new ArrayList<>())
.add(beanName);
}
} catch (Exception e) {
// 忽略无法获取类型的Bean
}
}
}

typeToPrimaryBeans.forEach((type, beanNames) -> {
if (beanNames.size() > 1) {
log.error("🚨 @Primary冲突: 类型 {} 有多个@Primary Bean:", type.getName());
beanNames.forEach(name -> log.error(" – {}", name));
}
});
}
}

三、解决方案

3.1 解决方案1：明确Bean命名策略

3.1.1 使用明确的Bean名称

@Configuration
public class ExplicitBeanNamingConfig {

// ❌ 问题代码：依赖默认命名
@Bean
public DataSource dataSource() {
return new HikariDataSource();
}

// ✅ 解决方案1：明确指定Bean名称
@Bean("myAppDataSource")
public DataSource appDataSource() {
return new HikariDataSource();
}

// ✅ 解决方案2：使用方法名作为Bean名称
@Bean
public DataSource appDataSource() { // 方法名就是Bean名称
return new HikariDataSource();
}
}

// 在需要注入的地方使用@Qualifier
@Component
public class DataService {

@Autowired
@Qualifier("appDataSource") // 明确指定注入哪个Bean
private DataSource dataSource;
}

3.1.2 模块化Bean命名

// 模块A的配置
@Configuration
public class ModuleAConfig {

@Bean("moduleA.dataSource")
public DataSource moduleADataSource() {
return DataSourceBuilder.create()
.url("jdbc:h2:mem:moduleA")
.build();
}

@Bean("moduleA.service")
public Service moduleAService() {
return new ModuleAService();
}
}

// 模块B的配置
@Configuration
public class ModuleBConfig {

@Bean("moduleB.dataSource")
public DataSource moduleBDataSource() {
return DataSourceBuilder.create()
.url("jdbc:h2:mem:moduleB")
.build();
}

@Bean("moduleB.service")
public Service moduleBService() {
return new ModuleBService();
}
}

// 主配置，选择使用哪个模块
@Configuration
public class PrimaryConfig {

@Bean
@Primary // 明确指定主要使用的Bean
@Qualifier("moduleA.service")
public Service primaryService() {
// 或者返回其中一个具体的Bean
return null; // 实际由Spring注入
}
}

3.2 解决方案2：正确处理@Primary冲突

3.2.1 单一@Primary策略

@Configuration
public class SinglePrimaryStrategyConfig {

// 方案1：集中管理@Primary
@Configuration
@EnableConfigurationProperties(DataSourceProperties.class)
public static class PrimaryDataSourceConfig {

@Bean
@Primary // 唯一的@Primary DataSource
@ConfigurationProperties(prefix = "spring.datasource.primary")
public DataSource primaryDataSource() {
return DataSourceBuilder.create().build();
}
}

@Configuration
public static class SecondaryDataSourceConfig {

@Bean("secondaryDataSource") // 不使用@Primary，但有明确名称
@ConfigurationProperties(prefix = "spring.datasource.secondary")
public DataSource secondaryDataSource() {
return DataSourceBuilder.create().build();
}
}

// 方案2：使用条件注解控制@Primary
@Configuration
public static class ConditionalPrimaryConfig {

@Bean
@ConditionalOnProperty(name = "datasource.primary.enabled", havingValue = "true")
@Primary
public DataSource hikariPrimaryDataSource() {
return new HikariDataSource();
}

@Bean
@ConditionalOnProperty(name = "datasource.primary.enabled", havingValue = "false", matchIfMissing = true)
@Primary
public DataSource tomcatPrimaryDataSource() {
return DataSourceBuilder.create()
.type(org.apache.tomcat.jdbc.pool.DataSource.class)
.build();
}
}
}

3.2.2 @Primary优先级管理

// 使用@Order或@AutoConfigureOrder控制@Primary的优先级
@Configuration
@Order(Ordered.HIGHEST_PRECEDENCE) // 最高优先级
public class HighPriorityPrimaryConfig {

@Bean
@Primary // 这个@Primary会生效
public HighPriorityService highPriorityService() {
return new HighPriorityService();
}
}

@Configuration
@Order(Ordered.LOWEST_PRECEDENCE) // 低优先级
public class LowPriorityPrimaryConfig {

@Bean
@Primary // 这个@Primary会被忽略（因为已经有更高优先级的@Primary）
public LowPriorityService lowPriorityService() {
return new LowPriorityService();
}
}

// 或者使用@AutoConfigureAfter
@Configuration
@AutoConfigureAfter(HighPriorityPrimaryConfig.class)
public class ConditionalPrimaryConfig {

@Bean
@ConditionalOnMissingBean(Service.class) // 确保没有Service时才创建
@Primary
public Service fallbackService() {
return new FallbackService();
}
}

3.3 解决方案3：禁用自动配置冲突

3.3.1 排除冲突的自动配置

@SpringBootApplication
// 排除Spring Boot的自动配置
@EnableAutoConfiguration(exclude = {
DataSourceAutoConfiguration.class,
DataSourceTransactionManagerAutoConfiguration.class,
HibernateJpaAutoConfiguration.class
})
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}

// 或者在application.yml中排除
# application.yml
spring:
autoconfigure:
exclude:
– org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration
– org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration

3.3.2 使用@ConditionalOnMissingBean保护自定义配置

@Configuration
public class ProtectedCustomConfig {

// 使用@ConditionalOnMissingBean保护自定义Bean
@Bean
@ConditionalOnMissingBean // 没有DataSource时才创建
public DataSource dataSource() {
return new MyCustomDataSource();
}

// 更精确的条件检查
@Bean
@ConditionalOnMissingBean(name = "dataSource", type = HikariDataSource.class)
public HikariDataSource hikariDataSource() {
return new HikariDataSource();
}
}

// 或者使用@ConditionalOnProperty
@Configuration
@ConditionalOnProperty(name = "custom.datasource.enabled", havingValue = "true")
public class ConditionalCustomConfig {

@Bean
@Primary // 仅在启用自定义配置时才标记为@Primary
public DataSource customDataSource() {
return new CustomDataSource();
}
}

3.4 解决方案4：启用Bean定义覆盖（谨慎使用）

3.4.1 临时解决方案

# application.yml – 临时启用Bean覆盖
spring:
main:
allow-bean-definition-overriding: true # 谨慎使用！

logging:
level:
org.springframework.beans.factory.support.DefaultListableBeanFactory: WARN

3.4.2 有控制的覆盖策略

@Configuration
public class ControlledBeanOverrideConfig {

// 方案1：使用BeanPostProcessor控制覆盖
@Bean
public static BeanFactoryPostProcessor beanOverrideController() {
return beanFactory -> {
if (beanFactory instanceof ConfigurableListableBeanFactory) {
ConfigurableListableBeanFactory clBeanFactory =
(ConfigurableListableBeanFactory) beanFactory;

// 允许特定Bean的覆盖
Set<String> allowedOverrides = Set.of(
"dataSource",
"entityManagerFactory"
);

// 自定义覆盖逻辑
for (String beanName : clBeanFactory.getBeanDefinitionNames()) {
if (allowedOverrides.contains(beanName)) {
BeanDefinition beanDef = clBeanFactory.getBeanDefinition(beanName);
// 修改Bean定义或允许覆盖
}
}
}
};
}

// 方案2：使用自定义BeanDefinitionRegistryPostProcessor
@Bean
public static BeanDefinitionRegistryPostProcessor smartOverrideProcessor() {
return new BeanDefinitionRegistryPostProcessor() {
@Override
public void postProcessBeanDefinitionRegistry(
BeanDefinitionRegistry registry) throws BeansException {

// 智能处理覆盖
String[] beanNames = registry.getBeanDefinitionNames();

for (String beanName : beanNames) {
BeanDefinition beanDef = registry.getBeanDefinition(beanName);

// 如果是@Primary Bean，检查冲突
if (beanDef.isPrimary()) {
handlePrimaryConflict(registry, beanName, beanDef);
}
}
}

@Override
public void postProcessBeanFactory(
ConfigurableListableBeanFactory beanFactory) throws BeansException {
// BeanFactory后处理
}

private void handlePrimaryConflict(
BeanDefinitionRegistry registry,
String beanName,
BeanDefinition beanDef) {

// 查找同类型的其他Bean
try {
Class<?> beanType = Class.forName(beanDef.getBeanClassName());
String[] allBeans = registry.getBeanNamesForType(beanType);

long primaryCount = Arrays.stream(allBeans)
.filter(name -> registry.getBeanDefinition(name).isPrimary())
.count();

if (primaryCount > 1) {
log.warn("检测到多个@Primary Bean: {}", beanType.getName());

// 解决方案：只保留第一个@Primary，移除其他的
boolean firstPrimary = true;
for (String name : allBeans) {
BeanDefinition def = registry.getBeanDefinition(name);
if (def.isPrimary()) {
if (firstPrimary) {
firstPrimary = false;
} else {
def.setPrimary(false); // 移除额外的@Primary标记
log.info("移除Bean '{}' 的@Primary标记", name);
}
}
}
}
} catch (Exception e) {
// 忽略异常
}
}
};
}
}

3.5 解决方案5：模块化架构设计

3.5.1 使用@ConfigurationProperties分离配置

// 主配置类，不定义具体Bean
@Configuration
@EnableConfigurationProperties({
PrimaryDataSourceProperties.class,
SecondaryDataSourceProperties.class
})
public class ModularDataSourceConfig {

@Bean
@Primary
@ConfigurationProperties(prefix = "datasource.primary")
public DataSource primaryDataSource(
PrimaryDataSourceProperties properties) {
return createDataSource(properties);
}

@Bean("secondaryDataSource")
@ConfigurationProperties(prefix = "datasource.secondary")
public DataSource secondaryDataSource(
SecondaryDataSourceProperties properties) {
return createDataSource(properties);
}

private DataSource createDataSource(DataSourceProperties properties) {
return DataSourceBuilder.create()
.url(properties.getUrl())
.username(properties.getUsername())
.password(properties.getPassword())
.build();
}
}

// 属性配置类
@ConfigurationProperties(prefix = "datasource.primary")
public class PrimaryDataSourceProperties extends DataSourceProperties {
// 可以添加Primary特有的属性
}

@ConfigurationProperties(prefix = "datasource.secondary")
public class SecondaryDataSourceProperties extends DataSourceProperties {
// 可以添加Secondary特有的属性
}

3.5.2 使用@Import选择性加载配置

// 主应用，选择性导入配置
@SpringBootApplication
@Import({
CoreModuleConfig.class,
ConditionalModuleConfig.class // 有条件地加载
})
public class ModularApplication {

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

// 核心模块配置
@Configuration
@Order(Ordered.HIGHEST_PRECEDENCE)
public class CoreModuleConfig {

@Bean
@Primary // 核心模块的Bean标记为@Primary
public CoreService coreService() {
return new CoreServiceImpl();
}
}

// 条件模块配置
@Configuration
@ConditionalOnProperty(name = "module.extra.enabled", havingValue = "true")
@Order(Ordered.LOWEST_PRECEDENCE) // 低优先级
public class ConditionalModuleConfig {

@Bean
public ExtraService extraService() {
return new ExtraServiceImpl();
}

// 注意：不标记@Primary，避免冲突
}

四、Spring Boot 3.x特定优化

4.1 使用@AutoConfiguration替代传统@Configuration

// Spring Boot 3.x的@AutoConfiguration有更好的加载顺序控制
@AutoConfiguration(
before = DataSourceAutoConfiguration.class, // 在DataSource自动配置之前
after = DataSourcePoolMetadataProvidersConfiguration.class
)
@ConditionalOnClass({DataSource.class, HikariDataSource.class})
@EnableConfigurationProperties(HikariDataSourceProperties.class)
public class CustomHikariAutoConfiguration {

// 使用@ConditionalOnMissingBean确保不会冲突
@Bean
@ConditionalOnMissingBean(DataSource.class)
@Primary // 安全地标记为@Primary，因为确保没有其他DataSource
public DataSource dataSource(HikariDataSourceProperties properties) {
HikariDataSource dataSource = properties
.initializeDataSourceBuilder()
.type(HikariDataSource.class)
.build();

// 自定义配置
return dataSource;
}
}

// 专门处理@Primary冲突的配置
@AutoConfiguration(after = {DataSourceAutoConfiguration.class})
@ConditionalOnSingleCandidate(DataSource.class) // 确保只有一个DataSource候选
public class PrimaryDataSourceResolver {

@Bean
@Primary // 安全：确保只有一个DataSource时才标记为@Primary
public DataSource primaryDataSource(DataSource dataSource) {
// 实际上返回已存在的DataSource，但确保它有@Primary标记
return dataSource;
}
}

4.2 使用RuntimeHints处理Bean定义

// Spring Boot 3.x新增的RuntimeHints API
@Configuration
public class BeanDefinitionHints implements RuntimeHintsRegistrar {

@Override
public void registerHints(RuntimeHints hints, ClassLoader classLoader) {
// 注册需要反射的Bean类
hints.reflection().registerType(
PrimaryService.class,
MemberCategory.INVOKE_PUBLIC_METHODS,
MemberCategory.INVOKE_DECLARED_CONSTRUCTORS
);

// 注册资源文件
hints.resources().registerPattern("META-INF/beans/*.xml");
}
}

// 结合@ImportRuntimeHints使用
@Configuration
@ImportRuntimeHints(BeanDefinitionHints.class)
public class HintEnabledConfig {

@Bean
@Primary
public PrimaryService primaryService() {
return new PrimaryService();
}
}

五、测试策略

5.1 Bean冲突检测测试

@SpringBootTest
class BeanConflictDetectionTest {

@Autowired
private ApplicationContext context;

@Test
void testNoDuplicateBeanNames() {
ConfigurableListableBeanFactory beanFactory =
(ConfigurableListableBeanFactory) context.getAutowireCapableBeanFactory();

Map<String, Integer> beanNameCount = new HashMap<>();

for (String beanName : beanFactory.getBeanDefinitionNames()) {
beanNameCount.merge(beanName, 1, Integer::sum);
}

List<String> duplicateBeans = beanNameCount.entrySet().stream()
.filter(entry -> entry.getValue() > 1)
.map(Map.Entry::getKey)
.collect(Collectors.toList());

assertTrue(duplicateBeans.isEmpty(),
"发现重复的Bean名称: " + duplicateBeans);
}

@Test
void testNoMultiplePrimaryBeans() {
ConfigurableListableBeanFactory beanFactory =
(ConfigurableListableBeanFactory) context.getAutowireCapableBeanFactory();

Map<Class<?>, List<String>> primaryBeansByType = new HashMap<>();

for (String beanName : beanFactory.getBeanDefinitionNames()) {
BeanDefinition beanDef = beanFactory.getBeanDefinition(beanName);

if (beanDef.isPrimary()) {
Class<?> beanType = beanFactory.getType(beanName);
if (beanType != null) {
primaryBeansByType
.computeIfAbsent(beanType, k -> new ArrayList<>())
.add(beanName);
}
}
}

List<String> conflicts = primaryBeansByType.entrySet().stream()
.filter(entry -> entry.getValue().size() > 1)
.map(entry -> String.format("%s: %s",
entry.getKey().getName(),
entry.getValue()))
.collect(Collectors.toList());

assertTrue(conflicts.isEmpty(),
"发现多个@Primary Bean: " + conflicts);
}

@Test
void testBeanDefinitionSources() {
// 验证Bean定义来源
ConfigurableListableBeanFactory beanFactory =
(ConfigurableListableBeanFactory) context.getAutowireCapableBeanFactory();

Map<String, String> beanSources = new HashMap<>();
boolean hasConflict = false;

for (String beanName : beanFactory.getBeanDefinitionNames()) {
BeanDefinition beanDef = beanFactory.getBeanDefinition(beanName);
String source = beanDef.getResourceDescription() != null
? beanDef.getResourceDescription()
: "unknown";

if (beanSources.containsKey(beanName)) {
String existingSource = beanSources.get(beanName);
if (!existingSource.equals(source)) {
hasConflict = true;
System.err.printf("警告: Bean '%s' 有多个定义来源:%n", beanName);
System.err.printf(" 来源1: %s%n", existingSource);
System.err.printf(" 来源2: %s%n", source);
}
} else {
beanSources.put(beanName, source);
}
}

assertFalse(hasConflict, "发现Bean定义冲突");
}
}

5.2 集成测试配置

@TestConfiguration
@Order(Ordered.HIGHEST_PRECEDENCE)
class TestPrimaryBeanConfig {

@Bean
@Primary // 测试环境中的@Primary Bean
@Qualifier("testPrimary")
public DataSource testDataSource() {
return new EmbeddedDatabaseBuilder()
.setType(EmbeddedDatabaseType.H2)
.generateUniqueName(true)
.build();
}

@Bean
@Qualifier("testSecondary")
public DataSource secondaryDataSource() {
return new EmbeddedDatabaseBuilder()
.setType(EmbeddedDatabaseType.H2)
.generateUniqueName(true)
.build();
}
}

@SpringBootTest
@Import(TestPrimaryBeanConfig.class)
class BeanOverrideIntegrationTest {

@Autowired
private ApplicationContext context;

@Test
void testPrimaryBeanInjection() {
// 当有多个同类型Bean时，应该注入@Primary的Bean
DataSource injectedDataSource = context.getBean(DataSource.class);

// 验证注入的是@Primary的Bean
DataSource primaryDataSource = context.getBean(
"testDataSource", DataSource.class);

assertSame(injectedDataSource, primaryDataSource,
"应该注入@Primary标记的Bean");
}

@Test
void testQualifierOverridesPrimary() {
// @Qualifier应该优先于@Primary
DataSource qualifiedDataSource = context.getBean(
"testSecondary", DataSource.class);

DataSource primaryDataSource = context.getBean(
"testDataSource", DataSource.class);

assertNotSame(qualifiedDataSource, primaryDataSource,
"@Qualifier应该能够选择非@Primary的Bean");
}
}

六、最佳实践总结

6.1 配置原则清单

6.2 问题排查流程

渲染错误: Mermaid 渲染失败: Parse error on line 6:
…型?} D –>|名称冲突| E[重命名或使用@Qualifier]
———————-^
Expecting 'AMP', 'COLON', 'DOWN', 'DEFAULT', 'NUM', 'COMMA', 'NODE_STRING', 'BRKT', 'MINUS', 'MULT', 'UNICODE_TEXT', got 'LINK_ID'

6.3 配置模板

// 安全的Bean定义模板
@Configuration(proxyBeanMethods = false)
@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE + 100) // 明确的顺序
@ConditionalOnProperty(prefix = "custom", name = "enabled", havingValue = "true")
public class SafeBeanConfiguration {

// 使用明确的Bean名称
@Bean("customDataSource")
@Primary // 谨慎使用，确保没有其他@Primary
@ConditionalOnMissingBean(name = "dataSource") // 保护性条件
@ConfigurationProperties(prefix = "custom.datasource")
public DataSource customDataSource() {
return DataSourceBuilder.create().build();
}

// 依赖注入使用@Qualifier
@Bean
public DataService dataService(
@Qualifier("customDataSource") DataSource dataSource) {
return new DataService(dataSource);
}

// 可选：使用BeanPostProcessor监控
@Bean
public static BeanFactoryPostProcessor beanMonitor() {
return beanFactory -> {
if (beanFactory instanceof ConfigurableListableBeanFactory) {
// 监控逻辑
}
};
}
}

通过上述系统化的分析和解决方案，可以有效地预防和解决Spring Boot中的Bean定义覆盖警告和@Primary冲突问题。关键在于理解Spring的Bean定义和初始化机制，并采取预防性的配置策略。