《Java 消息中间件·事件驱动架构》14.3 架构评审清单

import java.util.*;

public class FieldNamingConsistency {

    // 模拟事件目录中的字段定义
    static Map<String, List<String>> eventCatalog = new LinkedHashMap<>();
    static {
        eventCatalog.put("LoanCreated", List.of("loanId", "isbn", "memberId", "borrowedAt"));
        eventCatalog.put("LoanReturned", List.of("loanId", "returnedAt", "memberId", "isbn"));
        eventCatalog.put("ReservationCreated", List.of("reservationId", "isbn", "memberId", "status"));
        // 故意加入一个不一致的字段名
        eventCatalog.put("MemberRegistered", List.of("userId", "email", "registeredAt"));
    }

    static List<String> findInconsistencies() {
        Map<String, Set<String>> normalizedToVariants = new HashMap<>();
        for (Map.Entry<String, List<String>> entry : eventCatalog.entrySet()) {
            for (String field : entry.getValue()) {
                String norm = field.toLowerCase().replaceAll("[_-]", "");
                normalizedToVariants.computeIfAbsent(norm, k -> new LinkedHashSet<>()).add(field);
            }
        }
        List<String> issues = new ArrayList<>();
        for (Map.Entry<String, Set<String>> e : normalizedToVariants.entrySet()) {
            if (e.getValue().size() > 1) {
                issues.add("概念 '" + e.getKey() + "' 有多种写法: " + e.getValue());
            }
        }
        return issues;
    }

    public static void main(String[] args) {
        List<String> issues = findInconsistencies();
        System.out.println("=== 字段命名一致性扫描 ===");
        if (issues.isEmpty()) {
            System.out.println("✓ 通过：全卷无字段命名冲突");
        } else {
            issues.forEach(i -> System.out.println("✗ " + i));
        }
        System.out.println("\n扫描事件数: " + eventCatalog.size());
        System.out.println("评审通过: " + (issues.isEmpty() ? "是" : "否"));
    }
}

=== 字段命名一致性扫描 ===
✗ 概念 'memberid' 有多种写法: [memberId, userId]

扫描事件数: 4
评审通过: 否

import java.util.*;

public class IdempotencyKeyCheck {

    record ConsumerSpec(String name, String idempotencyKey) {}

    static boolean isValid(ConsumerSpec c) {
        String k = c.idempotencyKey().toLowerCase();
        boolean hasBusinessKey = k.contains("eventid") || k.contains("businesskey")
            || k.contains("orderid") || k.contains("loanid");
        boolean notOnlyOffset = !k.contains("only") || !k.contains("offset");
        return hasBusinessKey && notOnlyOffset;
    }

    public static void main(String[] args) {
        List<ConsumerSpec> consumers = List.of(
            new ConsumerSpec("order-projection", "eventId + orderId"),
            new ConsumerSpec("bad-consumer", "kafkaOffset only"),
            new ConsumerSpec("inventory-sync", "eventId + productId"),
            new ConsumerSpec("batch-reconciler", "batchId")
        );

        int pass = 0;
        for (ConsumerSpec c : consumers) {
            boolean ok = isValid(c);
            if (ok) pass++;
            System.out.println((ok ? "✓" : "✗") + " " + c.name() + " (" + c.idempotencyKey() + ")");
        }
        System.out.println("\n通过: " + pass + "/" + consumers.size());
        System.out.println("评审通过: " + (pass == consumers.size() ? "是" : "否"));
    }
}

✓ order-projection (eventId + orderId)
✗ bad-consumer (kafkaOffset only)
✓ inventory-sync (eventId + productId)
✗ batch-reconciler (batchId)

通过: 2/4
评审通过: 否

import java.util.*;

public class ArchitectureReviewChecklist {

    record Check(String id, String dimension, String question, boolean passed, String evidence) {}

