基于技能仓库(Skill Repository)的微服务能力编排实践

2次阅读

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

在微服务架构实践中，我们经常遇到两个典型问题：

重复开发：不同团队独立开发相似功能，比如支付服务、短信服务等，造成资源浪费
版本混乱：同一个服务存在多个版本，调用方难以管理依赖关系
调用链复杂：服务间直接调用形成网状结构，难以维护和监控

采用 JSON Schema 定义技能元数据，示例：

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "title": "SkillMetadata",
  "type": "object",
  "properties": {
    "skillId": {
      "type": "string",
      "description": "唯一技能标识"
    },
    "version": {
      "type": "string",
      "pattern": "^\\d+.\\d+.\\d+$"
    },
    "inputSchema": {
      "type": "object",
      "description": "输入参数结构"
    },
    "outputSchema": {
      "type": "object",
      "description": "输出结果结构"
    }
  },
  "required": ["skillId", "version"]
}

基于 Spring Cloud 实现的服务注册流程：

服务启动时通过 @PostConstruct 自动注册技能元数据
注册中心维护技能 ID 与实例的映射关系
客户端通过技能 ID 而非具体服务名进行调用

路由决策流程图：

graph TD
    A[调用请求] --> B{版本指定?}
    B -->| 是 | C[路由到指定版本]
    B -->| 否 | D[获取最新稳定版]
    D --> E[负载均衡选择实例]
    C --> F[检查版本可用性]
    F --> G[返回可用实例]

@RestController
@RequestMapping("/api/skill")
public class SkillRegistryController {

    @Autowired
    private SkillRepository repository;

    @PostMapping("/register")
    public ResponseEntity<String> registerSkill(@RequestBody SkillMetadata metadata) {
        // 校验元数据格式
        validateMetadata(metadata);

        // 存储到仓库
        repository.save(metadata);

        return ResponseEntity.ok("Skill registered successfully");
    }

    private void validateMetadata(SkillMetadata metadata) {// 实现 JSON Schema 校验逻辑}
}

采用语义化版本控制，关键代码：

public class VersionComparator implements Comparator<String> {
    @Override
    public int compare(String v1, String v2) {String[] parts1 = v1.split("\\.");
        String[] parts2 = v2.split("\\.");

        for (int i = 0; i < 3; i++) {int num1 = Integer.parseInt(parts1[i]);
            int num2 = Integer.parseInt(parts2[i]);

            if (num1 != num2) {return num1 - num2;}
        }
        return 0;
    }
}

@FeignClient(name = "skill-proxy", url = "${skill.repository.url}")
public interface SkillProxy {

    @RequestMapping(method = RequestMethod.POST, 
                   value = "/execute/{skillId}")
    Object executeSkill(@PathVariable("skillId") String skillId,
            @RequestParam(value = "version", required = false) String version,
            @RequestBody Object input);
}

采用多级缓存架构：

本地 Caffeine 缓存：存储高频访问的技能元数据
Redis 集群：缓存技能实例的健康状态
缓存失效策略：
主动推送：元数据变更时通知所有节点
被动刷新：客户端请求时检查版本差异

基于令牌桶的 QPS 限流实现：

public class RateLimiter {
    private final int capacity;
    private final AtomicInteger tokens;
    private final ScheduledExecutorService scheduler;

    public RateLimiter(int qps) {
        this.capacity = qps;
        this.tokens = new AtomicInteger(qps);
        this.scheduler = Executors.newSingleThreadScheduledExecutor();

        scheduler.scheduleAtFixedRate(() -> {if (tokens.get() < capacity) {tokens.incrementAndGet();
            }
        }, 1, 1, TimeUnit.SECONDS);
    }

    public boolean tryAcquire() {return tokens.decrementAndGet() >= 0;
    }
}

实现角色 - 技能访问矩阵：

CREATE TABLE skill_permissions (role_id VARCHAR(36) NOT NULL,
    skill_id VARCHAR(64) NOT NULL,
    min_version VARCHAR(16),
    max_version VARCHAR(16),
    PRIMARY KEY (role_id, skill_id)
);

处理方案：