Angular中如何将多个后端关联服务打包为统一公共服务调用

方案1：Proxy 自动方法透传（最符合理想调用需求） #

这个方案可以完全实现backendService.dogBark()直接调用底层服务方法的效果，不需要手动维护方法映射，底层服务新增/修改方法时上层完全不用调整代码。
实现逻辑是提前把所有注入的子服务的方法名做映射，用Proxy拦截BackendService的属性访问，自动匹配到对应的子服务实例调用方法。
Typescript实现示例：

// 先定义所有子服务的联合类型
type AllServices = FooService | BarService | DogService

export class BackendService {
  // 存储服务实例和方法名到服务的映射
  private serviceMap: Map<string, AllServices> = new Map()
  private methodToService: Map<string, AllServices> = new Map()

  constructor(
    private fooService: FooService,
    private barService: BarService,
    private dogService: DogService
  ) {
    // 初始化服务映射
    [this.fooService, this.barService, this.dogService].forEach(service => {
      const serviceName = service.constructor.name
      this.serviceMap.set(serviceName, service)
      // 遍历服务原型上的所有方法，建立方法名到服务实例的映射
      Object.getOwnPropertyNames(Object.getPrototypeOf(service)).forEach(method => {
        if (typeof service[method] === 'function' && method !== 'constructor') {
          // 如果有重名方法可以在这里加前缀或者抛错处理
          if (this.methodToService.has(method)) {
            throw new Error(`方法名冲突：${method} 存在于多个服务中`)
          }
          this.methodToService.set(method, service)
        }
      })
    })

    // 返回Proxy实例，拦截属性访问
    return new Proxy(this, {
      get(target, prop: string) {
        // 优先访问BackendService自身的属性/方法
        if (Reflect.has(target, prop)) {
          return Reflect.get(target, prop)
        }
        // 其次匹配子服务的方法
        if (target.methodToService.has(prop)) {
          const service = target.methodToService.get(prop)
          // 绑定this指向，避免方法内部this丢失
          return service[prop].bind(service)
        }
        // 也可以保留按服务名访问的能力，兼容原有的调用方式
        if (target.serviceMap.has(prop)) {
          return target.serviceMap.get(prop)
        }
        throw new Error(`不存在的方法或服务：${prop}`)
      }
    })
  }

  // 这里可以写BackendService自身的全局方法
  public setGlobalToken(token: string) {
    // 统一给所有子服务设置请求token之类的全局逻辑
    this.serviceMap.forEach(service => service.setToken?.(token))
  }
}

使用的时候两种调用方式都支持：

// 直接调用子服务方法
backendService.dogBark()
// 兼容旧的按服务名调用
backendService.dogService.dogBark()

方案2：DI框架装饰器自动挂载（适配NestJS/Angular等依赖注入场景） #

如果你用的是带依赖注入的框架，可以自定义装饰器自动把子服务的方法挂载到BackendService原型上，不需要手动写Proxy逻辑：

// 自定义挂载装饰器
function MountService() {
  return function (target: any, propertyKey: string) {
    const serviceType = Reflect.getMetadata('design:type', target, propertyKey)
    Object.getOwnPropertyNames(serviceType.prototype).forEach(method => {
      if (typeof serviceType.prototype[method] === 'function' && method !== 'constructor') {
        target.constructor.prototype[method] = function (...args: any[]) {
          return this[propertyKey][method](...args)
        }
      }
    })
  }
}

// 在BackendService中使用
@Injectable()
export class BackendService {
  @MountService()
  private fooService: FooService
  @MountService()
  private barService: BarService
  @MountService()
  private dogService: DogService
}

方案3：代码生成脚本（无运行时开销，适合生产环境稳定性要求高的场景） #

如果担心Proxy或者装饰器的运行时开销、调试问题，可以写个简单的Node脚本，自动扫描所有子服务的方法，生成BackendService的门面层代码，每次子服务迭代后重新执行一次脚本即可，完全不需要手动写重复方法。
脚本核心逻辑：

1. 扫描服务目录下的所有service文件
2. 解析每个service的方法名和类型定义
3. 自动生成BackendService的TS代码，包含所有透传方法和类型定义

注意如果出现不同服务的重名方法，以上三种方案都需要提前做冲突处理，比如给重名方法加服务名前缀（比如dogBark重名的话生成dogDogBark），或者明确指定优先使用哪个服务的方法。

内容的提问来源于stack exchange，提问作者jSun