Spring Boot能否运行时修改application.properties及实现方法

Great question! Yes, Spring Boot absolutely supports updating configuration values from application.properties at runtime via web requests. There are a few practical approaches to implement this, depending on your use case and whether you're using Spring Cloud or a vanilla Spring Boot application.

1. Use Spring Boot Actuator's /env Endpoint (Quick Built-in Solution) #

If you want a ready-to-go option, Spring Boot Actuator provides built-in endpoints to manage configuration. Here's how to set it up:

• Add the Actuator dependency to your project:
  For Maven:

  <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-actuator</artifactId>
  </dependency>
  

  For Gradle:

  implementation 'org.springframework.boot:spring-boot-starter-actuator'
  

• Enable and configure the endpoints in application.properties:

  # Expose the /env endpoint
  management.endpoints.web.exposure.include=env
  # Allow POST requests to update environment variables
  management.endpoint.env.post.enabled=true
  

• Send a POST request to update properties
  Use tools like curl or Postman to send a JSON payload to /actuator/env:

  curl -X POST http://localhost:8080/actuator/env \
  -H "Content-Type: application/json" \
  -d '{"server.port": 8081, "my.app.greeting": "Hello from runtime!"}'
  

• Refresh the context to apply changes
  The above updates modify in-memory configuration, but to make the changes take effect in your application beans, you need to refresh the context. You can either:

  • Use Spring Cloud's /actuator/refresh endpoint (add spring-cloud-starter-config dependency if needed), or
  • Create a simple custom endpoint to trigger a refresh:

    @RestController
    public class RefreshController {
        @Autowired
        private ConfigurableApplicationContext applicationContext;
    
        @PostMapping("/refresh-config")
        public String refreshConfig() {
            applicationContext.refresh();
            return "Configuration refreshed successfully!";
        }
    }
    

  Note: Context refresh restarts all beans, so use this cautiously in production to avoid downtime.

2. Custom Controller with @ConfigurationProperties & @RefreshScope (Granular Control) #

If you want more control over which properties are updatable and avoid full context refreshes, use this approach:

• Create a configuration class to bind your target properties, annotated with @RefreshScope to enable bean-level refresh:

  @ConfigurationProperties(prefix = "my.app")
  @RefreshScope
  @Component
  public class AppConfig {
      private String greeting;
      private int maxRetries;
  
      // Getters and Setters
  }
  

• Build a custom controller to modify these properties dynamically:

  @RestController
  @RequestMapping("/config")
  public class ConfigUpdateController {
      @Autowired
      private AppConfig appConfig;
  
      @PostMapping("/update")
      public String updateConfig(@RequestBody Map<String, Object> updates) {
          // Update specific properties based on the request payload
          updates.forEach((key, value) -> {
              switch (key) {
                  case "greeting":
                      appConfig.setGreeting((String) value);
                      break;
                  case "maxRetries":
                      appConfig.setMaxRetries((Integer) value);
                      break;
                  // Add other properties as needed
              }
          });
          return "Configuration updated successfully!";
      }
  }
  

  With @RefreshScope, any bean that injects AppConfig will automatically pick up the updated values without a full context restart—ideal for production environments where downtime is a concern.

3. Persist Changes to application.properties (Optional) #

By default, the above methods only modify in-memory configuration. If you want to save changes back to the actual application.properties file (so they persist after restart), add this logic:

@RestController
@RequestMapping("/config")
public class PersistentConfigController {
    @Value("${spring.config.location:classpath:/application.properties}")
    private String configFilePath;

    @Autowired
    private ConfigurableApplicationContext applicationContext;

    @PostMapping("/save")
    public String saveAndUpdateConfig(@RequestBody Map<String, String> updates) throws IOException {
        Properties properties = new Properties();
        File configFile = new File(configFilePath);

        // Load existing properties
        try (InputStream inputStream = new FileInputStream(configFile)) {
            properties.load(inputStream);
        }

        // Update properties from request
        updates.forEach(properties::setProperty);

        // Save back to file
        try (OutputStream outputStream = new FileOutputStream(configFile)) {
            properties.store(outputStream, "Updated via web request - " + LocalDateTime.now());
        }

        // Refresh context to apply changes
        applicationContext.refresh();
        return "Configuration saved to file and applied!";
    }
}

Important: If your app is packaged as a JAR, the internal application.properties can't be modified. Instead, use an external config file by setting spring.config.location to a path outside the JAR.

Key Notes for Production #

• Security: Always secure these endpoints with authentication/authorization (e.g., Spring Security Basic Auth or OAuth2) to prevent unauthorized configuration changes.
• Sensitive Data: Avoid updating sensitive properties (like database passwords) via web requests unless you have strict encryption and access controls in place.
• Smooth Refresh: Prefer @RefreshScope over full context refresh to minimize service disruption.

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