import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
public class LogConfig {
    @Value("${logging.level.root}")
    private String logLevel;

    public String getLogLevel() {
        return logLevel;
    }
}
// 修改properties文件后，重啟上下文或用Actuator刷新（詳見觀點(diǎn)4）

import org.springframework.core.env.Environment;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class ConfigService {
    @Autowired
    private Environment env;

    public String getDbUrl() {
        return env.getProperty("spring.datasource.url");  // 運(yùn)行時(shí)讀取
    }
}

import org.springframework.core.env.ConfigurableEnvironment;
import org.springframework.core.env.MapPropertySource;
import java.util.HashMap;
import java.util.Map;

@Autowired
private ConfigurableEnvironment env;

public void updateConfig() {
    Map<String, Object> map = new HashMap<>();
    map.put("custom.key", "newValue");
    env.getPropertySources().addLast(new MapPropertySource("dynamic", map));  // 添加新來源
}

management:
  endpoints:
    web:
      exposure:
        include: refresh

import org.springframework.jmx.export.annotation.ManagedResource;
import org.springframework.jmx.export.annotation.ManagedAttribute;

@ManagedResource
public class ConfigMBean {
    private String configValue = "default";

    @ManagedAttribute
    public String getConfigValue() { return configValue; }

    @ManagedAttribute
    public void setConfigValue(String value) { this.configValue = value; }
}

import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.boot.context.properties.ConfigurationProperties;

@RefreshScope
@ConfigurationProperties(prefix = "app")
public class AppConfig {
    private String mode;

    public String getMode() { return mode; }
    public void setMode(String mode) { this.mode = mode; }
}

import java.nio.file.*;

public class ConfigWatcher {
    public void watch() throws Exception {
        WatchService watcher = FileSystems.getDefault().newWatchService();
        Path dir = Paths.get("config/");
        dir.register(watcher, StandardWatchEventKinds.ENTRY_MODIFY);
        while (true) {
            WatchKey key = watcher.take();
            for (WatchEvent<?> event : key.pollEvents()) {
                // 檢測(cè)到Y(jié)AML變化，重新加載配置
                System.out.println("Config changed: " + event.context());
                // 調(diào)用refresh方法
            }
            key.reset();
        }
    }
}

spring:
  cloud:
    config:
      server:
        git:
          uri: https://github.com/your-repo/config-repo

app.id=your-app
apollo.meta=http://localhost:8080

nacos:
  config:
    server-addr: 127.0.0.1:8848

// 配置屬性類
@Configuration
@ConfigurationProperties(prefix = "app.service")
@Data
public class ServiceProperties {
    private int maxConnections = 100;
    private int timeout = 3000;
    private String environment;
    // getter和setter方法省略
}

// 使用@RefreshScope的服務(wù)類
@Service
@RefreshScope  // 關(guān)鍵注解，使該Bean支持動(dòng)態(tài)刷新
public class DynamicConfigService {
    
    @Autowired
    private ServiceProperties properties;
    
    public void printConfig() {
        System.out.println("當(dāng)前最大連接數(shù): " + properties.getMaxConnections());
        System.out.println("當(dāng)前超時(shí)時(shí)間: " + properties.getTimeout());
        System.out.println("當(dāng)前環(huán)境: " + properties.getEnvironment());
    }
    
    public ServiceProperties getProperties() {
        return properties;
    }
}

// 控制器，提供刷新端點(diǎn)
@RestController
@RequestMapping("/config")
public class ConfigController {
    
    @Autowired
    private DynamicConfigService configService;
    
    @Autowired
    private ApplicationContext context;
    
    @GetMapping("/current")
    public ServiceProperties getCurrentConfig() {
        return configService.getProperties();
    }
    
    @PostMapping("/refresh")
    public String refreshConfig() {
        // 觸發(fā)配置刷新
        ((RefreshScope) context.getBean("refreshScope")).refresh("dynamicConfigService");
        return "配置已刷新";
    }
}

// 1. 添加依賴（pom.xml）
// <dependency>
//     <groupId>org.springframework.cloud</groupId>
//     <artifactId>spring-cloud-starter-config</artifactId>
// </dependency>
// <dependency>
//     <groupId>org.springframework.cloud</groupId>
//     <artifactId>spring-cloud-starter-bus-amqp</artifactId>
// </dependency>

