Implement this interface as a Spring bean to be notified whenever the config + * center pushes a set of changed keys.
+ * + * @author odboy + * @version 3.0.0 + * @date 2026-10-21 + */ +@FunctionalInterface +public interface ConfigChangeHanlder { + + void onConfigChanged(MapHolds the client configuration, the remote configuration snapshot and the + * Spring environment wiring used to refresh {@code @Value} and + * {@code @ConfigurationProperties} fields at runtime.
+ * + * @author odboy + * @version 3.0.0 + * @date 2026-10-21 + */ +public class ConfigcenterContext { + + private static final Logger logger = LoggerFactory.getLogger("cn.odboy"); + + private static final ConfigcenterContext INSTANCE = new ConfigcenterContext(); + + public static final String MANAGER_PROPERTY_SOURCE = "kenaitoConfigPropertySource"; + + private static final String IGNORE_PLACEHOLDER = "[Ignore]"; + + private static final String LATEST_FETCH_TIMESTAMP = "latest.fetch.timestamp"; + + private static final ListPolls {@code /api/fetchChangedConfigs} at a fixed interval and applies + * incremental changes (including deleted keys) to the config center context.
+ * + * @author odboy + * @version 3.0.0 + * @date 2026-10-21 + */ +public class InternalConfigChangeListener { + + private static final Logger logger = LoggerFactory.getLogger("cn.odboy.confcenter"); + + private static final String LATEST_FETCH_TIMESTAMP = "latest.fetch.timestamp"; + + private final ScheduledExecutorService scheduler; + + private volatile boolean closed; + + private volatile long lastTime; + + public InternalConfigChangeListener() { + ConfigcenterContext context = ConfigcenterContext.getInstance(); + this.scheduler = Executors.newSingleThreadScheduledExecutor(runnable -> { + Thread thread = new Thread(runnable, "kenaito-config-listener"); + thread.setDaemon(true); + return thread; + }); + registerHttpListener(context); + } + + public void close() { + closed = true; + scheduler.shutdownNow(); + } + + private void registerHttpListener(ConfigcenterContext context) { + final String[] baseUrls = context.getApiBaseUrls(); + if (baseUrls.length == 0) { + logger.warn("[ConfigClient] no config center base url configured, skip change listener"); + return; + } + + long initialLastTime = context.getLastFetchTimestamp(); + if (initialLastTime <= 0) { + initialLastTime = System.currentTimeMillis(); + } + this.lastTime = initialLastTime; + final int interval = Math.max(1, context.getSyncIntervalSeconds()); + + scheduler.scheduleWithFixedDelay(() -> { + if (closed) { + return; + } + try { + poll(context, baseUrls); + } catch (Exception e) { + logger.error("[ConfigClient] error fetching config changes: {}", e.getMessage(), e); + } + }, interval, interval, TimeUnit.SECONDS); + + logger.info("[ConfigClient] change listener registered, intervalSeconds:{}, lastFetchTime:{}", + interval, initialLastTime); + } + + @SuppressWarnings("unchecked") + private void poll(ConfigcenterContext context, String[] baseUrls) { + for (String baseUrl : baseUrls) { + String url = context.buildTokenParameter(baseUrl + "/api/fetchChangedConfigs"); + MapThe last successfully fetched remote configuration is written to + * {@code config-cache.log} so that the application can still start when the + * config center is temporarily unavailable.
+ * + * @author odboy + * @version 3.0.0 + * @date 2026-10-21 + */ +public class LocalCacheUtils { + + private static final Logger logger = LoggerFactory.getLogger(LocalCacheUtils.class); + + private static final String CACHE_FILE_NAME = "config-cache.log"; + + private LocalCacheUtils() { + } + + private static String getStorageDir() { + String dir = ConfigcenterContext.getAnyProperty( + "kenaito.config.local-storage-dir", + "kenaito.configcenter.local-storage-dir"); + return dir != null ? dir : System.getProperty("user.dir"); + } + + public static void write(MapCollects {@code @Value} fields and {@code @ConfigurationProperties} beans while + * the application context starts, then refreshes only the fields affected by a + * config change. This is registered as a static bean by + * {@link cn.odboy.confcenter.springboot.KenaitoRefreshAutoConfiguration}.
+ * + * @author odboy + * @version 3.0.0 + * @date 2026-10-21 + */ +public class RefreshScopeRegistry implements BeanPostProcessor { + + private static final Logger logger = LoggerFactory.getLogger(RefreshScopeRegistry.class); + + private final Environment environment; + + private final MapInitializes the config center before the application context is created and + * injects the remote configuration as a high-priority property source.
+ * + *Registered through {@code META-INF/spring.factories}, which Spring Boot 3 + * still supports for {@link EnvironmentPostProcessor} implementations.
+ * + * @author odboy + * @version 3.0.0 + * @date 2026-10-21 + */ +public class KenaitoEnvironmentInitializer implements EnvironmentPostProcessor, Ordered { + + private final ConfigcenterContext ccContext = ConfigcenterContext.getInstance(); + + @Override + public void postProcessEnvironment(ConfigurableEnvironment environment, SpringApplication application) { + if (!ccContext.isRemoteEnabled() || ccContext.isProcessed()) { + return; + } + Properties properties = new Properties(); + // Extract config center settings from the Spring Environment. The config data + // post processor runs earlier, so application.properties is already loaded. + environment.getPropertySources().forEach(propertySource -> { + if (propertySource instanceof EnumerablePropertySource enumerable) { + for (String key : enumerable.getPropertyNames()) { + if (key.startsWith("kenaito.config.") + || key.startsWith("kenaito.configcenter.") + || key.equals("spring.application.name")) { + String value = environment.getProperty(key); + if (value != null) { + properties.setProperty(key, value); + } + } + } + } + }); + ccContext.init(properties, true); + ccContext.mergeRemoteProperties(properties); + PropertiesPropertySource propertySource = + new PropertiesPropertySource(ConfigcenterContext.MANAGER_PROPERTY_SOURCE, properties); + environment.getPropertySources().addFirst(propertySource); + } + + @Override + public int getOrder() { + // Run after ConfigDataEnvironmentPostProcessor (HIGHEST_PRECEDENCE + 10). + return Ordered.LOWEST_PRECEDENCE; + } +} diff --git a/kenaito-conf-springboot3-client/src/main/java/cn/odboy/confcenter/springboot/KenaitoRefreshAutoConfiguration.java b/kenaito-conf-springboot3-client/src/main/java/cn/odboy/confcenter/springboot/KenaitoRefreshAutoConfiguration.java new file mode 100644 index 0000000..a469835 --- /dev/null +++ b/kenaito-conf-springboot3-client/src/main/java/cn/odboy/confcenter/springboot/KenaitoRefreshAutoConfiguration.java @@ -0,0 +1,45 @@ +package cn.odboy.confcenter.springboot; + +import org.springframework.boot.autoconfigure.AutoConfiguration; +import org.springframework.context.ApplicationContext; +import org.springframework.context.ApplicationContextAware; +import org.springframework.context.annotation.Bean; +import org.springframework.core.env.Environment; + +import cn.odboy.confcenter.ConfigcenterContext; +import cn.odboy.confcenter.RefreshScopeRegistry; + +/** + * Spring Boot 3 auto configuration for config center refresh support. + * + *Registers a {@link RefreshScopeRegistry} bean post processor and captures the + * {@link ApplicationContext} so that remote config changes can update the Spring + * environment and refresh {@code @Value} / {@code @ConfigurationProperties} fields + * at runtime.
+ * + *Registered through + * {@code META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports}.
+ * + * @author odboy + * @version 3.0.0 + * @date 2026-10-21 + */ +@AutoConfiguration +public class KenaitoRefreshAutoConfiguration implements ApplicationContextAware { + + /** + * Must be static so the bean post processor is registered before regular beans + * are instantiated. + */ + @Bean + public static RefreshScopeRegistry kenaitoRefreshScopeRegistry(Environment environment) { + RefreshScopeRegistry registry = new RefreshScopeRegistry(environment); + ConfigcenterContext.setRefreshScopeRegistry(registry); + return registry; + } + + @Override + public void setApplicationContext(ApplicationContext applicationContext) { + ConfigcenterContext.setApplicationContext(applicationContext); + } +} diff --git a/kenaito-conf-springboot3-client/src/main/resources/META-INF/spring.factories b/kenaito-conf-springboot3-client/src/main/resources/META-INF/spring.factories new file mode 100644 index 0000000..a58f71e --- /dev/null +++ b/kenaito-conf-springboot3-client/src/main/resources/META-INF/spring.factories @@ -0,0 +1,2 @@ +org.springframework.boot.env.EnvironmentPostProcessor=\ +cn.odboy.confcenter.springboot.KenaitoEnvironmentInitializer diff --git a/kenaito-conf-springboot3-client/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports b/kenaito-conf-springboot3-client/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports new file mode 100644 index 0000000..78491be --- /dev/null +++ b/kenaito-conf-springboot3-client/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports @@ -0,0 +1 @@ +cn.odboy.confcenter.springboot.KenaitoRefreshAutoConfiguration