kcode-pi 0.1.0

package/vendor/kingdee-skills/kingdee-cosmic-reviewer/references/advanced-scenario-checklist.md

@@ -0,0 +1,307 @@
+# 高级场景检查表（分表分片/高并发/批量处理/微服务）
+
+## 🔴 P0 级问题
+
+### 1. 水平分表分片定位错误
+**检查点**:
+- 分表查询是否正确指定了分片键？
+- 是否存在跨分片查询但未带分片键的情况？
+- 分片键的值是否与实际数据分布一致？
+- `DB.execute()` 或原生 SQL 是否正确路由到目标分片？
+
+**风险**: 查询到错误分片的数据，或全分片扫描导致性能骤降
+
+**修正方案**:
+```java
+// ❌ 错误写法 - 未指定分片键，全分片扫描
+DataSet ds = QueryServiceHelper.queryDataSet("q", "sharded_entity", 
+    "id,name", null); // 无分片键条件!
+
+// ❌ 错误写法 - 分片键值不正确
+QFilter filter = new QFilter("org", QCP.equals, wrongOrgId); // 查错分片
+
+// ✅ 正确写法 - 必须带分片键
+QFilter shardFilter = new QFilter("org", QCP.equals, currentOrgId);
+QFilter bizFilter = new QFilter("billstatus", QCP.equals, "C");
+try (DataSet ds = QueryServiceHelper.queryDataSet("q", "sharded_entity", 
+    "id,name", new QFilter[]{shardFilter, bizFilter})) {
+    // 处理数据
+}
+```
+
+---
+
+### 2. 跨分片写操作
+**检查点**:
+- 同一事务内是否写了不同分片的数据？
+- 批量操作是否涉及多个分片？
+
+**风险**: 跨分片事务不被支持，可能导致数据不一致
+
+**修正方案**:
+```java
+// ❌ 错误写法 - 一个事务内写多个分片
+try (TXHandle h = TX.required("crossShard")) {
+    try {
+        SaveServiceHelper.save(orgAData); // 分片A
+        SaveServiceHelper.save(orgBData); // 分片B - 跨分片!
+    } catch (Throwable e) {
+        h.markRollback();
+        throw e;
+    }
+}
+
+// ✅ 正确写法 - 按分片分组，每组独立事务
+Map<Long, List<DynamicObject>> grouped = groupByOrg(allData);
+for (Map.Entry<Long, List<DynamicObject>> entry : grouped.entrySet()) {
+    try (TXHandle h = TX.required("saveShard_" + entry.getKey())) {
+        try {
+            SaveServiceHelper.save(entry.getValue().toArray(new DynamicObject[0]));
+        } catch (Throwable e) {
+            h.markRollback();
+            throw e;
+        }
+    }
+}
+```
+
+---
+
+### 3. 分布式锁粒度不当
+**检查点**:
+- 分布式锁的 key 粒度是否过粗（如只用模块名），导致不必要的锁竞争？
+- 分布式锁的 key 粒度是否过细（如用行级ID），导致锁数量爆炸？
+- 锁的超时时间是否合理？
+
+**风险**: 粒度过粗导致并发性能差；粒度过细导致锁管理开销大
+
+**修正方案**:
+```java
+// ❌ 错误写法 - 锁粒度过粗
+DLock lock = DLock.create("pm_purchase", "采购模块锁"); // 整个模块串行!
+
+// ❌ 错误写法 - 锁粒度过细
+for (DynamicObject entry : entries) {
+    DLock lock = DLock.create("entry_" + entry.getPkValue(), "分录行锁"); // 锁太多!
+}
+
+// ✅ 正确写法 - 以单据为粒度
+DLock lock = DLock.create("pm/purorder/" + billId, "采购订单" + billNo);
+lock.lock(30, TimeUnit.SECONDS); // 设置合理超时
+try {
+    doSomething();
+} finally {
+    lock.unlock();
+}
+```
+
+---
+
+## 🟠 P1 级问题
+
+### 4. 大批量操作未分批处理
+**检查点**:
+- 批量操作（save/delete/update）是否一次性处理所有数据？
+- 单次操作数据量是否超过 1000 条？
+- 是否有分批提交和进度反馈？
+
+**风险**: 大事务超时、OOM、数据库锁等待
+
+**修正方案**:
+```java
+// ❌ 错误写法 - 一次性处理所有数据
+DynamicObject[] allData = BusinessDataServiceHelper.load(entityName, "id", filter);
+SaveServiceHelper.save(allData); // 可能数万条数据!
+
+// ✅ 正确写法 - 分批处理
+int batchSize = 500;
+DynamicObject[] allData = BusinessDataServiceHelper.load(entityName, "id", filter);
+for (int i = 0; i < allData.length; i += batchSize) {
+    int end = Math.min(i + batchSize, allData.length);
+    DynamicObject[] batch = Arrays.copyOfRange(allData, i, end);
+    try (TXHandle h = TX.required("batch_" + i)) {
+        try {
+            SaveServiceHelper.save(batch);
+        } catch (Throwable e) {
+            h.markRollback();
+            throw e;
+        }
+    }
+}
+```
+
+---
+
+### 5. 高并发场景缓存穿透/击穿
+**检查点**:
+- 缓存查询未命中时是否直接查库？（缓存穿透）
+- 热点数据缓存过期瞬间是否有大量请求直接到数据库？（缓存击穿）
+- 恶意查询不存在的数据是否会绕过缓存？（缓存穿透）
+
+**风险**: 数据库被打爆，服务不可用
+
+**修正方案**:
+```java
+// ❌ 错误写法 - 缓存未命中直接查库
+Object data = cache.get(key);
+if (data == null) {
+    data = loadFromDB(key); // 高并发下大量请求打到数据库
+    cache.put(key, data);
+}
+
+// ✅ 正确写法 - 使用分布式锁防止击穿
+Object data = cache.get(key);
+if (data == null) {
+    DLock lock = DLock.create("cache_lock_" + key, "缓存加载锁");
+    if (lock.tryLock(5, TimeUnit.SECONDS)) {
+        try {
+            data = cache.get(key); // 双重检查
+            if (data == null) {
+                data = loadFromDB(key);
+                cache.put(key, data, 300); // 设置过期时间
+            }
+        } finally {
+            lock.unlock();
+        }
+    }
+}
+```
+
+---
+
+### 6. 微服务调用链超时传播
+**检查点**:
+- 微服务调用是否设置了超时时间？
+- 调用链中是否存在超时时间层层累加导致总超时过长？
+- 是否有降级/熔断策略？
+
+**风险**: 下游服务超时导致上游线程阻塞，服务级联故障
+
+**修正方案**:
+```java
+// ❌ 错误写法 - 无超时、无降级
+Object result = DispatchServiceHelper.invokeService(
+    "isv.ti.bo", "appId", "service", "method", args);
+
+// ✅ 正确写法 - 设置超时并处理异常
+try {
+    Object result = DispatchServiceHelper.invokeService(
+        "isv.ti.bo", "appId", "service", "method", args);
+    // 处理结果
+} catch (Exception e) {
+    logger.error("微服务调用失败，执行降级逻辑", e);
+    return getDefaultValue(); // 降级处理
+}
+```
+
+---
+
+### 7. 异步操作结果一致性
+**检查点**:
+- 异步操作完成后是否正确更新了主流程状态？
+- 异步失败时是否有补偿机制？
+- 是否使用了正确的线程池保证上下文传递？
+
+**风险**: 异步操作静默失败，主流程数据状态不一致
+
+**修正方案**:
+```java
+// ❌ 错误写法 - 异步操作无异常处理
+ThreadPools.executeOnce("asyncTask", () -> {
+    updateRelatedData(billId); // 失败了谁都不知道
+});
+
+// ✅ 正确写法 - 异步操作带上下文和异常处理
+ThreadPools.executeOnceIncludeRequestContext("asyncTask", () -> {
+    try {
+        updateRelatedData(billId);
+    } catch (Exception e) {
+        logger.error("异步更新关联数据失败: billId={}", billId, e);
+        // 记录失败日志或发送重试消息
+        retryQueue.put(billId);
+    }
+});
+```
+
+---
+
+## 🟡 P2 级问题
+
+### 8. 分页查询性能
+**检查点**:
+- 深分页（offset > 10000）是否使用了游标分页或 ID 范围分页？
+- 分页查询是否有合理的排序字段？
+
+**修正方案**:
+```java
+// ❌ 错误写法 - 深分页性能差
+// 第 10000 页，每页 20 条
+List<DynamicObject> data = BusinessDataServiceHelper.load(
+    filter, 200000, 20); // offset 太大!
+
+// ✅ 正确写法 - 基于 ID 范围分页
+QFilter pageFilter = new QFilter("id", QCP.large_than, lastMaxId);
+List<DynamicObject> data = BusinessDataServiceHelper.load(
+    entityName, "id,name", 
+    new QFilter[]{pageFilter}, "id ASC", 20);
+```
+
+---
+
+### 9. 定时任务并发执行
+**检查点**:
+- 定时任务是否考虑了多节点同时触发的情况？
+- 是否使用了分布式锁防止重复执行？
+
+**修正方案**:
+```java
+// ✅ 正确写法 - 定时任务加分布式锁
+@Override
+public void execute(RequestContext ctx, Map<String, Object> map) throws KDException {
+    DLock lock = DLock.create("task_" + taskName, "定时任务");
+    if (!lock.tryLock(0, TimeUnit.SECONDS)) {
+        logger.info("任务正在其他节点执行，跳过");
+        return;
+    }
+    try {
+        doTaskLogic();
+    } finally {
+        lock.unlock();
+    }
+}
+```
+
+---
+
+### 10. 数据导入/导出性能
+**检查点**:
+- 大数据量导入是否使用了流式处理？
+- 导出是否一次性加载所有数据到内存？
+- 是否有进度反馈机制？
+
+**修正方案**:
+```java
+// ❌ 错误写法 - 一次性加载所有数据导出
+List<DynamicObject> all = BusinessDataServiceHelper.load(filter); // OOM!
+
+// ✅ 正确写法 - 流式查询分批导出
+try (DataSet ds = QueryServiceHelper.queryDataSet("export", entity, fields, filter)) {
+    int count = 0;
+    List<Object[]> batch = new ArrayList<>(1000);
+    while (ds.hasNext()) {
+        Row row = ds.next();
+        batch.add(new Object[]{row.getString("name"), row.getBigDecimal("amount")});
+        if (batch.size() >= 1000) {
+            writeBatchToExcel(batch);
+            batch.clear();
+        }
+        count++;
+        if (count % 5000 == 0) {
+            feedbackProgress(count, "已导出 " + count + " 条");
+        }
+    }
+    if (!batch.isEmpty()) {
+        writeBatchToExcel(batch);
+    }
+}
+```