// 2. 配置文件（bootstrap.yml）
// spring:
//   application:
//     name: myapp
//   cloud:
//     config:
//       uri: http://config-server:8888
//       fail-fast: true
//   rabbitmq:
//     host: localhost
//     port: 5672
//     username: guest
//     password: guest
// management:
//   endpoints:
//     web:
//       exposure:
//         include: refresh,bus-refresh

// 3. 配置類
@Configuration
@RefreshScope
public class DatabaseConfig {
    
    @Value("${app.datasource.max-pool-size:10}")
    private int maxPoolSize;
    
    @Value("${app.datasource.connection-timeout:30000}")
    private int connectionTimeout;
    
    @Bean
    @RefreshScope
    public DataSource dataSource() {
        HikariConfig config = new HikariConfig();
        config.setJdbcUrl("jdbc:mysql://localhost:3306/mydb");
        config.setUsername("user");
        config.setPassword("password");
        config.setMaximumPoolSize(maxPoolSize);
        config.setConnectionTimeout(connectionTimeout);
        
        return new HikariDataSource(config);
    }
    
    // 提供獲取當(dāng)前配置的方法
    public Map<String, Object> getCurrentConfig() {
        Map<String, Object> config = new HashMap<>();
        config.put("maxPoolSize", maxPoolSize);
        config.put("connectionTimeout", connectionTimeout);
        return config;
    }
}

// 4. 控制器
@RestController
public class ConfigRefreshController {
    
    @Autowired
    private DatabaseConfig databaseConfig;
    
    @GetMapping("/db-config")
    public Map<String, Object> getDbConfig() {
        return databaseConfig.getCurrentConfig();
    }
}

@Component
@ConfigurationProperties(prefix = "app.cache")
@Data
public class CacheProperties {
    private int timeToLiveSeconds = 3600;
    private int maxSize = 1000;
    private boolean enabled = true;
}

@Service
public class CacheService implements ApplicationListener<EnvironmentChangeEvent> {
    
    @Autowired
    private CacheProperties cacheProperties;
    
    private Cache<String, Object> cache;
    
    @PostConstruct
    public void init() {
        initializeCache();
    }
    
    private void initializeCache() {
        // 根據(jù)配置初始化緩存
        this.cache = CacheBuilder.newBuilder()
                .expireAfterWrite(cacheProperties.getTimeToLiveSeconds(), TimeUnit.SECONDS)
                .maximumSize(cacheProperties.getMaxSize())
                .build();
    }
    
    @Override
    public void onApplicationEvent(EnvironmentChangeEvent event) {
        // 當(dāng)環(huán)境變更時(shí)，重新初始化緩存
        initializeCache();
        System.out.println("緩存配置已更新: TTL=" + cacheProperties.getTimeToLiveSeconds() 
                + ", 最大容量=" + cacheProperties.getMaxSize());
    }
    
    // 緩存操作方法省略
}

// 1. 添加依賴（pom.xml）
// <dependency>
//     <groupId>org.springframework.boot</groupId>
//     <artifactId>spring-boot-starter-actuator</artifactId>
// </dependency>

// 2. 配置文件（application.yml）
// management:
//   endpoints:
//     web:
//       exposure:
//         include: env,health,info
//   endpoint:
//     env:
//       post:
//         enabled: true

// 3. 自定義環(huán)境修改端點(diǎn)
@RestController
@RequestMapping("/system")
public class EnvironmentController {
    
    @Autowired
    private ConfigurableEnvironment environment;
    
    @GetMapping("/properties")
    public Map<String, Object> getProperties(@RequestParam(required = false) String prefix) {
        Map<String, Object> props = new HashMap<>();
        
        for (PropertySource<?> propertySource : environment.getPropertySources()) {
            if (propertySource instanceof EnumerablePropertySource) {
                EnumerablePropertySource<?> enumerable = (EnumerablePropertySource<?>) propertySource;
                for (String name : enumerable.getPropertyNames()) {
                    if (prefix == null || name.startsWith(prefix)) {
                        props.put(name, environment.getProperty(name));
                    }
                }
            }
        }
        
        return props;
    }
    
