2023-07-24 10:30:15.123  INFO --- [main] o.s.c.c.c.ConfigServicePropertySourceLocator : Fetching config from server at : http://localhost:8888
2023-07-24 10:30:15.456  INFO --- [main] o.s.c.c.c.ConfigServicePropertySourceLocator : Located environment: name=user-service, profiles=[dev], label=null, version=xxx

Bootstrap Context (父容器)
    ├── 加载 bootstrap.yml
    ├── 连接配置中心
    ├── 执行 PropertySourceLocator
    └── 为子容器提供基础配置
         │
         └── Main Application Context (子容器)  
             ├── 加载 application.yml
             ├── 执行业务自动配置
             └── 启动Web服务器

# bootstrap.yml - 启动引导配置
spring:
  application:
    name: user-service          # 服务标识，用于配置中心定位
  cloud:
    config:
      uri: http://config-server:8888    # 配置中心地址
      profile: dev                      # 环境标识
      label: master                     # 分支标识

# application.yml - 业务配置（可能来自配置中心）
server:
  port: 8080
spring:
  datasource:
    url: jdbc:mysql://db-server:3306/userdb
    username: ${db.username}     # 这个值可能来自配置中心
    password: ${db.password}     # 敏感信息从配置中心获取

public class BootstrapApplicationListener 
    implements ApplicationListener<ApplicationEnvironmentPreparedEvent> {
    
    @Override
    public void onApplicationEvent(ApplicationEnvironmentPreparedEvent event) {
        ConfigurableEnvironment environment = event.getEnvironment();
        
        // 1. 检查bootstrap功能是否启用
        if (!environment.getProperty("spring.cloud.bootstrap.enabled", Boolean.class, true)) {
            return;
        }
        
        // 2. 防止重复执行 - 这里有个巧妙的设计
        if (environment.getPropertySources().contains(BOOTSTRAP_PROPERTY_SOURCE_NAME)) {
            return;  // 已经处理过了，直接返回
        }
        
        // 3. 核心逻辑：创建Bootstrap Context
        ConfigurableApplicationContext context = bootstrapServiceContext(environment, event.getSpringApplication(), configName);
    }
}

private ConfigurableApplicationContext bootstrapServiceContext(
        ConfigurableEnvironment environment, SpringApplication application, String configName) {
    
    // 创建独立的Environment，避免污染原Environment
    StandardEnvironment bootstrapEnvironment = new StandardEnvironment();
    MutablePropertySources bootstrapProperties = bootstrapEnvironment.getPropertySources();
    
    // 清空默认的PropertySource，从零开始构建
    for (PropertySource<?> source : bootstrapProperties) {
        bootstrapProperties.remove(source.getName());
    }
    
    // 设置bootstrap专用的配置
    Map<String, Object> bootstrapMap = new HashMap<>();
    bootstrapMap.put("spring.config.name", configName);  // 默认是"bootstrap"
    bootstrapMap.put("spring.main.web-application-type", "none");  // bootstrap context不需要启动web服务器
    
    // 添加标记PropertySource，用于防重入
    bootstrapProperties.addFirst(new MapPropertySource(BOOTSTRAP_PROPERTY_SOURCE_NAME, bootstrapMap));
    
    // 同步原Environment的数据到bootstrap environment
    for (PropertySource<?> source : environment.getPropertySources()) {
        if (source instanceof PropertySource.StubPropertySource) {
            continue;  // 跳过占位符PropertySource
        }
        bootstrapProperties.addLast(source);
    }
    
    // 创建轻量级的SpringApplication
    SpringApplicationBuilder builder = new SpringApplicationBuilder()
            .profiles(environment.getActiveProfiles())
            .bannerMode(Banner.Mode.OFF)  // 不显示banner
            .environment(bootstrapEnvironment)
            .registerShutdownHook(false)  // 不注册关闭钩子
            .logStartupInfo(false)        // 不打印启动信息
            .web(WebApplicationType.NONE); // 不启动web容器
    
    // 指定bootstrap context的配置类
    builder.sources(BootstrapImportSelectorConfiguration.class);
    
    // 启动bootstrap context - 这里会走完整的SpringBoot启动流程
    final ConfigurableApplicationContext context = builder.run();
    context.setId("bootstrap");
    
    // 关键：将bootstrap context设置为main context的父容器
    addAncestorInitializer(application, context);
    
    // environment数据同步
    mergeDefaultProperties(environment.getPropertySources(), bootstrapProperties);
    
    return context;
}

@Configuration
public class PropertySourceBootstrapConfiguration 
    implements ApplicationContextInitializer<ConfigurableApplicationContext> {
    
    @Autowired(required = false)
    private List<PropertySourceLocator> propertySourceLocators = new ArrayList<>();
    
    @Override
    public void initialize(ConfigurableApplicationContext applicationContext) {
        CompositePropertySource composite = new CompositePropertySource(BOOTSTRAP_PROPERTY_SOURCE_NAME);
        
        // 按优先级排序
        AnnotationAwareOrderComparator.sort(this.propertySourceLocators);
        
        ConfigurableEnvironment environment = applicationContext.getEnvironment();
        
        // 依次执行每个PropertySourceLocator
        for (PropertySourceLocator locator : this.propertySourceLocators) {
            PropertySource<?> source = locator.locate(environment);
            if (source != null) {
                logger.info("Located property source: " + source);
                composite.addPropertySource(source);
            }
        }
        
        // 将外部配置添加到environment中
        if (!composite.getPropertySources().isEmpty()) {
            MutablePropertySources propertySources = environment.getPropertySources();
            insertPropertySources(propertySources, composite);
            
            // 处理配置变化带来的副作用
            reinitializeLoggingSystem(environment, logConfig, logFile);
            handleIncludedProfiles(environment);
        }
    }
}

