简易配置中心框架设计概述

引言

总体设计

架构概述

工作流程

主要模块

技术选型

代码实现概述

安装核心依赖

<dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-context</artifactId>
 <version>6.1.6</version>
</dependency>
<!-- 用于配置自动更新 -->
<dependency>
 <groupId>org.springframework.cloud</groupId>
 <artifactId>spring-cloud-context</artifactId>
 <version>4.1.0</version>
</dependency>
 <dependency>
 <groupId>com.squareup.okhttp3</groupId>
 <artifactId>okhttp</artifactId>
 <version>4.12.0</version>
</dependency>

<dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
 <groupId>com.h2database</groupId>
 <artifactId>h2</artifactId>
 <scope>runtime</scope>
</dependency>
<dependency>
 <groupId>org.mybatis.spring.boot</groupId>
 <artifactId>mybatis-spring-boot-starter</artifactId>
 <version>3.0.3</version>
</dependency>
<dependency>
 <groupId>mysql</groupId>
 <artifactId>mysql-connector-java</artifactId>
 <version>8.0.32</version>
</dependency>

Server端实现

关于参考概念

初始化数据

spring:
 application:
 name: config-server
 datasource:
 driver-class-name: org.h2.Driver
 url: jdbc:h2:mem:h2db
 username: root
 password: 自定义
 sql:
 init:
 schema-locations: classpath:db.sql
 mode: always
 h2:
 console:
 enabled: true
 path: /h2
 settings:
 web-allow-others: true
mybatis:
 configuration:
 log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Configs {
 private String app; // 应用
 private String env; // 环境
 private String ns; // 命名空间
 private String pkey; // 配置键
 private String pval; // 配置值
}
@Repository
@Mapper
public interface ConfigsMapper {
 @Select("select * from configs where app=#{app} and env=#{env} and ns=#{ns}")
 List<Configs> list(String app, String env, String ns);
 @Select("select * from configs where app=#{app} and env=#{env} and ns=#{ns} and pkey=#{pkey}")
 Configs select(String app, String env, String ns, String pkey);
 @Insert("insert into configs(app, env, ns, pkey, pval) values(#{app}, #{env}, #{ns}, #{pkey}, #{pval})")
 int insert(Configs configs);
 @Update("update configs set pval=#{pval} where app=#{app} and env=#{env} and ns=#{ns} and pkey=#{pkey}")
 int update(Configs configs);
}

create table if not exists `configs` (
 `app` varchar(64) not null,
 `env` varchar(64) not null,
 `ns` varchar(64) not null,
 `pkey` varchar(64) not null,
 `pval` varchar(128) null
);
insert into configs(app, env, ns, pkey, pval) values('app1', 'dev', 'public', 'ipman.a', 'dev100');
insert into configs(app, env, ns, pkey, pval) values('app1', 'dev', 'public', 'ipman.b', 'http://localhost:9192');
insert into configs(app, env, ns, pkey, pval) values('app1', 'dev', 'public', 'ipman.c', 'cc100');

开发服务端

支持长轮询

/**
 * WebMvc配置类,用于自定义Spring MVC的配置
 */
@Configuration
public class WebMvcConfig implements WebMvcConfigurer {
 /**
 * 定义并配置一个线程池任务执行器,用于处理异步请求。
 *
 * @return 配置好的ThreadPoolTaskExecutor实例。
 */
 @Bean
 public ThreadPoolTaskExecutor mvcTaskExecutor() {
 ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
 executor.setCorePoolSize(10); // 核心线程数
 executor.setQueueCapacity(100); // 队列容量
 executor.setMaxPoolSize(25); // 最大线程数
 return executor;
 }
 /**
 * 配置异步请求支持,设置任务执行器和超时时间。
 *
 * @param configurer 异步支持配置器
 */
 @Override
 public void configureAsyncSupport(AsyncSupportConfigurer configurer) {
 configurer.setTaskExecutor(mvcTaskExecutor());
 configurer.setDefaultTimeout(60_000L); // 设置默认超时时间 10s
 }
 /**
 * 全局异常处理器,捕获并处理异步请求超时异常。
 */
 @ControllerAdvice
 static class GlobalExceptionHandler {
 /**
 * 处理异步请求超时异常,返回304状态码。
 *
 * @param e 异常实例
 * @param request HTTP请求
 */
 @ResponseStatus(HttpStatus.NOT_MODIFIED) //返回 304 状态码
 @ResponseBody
 @ExceptionHandler(AsyncRequestTimeoutException.class) //捕获特定异常
 public void handleAsyncRequestTimeoutException(AsyncRequestTimeoutException e, HttpServletRequest request) {
 System.out.println("handleAsyncRequestTimeoutException");
 }
 }
}

提供基础服务

/**
 * 配置服务控制器,提供配置的查询、更新和版本查询功能
 */
