多微服务实例下的配置同步黑洞：Apollo 配置中心在多语言客户端的动态重载最佳实践

import { EventEmitter } from 'events';

// 模拟的 Apollo 配置更新通知接口
interface ApolloChangeEvent {
  namespace: string;
  changes: {
    [key: string]: {
      oldValue: string;
      newValue: string;
      changeType: 'ADD' | 'MODIFY' | 'DELETE';
    };
  };
}

class ConfigContainer extends EventEmitter {
  private configStore: Map<string, string> = new Map();

  constructor() {
    super();
    // 预填一些默认配置
    this.configStore.set('api.timeout', '3000');
    this.configStore.set('api.retry.limit', '3');
  }

  // 获取配置，如果是需要动态更新的值，千万不要在外部存成局部变量，而应该每次都从容器中取
  public get(key: string): string {
    const val = this.configStore.get(key);
    if (val === undefined) {
      throw new Error(`Config key not found: ${key}`);
    }
    return val;
  }

  public getInt(key: string): number {
    return parseInt(this.get(key), 10);
  }

  // 模拟 Apollo 客户端的长轮询监听回调
  public onApolloConfigChange(event: ApolloChangeEvent) {
    console.log(`[Apollo] Received config change in namespace: ${event.namespace}`);

    for (const [key, change] of Object.entries(event.changes)) {
      console.log(`[Apollo] Key [${key}] changed: ${change.oldValue} -> ${change.newValue}`);

      if (change.changeType === 'DELETE') {
        this.configStore.delete(key);
      } else {
        this.configStore.set(key, change.newValue);
      }

      // 派发针对特定 key 的变更事件
      this.emit(`change:${key}`, change.newValue);
    }

    // 派发全局变更事件
    this.emit('change', event.changes);
  }
}

// 导出全局唯一的配置管理容器
export const configContainer = new ConfigContainer();

// 业务侧如何动态使用和监听热重载配置
export class DynamicHttpClient {
  private timeout: number;
  private retryLimit: number;

  constructor() {
    // 1. 初始化时读取
    this.timeout = configContainer.getInt('api.timeout');
    this.retryLimit = configContainer.getInt('api.retry.limit');

    // 2. 监听对应 Key 的更新事件，做到无需重启直接热生效
    configContainer.on('change:api.timeout', (newValue: string) => {
      console.log(`[HttpClient] Dynamically updated timeout from ${this.timeout} to ${newValue}`);
      this.timeout = parseInt(newValue, 10);
    });

    configContainer.on('change:api.retry.limit', (newValue: string) => {
      console.log(`[HttpClient] Dynamically updated retryLimit from ${this.retryLimit} to ${newValue}`);
      this.retryLimit = parseInt(newValue, 10);
    });
  }

  public async request(url: string): Promise<void> {
    console.log(`[HttpClient] Requesting ${url} with timeout: ${this.timeout}ms, retries: ${this.retryLimit}`);
    // 实际发起网络请求逻辑...
  }
}

// 模拟演示热重载过程
const httpClient = new DynamicHttpClient();
httpClient.request('https://api.internal/v1/users');

// 模拟 Apollo 过了 1 秒推送了新配置
setTimeout(() => {
  configContainer.onApolloConfigChange({
    namespace: 'application',
    changes: {
      'api.timeout': {
        oldValue: '3000',
        newValue: '5000',
        changeType: 'MODIFY',
      },
      'api.retry.limit': {
        oldValue: '3',
        newValue: '5',
        changeType: 'MODIFY',
      }
    }
  });

  // 再次请求，可以看到超时参数已经动态改变
  httpClient.request('https://api.internal/v1/users');
}, 1000);