public interface Supplier<T> {
    T get();
}

import com.ctrip.framework.apollo.ConfigService;

Supplier<String> dynamicConfig = () -> {
  return ConfigService.getAppConfig().getProperty("some_config_key", "defaultValue");
}

// 构造一个Supplier<Integer>，表示限流 qps
private static final Supplier<Integer> QPS_LIMIT_CONFIG = () -> {
    return ConfigService.getAppConfig().getIntProperty("rate_limiter_qps", 100);
};
// 希望构造一个可以动态调整限流 qps 的 RateLimiter，但是这样实现并不对
private static final Supplier<RateLimiter> DYNAMIC_RATE_LIMITER = () -> {
    return RateLimiter.create(QPS_LIMIT_CONFIG.get());
}
    
// 这个方法处理请求
public void onRequest() {
  // 先判断是否触发了限流
  if(!DYNAMIC_RATE_LIMITER.get().tryAcquire()) {
    // 后边再执行真正逻辑
    // ...
  } else {
    // ...
  }
}

import com.github.ymwangzq.config.adapter.core.SupplierConfigAdapter;

// 和之前一样，构造一个Supplier<Integer>，表示限流 qps
private static final Supplier<Integer> QPS_LIMIT_CONFIG = ...;

// 把这个 Supplier 包装成 ConfigAdapter
private static final ConfigAdapter<Integer> QPS_LIMIT = SupplierConfigAdapter.createConfigAdapter(QPS_LIMIT_CONFIG);

// 构造动态的 RateLimiter
private static final ConfigAdapter<RateLimiter> DYNAMIC_RATE_LIMITER = QPS_LIMIT.map(qps -> RateLimiter.create(qps));

// 这个方法处理请求
public void onRequest() {
  // 先判断是否触发了限流
  if (!DYNAMIC_RATE_LIMITER.get().tryAcquire()) {
    // 后边再执行真正逻辑
    // ...
  } else {
    // ...
  }
}

// 把这个 Supplier 包装成 ConfigAdapter
private static final ConfigAdapter<Integer> QPS_LIMIT = SupplierConfigAdapter.createConfigAdapter(QPS_LIMIT_CONFIG);

// 两倍 qps
private static final ConfigAdapter<Integer> DOUBLE_QPS_LIMIT = QPS_LIMIT.map(qps -> 2 * qps);

// 构造动态的 RateLimiter
private static final ConfigAdapter<RateLimiter> DYNAMIC_RATE_LIMITER = 
    QPS_LIMIT.map(qpsLimit -> RateLimiter.create(qpsLimit));

// 构造两倍 qps 的动态 RateLimiter
private static final ConfigAdapter<RateLimiter> DYNAMIC_DOUBLE_RATE_LIMITER = 
    DOUBLE_QPS_LIMIT.map(qpsLimit -> RateLimiter.create(qpsLimit));

public interface ConfigAdapter<T> extends Supplier<T>, EventSource {
  /**
   * 获取配置内容
   */
  T get();

  /**
   * 将动态配置映射成新的动态配置/动态资源
   */
  <R> ConfigAdapter<R> map(@Nonnull ConfigAdapterMapper<? super T, R> configMapper);
}

public interface ConfigAdapterMapper<From, To> {
  /**
   * 动态配置变换逻辑
   */
  To map(@Nullable From from);

  /**
   * 清理逻辑
   */
  default void cleanUp(@Nullable To to) {
  }

  /* 其他接口暂时不需要关心，没有列出 */
}

public interface DelayCleanUpConfig {
    // 需要传入一个用于延迟清理资源的线程池
    ScheduledExecutorService delayCleanUpExecutor();

    // 这里设置清理资源的延迟时间
    LongSupplier cleanUpDelayMs();
}

import com.github.ymwangzq.config.adapter.facade.AdaptiveCleanUpProxy；

// 这是真实的资源对象
static class RealResource {
  // 这里搞一个 cleanup 方法被调用的计数器
  private static final AtomicInteger CLEAN_UP_COUNTER = new AtomicInteger(0);
  // 模拟一个根据配置内容变更的状态变量
  private final String configValue;

  public RealResource(String configValue) {
    this.configValue = configValue;
  }

  public String getConfigValue() {
    return configValue;
  }

  // 每当 cleanup 方法被调用的时候，就增加计数
  void cleanUp() {
    CLEAN_UP_COUNTER.incrementAndGet();
  }

  // 查看 cleanup 方法调用计数
  static int getCleanUpCounter() {
    return CLEAN_UP_COUNTER.get();
  }
}

// 壳对象
static class ResourceProxy extends RealResource implements AdaptiveCleanUpProxy<RealResource> {
  private final RealResource delegate;