@RestController
@Slf4j
public class ConfigController {
 @Autowired
 ConfigsMapper mapper;
 // 用于存储配置的版本信息
 Map<String, Long> VERSION = new HashMap<>();
 // 用于存储appKey与DeferredResult之间的映射,以支持异步返回配置版本信息
 MultiValueMap<String, DeferredResult<Long>> appKeyDeferredResult = new LinkedMultiValueMap<>();
 // 生成应用键
 static String getAppKey(String app, String env, String ns) {
 return app + "-" + env + "-" + ns;
 }
 /**
 * 查询配置列表。
 *
 * @param app 应用名称
 * @param env 环境标识
 * @param ns 命名空间
 * @return 配置列表
 */
 @RequestMapping("/list")
 public List<Configs> list(@RequestParam("app") String app,
 @RequestParam("env") String env,
 @RequestParam("ns") String ns) {
 return mapper.list(app, env, ns);
 }
 /**
 * 更新配置。
 *
 * @param app 应用名称
 * @param env 环境标识
 * @param ns 命名空间
 * @param params 要更新的配置参数映射
 * @return 更新后的配置列表
 */
 @RequestMapping("/update")
 public List<Configs> update(@RequestParam("app") String app,
 @RequestParam("env") String env,
 @RequestParam("ns") String ns,
 @RequestBody Map<String, String> params) {
 String appKey = getAppKey(app, env, ns);
 log.info("config update. push {} {}", app, params);
 log.debug("config update. push in defer debug {} {}", app, params);
 // 查询或更新配置, 并更新版本号
 params.forEach((k, v) -> insertOrUpdate(new Configs(app, env, ns, k, v)));
 VERSION.put(appKey, System.currentTimeMillis());
 // 如果有配置更新, 返回获取版本 /version 的请求
 List<DeferredResult<Long>> deferredResults = appKeyDeferredResult.get(appKey);
 if (deferredResults != null) {
 deferredResults.forEach(deferredResult -> {
 Long version = VERSION.getOrDefault(appKey, -1L);
 deferredResult.setResult(version);
 log.debug("config version poll set defer for {} {}", ns, version);
 });
 }
 return mapper.list(app, env, ns);
 }
 /**
 * 插入或更新配置项
 * @param configs 查询或更新配置
 */
 private void insertOrUpdate(Configs configs) {
 Configs conf = mapper.select(configs.getApp(), configs.getEnv(), configs.getNs(), configs.getPkey());
 if (conf == null) {
 mapper.insert(configs);
 } else {
 mapper.update(configs);
 }
 }
 /**
 * 异步查询配置版本。
 *
 * @param app 应用名称
 * @param env 环境标识
 * @param ns 命名空间
 * @return DeferredResult,异步返回配置的版本号
 */
 @GetMapping("/version")
 public DeferredResult<Long> version(@RequestParam("app") String app,
 @RequestParam("env") String env,
 @RequestParam("ns") String ns) {
 String appKey = getAppKey(app, env, ns);
 log.info("config version poll {}", appKey);
 log.debug("config version poll in defer debug {}", appKey);
 // 创建并返回一个异步结果对象,用于后续通知
 DeferredResult<Long> deferredResult = new DeferredResult<>();
 deferredResult.onCompletion(() -> {
 System.out.println("onCompletion");
 appKeyDeferredResult.remove(appKey);
 });
 deferredResult.onTimeout(() -> {
 System.out.println("onTimeout");
 appKeyDeferredResult.remove(appKey);
 });
 deferredResult.onError((Throwable t) -> {
 System.out.println("onError");
 appKeyDeferredResult.remove(appKey);
 });
 appKeyDeferredResult.add(appKey, deferredResult);
 log.debug("return defer for {}", ns);
 return deferredResult;
 }
}

启动基础服务

server:
 port: 9129

Client端实现

关于核心概念

开发客户端

自定义Spring配置数据源

/**
 * 配置服务接口,用于管理和提供配置信息。
 * 实现了IMRepositoryChangeListener接口,用于监听配置的变更。
 */
public interface IMConfigService extends IMRepositoryChangeListener {
 /**
 * 获取默认配置服务实例。
 *
 * @param applicationContext 应用上下文,用于获取应用相关资源。
 * @param meta 配置元数据,描述配置的来源和其它必要信息。
 * @return 返回配置服务实例。
 */
 static IMConfigService getDefault(ApplicationContext applicationContext, ConfigMeta meta) {
 // 获取默认配置仓库实例, 从仓库中(远程server服务)上加载配置
 IMRepository repository = IMRepository.getDefault(meta);
 // 从配置中心server,获取配置
 Map<String, String> config = repository.getConfig();
 // 创建配置服务实例
 IMConfigService configService = new IMConfigServiceImpl(applicationContext, config);
 // 注册配置变更监听器
 repository.addListener(configService);
 return configService;
 }
 /**
 * 获取所有配置属性的名称。
 *
 * @return 返回配置属性名称数组。
 */
 String[] getPropertyNames();
 /**
 * 根据属性名称获取属性值
 *
 * @param name 属性名称。
 * @return 返回属性值,如果不存在,则返回null。
 */
 String getProperty(String name);
}

/**
 * 该类是EnumerablePropertySource的子类,用于提供配置属性。
 * 它将IMConfigService作为属性源,
 * - 可以通过getPropertyNames()获取所有属性名,
 * - 通过getProperty(String name)获取指定属性的值。
 */