    static void runReview() {
        List<Check> checks = new ArrayList<>();
        // 契约
        checks.add(new Check("1.1", "契约", "事件命名是否用过去时？", true, "目录扫描零命中非过去时"));
        checks.add(new Check("1.2", "契约", "字段命名是否一致？", false, "memberId vs userId"));
        checks.add(new Check("1.3", "契约", "Schema 是否有版本号？", true, "schemaVersion 字段存在"));
        checks.add(new Check("1.4", "契约", "消费者是否声明字段依赖？", true, "inventory-sync 声明 requiredFields"));
        checks.add(new Check("1.5", "契约", "新增字段是否有默认值？", true, "regionCode 默认 UNKNOWN"));
        checks.add(new Check("1.6", "契约", "枚举值变更是否经审批？", true, "ADR-2047"));
        // 一致性
        checks.add(new Check("2.1", "一致性", "是否有幂等键？", true, "eventId + orderId"));
        checks.add(new Check("2.2", "一致性", "幂等边界是否覆盖业务周期？", true, "orderId 贯穿创建-支付-发货"));
        checks.add(new Check("2.3", "一致性", "补偿是否有超时？", true, "timeout=30s"));
        checks.add(new Check("2.4", "一致性", "补偿失败是否有人工出口？", false, "无告警配置"));
        checks.add(new Check("2.5", "一致性", "投影延迟是否可接受？", true, "p99=480ms, max=5000ms"));
        checks.add(new Check("2.6", "一致性", "是否有一致性窗口？", true, "consistencyWindow=5min"));
        checks.add(new Check("2.7", "一致性", "跨分区顺序是否处理？", true, "orderId 为 partition key"));
        // 运维
        checks.add(new Check("3.1", "运维", "是否有死信队列？", true, "dlq.topic=orders-dlq"));
        checks.add(new Check("3.2", "运维", "是否有 lag 告警？", true, "records-lag-max > 5000"));
        checks.add(new Check("3.3", "运维", "是否有异常告警？", true, "consumer-error-rate > 0"));
        checks.add(new Check("3.4", "运维", "是否有重放能力？", true, "有 replay.sh 脚本"));
        checks.add(new Check("3.5", "运维", "重放是否需要停服？", false, "当前需停服，计划改造"));
        checks.add(new Check("3.6", "运维", "健康检查是否覆盖消费？", true, "lastProcessedAt < 60s"));
        checks.add(new Check("3.7", "运维", "是否支持无损滚动？", true, "maxUnavailable=0"));
        // 成本
        checks.add(new Check("4.1", "成本", "保留期是否已确认？", true, "retention.ms=30d"));
        checks.add(new Check("4.2", "成本", "存储增长是否符合预期？", true, "实际 95% 在模型内"));
        checks.add(new Check("4.3", "成本", "消费者数量有容量规划？", true, "5 consumers, model validated"));
        checks.add(new Check("4.4", "成本", "是否有配额超限策略？", false, "未配置 quota"));
        checks.add(new Check("4.5", "成本", "是否清理孤儿消费者？", true, "月清理脚本"));

        Map<String, long[]> stats = new LinkedHashMap<>();
        for (Check c : checks) {
            long[] arr = stats.computeIfAbsent(c.dimension(), k -> new long[]{0, 0});
            arr[1]++;
            if (c.passed()) arr[0]++;
        }

        System.out.println("=== 架构评审结果 ===");
        int totalFail = 0;
        for (Map.Entry<String, long[]> e : stats.entrySet()) {
            long pass = e.getValue()[0];
            long total = e.getValue()[1];
            long fail = total - pass;
            totalFail += fail;
            System.out.println(e.getKey() + ": " + pass + "/" + total + " 通过" + (fail > 0 ? ", " + fail + " 条未通过" : ""));
        }
        System.out.println("\n未通过项详情:");
        for (Check c : checks) {
            if (!c.passed()) {
                System.out.println("  [" + c.id() + "] " + c.question() + " — " + c.evidence());
            }
        }
        System.out.println("\n总评: " + (totalFail == 0 ? "✓ 通过" : "✗ 未通过（" + totalFail + " 项 blocker）"));
        System.out.println("建议: " + (totalFail == 0 ? "可进入开发阶段" : "修复 blocker 后复评"));
    }

    public static void main(String[] args) {
        runReview();
    }
}

=== 架构评审结果 ===
契约: 5/6 通过, 1 条未通过
一致性: 6/7 通过, 1 条未通过
运维: 6/7 通过, 1 条未通过
成本: 4/5 通过, 1 条未通过

未通过项详情:
  [1.2] 字段命名是否一致？ — memberId vs userId
  [2.4] 补偿失败是否有人工出口？ — 无告警配置
  [3.5] 重放是否需要停服？ — 当前需停服，计划改造
  [4.4] 是否有配额超限策略？ — 未配置 quota

总评: ✗ 未通过（4 项 blocker）
建议: 修复 blocker 后复评