技能封装实战：如何设计高可复用的Skill模块

1次阅读

共计 2603 个字符，预计需要花费 7 分钟才能阅读完成。

在开发智能对话系统时，Skill 模块的封装质量直接影响系统的可维护性和扩展性。常见问题包括：

代码重复 ：相似功能技能存在大量重复代码
状态混乱 ：全局变量滥用导致技能间相互污染
扩展困难 ：新增技能需要修改核心调度逻辑
并发冲突 ：多用户请求时出现状态交叉

abstract class BaseSkill {abstract execute(): Promise<void>;
}

优点：简单直观
缺点：多重继承困难，容易造成父类膨胀

class Skill {constructor(private processor: SkillProcessor) {}}

优点：灵活度高
缺点：接口规范不易统一

interface ISkill {execute(ctx: SkillContext): Promise<SkillResult>;
}

优点：符合开闭原则，便于单元测试
缺点：需要显式管理上下文

/**
 * 技能执行上下文
 */
interface SkillContext {
  userId: string;
  sessionId: string;
  // 其他运行时参数
}

/**
 * 技能执行结果
 */
interface SkillResult {
  success: boolean;
  output?: unknown;
  metrics?: PerformanceMetrics;
}

/**
 * 技能基础接口
 */
interface ISkill {
  /**
   * 执行技能主逻辑
   * @throws SkillExecutionError 执行失败时抛出
   */
  execute(ctx: SkillContext): Promise<SkillResult>;
}

class WeatherSkill implements ISkill {private readonly logger = new Logger();

  async execute(ctx: SkillContext): Promise<SkillResult> {
    try {const startTime = Date.now();

      // 业务逻辑
      const forecast = await fetchWeather(ctx.params.location);

      return {
        success: true,
        output: formatForecast(forecast),
        metrics: {duration: Date.now() - startTime
        }
      };
    } catch (error) {this.logger.error('天气查询失败', { error, ctx});
      throw new SkillExecutionError('WEATHER_FETCH_FAILED');
    }
  }
}

class CompositeSkill implements ISkill {
  constructor(private readonly dependencies: ISkill[],
    private readonly combiner: ResultCombiner
  ) {}

  async execute(ctx: SkillContext) {
    const results = await Promise.all(this.dependencies.map(skill => skill.execute(ctx))
    );
    return this.combiner(results);
  }
}

使用懒加载机制
预加载高频技能
实现技能卸载策略

class SkillManager {private skillCache = new Map<string, ISkill>();

  async getSkill(name: string): Promise<ISkill> {if (!this.skillCache.has(name)) {const skill = await this.loadSkill(name);
      this.skillCache.set(name, skill);
    }
    return this.skillCache.get(name)!;
  }
}

class SessionScopedSkill implements ISkill {private readonly sessionStore = new WeakMap<SkillContext, SessionState>();

  async execute(ctx: SkillContext) {if (!this.sessionStore.has(ctx)) {this.sessionStore.set(ctx, createNewState());
    }
    // 使用会话隔离的状态
  }
}

内存泄漏
使用 WeakMap 存储会话数据
定期清理闲置技能实例

超时控制

async function withTimeout<T>(
  promise: Promise<T>,
  timeout: number
): Promise<T> {
  return Promise.race([
    promise,
    new Promise<never>((_, reject) => 
      setTimeout(() => reject(new Error('TIMEOUT')), timeout)
    )
  ]);
}

异常传播
定义明确的错误层级结构
避免吞噬底层异常

const testCases = [{ skill: new WeatherSkill(), iterations: 1000 },
  {skill: new TranslationSkill(), iterations: 500 }
];

for (const { skill, iterations} of testCases) {console.time(skill.constructor.name);

  for (let i = 0; i < iterations; i++) {await skill.execute(mockContext);
  }

  console.timeEnd(skill.constructor.name);
}