TypeScript中不兼容接口服务间的桥接方案优化咨询

你的核心痛点是避免为每个服务方法重复编写类型判断逻辑，同时要保证运行时的类型校验和TypeScript的类型安全。这里有一套更具扩展性的方案，利用类型映射（Type Mapping）和泛型来简化代码，同时保持灵活性：

第一步：定义统一的类型映射 #

首先，我们把服务类型、对应的服务类、模型类型以及参数类型都关联起来，让TypeScript能自动推断出它们之间的对应关系：

interface CampaignModel { id: number }
class CampaignService {
    public async find(startId: number, limit: number): Promise<CampaignModel[]> { return []; }
    // 示例新增方法：create
    public async create(data: Omit<CampaignModel, 'id'>): Promise<CampaignModel> { return { id: 1 }; }
}

interface LeadModel { id: string }
class LeadService {
    public async find(startId: string, limit: number): Promise<LeadModel[]> { return []; }
    public async create(data: Omit<LeadModel, 'id'>): Promise<LeadModel> { return { id: 'xxx' }; }
}

type ServiceType = 'Campaign' | 'Lead';

// 核心：建立服务类型与所有关联类型的映射
type ServiceMap = {
  Campaign: {
    Service: CampaignService;
    Model: CampaignModel;
    StartIdType: number;
  };
  Lead: {
    Service: LeadService;
    Model: LeadModel;
    StartIdType: string;
  };
};

第二步：用注册表+泛型方法重构桥接类 #

我们不再写一堆if-else判断，而是用运行时注册表存储服务实例，再通过泛型方法统一处理方法调用：

class ServiceByType {
  // 运行时服务注册表：键为ServiceType，值为对应的服务实例
  private readonly serviceRegistry: Record<ServiceType, ServiceMap[ServiceType]['Service']> = {
    Campaign: new CampaignService(),
    Lead: new LeadService(),
  };

  // 通用服务方法调用工具：抽离重复逻辑
  private async callServiceMethod<
    T extends ServiceType,
    M extends keyof ServiceMap[T]['Service']
  >(
    type: T,
    methodName: M,
    ...args: Parameters<ServiceMap[T]['Service'][M]>
  ): Promise<ReturnType<ServiceMap[T]['Service'][M]>> {
    const service = this.serviceRegistry[type];
    
    // 运行时校验：确保服务存在且方法存在
    if (!service || !(methodName in service)) {
      throw new Error(`Unsupported method "${String(methodName)}" for service type "${type}"`);
    }

    // 类型安全的方法调用
    return service[methodName](...args);
  }

  // 针对find方法的封装（一行搞定）
  public async find<T extends ServiceType>(
    type: T,
    startId: ServiceMap[T]['StartIdType'],
    limit: number
  ): Promise<ServiceMap[T]['Model'][]> {
    return this.callServiceMethod(type, 'find', startId, limit);
  }

  // 新增create方法同样只需一行
  public async create<T extends ServiceType>(
    type: T,
    data: Omit<ServiceMap[T]['Model'], 'id'>
  ): Promise<ServiceMap[T]['Model']> {
    return this.callServiceMethod(type, 'create', data);
  }
}

第三步：运行时类型校验 #

因为ServiceType是用户传入的参数（可能是任意字符串），我们需要加一个运行时校验函数确保合法性：

// 校验输入是否为合法的ServiceType
function isValidServiceType(type: string): type is ServiceType {
  return ['Campaign', 'Lead'].includes(type);
}

// 使用示例
const service = new ServiceByType();
const userInputType = 'Campaign'; // 假设来自用户输入

if (isValidServiceType(userInputType)) {
  // TypeScript自动推断：startId必须是number，返回CampaignModel[]
  service.find(userInputType, 16, 10);
  // 调用create方法，参数自动匹配CampaignModel的结构
  service.create(userInputType, {});
} else {
  throw new Error(`Invalid service type: ${userInputType}`);
}

// Lead类型的调用同样会自动校验参数
service.find('Lead', 'xxxawf', 10);
service.create('Lead', {});

方案优势 #

• 极强的扩展性：新增服务类型时，只需在ServiceType和ServiceMap中添加对应条目，再把服务实例加入注册表即可；新增服务方法时，只需在桥接类里加一行封装调用callServiceMethod的代码。
• 类型安全：TypeScript会自动根据传入的ServiceType推断参数类型和返回值类型，避免类型错误。
• 减少重复代码：所有方法的校验、服务查找逻辑都抽离到callServiceMethod中，不用再写一堆if-else分支。

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