Spring Boot属性后处理问题：自定义配置加载后无法获取属性值

为什么你的两种方法拿不到属性值？ #

核心原因是**@PropertySources注解的加载时机晚于ApplicationContextInitializer和EnvironmentPostProcessor的执行时机**：

• ApplicationContextInitializer和EnvironmentPostProcessor都是在Spring Boot应用启动的早期环境准备阶段执行的，此时ApplicationContext还未完全初始化，@PropertySources中指定的配置文件还没被加载到环境中。
• 而你手动传入-Dspring.config.location时，Spring Boot会在启动初期就主动加载这些配置文件，所以环境中能拿到属性值。

无需手动传参的解决方案 #

方案1：在EnvironmentPostProcessor中主动加载配置文件并处理属性

既然@PropertySources加载太晚，我们可以在EnvironmentPostProcessor里主动把需要的配置文件加载到环境中，再进行属性处理。这样既不需要手动传参，又能在Bean创建前完成处理：

public class PropertiesProcessor implements EnvironmentPostProcessor {
    private final PropertiesPropertySourceLoader propertiesLoader = new PropertiesPropertySourceLoader();

    @Override
    public void postProcessEnvironment(ConfigurableEnvironment environment, SpringApplication application) {
        // 先加载指定的外部配置文件到环境中
        loadExternalProperties(environment, "file:/opt/app/conf/database.properties");
        loadExternalProperties(environment, "file:/opt/app/conf/overrides.properties");
        // 加载默认的application.properties（可选，Spring Boot会自动加载，但这里可确保优先级）
        loadExternalProperties(environment, "classpath:application.properties");

        // 现在可以获取并处理属性了
        String rawPassword = environment.getProperty("spring.datasource.password");
        if (rawPassword != null) {
            // 执行你的后处理逻辑，比如解密
            String processedPassword = decrypt(rawPassword);
            // 将处理后的属性添加到环境最前面，确保优先级最高
            Map<String, Object> processedProps = new HashMap<>();
            processedProps.put("spring.datasource.password", processedPassword);
            environment.getPropertySources().addFirst(new MapPropertySource("processed-ds-props", processedProps));
        }
    }

    private void loadExternalProperties(ConfigurableEnvironment environment, String location) {
        try {
            Resource resource = new DefaultResourceLoader().getResource(location);
            if (resource.exists()) {
                List<PropertySource<?>> sources = propertiesLoader.load("external-props", resource);
                sources.forEach(source -> environment.getPropertySources().addLast(source));
            }
        } catch (IOException e) {
            // 可添加日志记录，忽略不存在的配置（符合你的ignoreResourceNotFound需求）
            e.printStackTrace();
        }
    }

    private String decrypt(String encryptedPassword) {
        // 替换成你的实际解密逻辑
        return encryptedPassword;
    }
}

然后在META-INF/spring.factories中保持原有配置：

org.springframework.boot.env.EnvironmentPostProcessor=com.myapp.PropertiesProcessor

方案2：使用@ConfigurationProperties + @PostConstruct

如果你的属性是绑定到特定配置类的，这种方式更优雅，适合Bean初始化阶段的属性处理：

@ConfigurationProperties(prefix = "spring.datasource")
public class DataSourceConfigProps {
    private String password;
    // 其他属性（url、username）的getter/setter

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @PostConstruct
    public void processPassword() {
        // 在Bean初始化后、被其他Bean依赖前处理密码
        this.password = decrypt(this.password);
    }

    private String decrypt(String encryptedPassword) {
        // 你的解密逻辑
        return encryptedPassword;
    }
}

然后在主启动类上开启配置属性绑定：

@SpringBootApplication
@EnableConfigurationProperties(DataSourceConfigProps.class)
public class YourApplication {
    public static void main(String[] args) {
        SpringApplication.run(YourApplication.class, args);
    }
}

方案3：自定义PropertySourcesPlaceholderConfigurer

这个方法会在Spring解析属性占位符时进行处理，时机在Bean属性注入之前：

@Configuration
public class PropertyPostProcessorConfig {

    @Bean
    public static PropertySourcesPlaceholderConfigurer propertyConfigurer() {
        return new PropertySourcesPlaceholderConfigurer() {
            @Override
            protected void processProperties(ConfigurableListableBeanFactory beanFactory, ConfigurablePropertyResolver propertyResolver) throws BeansException {
                // 获取原始属性值
                String rawPassword = propertyResolver.getProperty("spring.datasource.password");
                if (rawPassword != null) {
                    String processedPassword = decrypt(rawPassword);
                    // 将处理后的属性添加到属性源最前面，确保被优先读取
                    ((MutablePropertySources) propertyResolver.getPropertySources()).addFirst(
                            new MapPropertySource("processed-password", Collections.singletonMap("spring.datasource.password", processedPassword))
                    );
                }
                super.processProperties(beanFactory, propertyResolver);
            }
        };
    }

    private static String decrypt(String encryptedPassword) {
        // 解密逻辑
        return encryptedPassword;
    }
}

其他属性后处理方法 #

• 使用BeanPostProcessor：如果需要处理的是Bean的属性（而非环境中的原始属性），可以实现BeanPostProcessor，在postProcessBeforeInitialization方法中修改Bean的属性值。不过这个时机比前面的方案稍晚，适合Bean实例化后的属性调整。
• 自定义PropertySource：实现PropertySource接口，包装原始属性源，在获取属性时动态处理值，然后将这个自定义PropertySource添加到环境中。

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