public class IMPropertySource extends EnumerablePropertySource<IMConfigService> {
 /**
 * 构造函数,初始化属性源。
 * 通过SpringPropertySource添加配置中心数据源, 这样Spring就能拿到我们写入的配置了
 *
 * @param name 属性源的名称。
 * @param source 提供配置属性的服务实例。
 */
 public IMPropertySource(String name, IMConfigService source) {
 super(name, source);
 }
 @Override
 @SuppressWarnings("NullableProblems")
 public String[] getPropertyNames() {
 return source.getPropertyNames();
 }
 @Override
 public Object getProperty(@Nullable String name) {
 return source.getProperty(name);
 }
}

/**
 * 配置服务实现类,用于管理和提供配置信息
 */
@Slf4j
public class IMConfigServiceImpl implements IMConfigService {
 // 配置信息
 Map<String, String> config;
 // 应用上下文
 ApplicationContext applicationContext;
 /**
 * 构造函数,初始化配置服务。
 *
 * @param applicationContext 应用上下文,用于发布事件。
 * @param config 初始配置信息。
 */
 public IMConfigServiceImpl(ApplicationContext applicationContext, Map<String, String> config) {
 this.applicationContext = applicationContext;
 this.config = config;
 }
 /**
 * 获取所有配置属性的名称。
 *
 * @return 配置属性名称数组。
 */
 @Override
 public String[] getPropertyNames() {
 if (this.config == null) {
 return new String[]{};
 }
 return this.config.keySet().toArray(new String[0]);
 }
 /**
 * 根据属性名称获取对应的配置值。
 *
 * @param name 属性名称。
 * @return 对应的配置值,如果不存在则返回null。
 */
 @Override
 public String getProperty(String name) {
 return this.config.getOrDefault(name, null);
 }
 /**
 * 配置发生变化时的处理逻辑。
 * 更新配置信息,并发布环境变更事件。
 *
 * @param changeEvent 配置变更事件,包含新的配置信息。
 */
 @Override
 public void onChange(ChangeEvent changeEvent) {
 // 对比新旧值的变化
 Set<String> keys = calcChangeKeys(config, changeEvent.config());
 if (keys.isEmpty()) {
 log.info("[IM_CONFIG] calcChangeKeys return empty, ignore update.");
 }
 this.config = changeEvent.config();
 if (!config.isEmpty()) {
 /// 通过 spring-cloud-context 刷新配置
 log.info("[IM_CONFIG] fire an EnvironmentChangeEvent with keys:" + config.keySet());
 applicationContext.publishEvent(new EnvironmentChangeEvent(keys));
 }
 }
 /**
 * 计算配置变化的键集合。
 *
 * @param oldConfigs 旧配置信息。
 * @param newConfigs 新配置信息。
 * @return 发生变化的配置键集合。
 */
 private Set<String> calcChangeKeys(Map<String, String> oldConfigs, Map<String, String> newConfigs) {
 if (oldConfigs.isEmpty()) return newConfigs.keySet();
 if (newConfigs.isEmpty()) return oldConfigs.keySet();
 // 比较新旧配置,找出变化的键
 Set<String> news = newConfigs.keySet().stream()
 .filter(key -> !newConfigs.get(key).equals(oldConfigs.get(key)))
 .collect(Collectors.toSet());
 oldConfigs.keySet().stream()
 .filter(key -> !newConfigs.containsKey(key))
 .forEach(news::add);
 return news;
 }
}

访问Server获取和监听配置

@FunctionalInterface
public interface IMRepositoryChangeListener {
 /**
 * 配置发生变化时的回调方法。
 *
 * @param changeEvent 包含配置元数据和新配置信息的事件对象。
 * - meta: 配置的元数据,描述了配置的相关信息。
 * - config: 新的配置信息,以键值对的形式存储。
 */
 void onChange(ChangeEvent changeEvent);
 /**
 * ChangeEvent 类是一个记录类(JDK 16及以上版本特性),用于封装配置变化事件的信息。
 * 包含配置的元数据和新配置的数据。
 */
 record ChangeEvent(ConfigMeta meta, Map<String, String> config) {}
 // 如果jdk版本低于16, 不兼容record, 以下是低版本Java的实现
 // @Data
 // @AllArgsConstructor
 // class ChangeEvent {
 // private ConfigMeta meta;
 // private Map<String, String> config;
 // }
}

public interface IMRepository {
 /**
 * 获取默认配置仓库实例。
 * 通过给定的配置元数据初始化配置仓库。
 *
 * @param meta 配置元数据,描述配置源的相关信息。
 * @return 返回默认配置仓库实例。
 */
 static IMRepository getDefault(ConfigMeta meta) {
 return new IMRepositoryImpl(meta);
 }
 /**
 * 获取当前所有配置。
 * 该方法用于一次性获取配置源中的所有配置项。
 *
 * @return 返回包含所有配置项的Map,配置项的键为配置名,值为配置值。
 */
 Map<String, String> getConfig();
 /**
 * 添加配置变更监听器。
 * 通过添加监听器,可以监听配置项的变更事件。
 *
 * @param listener 配置变更监听器实例。
 */
 void addListener(IMRepositoryChangeListener listener);
}

