如何在SpringBootApplication的静态main方法中通过配置变量控制应用启动（OpenShift环境弹性测试场景）

Let's fix this problem step by step. The core issue here is that your main method runs before Spring's context is initialized, so you can't rely on @Value injection (static or not) to get your configuration value at that point. Here are two straightforward solutions that work perfectly for your use case:

Solution 1: Directly Read Environment/System Properties (Simplest) #

Since you're running on OpenShift, environment variables will automatically override values from application.yaml (Spring Boot follows a clear property priority order). You can read the value directly in your main method without waiting for Spring to inject anything:

@SpringBootApplication
public class AccountApplication {
    public static void main(String[] args) {
        // First check for OpenShift environment variable (uppercase with underscores)
        String responseStr = System.getenv("RESPONSE");
        
        // Fall back to system property (from application.yaml if not overridden)
        if (responseStr == null) {
            responseStr = System.getProperty("response", "0");
        }
        
        int response = Integer.parseInt(responseStr);
        
        if (response == 1) {
            SpringApplication.run(AccountApplication.class, args);
            System.out.println("Application started successfully!");
        } else {
            System.out.println("Skipping application startup: 'response' is not set to 1");
        }
    }
}

This approach is lightweight and avoids any Spring context initialization overhead if you decide not to start the app.

Solution 2: Use Spring's Environment Prepared Event (Spring-Native Approach) #

If you want to leverage Spring's full property loading logic (like profiles, property sources, and automatic priority handling), use an ApplicationListener to check the value after the environment is loaded but before the app context starts:

@SpringBootApplication
public class AccountApplication {
    public static void main(String[] args) {
        SpringApplication app = new SpringApplication(AccountApplication.class);
        
        // Add a listener to check the environment before startup
        app.addListeners((ApplicationListener<ApplicationEnvironmentPreparedEvent>) event -> {
            ConfigurableEnvironment env = event.getEnvironment();
            int response = Integer.parseInt(env.getProperty("response", "0"));
            
            if (response != 1) {
                System.out.println("Aborting startup: 'response' configuration is not 1");
                System.exit(0);
            }
        });
        
        app.run(args);
    }
}

This ensures you're using Spring's built-in mechanism to resolve the response value, respecting all of its property resolution rules (e.g., environment variables > application.yaml values).

Why Your Previous Attempts Failed #

• @Value injection only works after Spring initializes the application context. Your main method runs before this happens, so the non-static response variable was never populated.
• Static field injection via hacks (like @Value with a setter) also fails because the static setter is called after the main method executes—so when you checked response in main, it was still the default 0.

Both solutions above bypass this timing issue entirely, letting you control startup exactly how you need it for your OpenShift elasticity tests.

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