  public ResourceProxy(RealResource delegate) {
    super(delegate.getConfigValue());
    this.delegate = delegate;
  }

  public RealResource getDelegate() {
    return delegate;
  }

  public String getConfigValue() {
    return getDelegate().getConfigValue();
  }

  public void cleanUp() {
    throw new UnsupportedOperationException();
  }
}

@Test
void testAdaptiveCleanUp() {
  // 这里模拟一个动态配置
  AtomicReference<String> configValue = new AtomicReference<>();
  // 将配置值设置为 v1
  configValue.set("v1");
  // 先创建一个简单 String 的 ConfigAdapter
  ConfigAdapter<String> dynamicConfigValue = SupplierConfigAdapter.createConfigAdapter(configValue::get);
  // 创建自适应清理的 ConfigAdapter
  ConfigAdapter<ResourceProxy> configAdapter = ConfigAdapters.createAdaptiveCleanUp(
    dynamicConfigValue,
    () -> new ResourceProxy(new RealResource(dynamicConfigValue.get())),
    resource -> Optional.ofNullable(resource).ifPresent(RealResource::cleanUp));

  RealResource resource = configAdapter.get();
  // 验证是 v1
  Assertions.assertEquals("v1", resource.getConfigValue());
  Assertions.assertEquals(0, RealResource.getCleanUpCounter());
  // 配置更新成 v2
  configValue.set("v2");
  // 这里等 2s 是因为 SupplierConfigAdapter 内部 1s 才检查一次更新，等 2s 为了保证完成了更新
  sleepUninterruptibly(2, SECONDS);
  // 验证是 v2
  Assertions.assertEquals("v2", configAdapter.get().getConfigValue());
  // 触发一次 GC
  System.gc();
  // 这里等 2s 是因为 GcUtil 里的清理线程没 1s 执行一次
  sleepUninterruptibly(2, SECONDS);
  // 验证这时 cleanup 方法没有被执行
  Assertions.assertEquals(0, RealResource.getCleanUpCounter());
  // 把 resource 引用释放掉，让壳对象可以被 gc
  resource = null;
  // 触发一次 GC
  System.gc();
  // 这里等 2s 是因为 GcUtil 里的清理线程没 1s 执行一次
  sleepUninterruptibly(2, SECONDS);
  // 这时 cleanup 方法被执行到了
  Assertions.assertEquals(1, RealResource.getCleanUpCounter());
}   

ConfigAdapter<String> hostConfig = xxx;
ConfigAdapter<Integer> portConfig = xxx;

ConfigAdapter<HostAndPort> hostAndPortConfig = ConfigAdapters
        .mergeTwoConfigAdapters(hostConfig, portConfig, (port, host) -> HostAndPort.fromParts(host, port), merged -> { });

// 创建一个重试配置
// 第一次重试间隔是1000ms, 以后每次重试的间隔都 * 2; 重试间隔最大到120_000ms; 无论重试抛出什么异常, 都继续重试下去
RetryConfig retryConfig = new RetryForever(2, 1000, 120_000, null);

// 用这个重试配置创建资源，每次 hostAndPort 有变更的时候，如果创建资源失败，会不断进行重试
ConfigAdapter<SomeResource> dynamicResource = hostAndPortConfig.map(UpdateWithRetryMapper.wrap(hostAndPort -> {
    return new SomeResource(hostAndPort);
  }, retryConfig));

public final class BaseEventSource implements EventSource {

  private final List<EventListener> eventListeners = new ArrayList<>();

  public void dispatchEvent(@Nonnull Event event) {
    /* 遍历 eventListeners, 调用 processEvent 方法 */
  }

  public void addEventListener(@Nonnull EventListener eventListener) { ... }

  public void removeEventListener(@Nonnull EventListener eventListener) { ... }
}

public interface EventListener {
  void processEvent(Event event);
}

static ConfigAdapter<T> createConfigAdapter(EventSource eventSource, Supplier<T> fetcher, Consumer<T> cleanUp)

public <R> ConfigAdapter<R> map(@Nonnull ConfigAdapterMapper<? super T, R> configMapper) {
  return createConfigAdapter(this, () -> configMapper.map(this.get()), configMapper::cleanUp);
}

// 构造一个新的 EventSource，新的 newEventSource 会在任意一个入参 eventSources
// 收到通知事件的时候向监听者发出通知
public static EventSource anyOf(EventSource... eventSources) {
    BaseEventSource newEventSource = new BaseEventSource();
    Stream.of(eventSources).forEach(eventSource -> 
        eventSource.addEventListener(event -> newEventSource.dispatchEvent(event));
    return newEventSource;
}