/**
 * 实现了IMRepository接口的配置仓库类,用于管理和更新配置数据。
 */
public class IMRepositoryImpl implements IMRepository {
 // 当前配置实例的元数据信息, 列: 应用,环境,命名空间,配置服务信息
 ConfigMeta meta;
 // 存储配置的版本信息
 Map<String, Long> versionMap = new HashMap<>();
 // 存储配置数据
 Map<String, Map<String, String>> configMap = new HashMap<>();
 // 定时任务执行器
 // 配置变更监听器列表
 List<IMRepositoryChangeListener> listeners = new ArrayList<>();
 /**
 * 构造函数,初始化配置仓库
 *
 * @param meta 配置元数据,用于指定配置服务的地址和密钥等信息。
 */
 public IMRepositoryImpl(ConfigMeta meta) {
 this.meta = meta;
 // 异步长轮训心跳检测任务
 new Thread(this::heartbeat).start();
 }
 /**
 * 添加配置变更监听器。
 *
 * @param listener 配置变更监听器实例。
 */
 public void addListener(IMRepositoryChangeListener listener) {
 listeners.add(listener);
 }
 /**
 * 获取所有配置, 第一次初始化时, 通过Config-Server获取
 *
 * @return 返回当前配置的数据映射表。
 */
 @Override
 public Map<String, String> getConfig() {
 String key = meta.genKey();
 if (configMap.containsKey(key)) {
 return configMap.get(key);
 }
 return findAll();
 }
 /**
 * 获取所有配置, 通过Config-Server获取
 *
 * @return 返回从配置服务器获取到的配置数据映射表。
 */
 private @NotNull Map<String, String> findAll() {
 String listPath = meta.listPath();
 System.out.println("[IM_CONFIG] list all configs from ipman config server.");
 List<Configs> configs = HttpUtils.httpGet(listPath, new TypeReference<List<Configs>>() {
 });
 Map<String, String> resultMap = new HashMap<>();
 configs.forEach(c -> resultMap.put(c.getPkey(), c.getPval()));
 return resultMap;
 }
 /**
 * 心跳检测任务, 通过Config-Server获取配置的版本号,用于检测配置版本是否有更新。
 */
 private void heartbeat() {
 while (true) {
 try {
 // 通过请求Config-Server获取配置版本号
 String versionPath = meta.versionPath();
 HttpUtils.OkHttpInvoker okHttpInvoker = new HttpUtils.OkHttpInvoker();
 okHttpInvoker.init(20_000, 128, 300);
 Long version = JSON.parseObject(okHttpInvoker.get(versionPath), new TypeReference<Long>() {
 });
 // 检查是否有配置更新
 String key = meta.genKey();
 Long oldVersion = versionMap.getOrDefault(key, -1L);
 if (version > oldVersion) {
 System.out.println("[IM_CONFIG] current=" + version + ", old=" + oldVersion);
 System.out.println("[IM_CONFIG] need update new configs.");
 versionMap.put(key, version);
 Map<String, String> newConfigs = findAll();
 configMap.put(key, newConfigs);
 // 通知所有监听器配置发生了变更
 System.out.println("[IM_CONFIG] fire an EnvironmentChangeEvent with keys:" + newConfigs.keySet());
 listeners.forEach(listener ->
 listener.onChange(new IMRepositoryChangeListener.ChangeEvent(meta, newConfigs)));
 }
 } catch (Exception e) {
 System.out.println("[IM_CONFIG] loop request new configs.");
 }
 }
 }
}

配置Spring自定义数据源

/**
 * 该类是一个配置类,用于在Spring应用启动时,通过http请求从ipman-config-server获取配置,并将配置添加到Spring环境变量中。
 */
