从零开始封装Skill：新手开发者的模块化实践指南

2次阅读

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

作为新手开发者，直接调用第三方 Skill API 时常常会遇到以下问题：

代码臃肿 ：业务逻辑与 API 调用混杂在一起，一个函数可能长达数百行
难以测试 ：由于直接依赖外部服务，单元测试需要模拟网络请求
复用性差 ：相同功能的代码在不同地方重复编写
维护困难 ：当 API 发生变化时，需要修改多处代码

采用分层架构可以有效解决上述问题。我们推荐的三层结构如下：

API 层 ：负责与第三方 Skill 服务直接交互
Service 层 ：处理业务逻辑和流程控制
Domain 层 ：定义核心业务模型和规则

classDiagram
    class SkillAPI {+call(): Promise<Response>
    }

    class SkillService {
        -api: SkillAPI
        +execute(): Promise<Result>}

    class DomainModel {+validate(): boolean
    }

    SkillService --> SkillAPI
    SkillService --> DomainModel

/**
 * Skill 基类，提供重试机制和基础功能
 * @template T 返回结果类型
 * @template P 参数类型
 */
abstract class BaseSkill<T, P> {
    private readonly maxRetries: number;

    constructor(maxRetries = 3) {this.maxRetries = maxRetries;}

    protected abstract execute(params: P): Promise<T>;

    async run(params: P): Promise<T> {
        let lastError: Error;

        for (let i = 0; i < this.maxRetries; i++) {
            try {return await this.execute(params);
            } catch (error) {
                lastError = error as Error;
                await new Promise(resolve => setTimeout(resolve, 100 * Math.pow(2, i)));
            }
        }

        throw lastError!;
    }
}

/**
 * 权限校验装饰器
 * @param requiredRole 需要的角色
 */
function checkPermission(requiredRole: string) {return function(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
        const originalMethod = descriptor.value;

        descriptor.value = async function(...args: any[]) {const context = args[0]; // 假设第一个参数是上下文
            if (!context.user?.roles.includes(requiredRole)) {throw new Error('Permission denied');
            }

            return originalMethod.apply(this, args);
        };

        return descriptor;
    };
}

class UserSkill {@checkPermission('admin')
    async deleteUser(userId: string) {// 删除用户逻辑}
}

使用 EventEmitter 时务必清理监听器：

class SkillWithEvents {private emitter = new EventEmitter();
    private listeners: Record<string, Function[]> = {};

    addListener(event: string, callback: Function) {this.emitter.on(event, callback);
        if (!this.listeners[event]) {this.listeners[event] = [];}
        this.listeners[event].push(callback);
    }

    cleanup() {Object.entries(this.listeners).forEach(([event, callbacks]) => {callbacks.forEach(cb => this.emitter.off(event, cb));
        });
    }
}

封装前后的 Benchmark 结果（单位：ops/sec）：