@shundoo-ai/dsh-cosmic 1.0.21 → 1.0.22

package/skills/cosmic-build/knowledge/cosmic/platform/scenes/data-access/business-data/delete-service.md

@@ -5,58 +5,53 @@ source_doc: "20-动态领域模型/130-公共服务/240-数据删除服务.md"
 last_updated: "2026-03-07"
 status: "approved"
 scene_name: "数据删除服务"
-related_apis: ["DeleteServiceHelper.delete", "DeleteServiceHelper.deleteOperate"]
+related_apis: ["DeleteServiceHelper.deleteOperate", "OperationServiceHelper.executeOperate"]
 topic: "api/business-data"
 ---
 
 # 场景：数据删除服务
 
 ## 适用情况
-需要删除实体数据时，使用 `DeleteServiceHelper`：业务场景推荐 `deleteOperate`（走删除校验与插件），需要直接删库时使用 `delete`。
+删除实体数据使用 `DeleteServiceHelper.deleteOperate` 或 `OperationServiceHelper.executeOperate("delete", ...)`，
+执行删除校验与插件。
+
+> **DCS 部署：** `DeleteServiceHelper.delete(...)` 绕过删除校验，违反 `CVE-KD-0717-2`；
+> `BusinessDataWriter.delete`、`ORM.delete` 同样受限。通过 DCS 交付的插件不得调用它们，
+> 见 [dcs-code-rules.md](../../../../../../references/dcs-code-rules.md)。
 
 ## 方法签名
 ```java
-// 按实体类型和主键直接删库，不走删除校验
-delete(IDataEntityType type, Object[] pks) void
+// 调用单据删除操作，执行删除校验及插件
+deleteOperate(String operationKey, String entityName, Object[] pks, OperateOption option) OperationResult
 
-// 按实体名称和过滤条件直接删库，不走删除校验
+// 以下为受限签名，不得用于 DCS 插件（CVE-KD-0717-2）
+delete(IDataEntityType type, Object[] pks) void
 delete(String entityName, QFilter[] qFilters) void
-
-// 调用单据删除操作，走删除校验及插件
-deleteOperate(String operationKey, String entityName, Object[] pks, OperateOption option) OperationResult
 ```
 
 ## 代码示例
 `extracted` `needs-verification`
 
 ```java
-import kd.bos.entity.EntityMetadataCache;
-import kd.bos.servicehelper.operation.DeleteServiceHelper;
-
-// delete 按主键删除示例
-Object[] ids = new Object[]{formId};
-IDataEntityType type = EntityMetadataCache.getDataEntityType("test_entity");
-DeleteServiceHelper.delete(type, ids);
-```
-
-```java
-import kd.bos.context.RequestContext;
-import kd.bos.orm.query.QFilter;
+import kd.bos.dataentity.OperateOption;
 import kd.bos.servicehelper.operation.DeleteServiceHelper;
 
-// delete 按条件删除示例
-QFilter q1 = new QFilter("user", QCP.equals, Long.valueOf(RequestContext.get().getUserId()));
-QFilter q2 = new QFilter("formId", QCP.equals, formId);
-QFilter[] filter = new QFilter[]{q1, q2};
-DeleteServiceHelper.delete("test_entity", filter);
+// deleteOperate 示例（推荐）
+DeleteServiceHelper.deleteOperate("delete", "test_entity", new Object[] { billId }, OperateOption.create());
 ```
 
 ```java
 import kd.bos.dataentity.OperateOption;
-import kd.bos.servicehelper.operation.DeleteServiceHelper;
+import kd.bos.entity.operate.result.OperationResult;
+import kd.bos.exception.KDBizException;
+import kd.bos.servicehelper.operation.OperationServiceHelper;
 
-// deleteOperate 示例（推荐）
-DeleteServiceHelper.deleteOperate("delete", "test_entity", new Object[] { billId }, OperateOption.create());
+// 删除通过操作服务执行，并检查操作结果。
+OperationResult result = OperationServiceHelper.executeOperate("delete", "test_entity",
+        new Object[] { billId }, OperateOption.create());
+if (!result.isSuccess()) {
+    throw new KDBizException(result.getMessage());
+}
 ```
 
 ## 参数说明