@Data
public class PropertySourcesProcessor implements BeanFactoryPostProcessor, ApplicationContextAware, EnvironmentAware, PriorityOrdered {
 private final static String IPMAN_PROPERTY_SOURCES = "IMPropertySources";
 private final static String IPMAN_PROPERTY_SOURCE = "IMPropertySource";
 Environment environment;
 ApplicationContext applicationContext;
 /**
 * 处理 BeanFactory,在 Spring 应用启动过程中注入自定义属性源。
 *
 * @param beanFactory ConfigurableListableBeanFactory,
 * Spring BeanFactory 的一个接口,提供访问和操作 Spring 容器中所有 Bean 的能力。
 * @throws BeansException 如果处理过程中发生错误。
 */
 @Override
 public void postProcessBeanFactory(@NonNull ConfigurableListableBeanFactory beanFactory) throws BeansException {
 // 检查是否已存在 ipman 的属性源,若存在则不重复添加
 ConfigurableEnvironment ENV = (ConfigurableEnvironment) environment;
 if (ENV.getPropertySources().contains(IPMAN_PROPERTY_SOURCES)) {
 return;
 }
 // 设置config-server远程服务的调用信息
 String app = ENV.getProperty("ipman.app", "app1");
 String env = ENV.getProperty("ipman.env", "dev");
 String ns = ENV.getProperty("ipman.ns", "public");
 String configServer = ENV.getProperty("ipman.configServer", "http://localhost:9129");
 // 使用获取到的配置创建配置服务和属性源
 ConfigMeta configMeta = new ConfigMeta(app, env, ns, configServer);
 // 创建配置中心实现类, 省去技术细节, 理解了下:
 // 1.启动时候 ConfigService 从 Repository拿配置, 同时 Repository 关联了 ConfigService 这个对象,.
 // 2.当 Repository 巡检发现配置变了, 在去改 ConfigService 里的 config.
 // 3.改完后, 最终再用EnvironmentChangeEvent 去刷新
 IMConfigService configService = IMConfigService.getDefault(applicationContext, configMeta);
 // 创建SpringPropertySource, 此时Spring就能识别我们自定义的配置了
 IMPropertySource propertySource = new IMPropertySource(IPMAN_PROPERTY_SOURCE, configService);
 // 创建组合属性源并将 ipman 的属性源添加到其中
 CompositePropertySource composite = new CompositePropertySource(IPMAN_PROPERTY_SOURCES);
 composite.addPropertySource(propertySource);
 // 将组合属性源添加到环境变量中,并确保其被最先访问
 ENV.getPropertySources().addFirst(composite);
 }
 /**
 * 获取Bean处理器的优先级,实现 PriorityOrdered 接口。
 *
 * @return int 返回处理器的优先级,值越小优先级越高。
 */
 @Override
 public int getOrder() {
 return Ordered.HIGHEST_PRECEDENCE;
 }
 /**
 * 设置 Spring 环境配置
 *
 * @param environment Environment,Spring 环境接口,提供环境变量的访问。
 */
 @Override
 public void setEnvironment(@NonNull Environment environment) {
 this.environment = environment;
 }
 /**
 * 设置应用上下文
 *
 * @param applicationContext Spring应用的上下文环境。
 */
 @Override
 public void setApplicationContext(@NonNull ApplicationContext applicationContext) throws BeansException {
 this.applicationContext = applicationContext;
 }
}

关于Spring中@Value配置

@Value("${some.key}")
private String someKey;

@Value("${${some.key}}")
private String nestedKey;

@Value("${some.key:${some.other.key:100}}")
private String someKeyWithDefault;

@Value("${${some.key:other.key}}")
private String nestedKeyWithDefault;

@Value("${${some.key}:${another.key}}")
private String multiNestedKey;

@Value("#{new java.text.SimpleDateFormat('${some.key}').parse('${another.key}')}")
private Date parsedDate;

