如何用外部YAML文件动态创建Spring Boot配置Bean？

1. 基础类确认 #

先明确核心类结构（可根据实际代码调整）：

SimpleConfiguration 配置类 #

@ConfigurationProperties(prefix = "my.config")
public class SimpleConfiguration {
    private String configName;
    // 其他配置字段及对应的getter/setter
    public String getConfigName() {
        return configName;
    }
    public void setConfigName(String configName) {
        this.configName = configName;
    }
}

MyService 业务类 #

@Service
public class MyService {
    // 场景1：直接接收配置对象
    public void executeBusiness(SimpleConfiguration config) {
        System.out.println("执行业务，当前配置名称：" + config.getConfigName());
        // 业务逻辑实现
    }

    // 场景2：依赖注入配置Bean（仅用于动态注册Bean的方案）
    @Autowired
    private SimpleConfiguration simpleConfiguration;

    public void executeBusinessWithInjectedBean() {
        System.out.println("执行业务，当前配置名称：" + simpleConfiguration.getConfigName());
        // 业务逻辑实现
    }
}

2. 外部YAML配置加载工具 #

基于Spring原生工具实现配置解析，确保和内部配置加载逻辑一致：

import org.springframework.boot.context.properties.bind.Binder;
import org.springframework.core.env.PropertiesPropertySource;
import org.springframework.core.env.PropertySource;
import org.springframework.core.io.FileSystemResource;
import org.springframework.core.io.Resource;
import org.springframework.beans.factory.config.YamlPropertiesFactoryBean;

public class ExternalYamlLoader {
    public static SimpleConfiguration loadConfig(String filePath) {
        Resource resource = new FileSystemResource(filePath);
        YamlPropertiesFactoryBean yamlFactory = new YamlPropertiesFactoryBean();
        yamlFactory.setResources(resource);
        yamlFactory.afterPropertiesSet();

        PropertySource<?> propertySource = new PropertiesPropertySource("external-config", yamlFactory.getObject());
        return Binder.get(propertySource).bind("my.config", SimpleConfiguration.class).orElseThrow();
    }
}

3. 批量处理核心实现 #

根据业务需求选择两种方案之一：

方案一：直接传递配置对象（轻量高效，无需注册Bean） #

适合无需依赖注入配置Bean的场景，直接循环处理每个配置文件：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
import java.io.File;
import java.util.Arrays;

@Component
public class BatchConfigHandler implements CommandLineRunner {

    @Autowired
    private MyService myService;

    // 配置文件夹路径（建议通过内部配置读取，避免硬编码）
    private static final String CONFIG_DIR = "/your/config/folder/path";

    @Override
    public void run(String... args) throws Exception {
        File folder = new File(CONFIG_DIR);
        if (!folder.exists() || !folder.isDirectory()) {
            throw new RuntimeException("配置文件夹不存在或非目录");
        }

        // 筛选并排序配置文件，确保run1、run2、run3按顺序执行
        File[] configFiles = folder.listFiles((dir, name) -> name.startsWith("run") && name.endsWith(".yaml"));
        if (configFiles == null || configFiles.length == 0) {
            System.out.println("未找到符合条件的配置文件");
            return;
        }
        Arrays.sort(configFiles, (f1, f2) -> {
            int num1 = Integer.parseInt(f1.getName().replaceAll("run|\\.yaml", ""));
            int num2 = Integer.parseInt(f2.getName().replaceAll("run|\\.yaml", ""));
            return Integer.compare(num1, num2);
        });

        // 逐个处理配置文件
        for (File file : configFiles) {
            try {
                System.out.println("开始处理：" + file.getName());
                // 加载外部配置
                SimpleConfiguration config = ExternalYamlLoader.loadConfig(file.getAbsolutePath());
                // 执行业务
                myService.executeBusiness(config);
                // 清理临时资源（如有）
                System.out.println("处理完成：" + file.getName());
            } catch (Exception e) {
                System.err.println("处理" + file.getName() + "失败：" + e.getMessage());
                // 可选：是否终止流程，此处设为继续处理下一个
                continue;
            }
        }
    }
}

方案二：动态注册+销毁Bean（适合依赖注入场景） #

需将配置类注册为Spring Bean，处理完成后销毁，避免影响下一次处理：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.stereotype.Component;
import java.io.File;
import java.util.Arrays;

@Component
public class BatchBeanHandler implements CommandLineRunner {

    @Autowired
    private ConfigurableApplicationContext applicationContext;

    @Autowired
    private MyService myService;

    private static final String CONFIG_DIR = "/your/config/folder/path";

    @Override
    public void run(String... args) throws Exception {
        File folder = new File(CONFIG_DIR);
        if (!folder.exists() || !folder.isDirectory()) {
            throw new RuntimeException("配置文件夹不存在或非目录");
        }

        File[] configFiles = folder.listFiles((dir, name) -> name.startsWith("run") && name.endsWith(".yaml"));
        if (configFiles == null || configFiles.length == 0) {
            System.out.println("未找到符合条件的配置文件");
            return;
        }
        Arrays.sort(configFiles, (f1, f2) -> {
            int num1 = Integer.parseInt(f1.getName().replaceAll("run|\\.yaml", ""));
            int num2 = Integer.parseInt(f2.getName().replaceAll("run|\\.yaml", ""));
            return Integer.compare(num1, num2);
        });

        for (File file : configFiles) {
            try {
                System.out.println("开始处理：" + file.getName());
                // 加载外部配置
                SimpleConfiguration config = ExternalYamlLoader.loadConfig(file.getAbsolutePath());
                // 动态注册单例Bean
                applicationContext.getBeanFactory().registerSingleton("simpleConfiguration", config);
                // 执行业务（此时MyService注入的是当前配置Bean）
                myService.executeBusinessWithInjectedBean();
                // 销毁Bean，释放资源
                applicationContext.getBeanFactory().destroySingleton("simpleConfiguration");
                System.out.println("处理完成：" + file.getName());
            } catch (Exception e) {
                System.err.println("处理" + file.getName() + "失败：" + e.getMessage());
                // 确保异常时也销毁Bean
                try {
                    applicationContext.getBeanFactory().destroySingleton("simpleConfiguration");
                } catch (Exception ex) {
                    // 忽略销毁异常
                }
                continue;
            }
        }
    }
}

4. 关键注意事项 #

• 外部YAML文件需保持与内部application.yaml一致的前缀（my.config），确保解析正常
• 动态注册Bean时，注意Bean名称唯一，避免冲突
• 批量处理的异常捕获需覆盖到每个文件，防止单个文件失败导致全流程终止
• 配置文件夹路径建议通过内部配置（如application.yaml中的config.folder.path）读取，增强灵活性

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