如何编写一个高效可维护的Skill：从架构设计到代码实现

2次阅读

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

Skill 开发中常遇到以下问题：

代码耦合度高 ：业务逻辑与基础设施代码混杂，修改一处可能影响全局
扩展性差 ：新增 Skill 类型或修改行为需要大量重构
测试困难 ：缺乏清晰边界，单元测试难以覆盖核心逻辑
状态混乱 ：多个 Skill 实例间状态管理不规范，导致意外行为

采用 DDD 分层架构（示例架构图代码块）：

@startuml
package "应用层" {[Skill 控制器] --> [Skill 服务]
}

package "领域层" {[Skill 聚合根] --> [值对象]
    [领域服务] --> [Skill 聚合根]
}

package "基础设施层" {[ 仓储实现] --> [数据库]
    [消息队列] --> [事件总线]
}

[Skill 服务] --> [领域服务]
[领域服务] --> [仓储接口]
[仓储接口] .> [仓储实现]
@enduml

各层职责说明：

应用层 ：处理 HTTP 请求、权限校验等跨领域逻辑
领域层 ：包含核心业务规则和状态变更
基础设施层 ：提供持久化、消息通信等技术实现

public interface SkillFactory {Skill create(SkillType type, SkillConfig config);
}

// 具体工厂实现
public class DefaultSkillFactory implements SkillFactory {private Map<SkillType, SkillCreator> creators = new ConcurrentHashMap<>();

    @Override
    public Skill create(SkillType type, SkillConfig config) {SkillCreator creator = creators.get(type);
        if (creator == null) {throw new IllegalArgumentException("Unsupported skill type:" + type);
        }
        return creator.create(config);
    }

    // 注册创建逻辑
    public void registerCreator(SkillType type, SkillCreator creator) {creators.put(type, creator);
    }
}

class SkillExecutionEvent:
    def __init__(self, skill_id: str, params: dict):
        self.skill_id = skill_id
        self.params = params

class SkillExecutor:
    def __init__(self, event_bus: EventBus):
        self.event_bus = event_bus

    def execute(self, event: SkillExecutionEvent) -> ExecutionResult:
        # 前置校验
        validate(event.params)

        # 发布领域事件
        self.event_bus.publish(SkillStartedEvent(event.skill_id)
        )

        # 实际执行逻辑
        result = self._do_execute(event)

        # 后续处理
        self.event_bus.publish(SkillCompletedEvent(event.skill_id, result)
        )
        return result

interface SkillState {
    id: string;
    status: 'idle' | 'executing' | 'completed' | 'failed';
    lastExecutedAt?: Date;
    metadata: Record<string, any>;
}

class StateManager {private states = new Map<string, SkillState>();

    getState(skillId: string): SkillState {return this.states.get(skillId) || {
            id: skillId,
            status: 'idle',
            metadata: {}};
    }

    updateState(skillId: string, updater: (state: SkillState) => SkillState) {const current = this.getState(skillId);
        this.states.set(skillId, updater(current));
    }
}

并发控制 ：
使用线程池限制最大并发数
对共享状态采用乐观锁机制

缓存策略 ：

type SkillCache struct {store    map[string]Skill
    ttl      time.Duration
    mutex    sync.RWMutex
}

func (c *SkillCache) Get(id string) (Skill, bool) {c.mutex.RLock()
    defer c.mutex.RUnlock()
    skill, exists := c.store[id]
    return skill, exists
}

懒加载 ：
复杂 Skill 的初始化延迟到首次执行时
按需加载依赖资源

输入验证 ：对所有入参进行白名单校验
权限控制 ：RBAC 模型控制 Skill 访问权限

防注入措施 ：

public class SkillParamSanitizer {private static final Pattern SAFE_PATTERN = Pattern.compile("^[a-zA-Z0-9-_]+$");

    public String sanitize(String input) {if (!SAFE_PATTERN.matcher(input).matches()) {throw new SecurityException("Invalid input characters");
        }
        return input;
    }
}