public class PlaceholderHelper {
 private static final String PLACEHOLDER_PREFIX = "${";
 private static final String PLACEHOLDER_SUFFIX = "}";
 private static final String VALUE_SEPARATOR = ":";
 private static final String SIMPLE_PLACEHOLDER_PREFIX = "{";
 private static final String EXPRESSION_PREFIX = "#{";
 private static final String EXPRESSION_SUFFIX = "}";
 private PlaceholderHelper() {
 }
 private static final PlaceholderHelper INSTANCE = new PlaceholderHelper();
 public static PlaceholderHelper getInstance() {
 return INSTANCE;
 }
 /**
 * Resolve placeholder property values, e.g.
 * <br />
 * <br />
 * "${somePropertyValue}" -> "the actual property value"
 */
 public Object resolvePropertyValue(ConfigurableBeanFactory beanFactory, String beanName, String placeholder) {
 // resolve string value
 String strVal = beanFactory.resolveEmbeddedValue(placeholder);
 BeanDefinition bd = (beanFactory.containsBean(beanName) ? beanFactory
 .getMergedBeanDefinition(beanName) : null);
 // resolve expressions like "#{systemProperties.myProp}"
 return evaluateBeanDefinitionString(beanFactory, strVal, bd);
 }
 private Object evaluateBeanDefinitionString(ConfigurableBeanFactory beanFactory, String value,
 BeanDefinition beanDefinition) {
 if (beanFactory.getBeanExpressionResolver() == null) {
 return value;
 }
 Scope scope = (beanDefinition != null ? beanFactory
 .getRegisteredScope(Objects.requireNonNull(beanDefinition.getScope())) : null);
 return beanFactory.getBeanExpressionResolver()
 .evaluate(value, new BeanExpressionContext(beanFactory, scope));
 }
 /**
 * Extract keys from placeholder, e.g.
 * <ul>
 * <li>${some.key} => "some.key"</li>
 * <li>${some.key:${some.other.key:100}} => "some.key", "some.other.key"</li>
 * <li>${${some.key}} => "some.key"</li>
 * <li>${${some.key:other.key}} => "some.key"</li>
 * <li>${${some.key}:${another.key}} => "some.key", "another.key"</li>
 * <li>#{new java.text.SimpleDateFormat('${some.key}').parse('${another.key}')} => "some.key", "another.key"</li>
 * </ul>
 */
 public Set<String> extractPlaceholderKeys(String propertyString) {
 Set<String> placeholderKeys = new LinkedHashSet<>();
 if (!isNormalizedPlaceholder(propertyString) && !isExpressionWithPlaceholder(propertyString)) {
 return placeholderKeys;
 }
 Stack<String> stack = new Stack<>();
 stack.push(propertyString);
 while (!stack.isEmpty()) {
 String strVal = stack.pop();
 int startIndex = strVal.indexOf(PLACEHOLDER_PREFIX);
 if (startIndex == -1) {
 placeholderKeys.add(strVal);
 continue;
 }
 int endIndex = findPlaceholderEndIndex(strVal, startIndex);
 if (endIndex == -1) {
 // invalid placeholder?
 continue;
 }
 String placeholderCandidate = strVal.substring(startIndex + PLACEHOLDER_PREFIX.length(), endIndex);
 // ${some.key:other.key}
 if (placeholderCandidate.startsWith(PLACEHOLDER_PREFIX)) {
 stack.push(placeholderCandidate);
 } else {
 // some.key:${some.other.key:100}
 int separatorIndex = placeholderCandidate.indexOf(VALUE_SEPARATOR);
 if (separatorIndex == -1) {
 stack.push(placeholderCandidate);
 } else {
 stack.push(placeholderCandidate.substring(0, separatorIndex));
 String defaultValuePart =
 normalizeToPlaceholder(placeholderCandidate.substring(separatorIndex + VALUE_SEPARATOR.length()));
 if (StringUtils.hasText(defaultValuePart)) {
 stack.push(defaultValuePart);
 }
 }
 }
 // has remaining part, e.g. ${a}.${b}
 if (endIndex + PLACEHOLDER_SUFFIX.length() < strVal.length() - 1) {
 String remainingPart = normalizeToPlaceholder(strVal.substring(endIndex + PLACEHOLDER_SUFFIX.length()));
 if (!StringUtils.hasText(remainingPart)) {
 stack.push(remainingPart);
 }
 }
 }
 return placeholderKeys;
 }
 private boolean isNormalizedPlaceholder(String propertyString) {
 return propertyString.startsWith(PLACEHOLDER_PREFIX) && propertyString.endsWith(PLACEHOLDER_SUFFIX);
 }
 private boolean isExpressionWithPlaceholder(String propertyString) {
 return propertyString.startsWith(EXPRESSION_PREFIX) && propertyString.endsWith(EXPRESSION_SUFFIX)
 && propertyString.contains(PLACEHOLDER_PREFIX);
 }
 private String normalizeToPlaceholder(String strVal) {
 int startIndex = strVal.indexOf(PLACEHOLDER_PREFIX);
 if (startIndex == -1) {
 return null;
 }
 int endIndex = strVal.lastIndexOf(PLACEHOLDER_SUFFIX);
 if (endIndex == -1) {
 return null;
 }
 return strVal.substring(startIndex, endIndex + PLACEHOLDER_SUFFIX.length());
 }
 private int findPlaceholderEndIndex(CharSequence buf, int startIndex) {
 int index = startIndex + PLACEHOLDER_PREFIX.length();
 int withinNestedPlaceholder = 0;
 while (index < buf.length()) {
 if (StringUtils.substringMatch(buf, index, PLACEHOLDER_SUFFIX)) {
 if (withinNestedPlaceholder > 0) {
 withinNestedPlaceholder--;
 index = index + PLACEHOLDER_SUFFIX.length();
 } else {
 return index;
 }
 } else if (StringUtils.substringMatch(buf, index, SIMPLE_PLACEHOLDER_PREFIX)) {
 withinNestedPlaceholder++;
 index = index + SIMPLE_PLACEHOLDER_PREFIX.length();
 } else {
 index++;
 }
 }
 return -1;
 }
 public static void main(String[] args) {
 String strVal = "${some.key:other.key}";
 System.out.println(new PlaceholderHelper().extractPlaceholderKeys(strVal));
 strVal = "${some.key:${some.other.key:100}}";
 System.out.println(new PlaceholderHelper().extractPlaceholderKeys(strVal));
 strVal = "${${some.key}}";
 System.out.println(new PlaceholderHelper().extractPlaceholderKeys(strVal));
 strVal = "${${some.key:other.key}}";
 System.out.println(new PlaceholderHelper().extractPlaceholderKeys(strVal));
 strVal = "${${some.key}:${another.key}}";
 System.out.println(new PlaceholderHelper().extractPlaceholderKeys(strVal));
 }
}

@Data
@AllArgsConstructor
public class SpringValue {
 private Object bean; // 配置关联的关联的 Bean 对象
 private String beanName; // 配置关联的关联的 Bean 对象名称
 private String key; // @Value配置的key
 private String placeholder; // @Value配置的占位符
 private Field field; // @Value配置的 Bean 成员
}

/**
 * 提供用于检索类中具有特定注解或满足某些条件的字段的工具方法
 */
