如何基于Java程序参数条件化实例化Spring Boot特定Bean？

核心思路 #

通过Spring Boot的@ConditionalOnProperty注解结合配置类，根据启动时的mode参数仅实例化对应模式下的Engine及其依赖Bean；同时抽象Engine接口实现依赖注入的统一化，消除硬编码判断逻辑。

步骤1：抽象Engine统一接口 #

定义所有Engine实现类的共同接口，方便后续统一注入：

public interface Engine {
    void execute();
}

步骤2：为各模式创建条件化配置类 #

为MODE_A和MODE_B分别创建独立配置类，用@ConditionalOnProperty指定触发条件，同时在配置类中声明该模式下的所有依赖Bean：

MODE_A配置类

@Configuration
@ConditionalOnProperty(name = "mode", havingValue = "MODE_A")
public class ModeAEngineConfig {

    @Bean
    public DependencyA dependencyA(EngineArguments engineArguments) {
        return new DependencyA(engineArguments);
    }

    @Bean
    public DependencyB dependencyB(EngineConfig engineConfig) {
        return new DependencyB(engineConfig);
    }

    @Bean
    public HelperService helperService(DependencyA dependencyA, DependencyB dependencyB) {
        return new HelperService(dependencyA, dependencyB);
    }

    @Bean
    public Engine modeAEngine(DependencyA dependencyA, HelperService helperService) {
        return new ModeAEngine(dependencyA, helperService);
    }
}

MODE_B配置类

@Configuration
@ConditionalOnProperty(name = "mode", havingValue = "MODE_B")
public class ModeBEngineConfig {

    @Bean
    public DependencyX dependencyX(EngineArguments engineArguments) {
        return new DependencyX(engineArguments);
    }

    @Bean
    public DependencyY dependencyY(EngineConfig engineConfig) {
        return new DependencyY(engineConfig);
    }

    @Bean
    public ProcessorService processorService(DependencyX dependencyX, DependencyY dependencyY) {
        return new ProcessorService(dependencyX, dependencyY);
    }

    @Bean
    public Engine modeBEngine(DependencyX dependencyX, ProcessorService processorService) {
        return new ModeBEngine(dependencyX, processorService);
    }
}

步骤3：简化EngineService逻辑 #

直接注入Engine接口，Spring会自动根据mode参数注入对应实现类，无需手动判断模式：

@Service
public class EngineService {

    private final Engine engine;

    public EngineService(Engine engine) {
        this.engine = engine;
    }

    @PostConstruct
    public void execute() {
        engine.execute();
    }
}

步骤4：确保程序参数被Spring正确读取 #

要让@ConditionalOnProperty能读取到mode参数，需确保参数被Spring环境加载：

• 如果是启动命令行参数（如--mode=MODE_A），Spring Boot会自动将其加入环境变量，无需额外配置；
• 如果是配置文件中的参数，在application.yml或application.properties中添加mode: MODE_A即可；
• 若需将参数绑定到EngineArguments类，可使用@ConfigurationProperties或@Value：

@Component
@ConfigurationProperties(prefix = "") // 无参数前缀时设为空
public class EngineArguments {
    private String mode;

    // Getter & Setter
    public String getMode() {
        return mode;
    }

    public void setMode(String mode) {
        this.mode = mode;
    }
}

异常处理：无有效模式时快速失败 #

添加默认配置类，当没有匹配的mode时，启动阶段直接抛出异常：

@Configuration
public class DefaultEngineConfig {
    @Bean
    @ConditionalOnMissingBean(Engine.class)
    public Engine defaultEngine() {
        throw new IllegalStateException("No valid engine found!");
    }
}

关键注意点 #

• @ConditionalOnProperty的name参数要与启动参数/配置文件中的参数名完全一致；
• 条件判断发生在Bean实例化之前，因此自定义@Conditional条件类时，需通过ConditionContext.getEnvironment()获取参数，而非注入Bean；
• 每个模式的依赖Bean都放在对应的配置类中，确保只有当模式匹配时，该组Bean才会被创建，避免不必要的资源消耗。

内容的提问来源于stack exchange，提问作者Omegaspard