@@ -70,5 +65,5 @@ DeleteServiceHelper.deleteOperate("delete", "test_entity", new Object[] { billId
 | option | OperateOption | 自定义操作参数 |
 
 ## 注意事项
-- `delete` 直接删库，不执行删除校验、插件，不删除关联数据，谨慎使用
+- `delete` 直接删库，不执行删除校验、插件，不删除关联数据，DCS 禁止调用
 - `deleteOperate` 走完整删除流程，业务场景推荐使用

package/skills/cosmic-build/knowledge/cosmic/platform/scenes/data-access/ksql/db-batch.md

@@ -12,6 +12,10 @@ related_apis: ["DB.executeBatch", "DB.genLongIds", "DBRoute.of"]
 
 # 场景：DB 直接批量 SQL 操作
 
+> **DCS 部署：** `kd.bos.db.DB` 违反 `CVE-KD-0413`，本页仅供理解平台内部实现，
+> 不得作为 DCS 插件模板。查询使用 `QueryServiceHelper`，写入通过已验证的保存/操作服务，
+> 见 [dcs-code-rules.md](../../../../../../references/dcs-code-rules.md)。
+
 ## 适用情况
 需要绕过 ORM 框架直接执行批量 SQL 插入或更新时，使用 DB 工具类生成主键并批量执行 SQL，适用于高性能批量写入场景。
 

package/skills/cosmic-build/knowledge/cosmic/platform/scenes/data-access/ksql/db-direct-access.md

@@ -11,6 +11,10 @@ topic: "data-access/ksql"
 
 # 场景：DB 直接访问
 
+> **DCS 部署：** `kd.bos.db.DB` 违反 `CVE-KD-0413`，本页仅供理解平台内部实现，
+> 不得作为 DCS 插件模板。使用 `QueryServiceHelper` / `BusinessDataServiceHelper` 和操作服务，
+> 见 [dcs-code-rules.md](../../../../../../references/dcs-code-rules.md)。
+
 ## 适用情况
 需要通过 SQL 直接访问数据库时，使用 kd.bos.db.DB 类（基本用法与 JDBC 相似，统一使用 KSQL 语法，通过 DBRoute 路由到具体物理库）。
 

package/skills/cosmic-build/knowledge/cosmic/platform/scenes/data-access/qfilter/entity-object-access.md

@@ -11,6 +11,11 @@ topic: "data-access/qfilter"
 
 # 场景：实体对象访问模式
 
+> **DCS 部署：** `kd.bos.orm.ORM`、`kd.bos.db.DB` 与 `DeleteServiceHelper.delete`
+> 均受门禁限制（`CVE-KD-2026-0508`、`CVE-KD-0413`、`CVE-KD-0717-2`）。
+> 使用查询/业务数据服务和删除操作，本页保留的 ORM 代码仅供理解内部实现；
+> 见 [dcs-code-rules.md](../../../../../../references/dcs-code-rules.md)。
+
 ## 适用情况
 通过苍穹 ORM 引擎对实体对象进行增删改查操作，选择合适的帮助类或 ORM 接口。
 
@@ -19,10 +24,10 @@ topic: "data-access/qfilter"
 | 场景 | 推荐方式 | 次选 | 说明 |
 | ---- | -------- | ---- | ---- |
 | 保存 | SaveServiceHelper | 无 | 含 save，update |
-| 删除 | DeleteServiceHelper | 无 | |
-| 查询（结果为结构化对象） | BusinessDataServiceHelper | ORM.queryDynamicObject | loadFromCache 带缓存 |
+| 删除 | OperationServiceHelper.executeOperate("delete", ...) | DeleteServiceHelper.deleteOperate | 执行校验/插件，不使用 DeleteServiceHelper.delete |
+| 查询（结果为结构化对象） | BusinessDataServiceHelper | 无 | loadFromCache 带缓存，不在 DCS 插件中调用 ORM |
 | 查询（结果为平铺对象） | QueryServiceHelper | 无 | 拉平对象主要用于列表显示 |
-| 查询（结果为 DataSet） | QueryServiceHelper | ORM.queryDataSet | ORM 引擎接口更全，QueryServiceHelper未提供时选择ORM.queryDataSet |
+| 查询（结果为 DataSet） | QueryServiceHelper.queryDataSet | 无 | DCS 禁止 ORM；优先使用公开服务 API |
 
 ## 代码示例
 `extracted` `needs-verification`

package/skills/cosmic-build/knowledge/cosmic/platform/scenes/data-access/qfilter/qfilter-compose.md

@@ -5,7 +5,7 @@ source_doc: "060-开发平台/25-数据访问/02-QFilter条件.md"
 last_updated: "2026-03-07"
 status: "approved"
 scene_name: "复合条件AND/OR组合"
-related_apis: ["QFilter.and", "QFilter.or", "QFilter.toArray", "ORM.query"]
+related_apis: ["QFilter.and", "QFilter.or", "QFilter.toArray", "QueryServiceHelper.query"]
 topic: "data-access/qfilter"
 ---
 
@@ -48,16 +48,17 @@ QFilter f = (f1.or(f2)).and(f3.or(f4));
 
 ```java
 import kd.bos.orm.query.QFilter;
+import kd.bos.servicehelper.QueryServiceHelper;
 
-// QFilter 数组（ORM 引擎自动 and 关联）
+// 查询服务接收 QFilter 数组，数组元素自动按 AND 关联。
 QFilter f1 = new QFilter("name", QCP.equals, "tom");
 QFilter f2 = new QFilter("age", QCP.equals, 18);
-ORM.create().query("", "", new QFilter[]{f1, f2});
-ORM.create().query("", "", f1.toArray());
+QueryServiceHelper.query("entityName", "id,name", new QFilter[]{f1, f2});
+QueryServiceHelper.query("entityName", "id,name", f1.toArray());
 ```
 
 ## 注意事项
-- ORM 接口参数是 QFilter 数组，引擎将数组中的 QFilter 进行 and 关联
+- `QueryServiceHelper` 接收 QFilter 数组，元素按 AND 关联；DCS 插件不直接使用 ORM
 - 纯 and 条件场景可以不使用 QFilter 链，直接传 QFilter 数组
 - QFilter 链的每个元素仍是 QFilter 对象，可继续与其他 QFilter 链进行 and/or 关联
 - 过滤条件少用 or 条件，特别是跨库字段上用 or 条件（性能影响）

package/skills/cosmic-build/knowledge/cosmic/platform/scenes/event/after-bind-data-set-visible.md

@@ -37,14 +37,18 @@ public void afterBindData(EventObject e)
 import java.util.EventObject;
 import kd.bos.algo.DataSet;
 import kd.bos.form.plugin.AbstractFormPlugin;
+import kd.bos.orm.query.QCP;
+import kd.bos.orm.query.QFilter;
 import kd.bos.servicehelper.QueryServiceHelper;
 
 public class XxxFormPlugin extends AbstractFormPlugin {
     @Override
     public void afterBindData(EventObject e) {
         super.afterBindData(e);
+        // 按实际业务限定查询范围，DCS 禁止无有效过滤条件的全表查询。
+        QFilter[] filters = {new QFilter("enable", QCP.equals, "1")};
         try (DataSet periodSet = QueryServiceHelper.queryDataSet(
-                "fi.bd.index.period", "bd_period_type", "id", null, null)) {
+                "fi.bd.index.period", "bd_period_type", "id", filters, null)) {
             Integer periodCount = Integer.valueOf(periodSet.count("id", false));
             getView().setVisible(Boolean.valueOf(periodCount.intValue() == 0), new String[]{"period1"});
             getView().setVisible(Boolean.valueOf(periodCount.intValue() > 0), new String[]{"period2"});

package/skills/cosmic-build/knowledge/cosmic/platform/scenes/event/click-return-data.md

@@ -21,8 +21,8 @@ related_apis: ["IFormView.returnDataToParent", "IFormView.close"]
 ## 涉及的核心对象（必读）
 | 对象 | 用途 | 文档路径 |
 |------|------|---------|
-| IFormView | 回传数据并关闭页面 | output/platform/form/core/view.md |
-| IDataModel | 读取分录或字段数据 | output/platform/form/core/model.md |
+| IFormView | 回传数据并关闭页面 | knowledge/cosmic/platform/core/view.md |
+| IDataModel | 读取分录或字段数据 | knowledge/cosmic/platform/core/model.md |
 
 ## 方法签名
 ```java

package/skills/cosmic-build/knowledge/cosmic/platform/scenes/event/closed-call-back-set-value.md

@@ -20,8 +20,8 @@ related_apis: ["ClosedCallBackEvent.getReturnData", "ClosedCallBackEvent.getActi
 ## 涉及的核心对象（必读）
 | 对象 | 用途 | 文档路径 |
 |------|------|---------|
-| IDataModel | 写入返回数据 | platform/form/core/model.md |
-| IFormView | 触发后续操作 | platform/form/core/view.md |
+| IDataModel | 写入返回数据 | knowledge/cosmic/platform/core/model.md |
+| IFormView | 触发后续操作 | knowledge/cosmic/platform/core/view.md |
 
 ## 方法签名
 ```java

package/skills/cosmic-build/knowledge/cosmic/platform/scenes/event/register-listener.md

@@ -47,7 +47,7 @@ import kd.bos.form.plugin.AbstractFormPlugin;
 
 public class ButtonClickDomo extends AbstractFormPlugin implements ClickListener {
 
-	private final static String KEY_BUTTON1 = "buttonap1";
+	private static final String KEY_BUTTON1 = "buttonap1";
 
 	@Override
 	public void registerListener(EventObject e) {

package/skills/cosmic-build/knowledge/cosmic/platform/scenes/event/set-filter-tab-org.md

@@ -60,6 +60,9 @@ public class TabFilterPlugin extends AbstractListPlugin {
             case "anomaly_tab":
                 filter = new QFilter(field, QCP.equals, "3");
                 break;
+            default:
+                // 未匹配的页签保留列表原有过滤条件。
+                break;
         }
 
         if (null != filter) {

package/skills/cosmic-build/knowledge/cosmic/platform/scenes/infra/dispatch-service/microservice-dev.md

@@ -31,26 +31,32 @@ invokeService(String factoryQualifiedPrefix, String appId, String serviceName, S
 package kd.ecos_test.ecos_testapp.servicehelper;
 
 /**
- * 微服务，ServiceFactory一个应用一个，目录需要kd.云id.应用id.servicehelper
+ * Microservice: one ServiceFactory per application.
+ * The directory must follow: kd.{cloudId}.{appId}.servicehelper
  */
-import java.util.HashMap;
-import java.util.Map;
 import kd.bos.dataentity.TypesContainer;
 import kd.bos.dataentity.resource.ResManager;
+import kd.bos.exception.KDBizException;
 
-public class ServiceFactory {
-    private static Map<String, String>  serviceMap = new HashMap<>();
+public final class ServiceFactory {
 
-    static {
-        serviceMap.put("WztTestService", "kd.bos.ecos.service.impl.WztTestServiceImpl");
+    private ServiceFactory() {
     }
 
     public static Object getService(String serviceName) {
-        String className = serviceMap.get(serviceName);
+        String className = implementationOf(serviceName);
         if (className == null) {
-            throw new RuntimeException(String.format(ResManager.loadKDString("%s对应的服务实现未找到", "ServiceFactory_0", "bos-ecos-mservice"), serviceName));
+            throw new KDBizException(String.format(ResManager.loadKDString("%s对应的服务实现未找到", "ServiceFactory_0", "bos-ecos-mservice"), serviceName));
         }
-    return TypesContainer.getOrRegisterSingletonInstance(className);
+        return TypesContainer.getOrRegisterSingletonInstance(className);
+    }
+
+    // 使用 switch，避免 DCS 禁止的静态 Map（CVE-KD-0056）
+    private static String implementationOf(String serviceName) {
+        if ("WztTestService".equals(serviceName)) {
+            return "kd.bos.ecos.service.impl.WztTestServiceImpl";
+        }
+        return null;
     }
 }
 ```
@@ -78,7 +84,8 @@ public class TestService extends AbstractFormPlugin{
     "test",
     content);
 
-    System.out.println("调用结果-----"+result);
+    // 向用户展示结果；DCS 禁止使用 System.out/err（CVE-KD-0209-1）
+    this.getView().showMessage(result);
   }
  }
 

package/skills/cosmic-build/knowledge/cosmic/platform/scenes/infra/dist-lock/dist-lock-basic.md

@@ -52,13 +52,10 @@ DLock lock = DLock.create("fi/gl/N20180503-8808", "凭证N20180503-8808");
 // 一直等待直到获得锁
 lock.lock();
 try {
-	// 获取锁信息：
+	// DLock.getLockInfo(key) 查询单个锁，DLock.getAllLockInfo() 查询所有锁：
     // {key: fi/gl/N20180503-8808, desc: 凭证N20180503-8808, owner: 163388da76b0046, waitingLocks: 0, createTime: 2018-05-08 11:35:50.087}
-	System.out.println(DLock.getLockInfo("fi/gl/N20180503-8808"));
-
-    // 获取所有锁信息
-	// System.out.println(DLock.getAllLockInfo());
-	// ...
+	// 按需写入平台日志；DCS 禁止使用 System.out（CVE-KD-0209-1）
+	// 在此执行持锁期间的业务逻辑
 } finally {
 	lock.unlock();
 }

package/skills/cosmic-build/knowledge/cosmic/platform/scenes/infra/mq/mq-subscribe.md

@@ -11,6 +11,10 @@ topic: "infra/mq"
 
 # 场景：订阅MQ消息（消费者）
 
+> **DCS 部署：** 实现或引用 `kd.bos.mq.MessageConsumer` 违反 `CVE-KD-20260901-4`，
+> RabbitMQ / RocketMQ / Kafka 客户端也受限。交付 DCS 插件时使用已验证的平台调度或事件订阅，
+> 不复制本页消费者实现；本页仅供理解内部机制，见 [dcs-code-rules.md](../../../../../../references/dcs-code-rules.md)。
+
 ## 适用情况
 
 需要接收并处理 MQ 消息时，实现 `MessageConsumer` 接口，在 XML 配置文件中注册队列和消费者，消费完成后通过 `MessageAcker` 进行 ack/deny/discard 确认。
@@ -47,7 +51,7 @@ public class DemoConsumer implements MessageConsumer {
              try {
                   //业务处理
                   acker.ack(messageId);
-             } catch (Throwable e) {
+             } catch (Exception e) {
                   //记录异常日志
                   log.error("消费异常",e);
                   //是否废弃这条消息，根据具体场景判断

package/skills/cosmic-build/knowledge/cosmic/platform/scenes/infra/thread-pool/async-operation.md

@@ -51,7 +51,7 @@ import kd.bos.logging.Log;
 import kd.bos.logging.LogFactory;
 
 /**
- * 演示如何把操作切换为异步执行
+ * Demonstrates how to switch an operation to async execution
 */
 public class SwitchAsynSampleOpPlugin extends AbstractOperationServicePlugIn {
 
@@ -81,6 +81,8 @@ public class SwitchAsynSampleOpPlugin extends AbstractOperationServicePlugIn {
 
 		log.info("swithToAsyn");
 
+		// Notify the operation engine to switch the operation to async execution
+		// If the current scenario supports async execution, executing this statement will immediately interrupt the operation,
 		// 通知操作引擎，把操作切换为异步执行
 		// 如果当前场景支持异步执行操作，执行此语句后，会即时中断操作，由操作引擎另起一个线程，重新执行操作
 		// 如果当前场景，不支持异步执行操作，执行此语句时，不会有任何效果，请求被引擎自动忽略，代码继续往后执行
@@ -119,13 +121,13 @@ public class SwitchAsynSampleOpPlugin extends AbstractOperationServicePlugIn {
 	}
 
 	/**
-	 * 暂停执行：循环等待，每次500ms
+	 * Pause execution: loop wait, 500ms each time
 	 *
-	 * @param cycleTime 循环次数，最多10次
+	 * @param cycleTime Number of cycles, maximum 10
 	 */
 	private void sleep(int cycleTime) {
 
-		log.info("sleep: " + String.valueOf(cycleTime * 500) + "ms");
+		log.info("sleep: " + (cycleTime * 500) + "ms");
 
 		int count = 0;
 		if (cycleTime < 1 || cycleTime > 10) {
@@ -143,7 +145,8 @@ public class SwitchAsynSampleOpPlugin extends AbstractOperationServicePlugIn {
 				count++;
 			}
 		} catch (InterruptedException e) {
-			// donothing
+			// 保留线程中断信号，避免吞掉取消请求。
+			Thread.currentThread().interrupt();
 		}
 	}
 }
@@ -176,7 +179,8 @@ class SwitchAsynValidatorSample extends AbstractValidator {
 
 			}
 		} catch (InterruptedException e) {
-			// donothing
+			// 保留线程中断信号，避免吞掉取消请求。
+			Thread.currentThread().interrupt();
 		}
 	}
 }

package/skills/cosmic-build/knowledge/cosmic/platform/scenes/infra/thread-pool/big-task-async.md

@@ -100,7 +100,7 @@ import java.util.Map;
 import java.util.HashMap;
 
 /**
- * 执行业务逻辑
+ * Execute business logic
  * @param rc
  * @param params
  * @throws KDException
@@ -139,8 +139,10 @@ public void execute(RequestContext rc, Map<String, Object> params) throws KDExce
             Thread.sleep(500);
         }
     } catch (InterruptedException e) {
-        // 输出monitor日志
+        // 保留中断信号并结束任务，不能继续报告成功。
+        Thread.currentThread().interrupt();
         log.error(e);
+        return;
     }
 
     // 任务执行完毕，输出自定义结果，放在data中输出

package/skills/cosmic-build/knowledge/cosmic/platform/scenes/infra/thread-pool/schedule-task.md

@@ -53,11 +53,11 @@ import kd.bos.schedule.executor.AbstractTask;
 import java.util.Map;
 
 /**
- * 我的模拟任务
+ * My simulated task
  *
  */
 public class MyTask extends AbstractTask {
-	private static Log log = LogFactory.getLog("kd.bos.schedule.formplugin.tasktest.MyTask");
+	private static final Log log = LogFactory.getLog("kd.bos.schedule.formplugin.tasktest.MyTask");
 
 	@Override
 	public void execute(RequestContext context, Map<String, Object> params) throws KDException {
@@ -68,13 +68,14 @@ public class MyTask extends AbstractTask {
 			feedbackProgress(i);
 
 			//暂停100ms
+			// DCS 禁止循环内日志，改为循环外记录汇总（CVE-KD-0058-1）
 			try {
-				//do something
-				log.debug("i:" + i);
-
+				// 在此执行任务业务逻辑
 				Thread.sleep(100);
 			} catch (InterruptedException e) {
-				log.error(e.getMessage(),e);
+				// 恢复中断标志并结束任务（S2142）
+				Thread.currentThread().interrupt();
+				return;
 			}
 
 			if (i == 0){
@@ -85,9 +86,10 @@ public class MyTask extends AbstractTask {
 			//判断是否需要中止，也可以不支持
 			if (isStop()){
 				stop();
+				return;
 			}
 		}
-
+		log.info("MyTask finished");
 	}
 
 }

package/skills/cosmic-build/knowledge/cosmic/platform/scenes/operation/operation-interactive.md

@@ -66,15 +66,16 @@ import kd.bos.form.MessageBoxResult;
 
 public class ThrowInteractionExceptionOp extends AbstractOperationServicePlugIn {
 
-	private final static String Interaction_Sponore = "kd.bos.plugin.sample.bill.bizoperation.bizcase.ThrowInteractionExceptionOp";
-	private final static String KEY_IntegerField = "integerfield1";
+	private static final String INTERACTION_SPONSOR = "kd.bos.plugin.sample.bill.bizoperation.bizcase.ThrowInteractionExceptionOp";
+	private static final String KEY_INTEGER_FIELD = "integerfield1";
 
 	/**
-	 * 列表执行操作时，指定数据包中要包含的字段：本插件要用到整数1字段，数据包中必须要有这个字段值
+	 * When executing an operation from the list, specify the fields to include in the data package:
+	 * this plugin needs to use the integer1 field, so the data package must contain this field value
 	 */
 	@Override
 	public void onPreparePropertys(PreparePropertysEventArgs e) {
-		e.getFieldKeys().add(KEY_IntegerField);
+		e.getFieldKeys().add(KEY_INTEGER_FIELD);
 	}
 
 	@Override
@@ -83,7 +84,7 @@ public class ThrowInteractionExceptionOp extends AbstractOperationServicePlugIn
 		// 找出本批次数据中，最大的整数1字段值
 		int maxFieldValue = 0;
 		for (ExtendedDataEntity dataEntity : e.getValidExtDataEntities()) {
-			int fieldValue = (int)dataEntity.getValue(KEY_IntegerField);
+			int fieldValue = (int)dataEntity.getValue(KEY_INTEGER_FIELD);
 			if (maxFieldValue < fieldValue) {
 				maxFieldValue = fieldValue;
 			}
@@ -101,24 +102,20 @@ public class ThrowInteractionExceptionOp extends AbstractOperationServicePlugIn
 	}
 
 	/**
-	 * 显示交互提示，如需取消后续操作，返回false
+	 * Show interaction prompt; return false to cancel subsequent operations
 	 */
 	private boolean showInteractionMessage() {
 		// 判断是否确认后的回调
 		String confirmResultString = this.getOption().getVariableValue(OperateOptionConst.INTERACTIONCONFIRMRESULT, "");
 		InteractionConfirmResult confirmResult = InteractionConfirmResult.fromJsonString(confirmResultString);
 
+		// Check whether the interaction confirmation result set contains the result of this interaction;
+		// if it does, this is a post-interaction callback, directly judge the returned interaction result;
 		// 检查交互确认结果集合中，有没有包含本交互的结果，如果有，说明是交互后的回调处理，直接判断返回的交互结果，不能再显示交互，否则会死循环
-		if (confirmResult.getResults().containsKey(Interaction_Sponore)) {
-			MessageBoxResult result = MessageBoxResult.valueOf(confirmResult.getResults().get(Interaction_Sponore));
-			if (result == MessageBoxResult.Yes) {
-				// 用户已经确认，跳出本方法，继续执行后续操作
-				return true;
-			}
-			else {
-				// 用户否定了确认提示，跳出本方法，中止后续操作
-				return false;
-			}
+		if (confirmResult.getResults().containsKey(INTERACTION_SPONSOR)) {
+			MessageBoxResult result = MessageBoxResult.valueOf(confirmResult.getResults().get(INTERACTION_SPONSOR));
+			// 仅确认时继续后续操作，拒绝时返回 false。
+			return result == MessageBoxResult.Yes;
 		}
 
 		// 生成一条交互提示
@@ -132,11 +129,11 @@ public class ThrowInteractionExceptionOp extends AbstractOperationServicePlugIn
 		interactionContext.addOperateInfo(errorInfo);
 
 		// 抛出一个交互中断，退出当前操作执行代码
-		throw new KDInteractionException(Interaction_Sponore, interactionContext);
+		throw new KDInteractionException(INTERACTION_SPONSOR, interactionContext);
 	}
 
 	/**
-	 * 显示定制交互界面，如需取消后续操作，返回false
+	 * Show custom interaction UI; return false to cancel subsequent operations
 	 */
 	private boolean showInteractionForm(BeforeOperationArgs e, int maxFieldValue) {
 
@@ -144,10 +141,12 @@ public class ThrowInteractionExceptionOp extends AbstractOperationServicePlugIn
 		String confirmResultString = this.getOption().getVariableValue(OperateOptionConst.INTERACTIONCONFIRMRESULT, "");
 		InteractionConfirmResult confirmResult = InteractionConfirmResult.fromJsonString(confirmResultString);
 
+		// Check whether the interaction confirmation result set contains the result of this interaction;
+		// if it does, this is a post-interaction callback, directly judge the returned interaction result;
 		// 检查交互确认结果集合中，有没有包含本交互的结果，如果有，说明是交互后的回调处理，直接判断返回的交互结果，不能再显示交互，否则会死循环
-		if (confirmResult.getResults().containsKey(Interaction_Sponore)) {
+		if (confirmResult.getResults().containsKey(INTERACTION_SPONSOR)) {
 
-			String newFieldValue = confirmResult.getResults().get(Interaction_Sponore);
+			String newFieldValue = confirmResult.getResults().get(INTERACTION_SPONSOR);
 			if (StringUtils.isBlank(newFieldValue)) {
 				// 在交互界面，用户点击了取消按钮，不需要继续
 				return false;
@@ -155,9 +154,9 @@ public class ThrowInteractionExceptionOp extends AbstractOperationServicePlugIn
 			else {
 				for (ExtendedDataEntity dataEntity : e.getValidExtDataEntities()) {
 					// 对超过500的数据包，更改为用户指定的新整数值
-					int fieldValue = (int)dataEntity.getValue(KEY_IntegerField);
+					int fieldValue = (int)dataEntity.getValue(KEY_INTEGER_FIELD);
 					if (fieldValue >= 500) {
-						dataEntity.setValue(KEY_IntegerField, Integer.valueOf(newFieldValue));
+						dataEntity.setValue(KEY_INTEGER_FIELD, Integer.valueOf(newFieldValue));
 					}
 				}
 				// 用户已经确认，跳出本方法，继续执行操作
@@ -171,10 +170,10 @@ public class ThrowInteractionExceptionOp extends AbstractOperationServicePlugIn
 
 		// 指定显示的交互界面，以及界面显示参数
 		interactionContext.setCustShowFormId("demo_showinteger");
-		interactionContext.getCustShowParameter().put(KEY_IntegerField, String.valueOf(maxFieldValue));
+		interactionContext.getCustShowParameter().put(KEY_INTEGER_FIELD, String.valueOf(maxFieldValue));
 
 		// 抛出一个交互中断，退出当前操作执行代码
-		throw new KDInteractionException(Interaction_Sponore, interactionContext);
+		throw new KDInteractionException(INTERACTION_SPONSOR, interactionContext);
 	}
 }
 ```
@@ -190,24 +189,24 @@ import kd.bos.dataentity.utils.StringUtils;
 import kd.bos.form.control.Control;
 import kd.bos.form.plugin.AbstractFormPlugin;
 
-public class ThrowInteraction_ShowIntegerPlugin extends AbstractFormPlugin {
+public class ThrowInteractionShowIntegerPlugin extends AbstractFormPlugin {
 
-	private final static String KEY_OK = "btnok";
-	private final static String KEY_Cancel = "btncancel";
-	private final static String KEY_IntegerField = "integerfield1";
+	private static final String KEY_OK = "btnok";
+	private static final String KEY_CANCEL = "btncancel";
+	private static final String KEY_INTEGER_FIELD = "integerfield1";
 
 	@Override
 	public void registerListener(EventObject e) {
 		super.registerListener(e);
 
-		this.addClickListeners(KEY_OK, KEY_Cancel);
+		this.addClickListeners(KEY_OK, KEY_CANCEL);
 	}
 
 	@Override
 	public void afterCreateNewData(EventObject e) {
-		Object fieldValue = this.getView().getFormShowParameter().getCustomParam(KEY_IntegerField);
+		Object fieldValue = this.getView().getFormShowParameter().getCustomParam(KEY_INTEGER_FIELD);
 		if (fieldValue != null){
-			this.getModel().setValue(KEY_IntegerField, fieldValue);
+			this.getModel().setValue(KEY_INTEGER_FIELD, fieldValue);
 		}
 	}
 
@@ -216,10 +215,10 @@ public class ThrowInteraction_ShowIntegerPlugin extends AbstractFormPlugin {
 		super.click(evt);
 		Control source = (Control) evt.getSource();
 		if (StringUtils.equals(source.getKey(), KEY_OK)) {
-			this.getView().returnDataToParent(String.valueOf(this.getModel().getValue(KEY_IntegerField)));
+			this.getView().returnDataToParent(String.valueOf(this.getModel().getValue(KEY_INTEGER_FIELD)));
 			this.getView().close();
 		}
-		else if (StringUtils.equals(source.getKey(), KEY_Cancel)) {
+		else if (StringUtils.equals(source.getKey(), KEY_CANCEL)) {
 			this.getView().returnDataToParent(null);
 			this.getView().close();
 		}
@@ -228,7 +227,7 @@ public class ThrowInteraction_ShowIntegerPlugin extends AbstractFormPlugin {
 ```
 
 ## 注意事项
-- 交互标识（Interaction_Sponore）必须固定且唯一，足够长以避免和其他插件的交互重复
+- 交互标识（INTERACTION_SPONSOR）必须固定且唯一，足够长以避免和其他插件的交互重复
 - 在抛出交互异常前，必须先检查交互结果，判断是否是交互回调；如果是回调，不能再次抛出，否则会死循环
 - 默认交互模式（不指定自定义界面）：系统弹出标准确认框，结果为 Yes 或 No
 - 自定义交互界面：通过 `setCustShowFormId` 指定，通过 `getCustShowParameter().put` 传递参数