public interface FieldUtils {
 /**
 * 查找类中所有被指定注解标注的字段
 *
 * @param aClass 要搜索的类。
 * @param annotationClass 指定的注解类型。
 * @return 所有被指定注解标注的字段列表。
 */
 static List<Field> findAnnotatedField(Class<?> aClass, Class<? extends Annotation> annotationClass) {
 return findField(aClass, f -> f.isAnnotationPresent(annotationClass));
 }
 /**
 * 根据给定的函数条件查找类中所有满足条件的字段
 *
 * @param aClass 要搜索的类。
 * @param function 用于判断字段是否满足条件的函数。
 * @return 所有满足条件的字段列表。
 */
 static List<Field> findField(Class<?> aClass, Function<Field, Boolean> function) {
 List<Field> result = new ArrayList<>();
 while (aClass != null) {
 Field[] fields = aClass.getDeclaredFields();
 for (Field f : fields) {
 if (function.apply(f)) {
 result.add(f);
 }
 }
 // spring中有些类会被CGLIB代理,所以需要通过父类获取Field
 aClass = aClass.getSuperclass();
 }
 return result;
 }
}

/**
 * process spring value
 * 1. 扫描所有 spring value,保存起来
 * 2. 在配置变更时, 更新所有 spring value
 *
 * @Author IpMan
 * @Date 2024年5月12日 12:04
 */
@Slf4j
public class SpringValueProcessor implements BeanPostProcessor, BeanFactoryAware, ApplicationListener<EnvironmentChangeEvent> {
 // 占位符操作工具,如: ${key:default}, 拿到 key
 static final PlaceholderHelper placeholderHelper = PlaceholderHelper.getInstance();
 // 保存所有使用@SpringValue注解的字段及其相关信息
 static final MultiValueMap<String, SpringValue> VALUE_HOLDER = new LinkedMultiValueMap<>();
 private BeanFactory beanFactory;
 /**
 * 设置BeanFactory,使处理器能够访问Spring BeanFactory。
 *
 * @param beanFactory Spring的BeanFactory。
 * @throws BeansException 如果设置过程中发生错误。
 */
 @Override
 public void setBeanFactory(@NotNull BeanFactory beanFactory) throws BeansException {
 this.beanFactory = beanFactory;
 }
 /**
 * 在Bean初始化之前处理Bean,扫描并保存所有使用@SpringValue注解的字段。
 *
 * @param bean 当前处理的Bean实例。
 * @param beanName 当前处理的Bean名称。
 * @return 处理后的Bean实例。
 * @throws BeansException 如果处理过程中发生错误。
 */
 @Override
 public Object postProcessBeforeInitialization(@NotNull Object bean, @NotNull String beanName) throws BeansException {
 List<Field> fields = FieldUtils.findAnnotatedField(bean.getClass(), Value.class);
 fields.forEach(field -> {
 log.info("[IM_CONFIG] >> find spring value:{}", field);
 Value value = field.getAnnotation(Value.class);
 placeholderHelper.extractPlaceholderKeys(value.value()).forEach(key -> {
 log.info("[IM_CONFIG] >> find spring value:{} for field:{}", key, field);
 SpringValue springValue = new SpringValue(bean, beanName, key, value.value(), field);
 VALUE_HOLDER.add(key, springValue);
 }
 );
 }
 );
 return bean;
 }
 /**
 * 当@Value配置, 发生改变时,更新所有相关字段的值。
 *
 * @param event 包含环境变量变更信息的事件。
 */
 @Override
 public void onApplicationEvent(@NotNull EnvironmentChangeEvent event) {
 // 更新所有与变更的键相关的@SpringValue字段的值
 log.info("[IM_CONFIG] >> update spring value for keys: {}", event.getKeys());
 event.getKeys().forEach(key -> {
 log.info("[IM_CONFIG] >> update spring value: {}", key);
 List<SpringValue> springValues = VALUE_HOLDER.get(key);
 if (springValues == null || springValues.isEmpty()) {
 return;
 }
 // 更新每个相关@Value字段的值
 springValues.forEach(springValue -> {
 log.info("[IM_CONFIG] >> update spring value:{} for key:{}", springValue, key);
 try {
 // 解析并设置新值
 Object value = placeholderHelper.resolvePropertyValue((ConfigurableBeanFactory) beanFactory,
 springValue.getBeanName(), springValue.getPlaceholder());
 log.info("[IM_CONFIG] >> update spring value:{} for holder:{}", value, springValue.getPlaceholder());
 springValue.getField().setAccessible(true);
 springValue.getField().set(springValue.getBean(), value);
 } catch (IllegalAccessException ex) {
 log.error("[IM_CONFIG] >> update spring value error", ex);
 }
 });
 });
 }
}

最终提供客户端集成方式

