Spring中如何确保EnvironmentConfig初始化后再创建其他Bean

要将BeanA、BeanB改为Spring管理并解决EnvironmentConfig的初始化时机问题，有以下几种可行方案：

方案一：重构EnvironmentConfig，使用构造注入（推荐） #

这种方式符合Spring依赖注入的最佳实践，从根源上避免事后设置environment的问题：

1. 修改EnvironmentConfig，通过构造函数接收environment并完成Storage初始化：

@Component
public class EnvironmentConfig {
    private final Environment environment;
    private final Storage storage;

    // 若environment是自定义类型，需确保它已被Spring管理；若为Spring自带的org.springframework.core.env.Environment，可直接@Autowired注入
    public EnvironmentConfig(Environment environment) {
        this.environment = environment;
        this.storage = initStorage();
    }

    private Storage initStorage() {
        // 从environment读取配置，创建并返回Storage实例的逻辑
        return new Storage(...);
    }

    public Storage getStorage() {
        return storage;
    }
}

2. 将自定义Environment注册为Spring Bean（如果不是Spring自带的Environment），修改AppConfig：

package com.company.packageX;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan(basePackages = "com.company.packageX")
public class AppConfig {
    @Bean
    public Environment environment() {
        // 原main方法中读取配置文件创建Environment的逻辑移到此处
        return loadEnvironmentFromConfigFile();
    }
}

3. 给BeanA、BeanB添加@Component注解，让Spring自动管理并注入依赖：

@Component
public class BeanA {
    private final Storage storage;

    public BeanA(EnvironmentConfig environmentConfig) {
        this.storage = environmentConfig.getStorage();
    }
    // 其他业务代码
}

@Component
public class BeanB {
    private final BeanA beanA;

    public BeanB(BeanA beanA) {
        this.beanA = beanA;
    }
    // 其他业务代码
}

4. 简化main方法，容器启动时所有Bean都会完成正确初始化：

public static void main(final String... args) {
    try (AnnotationConfigApplicationContext context =
         new AnnotationConfigApplicationContext(AppConfig.class)) {
        BeanB beanB = context.getBean(BeanB.class);
        // 使用beanB处理业务逻辑
    }
}

方案二：使用懒加载延迟Bean初始化 #

如果无法重构EnvironmentConfig的构造逻辑，可通过@Lazy注解延迟BeanA、BeanB的初始化，确保它们在EnvironmentConfig设置完environment后再实例化：

1. 给BeanA、BeanB添加@Component和@Lazy注解：

@Component
@Lazy
public class BeanA {
    private final Storage storage;

    public BeanA(EnvironmentConfig environmentConfig) {
        this.storage = environmentConfig.getStorage();
    }
}

@Component
@Lazy
public class BeanB {
    private final BeanA beanA;

    public BeanB(BeanA beanA) {
        this.beanA = beanA;
    }
}

2. 修改main方法，先设置EnvironmentConfig的environment，再手动触发Bean初始化：

public static void main(final String... args) {
    try (AnnotationConfigApplicationContext context =
         new AnnotationConfigApplicationContext(AppConfig.class)) {
        EnvironmentConfig environmentConfig = context.getBean(EnvironmentConfig.class);
        environmentConfig.setEnvironment(environment);

        // 此时获取Bean会触发初始化，EnvironmentConfig已完成配置
        BeanA beanA = context.getBean(BeanA.class);
        BeanB beanB = context.getBean(BeanB.class);
        // 使用beanB处理业务逻辑
    }
}

方案三：手动注册已配置的EnvironmentConfig #

通过分步启动Spring容器，先注册配置好的EnvironmentConfig，再刷新容器初始化其他Bean：

1. 修改main方法，调整容器启动流程：

public static void main(final String... args) {
    // 创建容器但不自动刷新
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
    // 注册配置类
    context.register(AppConfig.class);

    // 初始化并配置EnvironmentConfig
    EnvironmentConfig environmentConfig = new EnvironmentConfig();
    environmentConfig.setEnvironment(environment);
    // 将配置好的实例注册为单例Bean，覆盖组件扫描生成的实例
    context.getBeanFactory().registerSingleton("environmentConfig", environmentConfig);

    // 刷新容器，此时BeanA、BeanB会依赖已配置的EnvironmentConfig完成初始化
    context.refresh();

    BeanB beanB = context.getBean(BeanB.class);
    // 使用beanB处理业务逻辑

    // 关闭容器
    context.close();
}

2. 给BeanA、BeanB添加@Component注解，确保被组件扫描识别。

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