Spring Core中YAML配置：能否不依赖Spring Boot使用？求专家见解

Great question! It’s totally understandable to wonder about this—Spring Boot makes YAML feel so seamless that it’s easy to forget it’s not a native feature of plain Spring Core. Let’s break down what’s possible, even if the official docs suggest it’s not supported out of the box.

First, the straight answer: Spring Core doesn’t include built-in YAML parsing support—that’s a convenience added by Spring Boot, which uses the snakeyaml library under the hood plus its own YamlPropertySourceLoader to handle YAML files. But that doesn’t mean you can’t use YAML in a pure Spring Core project—you just need to add a bit of manual setup.

Step 1: Add Required Dependencies #

First, you’ll need the snakeyaml library (the same one Spring Boot uses) and your standard Spring Core dependencies. For Maven, add these to your pom.xml:

<dependency>
    <groupId>org.yaml</groupId>
    <artifactId>snakeyaml</artifactId>
    <version>2.2</version> <!-- Use the latest stable version -->
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>6.0.11</version> <!-- Match your Spring Core version -->
</dependency>

Step 2: Load YAML into Spring’s Environment #

Spring Core defaults to loading .properties files, so you’ll need to manually parse your YAML file and register it as a property source. Here’s a practical implementation using a configuration class:

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.support.PropertySourcesPlaceholderConfigurer;
import org.springframework.core.io.ClassPathResource;
import org.yaml.snakeyaml.Yaml;

import java.io.IOException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Configuration
public class YamlConfiguration {

    @Bean
    public static PropertySourcesPlaceholderConfigurer yamlPropertySourceLoader() throws IOException {
        PropertySourcesPlaceholderConfigurer configurer = new PropertySourcesPlaceholderConfigurer();
        Yaml yamlParser = new Yaml();
        
        // Load your YAML file (e.g., src/main/resources/app.yml)
        Map<String, Object> yamlData = yamlParser.load(new ClassPathResource("app.yml").getInputStream());
        
        // Flatten nested YAML structure into properties-style keys (e.g., "db.url" instead of nested "db: { url: ... }")
        Map<String, String> flattenedProperties = flattenYamlStructure(yamlData, "");
        
        // Convert to Spring's Properties format and register
        configurer.setProperties(org.springframework.core.io.support.PropertiesLoaderUtils.convertProperties(flattenedProperties));
        return configurer;
    }

    // Helper method to flatten nested YAML maps into a flat key-value structure
    private static Map<String, String> flattenYamlStructure(Map<String, Object> data, String parentKey) {
        Map<String, String> result = new HashMap<>();
        
        for (Map.Entry<String, Object> entry : data.entrySet()) {
            String currentKey = parentKey.isEmpty() ? entry.getKey() : parentKey + "." + entry.getKey();
            
            if (entry.getValue() instanceof Map) {
                // Recursively flatten nested maps
                result.putAll(flattenYamlStructure((Map<String, Object>) entry.getValue(), currentKey));
            } else if (entry.getValue() instanceof List) {
                // Handle lists by appending index (e.g., "servers[0].host")
                List<?> list = (List<?>) entry.getValue();
                for (int i = 0; i < list.size(); i++) {
                    result.putAll(flattenYamlStructure((Map<String, Object>) list.get(i), currentKey + "[" + i + "]"));
                }
            } else {
                // Add simple key-value pairs
                result.put(currentKey, entry.getValue().toString());
            }
        }
        
        return result;
    }
}

Step 3: Use the YAML Properties #

Once the YAML is loaded, you can access properties just like you would with .properties files, using @Value:

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
public class DatabaseConfig {
    @Value("${db.url}")
    private String dbUrl;
    
    @Value("${db.username}")
    private String dbUsername;
    
    // Getters and business logic here
}

Alternative: Reuse Spring Boot’s YamlPropertySourceLoader #

If you don’t want to write your own flattening logic, you can use Spring Boot’s YamlPropertySourceLoader directly. You’ll need to add the spring-boot dependency (but you don’t have to use any of its auto-configuration features):

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot</artifactId>
    <version>3.1.3</version> <!-- Match your Spring version compatibility -->
    <scope>compile</scope>
</dependency>

Then, modify your configuration class to use this loader instead of manual parsing:

import org.springframework.boot.env.YamlPropertySourceLoader;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.support.PropertySourcesPlaceholderConfigurer;
import org.springframework.core.env.PropertySource;
import org.springframework.core.io.ClassPathResource;

import java.io.IOException;
import java.util.List;

@Configuration
public class SpringBootYamlConfig {

    @Bean
    public static PropertySourcesPlaceholderConfigurer yamlPropertySourceLoader() throws IOException {
        PropertySourcesPlaceholderConfigurer configurer = new PropertySourcesPlaceholderConfigurer();
        YamlPropertySourceLoader loader = new YamlPropertySourceLoader();
        
        List<PropertySource<?>> propertySources = loader.load("yamlProperties", new ClassPathResource("app.yml"));
        propertySources.forEach(ps -> configurer.getPropertySources().addLast(ps));
        
        return configurer;
    }
}

This gives you all the benefits of Spring Boot’s YAML handling (like profile support with --- separators) without the full Spring Boot auto-config.

Key Notes #

• The official docs say it’s not feasible because Spring Core doesn’t include YAML support out of the box, but with a bit of manual work, it’s absolutely doable.
• If you want to bind YAML to POJOs (like Spring Boot’s @ConfigurationProperties), you’ll need to implement that logic yourself or use a third-party library, since @ConfigurationProperties is a Spring Boot feature.

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