    @PostMapping("/properties")
    public String updateProperty(@RequestParam String name, 
                               @RequestParam String value) {
        MutablePropertySources propertySources = environment.getPropertySources();
        
        // 查找或創(chuàng)建自定義屬性源
        MapPropertySource customSource;
        if (propertySources.contains("dynamicProperties")) {
            PropertySource<?> source = propertySources.get("dynamicProperties");
            customSource = (MapPropertySource) source;
        } else {
            customSource = new MapPropertySource("dynamicProperties", new HashMap<>());
            propertySources.addFirst(customSource);
        }
        
        // 更新屬性
        Map<String, Object> source = new HashMap<>(customSource.getSource());
        source.put(name, value);
        
        customSource = new MapPropertySource("dynamicProperties", source);
        propertySources.replace("dynamicProperties", customSource);
        
        return "屬性 " + name + " 已更新為: " + value;
    }
}

@Component
public class DynamicPropertyLoader {
    
    private static final Logger logger = LoggerFactory.getLogger(DynamicPropertyLoader.class);
    
    @Autowired
    private ConfigurableEnvironment environment;
    
    private File configFile;
    private long lastModified;
    private final Map<String, Object> dynamicProperties = new ConcurrentHashMap<>();
    
    @Value("${app.config.path:config/dynamic.properties}")
    private String configPath;
    
    @PostConstruct
    public void init() {
        this.configFile = new File(configPath);
        this.lastModified = configFile.lastModified();
        loadProperties();
        
        // 啟動(dòng)定時(shí)任務(wù)，定期檢查配置文件變化
        Executors.newSingleThreadScheduledExecutor()
                .scheduleAtFixedRate(this::checkAndReload, 30, 30, TimeUnit.SECONDS);
    }
    
    private void loadProperties() {
        try (InputStream input = new FileInputStream(configFile)) {
            Properties props = new Properties();
            props.load(input);
            
            // 更新動(dòng)態(tài)屬性集合
            dynamicProperties.clear();
            for (String name : props.stringPropertyNames()) {
                dynamicProperties.put(name, props.getProperty(name));
            }
            
            // 更新環(huán)境屬性
            updateEnvironment();
            
            logger.info("動(dòng)態(tài)配置已加載: {}", dynamicProperties.keySet());
        } catch (IOException e) {
            logger.error("加載動(dòng)態(tài)配置失敗", e);
        }
    }
    
    private void updateEnvironment() {
        MutablePropertySources propertySources = environment.getPropertySources();
        
        // 移除舊的屬性源
        if (propertySources.contains("dynamicProperties")) {
            propertySources.remove("dynamicProperties");
        }
        
        // 添加新的屬性源
        propertySources.addFirst(new MapPropertySource("dynamicProperties", dynamicProperties));
    }
    
    private void checkAndReload() {
        if (configFile.exists() && configFile.lastModified() > lastModified) {
            logger.info("檢測(cè)到配置文件變更，重新加載");
            lastModified = configFile.lastModified();
            loadProperties();
        }
    }
    
    // 提供API動(dòng)態(tài)更新單個(gè)屬性
    public void updateProperty(String name, String value) {
        dynamicProperties.put(name, value);
        updateEnvironment();
        logger.info("動(dòng)態(tài)屬性已更新: {}={}", name, value);
    }
    
    // 獲取當(dāng)前所有動(dòng)態(tài)屬性
    public Map<String, Object> getAllProperties() {
        return new HashMap<>(dynamicProperties);
    }
}

// 控制器
@RestController
@RequestMapping("/dynamic-config")
public class DynamicConfigController {
    
    @Autowired
    private DynamicPropertyLoader propertyLoader;
    
    @GetMapping
    public Map<String, Object> getAllProperties() {
        return propertyLoader.getAllProperties();
    }
    
    @PostMapping
    public String updateProperty(@RequestParam String name, 
                               @RequestParam String value) {
        propertyLoader.updateProperty(name, value);
        return "屬性已更新";
    }
}

// 1. 添加依賴（pom.xml）
// <dependency>
//     <groupId>com.ctrip.framework.apollo</groupId>
//     <artifactId>apollo-client</artifactId>
//     <version>2.1.0</version>
// </dependency>

