Spring Boot依赖Jar内部私有配置属性不生效的解决办法

Alright, let's break down your problem into two clear parts: getting library B's environment-specific config files recognized when it's included as a dependency in app A, and locking down certain properties in B so app A can't override them. Here's a step-by-step solution tailored for Spring Boot:

By default, Spring Boot only auto-loads configuration files from the main application's classpath (your app A). To get B's application-dev.properties, application-stage.properties, and application-live.properties picked up, you have two robust options:

Option 1: Use Profile-Specific Auto-Configuration Classes #

Create profile-bound configuration classes in B that load the corresponding config file, then register them as auto-configurations so app A picks them up automatically:

1. Create profile-specific config classes in B:

   package com.example.b.config;
   
   import org.springframework.context.annotation.Configuration;
   import org.springframework.context.annotation.Profile;
   import org.springframework.context.annotation.PropertySource;
   
   @Configuration
   @Profile("dev")
   @PropertySource("classpath:application-dev.properties")
   public class BDevConfiguration {}
   
   @Configuration
   @Profile("stage")
   @PropertySource("classpath:application-stage.properties")
   public class BStageConfiguration {}
   
   @Configuration
   @Profile("live")
   @PropertySource("classpath:application-live.properties")
   public class BLiveConfiguration {}
   

2. Register these auto-configurations:

   • For Spring Boot 2.7+: Create a file META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports in B's resources, and add each config class's fully qualified name:

     com.example.b.config.BDevConfiguration
     com.example.b.config.BStageConfiguration
     com.example.b.config.BLiveConfiguration
     

   • For older Spring Boot versions: Add the classes to META-INF/spring.factories:

     org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
     com.example.b.config.BDevConfiguration,\
     com.example.b.config.BStageConfiguration,\
     com.example.b.config.BLiveConfiguration
     

Now when app A activates a profile (e.g., dev), B's corresponding config file will be loaded automatically.

Option 2: Use an EnvironmentPostProcessor (More Flexible) #

If you want more control over how config files are loaded (like dynamic profile detection), implement an EnvironmentPostProcessor in B to inject its config files directly into the application environment:

1. Create the EnvironmentPostProcessor:

   package com.example.b.env;
   
   import org.springframework.boot.SpringApplication;
   import org.springframework.boot.env.EnvironmentPostProcessor;
   import org.springframework.boot.env.PropertiesPropertySourceLoader;
   import org.springframework.boot.env.PropertySourceLoader;
   import org.springframework.core.env.ConfigurableEnvironment;
   import org.springframework.core.env.PropertySource;
   import org.springframework.core.io.ClassPathResource;
   import org.springframework.core.io.Resource;
   
   import java.io.IOException;
   import java.util.Arrays;
   import java.util.List;
   
   public class BEnvironmentPostProcessor implements EnvironmentPostProcessor {
       private final PropertySourceLoader loader = new PropertiesPropertySourceLoader();
   
       @Override
       public void postProcessEnvironment(ConfigurableEnvironment environment, SpringApplication application) {
           List<String> activeProfiles = Arrays.asList(environment.getActiveProfiles());
           String configFileName = determineConfigFile(activeProfiles);
   
           if (configFileName != null) {
               try {
                   Resource resource = new ClassPathResource(configFileName);
                   List<PropertySource<?>> propertySources = loader.load("b-environment-config", resource);
                   // Add B's config to the front of the property sources (highest priority)
                   propertySources.forEach(ps -> environment.getPropertySources().addFirst(ps));
               } catch (IOException e) {
                   throw new RuntimeException("Failed to load B's environment configuration", e);
               }
           }
       }
   
       private String determineConfigFile(List<String> activeProfiles) {
           if (activeProfiles.contains("dev")) {
               return "application-dev.properties";
           } else if (activeProfiles.contains("stage")) {
               return "application-stage.properties";
           } else if (activeProfiles.contains("live")) {
               return "application-live.properties";
           }
           return null; // Fallback if no matching profile
       }
   }
   

2. Register the processor:
   Add this line to META-INF/spring.factories in B:

   org.springframework.boot.env.EnvironmentPostProcessor=com.example.b.env.BEnvironmentPostProcessor
   

This method not only loads B's config files but also sets them to have higher priority than app A's configs (we'll use this for the second part of your problem).

To ensure app A can't modify certain properties in B, we need to make B's configs take precedence over A's. Here's how:

Leverage Property Source Priority #

The EnvironmentPostProcessor approach above already adds B's configs to the front of the property source list, which means they have higher priority than any configs from app A. Any property defined in B's files will override the same property in A's configs.

Use Immutable Configuration Properties (Optional) #

For extra safety, bind B's properties to an immutable class using Spring Boot's @ConstructorBinding (available in Spring Boot 2.2+). This makes the properties read-only once initialized:

1. Create an immutable properties class in B:

   package com.example.b.props;
   
   import org.springframework.boot.context.properties.ConfigurationProperties;
   import org.springframework.boot.context.properties.ConstructorBinding;
   
   @ConfigurationProperties(prefix = "b.core")
   @ConstructorBinding
   public class BCoreProperties {
       private final String criticalSetting;
       private final int fixedTimeout;
   
       // Constructor-based injection (no setters)
       public BCoreProperties(String criticalSetting, int fixedTimeout) {
           this.criticalSetting = criticalSetting;
           this.fixedTimeout = fixedTimeout;
       }
   
       // Getters only
       public String getCriticalSetting() {
           return criticalSetting;
       }
   
       public int getFixedTimeout() {
           return fixedTimeout;
       }
   }
   

2. Enable the properties in your auto-config class:

   package com.example.b.config;
   
   import com.example.b.props.BCoreProperties;
   import org.springframework.boot.context.properties.EnableConfigurationProperties;
   import org.springframework.context.annotation.Configuration;
   
   @Configuration
   @EnableConfigurationProperties(BCoreProperties.class)
   public class BAutoConfiguration {
       // Use BCoreProperties in your beans here
   }
   

With this setup, even if app A tries to set b.core.criticalSetting, B's value will take precedence (thanks to the property source priority), and the immutable class ensures no code in A can modify the value at runtime.

Final Checks #

• Make sure library B is packaged as a valid Spring Boot jar (or a starter jar) with all config files in the src/main/resources directory.
• Verify that app A activates the correct profile (e.g., via spring.profiles.active=dev in its own config or VM arguments).

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