package/vendor/kingdee-skills/kingdee-cosmic-reviewer/references/algox-performance-checklist.md

@@ -0,0 +1,129 @@
+# AlgoX 大数据计算性能检查表
+
+## 🟠 P1 级问题
+
+### 1. 循环内获取 FieldIndex
+**检查点**:
+- `map()`/`filter()` 内是否调用 `getFieldIndex()`？
+- 是否在 lambda 表达式中重复计算？
+
+**风险**: 性能损耗，不必要的重复计算
+
+**修正方案**:
+```java
+// ❌ 错误写法
+ds.map(row -> {
+    int idx = row.getMeta().getFieldIndex("amount"); // 每行都查！
+    return row.getBigDecimal(idx);
+});
+
+// ✅ 正确写法 - 缓存为成员变量
+private int amountIndex = -1;
+
+public void process(DataSet ds) {
+    amountIndex = ds.getRowMeta().getFieldIndex("amount");
+    ds.map(row -> row.getBigDecimal(amountIndex));
+}
+```
+
+---
+
+### 2. 集合无限累积
+**检查点**:
+- 是否在 `map` 中无限制 `add` 到 List？
+- 是否在循环中持续累积数据？
+
+**风险**: OOM 内存溢出
+
+**修正方案**:
+```java
+// ❌ 错误写法
+List<Object> result = new ArrayList<>();
+ds.forEach(row -> {
+    result.add(transform(row)); // 无限累积！
+});
+
+// ✅ 正确写法 - 分批处理
+int batchSize = 10000;
+List<Object> batch = new ArrayList<>(batchSize);
+ds.forEach(row -> {
+    batch.add(transform(row));
+    if (batch.size() >= batchSize) {
+        saveBatch(batch);
+        batch.clear();
+    }
+});
+if (!batch.isEmpty()) {
+    saveBatch(batch);
+}
+```
+
+---
+
+### 3. DataSet 未关闭
+**检查点**:
+- `DataSet` 是否使用 try-with-resources？
+
+**修正方案**:
+```java
+// ❌ 错误写法
+DataSet ds = Algo.create().query(...);
+process(ds);
+// ds 未关闭！
+
+// ✅ 正确写法
+try (DataSet ds = Algo.create().query(...)) {
+    process(ds);
+}
+```
+
+---
+
+### 4. AlgoContext 未关闭
+**检查点**:
+- `AlgoContext` 是否正确关闭？
+
+**修正方案**:
+```java
+// ✅ 正确写法
+try (AlgoContext ctx = Algo.newContext()) {
+    DataSet ds = ...;
+    // 处理数据
+}
+```
+
+---
+
+## 🟡 P2 级问题
+
+### 5. 不必要的 collect
+**检查点**:
+- 是否将 DataSet 收集到 List 后又遍历？
+
+**修正方案**:
+```java
+// ❌ 错误写法
+List<Row> rows = ds.collect(Collectors.toList());
+rows.forEach(this::process);
+
+// ✅ 正确写法 - 直接遍历
+ds.forEach(this::process);
+```
+
+---
+
+### 6. 重复计算
+**检查点**:
+- 是否多次调用相同的 `filter()`/`groupBy()`？
+
+**修正方案**:
+```java
+// ❌ 错误写法
+long count = ds.filter("status = 1").count();
+DataSet filtered = ds.filter("status = 1"); // 重复过滤！
+
+// ✅ 正确写法 - 缓存中间结果
+DataSet filtered = ds.filter("status = 1");
+long count = filtered.count();
+process(filtered);
+```