// 2. 配置文件（application.properties）
// app.id=your-app-id
// apollo.meta=http://apollo-config-service:8080
// apollo.bootstrap.enabled=true
// apollo.bootstrap.eagerLoad.enabled=true

// 3. Apollo配置類
@Configuration
@EnableApolloConfig
public class ApolloConfiguration {
    
    // 使用Apollo的Config API動(dòng)態(tài)獲取配置
    @Bean
    public Config apolloConfig() {
        return ConfigService.getAppConfig();
    }
    
    // 添加配置變更監(jiān)聽器
    @PostConstruct
    public void init() {
        Config config = apolloConfig();
        config.addChangeListener(changeEvent -> {
            for (String key : changeEvent.changedKeys()) {
                ConfigChange change = changeEvent.getChange(key);
                System.out.println(String.format("配置變更 - 鍵: %s, 舊值: %s, 新值: %s", 
                        key, change.getOldValue(), change.getNewValue()));
            }
        });
    }
}

// 4. 使用動(dòng)態(tài)配置的服務(wù)類
@Service
public class ApiGatewayService {
    
    private final Config config;
    
    // Apollo推薦的最佳實(shí)踐：直接注入Config而非使用@Value
    public ApiGatewayService(Config config) {
        this.config = config;
    }
    
    public int getRequestTimeout() {
        // 每次調(diào)用都會(huì)獲取最新值
        return config.getIntProperty("api.request.timeout", 5000);
    }
    
    public int getMaxConcurrentRequests() {
        return config.getIntProperty("api.max.concurrent.requests", 200);
    }
    
    public boolean isCircuitBreakerEnabled() {
        return config.getBooleanProperty("api.circuit.breaker.enabled", true);
    }
    
    public Map<String, Object> getAllApiConfigs() {
        Map<String, Object> configs = new HashMap<>();
        configs.put("requestTimeout", getRequestTimeout());
        configs.put("maxConcurrentRequests", getMaxConcurrentRequests());
        configs.put("circuitBreakerEnabled", isCircuitBreakerEnabled());
        return configs;
    }
}

// 5. 控制器
@RestController
@RequestMapping("/api-config")
public class ApiConfigController {
    
    @Autowired
    private ApiGatewayService gatewayService;
    
    @GetMapping
    public Map<String, Object> getApiConfigs() {
        return gatewayService.getAllApiConfigs();
    }
}

// 1. 添加依賴（pom.xml）
// <dependency>
//     <groupId>com.alibaba.cloud</groupId>
//     <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
//     <version>2021.0.1.0</version>
// </dependency>

// 2. 配置文件（bootstrap.properties）
// spring.application.name=nacos-config-example
// spring.cloud.nacos.config.server-addr=127.0.0.1:8848
// spring.cloud.nacos.config.file-extension=yaml

// 3. 使用@RefreshScope的配置類
@Configuration
@RefreshScope
public class ThreadPoolConfig {
    
    @Value("${thread.pool.core-size:10}")
    private int corePoolSize;
    
    @Value("${thread.pool.max-size:50}")
    private int maxPoolSize;
    
    @Value("${thread.pool.queue-capacity:100}")
    private int queueCapacity;
    
    @Bean
    public ThreadPoolTaskExecutor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(corePoolSize);
        executor.setMaxPoolSize(maxPoolSize);
        executor.setQueueCapacity(queueCapacity);
        executor.setThreadNamePrefix("dynamic-task-");
        
        return executor;
    }
    
    public Map<String, Object> getThreadPoolConfig() {
        Map<String, Object> config = new HashMap<>();
        config.put("corePoolSize", corePoolSize);
        config.put("maxPoolSize", maxPoolSize);
        config.put("queueCapacity", queueCapacity);
        return config;
    }
}

// 4. 添加配置監(jiān)聽器
@Component
public class NacosConfigListener {
    
    private static final Logger logger = LoggerFactory.getLogger(NacosConfigListener.class);
    
    @NacosValue(value = "${thread.pool.core-size:10}", autoRefreshed = true)
    private int corePoolSize;
    
    @Autowired
    private ThreadPoolTaskExecutor taskExecutor;
    
    @Autowired
    private ThreadPoolConfig threadPoolConfig;
    
