1. 引言：条件化加载Bean的必要性
在spring boot应用开发中，我们经常需要根据不同的环境、配置或业务需求来启用或禁用特定的功能模块。条件化加载（conditional loading）是spring框架提供的一项强大功能，它允许我们精确控制哪些bean应该被spring容器实例化。@conditionalonproperty是实现这一目标的关键注解之一，它根据spring环境中的属性值来决定bean是否应该被创建。
然而，在使用@ConditionalOnProperty时，尤其当结合@ConfigurationProperties和多个配置类时，可能会遇到一些挑战。本文将通过一个实际案例，详细阐述如何正确地应用这些注解，以实现组件的按需加载。
2. 问题分析：为何初始尝试失败
假设我们有多个组件（ComponentAConfig, ComponentBConfig, ComponentCConfig），并希望通过一个配置属性（如application.use）来决定加载哪一个。最初的尝试可能是在每个组件类上使用@ConditionalOnProperty，并将它们都定义为@Configuration类，然后在一个主配置类中尝试收集它们。
// 原始尝试的核心问题示例（伪代码，仅为说明问题）
@Configuration
@ConditionalOnProperty(prefix = "application", name = "use", havingValue = "componentA")
public class ComponentAConfig extends ComponentConfig { /* ... */ }
@Configuration
@ConditionalOnProperty(prefix = "application", name = "use", havingValue = "componentB")
public class ComponentBConfig extends ComponentConfig { /* ... */ }
// ... 类似ComponentCConfig
@Configuration
@ConfigurationProperties(prefix = "application.components")
public class MainConfig {
// 试图通过这种方式来收集，但@ConditionalOnProperty可能无法阻止这些List的实例化
private List componentA = new ArrayList<>();
private List componentB = new ArrayList<>();
private List componentC = new ArrayList<>();
} 这种方法失败的原因在于：
- @Configuration的生命周期：被@Configuration注解的类会被Spring容器优先处理，即使其内部的@Bean方法是条件化的，但@Configuration类本身通常会被实例化。
- @ConfigurationProperties的绑定机制：当MainConfig被@ConfigurationProperties(prefix = "application.components")注解时，Spring会尝试将application.components下的所有属性绑定到MainConfig的相应字段上。此时，ComponentAConfig、ComponentBConfig等虽然也带有@Configuration和@ConditionalOnProperty，但MainConfig的属性绑定过程并不会受到这些条件注解的直接影响，导致其内部的List仍会被初始化，即使对应的组件没有被实际加载为Spring Bean。
- 误解条件注解的作用范围：@ConditionalOnProperty是控制Bean的创建，而不是控制属性的绑定。如果MainConfig尝试绑定所有可能的组件列表，它会尝试去查找并绑定这些属性，而不会因为某个组件的@ConditionalOnProperty条件不满足就跳过其对应的属性绑定。
正确的做法是让每个组件成为独立的Spring Bean，并直接对其应用条件注解，然后通过依赖注入来获取当前激活的组件。
3. 解决方案：重构与条件化组件加载
为了实现精确的条件化加载，我们需要对代码结构进行如下重构：
3.1 定义组件的配置部分
首先，定义一个POJO类来表示每个组件的具体配置项。
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@NoArgsConstructor
public class ComponentConfigPart {
private String ex1;
private String ex2;
private String ex3;
}3.2 定义抽象组件基类
创建一个抽象基类ComponentConfig，它将包含所有组件共有的属性（例如，一个ComponentConfigPart列表）和一些初始化逻辑。
import lombok.Data;
import javax.annotation.PostConstruct;
import java.util.ArrayList;
import java.util.List;
@Data
public abstract class ComponentConfig {
private List parts = new ArrayList<>();
@PostConstruct
public void init() {
System.out.println("Created instance of " + this.getClass().getSimpleName());
System.out.println("Created " + this);
}
} @PostConstruct注解用于在Bean初始化完成后执行一些自定义逻辑，这里我们用它来打印日志，以便观察哪个组件被实际加载。
3.3 实现具体的条件化组件
现在，我们为每个具体的组件（A、B、C）创建独立的类，它们将：
- 继承自ComponentConfig。
- 使用@Component注解，使其成为Spring管理的Bean。
- 使用@ConfigurationProperties注解，绑定其特有的配置属性。
- 使用@ConditionalOnProperty注解，根据application.use属性的值来决定是否创建此Bean。
ComponentAConfig.java
import lombok.ToString;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
@Component
@ConfigurationProperties(prefix = "application.components.a")
@ConditionalOnProperty(prefix = "application", name = "use", havingValue = "componentA")
@ToString(callSuper = true)
public class ComponentAConfig extends ComponentConfig {
}ComponentBConfig.java
import lombok.ToString;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
@Component
@ConfigurationProperties(prefix = "application.components.b")
@ConditionalOnProperty(prefix = "application", name = "use", havingValue = "componentB")
@ToString(callSuper = true)
public class ComponentBConfig extends ComponentConfig {
}ComponentCConfig.java (示例，与A、B类似)
import lombok.ToString;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
@Component
@ConfigurationProperties(prefix = "application.components.c")
@ConditionalOnProperty(prefix = "application", name = "use", havingValue = "componentC")
@ToString(callSuper = true)
public class ComponentCConfig extends ComponentConfig {
}通过将@Component、@ConfigurationProperties和@ConditionalOnProperty直接应用于具体的组件类，我们确保了只有当application.use属性的值与havingValue匹配时，该组件才会被Spring容器扫描、绑定属性并实例化为Bean。
3.4 主配置类：注入激活的组件
现在，我们需要一个地方来使用这个被条件化加载的组件。我们可以创建一个主配置类或服务类，通过@Autowired注入ComponentConfig的实例。由于Spring只会加载一个满足条件的具体实现，所以这里可以安全地注入抽象基类。
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import javax.annotation.PostConstruct;
@Configuration
public class MainConfig {
@Autowired(required = false) // 使用required = false，以防没有组件被激活
private ComponentConfig config;
@PostConstruct
public void init() {
if (config != null) {
System.out.println("MainConfig has autowired class of " + config.getClass().getSimpleName());
} else {
System.out.println("No ComponentConfig bean was loaded.");
}
}
}注意：@Autowired(required = false)是一个可选但推荐的做法，以防万一没有任何组件满足条件被加载时，应用不会因为找不到Bean而启动失败。在实际应用中，你可能需要更健壮的错误处理或默认行为。
4. 配置文件示例
现在，我们来看application.yml如何配置。
4.1 激活 ComponentA
当application.use设置为componentA时：
application:
components:
a:
parts:
- ex1: a
ex2: aa
ex3: aaa
- ex1: a2
ex2: aa2
ex3: aaa2
b: # 即使存在b的配置，但因为use不是componentB，ComponentBConfig不会被加载
parts:
- ex1: b
ex2: bb
ex3: bbb
- ex1: b2
ex2: bb2
ex3: bbb2
use: componentA # 关键设置控制台输出：
Created instance of ComponentAConfig Created ComponentAConfig(super=ComponentConfig(parts=[ComponentConfigPart(ex1=a, ex2=aa, ex3=aaa), ComponentConfigPart(ex1=a2, ex2=aa2, ex3=aaa2)])) MainConfig has autowired class of ComponentAConfig
可以看到，只有ComponentAConfig被实例化并绑定了其对应的属性。
4.2 激活 ComponentB
当application.use设置为componentB时：
application:
components:
a:
parts:
- ex1: a
ex2: aa
ex3: aaa
- ex1: a2
ex2: aa2
ex3: aaa2
b:
parts:
- ex1: b
ex2: bb
ex3: bbb
- ex1: b2
ex2: bb2
ex3: bbb2
use: componentB # 关键设置控制台输出：
Created instance of ComponentBConfig Created ComponentBConfig(super=ComponentConfig(parts=[ComponentConfigPart(ex1=b, ex2=bb, ex3=bbb), ComponentConfigPart(ex1=b2, ex2=bb2, ex3=bbb2)])) MainConfig has autowired class of ComponentBConfig
此时，ComponentBConfig被实例化，而ComponentAConfig则不会。
5. 注意事项与最佳实践
- @ConditionalOnProperty的精确性：确保prefix、name和havingValue与你的application.yml或application.properties中的属性精确匹配。
- 避免冗余配置：尽管其他组件的配置属性可能存在于application.yml中，但由于@ConditionalOnProperty的存在，它们不会被绑定到未激活的组件实例上。
- 默认值处理：如果@ConditionalOnProperty的条件不满足，Bean将不会被创建。如果需要一个默认行为，可以考虑使用@ConditionalOnMissingBean或提供一个非条件化的默认实现。
- 抽象与多态：通过定义抽象基类（ComponentConfig）并注入它，可以实现多态性，使得使用方无需关心具体加载的是哪个组件，提高了代码的灵活性和可维护性。
- Lombok集成：本文示例使用了Lombok的@Data、@NoArgsConstructor和@ToString注解，它们可以极大地简化POJO类的编写，减少样板代码。
- @Configuration与@Component的选择：当你的类主要用于定义Bean并包含业务逻辑时，使用@Component是更常见的做法。@Configuration通常用于定义包含@Bean方法的配置类，或作为Spring Boot应用的主配置入口。在这个场景中，将每个组件定义为@Component并直接应用条件注解是更简洁有效的。
6. 总结
通过本文的详细讲解和示例，我们学习了如何在Spring Boot中有效地利用@ConditionalOnProperty和@ConfigurationProperties实现Bean的条件化加载。关键在于将每个可条件加载的组件定义为独立的Spring Bean（使用@Component），并直接在其上应用@ConditionalOnProperty注解，同时配合@ConfigurationProperties进行属性绑定。这种方法确保了Spring容器只创建和初始化满足条件的组件，从而实现了高度灵活和资源优化的应用架构。
