【情报二期】数据域服务 - 适配烽火服务，布/停控任务接口调整完成；更新配置文件

src/main/java/com/hhwy/qbeqsjy/common/Constants.java

@@ -201,10 +201,9 @@ public class Constants {
     /**
      * 定时任务违规的字符
      */
-    public static final String[] JOB_ERROR_STR = { "java.net.URL", "javax.naming.InitialContext", "org.yaml.snakeyaml",
-            "org.springframework", "org.apache", "com.ruoyi.common.utils.file", "com.ruoyi.common.config", "com.ruoyi.generator" };
-
-
+    public static final String[] JOB_ERROR_STR = { "java.net.URL", "javax.naming.InitialContext", "org.yaml.snakeyaml", "org.springframework", "org.apache", "com.ruoyi.common.utils.file", "com.ruoyi.common.config", "com.ruoyi.generator" };
+    public static final String CTRL_ING_MSG = "布控任务正在执行中";
+    public static final String STOP_CTRL_ING_MSG = "停控任务正在执行中";
     public static final String PARAMS_EMPTY_MSG = "请求参数为空";
     public static final String PARAMS_ILLEGAL_MSG = "请求参数非法";
     public static final String SERVER_ERROR_MSG = "服务端处理请求发生异常";

src/main/java/com/hhwy/qbeqsjy/controller/CtrlController.java

@@ -1,13 +1,15 @@
 package com.hhwy.qbeqsjy.controller;
 
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
 import com.hhwy.qbeqsjy.common.Constants;
 import com.hhwy.qbeqsjy.domain.AjaxResult;
 import com.hhwy.qbeqsjy.dto.CtrlDTO;
 import com.hhwy.qbeqsjy.service.CtrlService;
 import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Value;
-import org.springframework.validation.annotation.Validated;
 import org.springframework.web.bind.annotation.*;
 import java.util.List;
 import java.util.Map;
@@ -28,16 +30,33 @@ public class CtrlController {
      * 下发布控任务，不支持批量操作
      * @param ctrlDTO
      * @return
+     *
+     * 请求参数：
+     * {
+     *     "taskId":"59275350793392128",
+     *     "endCtrlTime":"2025-03-20 00:00:00",
+     *     "resourceIdList":["aaa","bbb","ccc"],
+     *     "areaIdList":["111","222"],
+     *     "clueList":[
+     *         {
+     *             "clue":"xxxxxxxxxxx",
+     *             "clueType":"D201005"
+     *         },
+     *         ......
+     *     ]
+     * }
      */
     @PostMapping("/ctrl")
-    public AjaxResult ctrl(@Validated @RequestBody CtrlDTO ctrlDTO){
+    public AjaxResult ctrl(@RequestBody CtrlDTO ctrlDTO){
+        String taskId = ctrlDTO.getTaskId();
+        List<Map<String, Object>> clueList = ctrlDTO.getClueList();
+        List<String> resourceIdList = ctrlDTO.getResourceIdList();
+        if(StringUtils.isBlank(taskId) || clueList == null || clueList.size() == 0 || resourceIdList == null || resourceIdList.size() == 0){
+            return AjaxResult.error(Constants.PARAMS_EMPTY_MSG);
+        }
         try {
-            List<Map<String, Object>> clueList = ctrlDTO.getClueList();
-            if(clueList == null || clueList.size() == 0){
-                return AjaxResult.error(Constants.PARAMS_EMPTY_MSG);
-            }
             ctrlService.processCtrl(ctrlDTO);
-            return AjaxResult.success();
+            return AjaxResult.success(Constants.CTRL_ING_MSG);
         }catch (Exception e){
             log.error("布控任务下发发生异常", e);
         }
@@ -47,19 +66,36 @@ public class CtrlController {
 
     /**
      * 停止布控任务，不支持批量操作
-     * @param ctrlDTO
+     * @param reqBody
      * @return
+     *
+     * 请求参数：
+     * {
+     *     "taskId":"59275350793392128",
+     *     "clueList":[
+     *         {
+     *             "clue":"13502082832",
+     *             "clueType":"D201005"
+     *         }
+     *     ]
+     * }
      */
-    /*@PostMapping("/stop")
-    public AjaxResult stop(@Validated @RequestBody CtrlDTO ctrlDTO){
+    @PostMapping("/stopCtrl")
+    public AjaxResult stopCtrl(@RequestBody JSONObject reqBody){
+        String taskId = reqBody.getString("taskId");
+        JSONArray clueList = reqBody.getJSONArray("clueList");
+        if(StringUtils.isBlank(taskId) || clueList == null || clueList.size() == 0){
+            return AjaxResult.error(Constants.PARAMS_EMPTY_MSG);
+        }
         try{
-            return ctrlService.doStopCtrl()
+            ctrlService.processStopCtrl(taskId, clueList);
+            return AjaxResult.success(Constants.STOP_CTRL_ING_MSG);
         } catch (Exception e){
             log.error("任务停控发生异常", e);
         }
         return AjaxResult.error(Constants.SERVER_ERROR_MSG);
 
-    }*/
+    }
 
 
 }

src/main/java/com/hhwy/qbeqsjy/dao/CtrlDao.java

@@ -20,7 +20,7 @@ public class CtrlDao {
      * @return
      */
     public boolean batchInsertCtrlErrorInfo(List<Object[]> ctrlErrorList){
-        String sql = "insert into t_ctrl_error_info (task_id, account, account_type, end_ctrl_time, resource_id_list, area_id_list, create_time) values (?, ?, ?, ?, ?, ?, ?)";
+        String sql = "insert into t_ctrl_error_info (task_id, clue, clue_type, end_ctrl_time, resource_id_list, area_id_list, create_time) values (?, ?, ?, ?, ?, ?, ?)";
         try {
             int[] batchUpdate = gaussDBJdbcTemplate.batchUpdate(sql, ctrlErrorList);
             return batchUpdate.length == ctrlErrorList.size();
@@ -31,5 +31,22 @@ public class CtrlDao {
     }
 
 
+    /**
+     * 批量插入停控失败线索数据
+     * @param stopCtrlErrorList
+     * @return
+     */
+    public boolean batchInsertStopCtrlErrorInfo(List<Object[]> stopCtrlErrorList){
+        String sql = "insert into t_stop_ctrl_error_info (task_id, clue, clue_type, create_time) values (?, ?, ?, ?)";
+        try {
+            int[] batchUpdate = gaussDBJdbcTemplate.batchUpdate(sql, stopCtrlErrorList);
+            return batchUpdate.length == stopCtrlErrorList.size();
+        } catch (Exception e){
+            log.error("【批量插入停控失败线索数据发生异常】 异常信息：", e);
+        }
+        return false;
+    }
+
+
 
 }

src/main/java/com/hhwy/qbeqsjy/dto/CtrlDTO.java

@@ -18,7 +18,6 @@ import java.util.Map;
 public class CtrlDTO {
 
     // 任务编号
-    @NotBlank(message = "taskId不能为空")
     private String taskId;
     // 开始布控时间
     private String startCtrlTime;

src/main/java/com/hhwy/qbeqsjy/kafka/service/DataProcessService.java

@@ -9,7 +9,6 @@ import org.apache.commons.lang3.StringUtils;
 import org.apache.kafka.clients.consumer.ConsumerRecord;
 import org.apache.kafka.clients.consumer.ConsumerRecords;
 import org.apache.kafka.clients.consumer.KafkaConsumer;
-import org.apache.kafka.clients.producer.KafkaProducer;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.context.ApplicationListener;
 import org.springframework.context.event.ContextRefreshedEvent;

src/main/java/com/hhwy/qbeqsjy/service/CtrlService.java

@@ -42,8 +42,10 @@ public class CtrlService {
     private String multiThreadEnabled;
     @Value("${thread.num}")
     private int threadNum;
-    @Value("${txt.output.path}")
-    private String txtOutputPath;
+    @Value("${ctrl.txt.output.path}")
+    private String ctrlTxtOutputPath;
+    @Value("${stop.ctrl.txt.output.path}")
+    private String stopCtrlTxtOutputPath;
     @Resource
     private CtrlDao ctrlDao;
     @Value("${uniCtrl.add.url}")
@@ -54,65 +56,185 @@ public class CtrlService {
     private String uniCtrlQueryUrl;
 
 
-    public void processCtrl(CtrlDTO ctrlDTO) throws IOException {
+    /**
+     * 处理布控任务
+     * @param ctrlDTO
+     */
+    public void processCtrl(CtrlDTO ctrlDTO) {
         String taskId = ctrlDTO.getTaskId();
         String endCtrlTime = ctrlDTO.getEndCtrlTime();
         List<Map<String, Object>> clueList = ctrlDTO.getClueList();
         List<String> resourceIdList = ctrlDTO.getResourceIdList();
         List<String> areaIdList = ctrlDTO.getAreaIdList();
-        // 默认单线程处理任务
+        // 默认只开启一个子线程处理任务
         if(!Constants.MULTI_THREAD_ENABLED_FLAG.equals(multiThreadEnabled)){
+            ExecutorService executorService = Executors.newFixedThreadPool(Constants.NUM_1);
+            executorService.execute(() -> {
+                Date createTime = new Date();
+                List<Object[]> ctrlErrorList = new ArrayList<>();
+                int ctrlNum = 0;
+                HttpClient httpClient = new HttpClient();
+                for (Map<String, Object> clueMap : clueList) {
+                    if(!clueMap.isEmpty()){
+                        // 重新组装前端传入的参数
+                        String clue = String.valueOf(clueMap.get("clue"));
+                        String clueType = String.valueOf(clueMap.get("clueType"));
+                        clueMap.put("taskId", taskId);
+                        clueMap.put("endCtrlTime", endCtrlTime);
+                        clueMap.put("resourceIdList", resourceIdList);
+                        clueMap.put("areaIdList", areaIdList);
+                        AjaxResult result = doCtrl(httpClient, clueMap);
+                        int code = (int) result.get("code");
+                        if(code == 500){
+                            // 记录布控失败的线索信息，等待当前任务布控操作执行结束后再批量入库，后续通过设置定时任务按照记录的布控失败线索信息继续实施布控
+                            // 存在操作延迟，但保证数据最终一致性
+                            Object[] errorData = new Object[]{taskId, clue, clueType, endCtrlTime, resourceIdList, areaIdList, createTime};
+                            ctrlErrorList.add(errorData);
+                        } else {
+                            JSONObject data = (JSONObject) result.get("data");
+                            if(data == null){
+                                String msg = (String) result.get("msg");
+                                log.info("任务ID：{}，线索值：{}，布控服务返回信息：{}", taskId, clue, msg);
+                            } else {
+                                String clueId = data.getString("clueId");
+                                log.info("任务ID：{}，线索值：{}，线索ID：{}", taskId, clue, clueId);
+                            }
+                        }
+                        ctrlNum++;
+                    }
+                    // 每布控5000条线索，当前线程睡眠30s，减轻【统一布控】服务端压力
+                    if(ctrlNum == Constants.NUM_5000){
+                        CommonUtil.threadSleep(Constants.NUM_30000);
+                        ctrlNum = 0;
+                    }
+                }
+                log.info("--- > 任务ID：{}，线索集合布控完成", taskId);
+                if(ctrlErrorList.size() > 0){
+                    log.info("--- > 任务ID：{}，线索集合布控失败的线索数量：{}，布控失败数据开始执行批量入库操作...", taskId, ctrlErrorList.size());
+                    boolean optFlag = ctrlDao.batchInsertCtrlErrorInfo(ctrlErrorList);
+                    if(optFlag){
+                        log.info("--- > 任务ID：{}，线索集合布控失败数据批量入库成功，数据量：{}", taskId, ctrlErrorList.size());
+                    } else {
+                        log.error("--- > 任务ID：{}，线索集合布控失败数据批量入库失败，现以.txt文件形式记录到服务器指定路径，后续可手动录入目标表", taskId);
+                        StringBuffer sbRow = new StringBuffer();
+                        BufferedWriter bw = null;
+                        try {
+                            bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(ctrlTxtOutputPath + taskId + "_" + TimeTool.getNowTimeStamp() + ".txt"), "UTF-8"));
+                        } catch (IOException e) {
+                            log.error("--- > 任务ID：{}，创建目标文件失败，异常信息：{}", taskId, e.getMessage());
+                            throw new RuntimeException(e);
+                        }
+                        // 字段信息：taskId, clue, clueType, endCtrlTime, resourceIdList, areaIdList, createTime
+                        int dataRows = 0;
+                        for (Object[] item : ctrlErrorList) {
+                            sbRow.append(item[0]);
+                            sbRow.append("\t");
+                            sbRow.append(item[1]);
+                            sbRow.append("\t");
+                            sbRow.append(item[2]);
+                            sbRow.append("\t");
+                            sbRow.append(item[3]);
+                            sbRow.append("\t");
+                            sbRow.append(item[4]);
+                            sbRow.append("\t");
+                            sbRow.append(item[5]);
+                            sbRow.append("\t");
+                            sbRow.append(item[6]);
+                            sbRow.append("\r\n");
+                            dataRows++;
+                        }
+                        try {
+                            bw.write(sbRow.toString());
+                            bw.flush();
+                        } catch (IOException e) {
+                            log.error("--- > 任务ID：{}，线索集合布控失败数据写入目标文件失败，异常信息：{}", taskId, e.getMessage());
+                            throw new RuntimeException(e);
+                        }
+                        log.info("--- > 任务ID：{}，线索集合布控失败数据已记录到目标文件，数据行数：{}", taskId, dataRows);
+                    }
+                }
+            });
+            executorService.shutdown();
+        } else {   // 开启多线程处理任务
+            int accountsPerThread = clueList.size() / threadNum;
+            ExecutorService executor = Executors.newFixedThreadPool(threadNum);
+            for (int i = 0; i < threadNum; i++) {
+                int startIndex = i * accountsPerThread;
+                int endIndex = (i == threadNum - 1) ? clueList.size() : (i + 1) * accountsPerThread;
+                // 根据调用方提交的任务对应线索集合和每一个线程需处理线索集合中的起、止索引号创建对应的布控任务类
+                Callable<List<Map<String, String>>> task = new CtrlTask(taskId,i + 1, endCtrlTime, clueList, startIndex, endIndex, resourceIdList, areaIdList);
+                // 提交任务
+                executor.submit(task);
+            }
+            executor.shutdown();
+        }
+    }
+
+
+    /**
+     * 处理停控任务
+     * @param taskId
+     * @param clueList
+     */
+    public void processStopCtrl(String taskId, JSONArray clueList) {
+        // 停控任务只开启一个子线程处理即可
+        ExecutorService executorService = Executors.newFixedThreadPool(Constants.NUM_1);
+        executorService.execute(() -> {
             Date createTime = new Date();
-            List<Object[]> ctrlErrorList = new ArrayList<>();
-            int ctrlNum = 0;
+            List<Object[]> stopCtrlErrorList = new ArrayList<>();
+            int stopCtrlNum = 0;
             HttpClient httpClient = new HttpClient();
-            for (Map<String, Object> clueMap : clueList) {
-                if(!clueMap.isEmpty()){
+            for (Object item : clueList) {
+                JSONObject clueObj = (JSONObject) item;
+                if(!clueObj.isEmpty()){
                     // 重新组装前端传入的参数
-                    String clue = String.valueOf(clueMap.get("clue"));
-                    String clueType = String.valueOf(clueMap.get("clueType"));
-                    clueMap.put("taskId", taskId);
-                    clueMap.put("endCtrlTime", endCtrlTime);
-                    clueMap.put("resourceIdList", resourceIdList);
-                    clueMap.put("areaIdList", areaIdList);
-                    AjaxResult result = doCtrl(httpClient, clueMap);
+                    String clue = String.valueOf(clueObj.get("clue"));
+                    String clueType = String.valueOf(clueObj.get("clueType"));
+                    clueObj.put("taskId", taskId);
+                    AjaxResult result = doStopCtrl(httpClient, clueObj);
                     int code = (int) result.get("code");
                     if(code == 500){
-                        // 记录布控失败的线索信息，等待当前任务布控操作执行结束后再批量入库，后续通过设置定时任务按照记录的布控失败线索信息继续实施布控
+                        // 记录停控失败的线索信息，等待当前任务停控操作执行结束后再批量入库，后续通过设置定时任务按照记录的停控失败线索信息继续实施停控
                         // 存在操作延迟，但保证数据最终一致性
-                        Object[] errorData = new Object[]{taskId, clue, clueType, endCtrlTime, resourceIdList, areaIdList, createTime};
-                        ctrlErrorList.add(errorData);
+                        Object[] errorData = new Object[]{taskId, clue, clueType, createTime};
+                        stopCtrlErrorList.add(errorData);
                     } else {
                         JSONObject data = (JSONObject) result.get("data");
                         if(data == null){
                             String msg = (String) result.get("msg");
-                            log.info("任务ID：{}，线索值：{}，布控服务返回信息：{}", taskId, clue, msg);
+                            log.info("任务ID：{}，线索值：{}，停控服务返回信息：{}", taskId, clue, msg);
                         } else {
                             String clueId = data.getString("clueId");
                             log.info("任务ID：{}，线索值：{}，线索ID：{}", taskId, clue, clueId);
                         }
                     }
-                    ctrlNum++;
+                    stopCtrlNum++;
                 }
-                // 每布控5000条线索，当前线程睡眠30s，减轻【统一布控】服务端压力
-                if(ctrlNum == Constants.NUM_5000){
+                // 每停控5000条线索，当前线程睡眠30s，减轻【统一布控】服务端压力
+                if(stopCtrlNum == Constants.NUM_5000){
                     CommonUtil.threadSleep(Constants.NUM_30000);
-                    ctrlNum = 0;
+                    stopCtrlNum = 0;
                 }
             }
-            log.info("--- > 任务ID：{}，线索集合布控完成", taskId);
-            if(ctrlErrorList.size() > 0){
-                log.info("--- > 任务ID：{}，线索集合布控失败的线索数量：{}，布控失败数据开始执行批量入库操作...", taskId, ctrlErrorList.size());
-                boolean optFlag = ctrlDao.batchInsertCtrlErrorInfo(ctrlErrorList);
+            log.info("--- > 任务ID：{}，线索集合停控完成", taskId);
+            if(stopCtrlErrorList.size() > 0){
+                log.info("--- > 任务ID：{}，线索集合停控失败的线索数量：{}，停控失败数据开始执行批量入库操作...", taskId, stopCtrlErrorList.size());
+                boolean optFlag = ctrlDao.batchInsertStopCtrlErrorInfo(stopCtrlErrorList);
                 if(optFlag){
-                    log.info("--- > 任务ID：{}，线索集合布控失败数据批量入库成功，数据量：{}", taskId, ctrlErrorList.size());
+                    log.info("--- > 任务ID：{}，线索集合停控失败数据批量入库成功，数据量：{}", taskId, stopCtrlErrorList.size());
                 } else {
-                    log.error("--- > 任务ID：{}，线索集合布控失败数据批量入库失败，现以.txt文件形式记录到服务器指定路径，后续可手动录入目标表", taskId);
+                    log.error("--- > 任务ID：{}，线索集合停控失败数据批量入库失败，现以.txt文件形式记录到服务器指定路径，后续可手动录入目标表", taskId);
                     StringBuffer sbRow = new StringBuffer();
-                    BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(txtOutputPath + taskId + "_" + TimeTool.getNowTimeStamp() + ".txt"), "UTF-8"));
-                    // 字段信息：taskId, clue, clueType, endCtrlTime, resourceIdList, areaIdList, createTime
+                    BufferedWriter bw = null;
+                    try {
+                        bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(stopCtrlTxtOutputPath + taskId + "_" + TimeTool.getNowTimeStamp() + ".txt"), "UTF-8"));
+                    } catch (IOException e) {
+                        log.error("--- > 任务ID：{}，创建目标文件失败，异常信息：{}", taskId, e.getMessage());
+                        throw new RuntimeException(e);
+                    }
+                    // 字段信息：taskId, clue, clueType, createTime
                     int dataRows = 0;
-                    for (Object[] item : ctrlErrorList) {
+                    for (Object[] item : stopCtrlErrorList) {
                         sbRow.append(item[0]);
                         sbRow.append("\t");
                         sbRow.append(item[1]);
@@ -120,33 +242,21 @@ public class CtrlService {
                         sbRow.append(item[2]);
                         sbRow.append("\t");
                         sbRow.append(item[3]);
-                        sbRow.append("\t");
-                        sbRow.append(item[4]);
-                        sbRow.append("\t");
-                        sbRow.append(item[5]);
-                        sbRow.append("\t");
-                        sbRow.append(item[6]);
                         sbRow.append("\r\n");
                         dataRows++;
                     }
-                    bw.write(sbRow.toString());
-                    bw.flush();
-                    log.info("--- > 任务ID：{}，线索集合布控失败数据已记录到目标文件，数据行数：{}", taskId, dataRows);
+                    try {
+                        bw.write(sbRow.toString());
+                        bw.flush();
+                    } catch (IOException e) {
+                        log.error("--- > 任务ID：{}，线索集合停控失败数据写入目标文件失败，异常信息：{}", taskId, e.getMessage());
+                        throw new RuntimeException(e);
+                    }
+                    log.info("--- > 任务ID：{}，线索集合停控失败数据已记录到目标文件，数据行数：{}", taskId, dataRows);
                 }
             }
-        } else {   // 开启多线程处理任务
-            int accountsPerThread = clueList.size() / threadNum;
-            ExecutorService executor = Executors.newFixedThreadPool(threadNum);
-            for (int i = 0; i < threadNum; i++) {
-                int startIndex = i * accountsPerThread;
-                int endIndex = (i == threadNum - 1) ? clueList.size() : (i + 1) * accountsPerThread;
-                // 根据调用方提交的任务对应线索集合和每一个线程需处理线索集合中的起、止索引号创建对应的布控任务类
-                Callable<List<Map<String, String>>> task = new CtrlTask(taskId,i + 1, endCtrlTime, clueList, startIndex, endIndex, resourceIdList, areaIdList);
-                // 提交任务
-                executor.submit(task);
-            }
-            executor.shutdown();
-        }
+        });
+        executorService.shutdown();
     }
 
 
@@ -308,22 +418,22 @@ public class CtrlService {
                 log.info("【线索停控状态: 成功】 clueId：{}", clueId);
                 Map<String, Object> resultMap = new HashMap<>();
                 resultMap.put("clueId", clueId);
-                return AjaxResult.success(resultMap);
+                return AjaxResult.success(resultMap);   // code：200
             }else if(Constants.STOP_CTRL_TODO.equals(status)){
                 log.info("【线索停控状态: 待停控】 clueId: {}", clueId);
-                return AjaxResult.warn(Constants.STOP_CTRL_TODO_MSG);
+                return AjaxResult.warn(Constants.STOP_CTRL_TODO_MSG);   // code：601
             }else {
                 log.info("【线索停控: 失败】 clueId: {}, 响应码：{}", clueId, status);
-                return AjaxResult.error(Constants.STOP_CTRL_FAIL_MSG);
+                return AjaxResult.error(Constants.STOP_CTRL_FAIL_MSG);   // code：500
             }
         } else if (Constants.STOP_CTRL_EXIST.equals(statusCode)){
             log.error("【线索已经停控，无需再次发起停控】 clueId：{}", clueIdOrigin);
-            return AjaxResult.success(message);
+            return AjaxResult.success(message);   // code：200
 
         } else {
             // 如果停控请求处理失败，则直接返回异常信息，无需查询线索停控状态
             log.error("【线索停控请求处理失败】 clueId：{}, 响应码：{}, 异常信息：{}", clueIdOrigin, statusCode, message);
-            return AjaxResult.error(message);
+            return AjaxResult.error(message);   // code：500
         }
     }
 
@@ -338,6 +448,7 @@ public class CtrlService {
         String taskId = (String) frontParamsMap.get("taskId");
         String clue = (String) frontParamsMap.get("clue");
         String clueId = fromAreaCode.concat("_").concat(taskId).concat("_").concat(clue);
+        // 构建调用烽火停控接口所需的请求参数
         JSONObject params = new JSONObject();
         params.put("clue_id", clueId);
         params.put("from_areacode", fromAreaCode);

src/main/resources/application.properties

@@ -41,14 +41,15 @@ uniCtrl.query.url=http://130.0.46.141:8090/lokiRest/unictrl/query/status
 # \u4E1A\u52A1topic
 topic.name=UNICTRL_DATA_QBEQSJYCTRL_V1.0
 
-# \u662F\u5426\u5F00\u542F\u591A\u7EBF\u7A0B - \u9ED8\u8BA4\u5355\u7EBF\u7A0B
+# \u662F\u5426\u5F00\u542F\u591A\u7EBF\u7A0B\u6267\u884C\u4EFB\u52A1 - false\uFF1A\u9ED8\u8BA4\u53EA\u5F00\u542F\u4E00\u4E2A\u5B50\u7EBF\u7A0B
 multi.thread.enabled=false
 
-# \u6267\u884C\u4EFB\u52A1\u7684\u7EBF\u7A0B\u6570\u91CF - \u5F53 multi.thread.enabled=true \u65F6\u8BE5\u914D\u7F6E\u751F\u6548\uFF0C\u5426\u5219\u65E0\u6548
+# \u6267\u884C\u4EFB\u52A1\u7684\u7EBF\u7A0B\u6570\u91CF - \u5F53[multi.thread.enabled=true]\u65F6\u8BE5\u914D\u7F6E\u751F\u6548\uFF0C\u5426\u5219\u65E0\u6548
 thread.num=5
 
-# \u4EE5.txt\u6587\u4EF6\u8BB0\u5F55\u5E03\u63A7\u5931\u8D25\u7EBF\u7D22\u6570\u636E\u8F93\u51FA\u8DEF\u5F84
-txt.output.path=/home/qbeqsjy/ctrl_error/
+# \u4EE5.txt\u6587\u4EF6\u8BB0\u5F55\u5E03/\u505C\u63A7\u5931\u8D25\u7EBF\u7D22\u6570\u636E\u8F93\u51FA\u8DEF\u5F84
+ctrl.txt.output.path=/home/qbeqsjy/ctrl_error/
+stop.ctrl.txt.output.path=/home/qbeqsjy/stop_ctrl_error/
 
 # \u5E03\u63A7\u8D44\u6E90\u5217\u8868
 # \u4E1A\u52A1ID\uFF1A\u70FD\u706B\u76D8\u53E4\u5E73\u53F0\u6570\u636E\u8D44\u6E90\u6807\u8BC6\u7B26