    // Nacos配置變更監(jiān)聽器
    @NacosConfigListener(dataId = "nacos-config-example.yaml", groupId = "DEFAULT_GROUP")
    public void onConfigChange(String newContent) {
        logger.info("Nacos配置已變更: {}", newContent);
        
        // 根據(jù)新配置動(dòng)態(tài)調(diào)整線程池參數(shù)
        try {
            // 使用反射獲取ThreadPoolExecutor
            ThreadPoolExecutor executor = taskExecutor.getThreadPoolExecutor();
            
            // 獲取新的配置值（這里簡(jiǎn)化處理，實(shí)際應(yīng)解析newContent）
            int newCoreSize = threadPoolConfig.getThreadPoolConfig().get("corePoolSize");
            int newMaxSize = threadPoolConfig.getThreadPoolConfig().get("maxPoolSize");
            
            // 動(dòng)態(tài)調(diào)整線程池參數(shù)
            executor.setCorePoolSize(newCoreSize);
            executor.setMaximumPoolSize(newMaxSize);
            
            logger.info("線程池參數(shù)已動(dòng)態(tài)調(diào)整: coreSize={}, maxSize={}", 
                    executor.getCorePoolSize(), executor.getMaximumPoolSize());
        } catch (Exception e) {
            logger.error("動(dòng)態(tài)調(diào)整線程池參數(shù)失敗", e);
        }
    }
}

// 1. 添加依賴（pom.xml）
// <dependency>
//     <groupId>org.springframework.cloud</groupId>
//     <artifactId>spring-cloud-starter-kubernetes-config</artifactId>
// </dependency>

// 2. 配置文件（bootstrap.yml）
// spring:
//   cloud:
//     kubernetes:
//       config:
//         enabled: true
//         sources:
//           - name: app-config
//             namespace: default
//       reload:
//         enabled: true
//         mode: polling
//         period: 30000

// 3. Kubernetes ConfigMap YAML示例
// apiVersion: v1
// kind: ConfigMap
// metadata:
//   name: app-config
// data:
//   application.yml: |-
//     app:
//       feature:
//         enabled: true
//       cache:
//         ttl: 3600
//       rate-limit:
//         max-requests: 100

// 4. 配置類
@Configuration
@RefreshScope
@ConfigurationProperties(prefix = "app")
@Data
public class ApplicationConfig {
    
    private FeatureConfig feature = new FeatureConfig();
    private CacheConfig cache = new CacheConfig();
    private RateLimitConfig rateLimit = new RateLimitConfig();
    
    @Data
    public static class FeatureConfig {
        private boolean enabled = false;
    }
    
    @Data
    public static class CacheConfig {
        private int ttl = 1800; // seconds
    }
    
    @Data
    public static class RateLimitConfig {
        private int maxRequests = 50;
    }
}

// 5. 服務(wù)類
@Service
@RefreshScope
public class FeatureToggleService {
    
    @Autowired
    private ApplicationConfig config;
    
    public boolean isFeatureEnabled() {
        return config.getFeature().isEnabled();
    }
    
    public int getCacheTtl() {
        return config.getCache().getTtl();
    }
    
    public int getRateLimit() {
        return config.getRateLimit().getMaxRequests();
    }
    
    public Map<String, Object> getAllConfig() {
        Map<String, Object> configMap = new HashMap<>();
        configMap.put("featureEnabled", isFeatureEnabled());
        configMap.put("cacheTtl", getCacheTtl());
        configMap.put("rateLimit", getRateLimit());
        return configMap;
    }
}

// 1. 定義MBean接口
public interface ConfigurationMBean {
    
    int getConnectionTimeout();
    void setConnectionTimeout(int timeout);
    
    int getMaxConnections();
    void setMaxConnections(int maxConnections);
    
    boolean isMetricsEnabled();
    void setMetricsEnabled(boolean enabled);
}

// 2. 實(shí)現(xiàn)MBean
@Component
public class ConfigurationManager implements ConfigurationMBean {
    
    private int connectionTimeout = 3000;
    private int maxConnections = 100;
    private boolean metricsEnabled = true;
    
    private final List<ConfigChangeListener> listeners = new ArrayList<>();
    