public class IMConfigRegistry implements ImportBeanDefinitionRegistrar {
 @Override
 public void registerBeanDefinitions(@NonNull AnnotationMetadata importingClassMetadata,
 @NonNull BeanDefinitionRegistry registry) {
 // 注册 @ConfigurationProperties() 配置方式的注册中心处理器
 registerClass(registry, PropertySourcesProcessor.class);
 // 注册 @Value() 配置方式的注册中心处理器
 registerClass(registry, SpringValueProcessor.class);
 }
 /**
 * 向给定的 BeanDefinitionRegistry 注册一个类。
 * 如果该类已经注册,则不进行重复注册。
 *
 * @param registry BeanDefinitionRegistry 实例,用于注册 Bean。
 * @param aClass 需要注册的类。
 */
 private static void registerClass(BeanDefinitionRegistry registry, Class<?> aClass) {
 System.out.println("registry " + aClass.getName());
 // 判断PropertySourcesProcessor 是否已经注册Bean
 Optional<String> first = Arrays.stream(registry.getBeanDefinitionNames())
 .filter(x -> aClass.getName().equals(x))
 .findFirst();
 if (first.isPresent()) {
 System.out.println(aClass.getName() + " already registered");
 return;
 }
 // 注册PropertySourcesProcessor
 AbstractBeanDefinition beanDefinition =
 BeanDefinitionBuilder.genericBeanDefinition(aClass).getBeanDefinition();
 registry.registerBeanDefinition(aClass.getName(), beanDefinition);
 System.out.println("registered " + aClass.getName());
 }
}

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Inherited
@Import({IMConfigRegistry.class})
public @interface EnableIpManConfig {
}

测试与体验

准备工作

ipman:
 a: "a-00"
 b: "b-00"
 c: "c-00"

@Data
@ConfigurationProperties(prefix = "ipman")
public class DemoConfig {
 private String a;
 private String b;
 private String c;
}

测试配置的初始化

@SpringBootApplication
@EnableConfigurationProperties({DemoConfig.class})
@EnableIpManConfig // 激活配置中心
@RestController
public class ConfigDemoApplication {
 @Value("${ipman.a:213213}")
 private String a;
 @Value("${ipman.b}")
 private String b;
 @Value("${ipman.c}")
 private String c;
 @Autowired
 private DemoConfig demoConfig;
 public static void main(String[] args) {
 SpringApplication.run(ConfigDemoApplication.class, args);
 }
 @Autowired
 Environment environment;
 @GetMapping("/")
 public String demo() {
 return "ipman.a = " + a + ", \n" +
 "ipman.b = " + b + ", \n" +
 "ipman.c = " + c + ", \n" +
 "ipman.demo.a = " + demoConfig.getA() + ", \n" +
 "ipman.demo.b = " + demoConfig.getB() + ", \n" +
 "ipman.demo.c = " + demoConfig.getC() + ", \n";
 }
 @Bean
 ApplicationRunner applicationRunner() {
 System.out.println("===> " + Arrays.toString(environment.getActiveProfiles()));
 return args -> {
 System.out.println(a);
 System.out.println(demoConfig.getA());
 };
 }
}

测试配置动态变更

@SpringBootTest(classes = {ConfigDemoApplication.class})
@Slf4j
class ConfigDemoApplicationTests {
 static ApplicationContext context1;
 @Autowired
 private DemoConfig demoConfig;
 static MockMvc mockMvc;
 @BeforeAll
 static void init() {
 System.out.println(" ================================ ");
 System.out.println(" ============ 9129 ============= ");
 System.out.println(" ================================ ");
 System.out.println(" ================================ ");
 context1 = SpringApplication.run(ConfigServerApplication.class,
 "--logging.level.root=info",
 "--logging.level.org.springframework.jdbc=debug",
 "--logging.level.cn.ipman.config=debug",
 "--mybatis.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl",
 "--server.port=9129",
 "--spring.application.name=config-server",
 "--spring.datasource.driver-class-name=org.h2.Driver",
 "--spring.datasource.url=jdbc:h2:mem:h2db",
 "--spring.datasource.username=root",
 "--spring.datasource.password=123456",
 "--spring.sql.init.schema-locations=classpath:db.sql",
 "--spring.sql.init.mode=always",
 "--spring.h2.console.enabled=true",
 "--spring.h2.console.path=/h2",
 "--spring.h2.console.settings.web-allow-others=true"
 );
 mockMvc = MockMvcBuilders.webAppContextSetup((WebApplicationContext) context1).build();
 }
 @Test
 void contextLoads() throws Exception {
 System.out.println("config demo running ... ");
 Map<String, String> configs = new HashMap<>();
 configs.put("ipman.a", "demo1");
 configs.put("ipman.b", "demo2");
 configs.put("ipman.c", "demo3");
 // 模拟调用 config-server 修改配置
 MvcResult mvcResult = mockMvc.perform(
 MockMvcRequestBuilders.post("/update?app=app1&env=dev&ns=public")
 .content(JSON.toJSONString(configs))
 .contentType("application/json")).andDo(print())
 .andExpect(MockMvcResultMatchers.status().isOk())
 .andReturn();
 List<Configs> newConfigs = JSON.parseObject(
 mvcResult.getResponse().getContentAsString(),
 new TypeReference<List<Configs>>() {
 }
 );
 System.out.println("config update to " + newConfigs);
 // 验证 config-client 是否将配置也成功更新
 Thread.sleep(5_000 * 2);
 Assertions.assertEquals(configs.get("ipman.a"), demoConfig.getA());
 Assertions.assertEquals(configs.get("ipman.b"), demoConfig.getB());
 Assertions.assertEquals(configs.get("ipman.c"), demoConfig.getC());
 }
 @AfterAll
 static void destroy() {
 System.out.println(" =========== close spring context ======= ");
 SpringApplication.exit(context1, () -> 1);
 }
}

总结