public class NacosPropertySourceLocator implements PropertySourceLocator {
    
    @Override
    public PropertySource<?> locate(Environment environment) {
        ConfigService configService = nacosConfigManager.getConfigService();
        
        String dataId = environment.getProperty("spring.application.name");
        String group = nacosConfigProperties.getGroup();
        
        try {
            // 从Nacos服务器获取配置
            String content = configService.getConfig(dataId, group, 5000);
            if (StringUtils.hasText(content)) {
                return NacosPropertySourceBuilder.build(dataId, content);
            }
        } catch (Exception e) {
            logger.warn("Failed to load config from nacos", e);
        }
        
        return null;
    }
}

private void mergeDefaultProperties(MutablePropertySources environment, MutablePropertySources bootstrap) {
    // 创建扩展的默认PropertySource
    ExtendedDefaultPropertySource result = new ExtendedDefaultPropertySource(DEFAULT_PROPERTIES, defaultProperties);
    
    // 将bootstrap environment中的配置源添加进来
    for (PropertySource<?> source : bootstrap) {
        if (!environment.contains(source.getName())) {
            result.add(source);  // 添加到扩展PropertySource中
        }
    }
    
    // 替换原来的默认PropertySource
    environment.replace(DEFAULT_PROPERTIES, result);
}

private static class ExtendedDefaultPropertySource extends SystemEnvironmentPropertySource {
    
    @Override
    public Object getProperty(String name) {
        // 优先从外部配置源查找
        if (this.sources.containsProperty(name)) {
            return this.sources.getProperty(name);
        }
        // 再从默认配置查找
        return super.getProperty(name);
    }
}

# bootstrap.yml
spring:
  application:
    name: user-service
  profiles:
    active: ${SPRING_PROFILES_ACTIVE:dev}
  cloud:
    nacos:
      config:
        server-addr: ${NACOS_SERVER:localhost:8848}
        file-extension: yaml
        shared-configs:
          - data-id: common-${spring.profiles.active}.yaml
            refresh: true

# bootstrap.yml - 存储在镜像中，相对安全
spring:
  application:
    name: payment-service
  cloud:
    vault:
      host: vault.company.com
      port: 8200
      scheme: https
      authentication: kubernetes

# Vault中存储的敏感配置
{
  "database": {
    "password": "super-secret-password"
  },
  "api": {
    "key": "very-important-api-key"
  }
}

// 检查配置的来源
@RestController
public class ConfigDebugController {
    
    @Autowired
    private Environment environment;
    
    @GetMapping("/config/debug/{key}")
    public Map<String, Object> debugConfig(@PathVariable String key) {
        Map<String, Object> result = new HashMap<>();
        
        if (environment instanceof StandardEnvironment) {
            StandardEnvironment env = (StandardEnvironment) environment;
            for (PropertySource<?> ps : env.getPropertySources()) {
                if (ps.containsProperty(key)) {
                    result.put(ps.getName(), ps.getProperty(key));
                }
            }
        }
        
        result.put("resolved", environment.getProperty(key));
        return result;
    }
}

# bootstrap.yml
spring:
  cloud:
    config:
      timeout: 10000        # 连接超时时间
      retry:
        max-attempts: 3     # 最大重试次数
        initial-interval: 1000  # 重试间隔
      fail-fast: false      # 启动失败时不要立即退出

@Component
public class CustomPropertySourceLocator implements PropertySourceLocator {
    
    @Override
    public PropertySource<?> locate(Environment environment) {
        // 不要注入其他Bean，直接使用Environment
        String configUrl = environment.getProperty("custom.config.url");
        String token = environment.getProperty("custom.config.token");
        
        // 直接调用HTTP API获取配置
        return loadConfigFromUrl(configUrl, token);
    }
}

// 只对需要动态刷新的Bean使用@RefreshScope
@RefreshScope
@Component
public class DynamicConfigBean {
    
    @Value("${business.timeout:5000}")
    private int timeout;
    
    // 这个Bean会在配置刷新时重新创建
}

// 对于不需要刷新的Bean，不要使用@RefreshScope
@Component  // 不加@RefreshScope
public class StaticConfigBean {
    
    @Value("${server.name}")
    private String serverName;
    
    // 这个Bean在应用启动后不会重新创建
}

@Component
public class CachingPropertySourceLocator implements PropertySourceLocator {
    
    private volatile PropertySource<?> cachedPropertySource;
    private volatile long lastUpdateTime = 0;
    private final long cacheTimeout = 30000; // 30秒缓存
    
    @Override
    public PropertySource<?> locate(Environment environment) {
        long now = System.currentTimeMillis();
        
        if (cachedPropertySource != null && (now - lastUpdateTime) < cacheTimeout) {
            return cachedPropertySource;  // 返回缓存的配置
        }
        
        // 重新加载配置
        PropertySource<?> newSource = loadFromRemote(environment);
        if (newSource != null) {
            cachedPropertySource = newSource;
            lastUpdateTime = now;
        }
        
        return cachedPropertySource;
    }
}