    @PostConstruct
    public void registerMBean() {
        try {
            MBeanServer server = ManagementFactory.getPlatformMBeanServer();
            ObjectName objectName = new ObjectName("com.example:type=Configuration");
            server.registerMBean(this, objectName);
        } catch (Exception e) {
            throw new RuntimeException("Failed to register configuration MBean", e);
        }
    }
    
    @Override
    public int getConnectionTimeout() {
        return connectionTimeout;
    }
    
    @Override
    public void setConnectionTimeout(int timeout) {
        int oldValue = this.connectionTimeout;
        this.connectionTimeout = timeout;
        notifyListeners("connectionTimeout", oldValue, timeout);
    }
    
    @Override
    public int getMaxConnections() {
        return maxConnections;
    }
    
    @Override
    public void setMaxConnections(int maxConnections) {
        int oldValue = this.maxConnections;
        this.maxConnections = maxConnections;
        notifyListeners("maxConnections", oldValue, maxConnections);
    }
    
    @Override
    public boolean isMetricsEnabled() {
        return metricsEnabled;
    }
    
    @Override
    public void setMetricsEnabled(boolean enabled) {
        boolean oldValue = this.metricsEnabled;
        this.metricsEnabled = enabled;
        notifyListeners("metricsEnabled", oldValue, enabled);
    }
    
    // 添加配置變更監(jiān)聽器
    public void addListener(ConfigChangeListener listener) {
        listeners.add(listener);
    }
    
    // 通知所有監(jiān)聽器
    private void notifyListeners(String property, Object oldValue, Object newValue) {
        for (ConfigChangeListener listener : listeners) {
            listener.onConfigChange(property, oldValue, newValue);
        }
    }
    
    // 配置變更監(jiān)聽器接口
    public interface ConfigChangeListener {
        void onConfigChange(String property, Object oldValue, Object newValue);
    }
}

// 3. 使用MBean的服務(wù)
@Service
public class ConnectionPoolService implements ConfigurationManager.ConfigChangeListener {
    
    private static final Logger logger = LoggerFactory.getLogger(ConnectionPoolService.class);
    
    private final ConfigurationManager configManager;
    private ExecutorService connectionPool;
    
    @Autowired
    public ConnectionPoolService(ConfigurationManager configManager) {
        this.configManager = configManager;
        configManager.addListener(this);
        initializeConnectionPool();
    }
    
    private void initializeConnectionPool() {
        // 根據(jù)配置初始化連接池
        connectionPool = new ThreadPoolExecutor(
            10, 
            configManager.getMaxConnections(),
            60L, TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(),
            new ThreadFactoryBuilder().setNameFormat("conn-pool-%d").build()
        );
        logger.info("連接池已初始化，最大連接數(shù): {}", configManager.getMaxConnections());
    }
    
    @Override
    public void onConfigChange(String property, Object oldValue, Object newValue) {
        if ("maxConnections".equals(property)) {
            logger.info("檢測(cè)到最大連接數(shù)變更: {} -> {}", oldValue, newValue);
            ThreadPoolExecutor executor = (ThreadPoolExecutor) connectionPool;
            executor.setMaximumPoolSize((Integer) newValue);
            logger.info("連接池最大連接數(shù)已動(dòng)態(tài)調(diào)整為: {}", executor.getMaximumPoolSize());
        } else if ("metricsEnabled".equals(property)) {
            logger.info("指標(biāo)收集狀態(tài)變更: {} -> {}", oldValue, newValue);
            // 實(shí)現(xiàn)指標(biāo)收集的開關(guān)邏輯
        }
    }
    
    // 連接池操作方法省略
}

// 1. 配置實(shí)體類
@Entity
@Table(name = "app_config")
@Data
public class ConfigEntity {
    
    @Id
    private String key;
    
    private String value;
    
    private String description;
    
    @Column(name = "last_updated")
    private LocalDateTime lastUpdated;
}

// 2. 配置倉(cāng)庫(kù)
@Repository
public interface ConfigRepository extends JpaRepository<ConfigEntity, String> {
    List<ConfigEntity> findByLastUpdatedGreaterThan(LocalDateTime time);
}

// 3. 配置服務(wù)
@Service
public class DatabaseConfigService {
    
    private static final Logger logger = LoggerFactory.getLogger(DatabaseConfigService.class);
    
    @Autowired
    private ConfigRepository configRepository;
    
    private final Map<String, String> configCache = new ConcurrentHashMap<>();
    private LocalDateTime lastSyncTime = LocalDateTime.now();
    
    @PostConstruct
    public void init() {
        // 初始加載所有配置
        refreshAllConfig();
        
        // 啟動(dòng)定時(shí)任務(wù)，每30秒檢查更新
        Executors.newSingleThreadScheduledExecutor()
                .scheduleAtFixedRate(this::refreshChangedConfig, 30, 30, TimeUnit.SECONDS);
    }
    
    // 刷新所有配置
    public void refreshAllConfig() {
        logger.info("從數(shù)據(jù)庫(kù)加載所有配置");
        List<ConfigEntity> allConfig = configRepository.findAll();
        
        configCache.clear();
        for (ConfigEntity config : allConfig) {
            configCache.put(config.getKey(), config.getValue());
        }
        
        lastSyncTime = LocalDateTime.now();
        logger.info("配置加載完成，共 {} 項(xiàng)", configCache.size());
    }
    
    // 只刷新變更的配置
    public void refreshChangedConfig() {
        logger.debug("檢查配置變更");
        
        List<ConfigEntity> changedConfig = configRepository.findByLastUpdatedGreaterThan(lastSyncTime);
        if (!changedConfig.isEmpty()) {
            logger.info("檢測(cè)到 {} 項(xiàng)配置變更", changedConfig.size());
            
            for (ConfigEntity config : changedConfig) {
                String oldValue = configCache.get(config.getKey());
                configCache.put(config.getKey(), config.getValue());
                logger.info("配置[{}]已更新: {} -> {}", config.getKey(), oldValue, config.getValue());
            }
            
            lastSyncTime = LocalDateTime.now();
        }
    }
    
    // 獲取配置值，支持默認(rèn)值
    public String getConfig(String key, String defaultValue) {
        return configCache.getOrDefault(key, defaultValue);
    }
    
    // 獲取整型配置
    public int getIntConfig(String key, int defaultValue) {
        String value = getConfig(key, String.valueOf(defaultValue));
        try {
            return Integer.parseInt(value);
        } catch (NumberFormatException e) {
            logger.warn("配置[{}]值[{}]轉(zhuǎn)換為整數(shù)失敗，使用默認(rèn)值{}", key, value, defaultValue);
            return defaultValue;
        }
    }
    
    // 獲取布爾配置
    public boolean getBooleanConfig(String key, boolean defaultValue) {
        String value = getConfig(key, String.valueOf(defaultValue));
        return Boolean.parseBoolean(value);
    }
    
    // 更新配置
    @Transactional
    public void updateConfig(String key, String value, String description) {
        ConfigEntity config = configRepository.findById(key)
                .orElse(new ConfigEntity());
        
        config.setKey(key);
        config.setValue(value);
        config.setDescription(description);
        config.setLastUpdated(LocalDateTime.now());
        
        configRepository.save(config);
        
        // 更新緩存
        configCache.put(key, value);
        logger.info("配置[{}]已更新為: {}", key, value);
    }
    
    // 獲取所有配置
    public Map<String, String> getAllConfig() {
        return new HashMap<>(configCache);
    }
}

// 4. 配置控制器
@RestController
@RequestMapping("/db-config")
public class DatabaseConfigController {
    
    @Autowired
    private DatabaseConfigService configService;
    
    @GetMapping
    public Map<String, String> getAllConfig() {
        return configService.getAllConfig();
    }
    
    @GetMapping("/{key}")
    public String getConfig(@PathVariable String key,
                           @RequestParam(required = false) String defaultValue) {
        return configService.getConfig(key, defaultValue);
    }
    
    @PostMapping("/{key}")
    public String updateConfig(@PathVariable String key,
                             @RequestParam String value,
                             @RequestParam(required = false) String description) {
        configService.updateConfig(key, value, description != null ? description : "");
        return "配置已更新";
    }
    
    @PostMapping("/refresh")
    public String refreshConfig() {
        configService.refreshAllConfig();
        return "所有配置已刷新";
    }
}