6aspec 2.0.0-dev.10

package/.6aspec/rules/biz/scheduled_job_rule.md

@@ -0,0 +1,850 @@
+# 定时任务开发规范
+
+## 概述
+
+本规范定义了系统中定时任务的开发标准，包括 Java 类编写规范、XML 配置文件规范、命名规范等。
+
+---
+
+## 一、定时任务组成
+
+每个定时任务由 **两部分** 组成：
+
+### 1.1 Java 类（必需）
+
+**包路径规范**：
+```
+**.job.schedule
+```
+
+**开发规范**：
+- 实现定时任务执行逻辑
+- 包含任务调度的核心业务代码
+- 继承框架提供的 Job 基类或实现 Job 接口
+
+### 1.2 XML 配置文件（必需）
+
+**文件路径规范**：
+```
+{项目根目录}/data/task/{任务UUID}.xml
+```
+
+**说明**：
+- 每个定时任务对应一个独立的 XML 配置文件
+- 文件名为任务的唯一标识 UUID
+- 包含任务的调度配置（Cron 表达式、执行参数等）
+
+---
+
+## 二、Java 类开发规范
+
+### 2.1 包结构
+
+```
+com.mysoft.rental.{module}.job.schedule
+├── {TaskName}Job.java              # 定时任务类
+├── {业务分类}/                      # 按业务领域分类（可选）
+│   └── {TaskName}Job.java
+└── ...
+```
+
+### 2.2 类命名规范
+
+**格式**：`{任务描述}Job`
+
+| 场景 | 命名格式 | 示例 |
+|------|---------|------|
+| 数据同步任务 | `{DataName}SyncJob` | `RoomStatusSyncExceptionJob` |
+| 数据清理任务 | `{DataName}CleanJob` | `ExpiredDataCleanJob` |
+| 数据统计任务 | `{DataName}StatisticsJob` | `DailyReportStatisticsJob` |
+| 通知提醒任务 | `{EventName}NotificationJob` | `ContractExpiryNotificationJob` |
+| 数据校验任务 | `{DataName}ValidateJob` | `DataConsistencyValidateJob` |
+
+**命名规则**：
+- 使用清晰、语义化的名称
+- 体现任务的业务目的
+- 统一以 `Job` 结尾
+
+### 2.3 类结构模板
+
+```java
+package com.mysoft.rental.{module}.job.schedule;
+
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+/**
+ * {任务描述}定时任务
+ *
+ * @author {作者}
+ * @description {详细描述任务的作用}
+ * @date {创建日期}
+ */
+@Slf4j
+@Component
+public class XxxJob {
+    
+    @Autowired
+    private XxxService xxxService;
+    
+    /**
+     * 执行定时任务
+     * 
+     * @description {任务执行逻辑描述}
+     */
+    public void execute() {
+        log.info("开始执行【{}】定时任务", "任务名称");
+        
+        try {
+            // 1. 任务前置检查
+            if (!preCheck()) {
+                log.warn("【{}】定时任务前置检查未通过，跳过执行", "任务名称");
+                return;
+            }
+            
+            // 2. 执行核心业务逻辑
+            executeCore();
+            
+            // 3. 任务后置处理（可选）
+            postProcess();
+            
+            log.info("【{}】定时任务执行完成", "任务名称");
+            
+        } catch (Exception e) {
+            log.error("【{}】定时任务执行异常", "任务名称", e);
+            // 不抛出异常，避免影响下次调度
+        }
+    }
+    
+    /**
+     * 前置检查
+     */
+    private boolean preCheck() {
+        // 检查任务执行条件
+        return true;
+    }
+    
+    /**
+     * 核心业务逻辑
+     */
+    private void executeCore() {
+        // 业务处理逻辑
+        xxxService.handleTask();
+    }
+    
+    /**
+     * 后置处理
+     */
+    private void postProcess() {
+        // 清理资源、统计数据等
+    }
+}
+```
+
+### 2.4 关键要点
+
+#### 2.4.1 类注解
+
+**必需注解**：
+- `@Component` 或 `@Service` - 让 Spring 管理
+- `@Slf4j` - 日志记录
+
+```java
+@Slf4j
+@Component
+public class RoomStatusSyncExceptionJob {
+    // ...
+}
+```
+
+#### 2.4.2 执行方法
+
+**方法命名**：
+- 常用方法名：`execute()`、`run()`、`process()`
+- 使用无参方法，参数通过配置文件传递
+
+**方法特点**：
+- `public` 访问修饰符
+- `void` 返回类型（不返回值）
+- 无参数或少量参数
+
+```java
+public void execute() {
+    // 任务执行逻辑
+}
+```
+
+#### 2.4.3 异常处理
+
+**原则**：捕获所有异常，不向外抛出
+
+```java
+public void execute() {
+    try {
+        // 业务逻辑
+    } catch (BusinessLogicException e) {
+        log.error("业务处理异常：{}", e.getMessage(), e);
+    } catch (Exception e) {
+        log.error("系统异常", e);
+    }
+    // 不抛出异常，确保下次调度不受影响
+}
+```
+
+**原因**：
+- 避免异常导致任务从调度器中移除
+- 确保定时任务持续执行
+- 通过日志记录问题，便于排查
+
+#### 2.4.4 日志规范
+
+**必需日志**：
+- 任务开始：`log.info("开始执行【XXX】定时任务")`
+- 任务完成：`log.info("【XXX】定时任务执行完成")`
+- 异常情况：`log.error("【XXX】定时任务执行异常", e)`
+
+**建议日志**：
+- 关键节点：记录处理进度
+- 数据统计：记录处理数量
+
+```java
+public void execute() {
+    log.info("开始执行【房态同步异常处理】定时任务");
+    
+    try {
+        List<Data> dataList = xxxService.queryData();
+        log.info("【房态同步异常处理】查询到 {} 条待处理数据", dataList.size());
+        
+        int successCount = 0;
+        int failCount = 0;
+        
+        for (Data data : dataList) {
+            try {
+                xxxService.process(data);
+                successCount++;
+            } catch (Exception e) {
+                failCount++;
+                log.error("处理数据[{}]失败", data.getId(), e);
+            }
+        }
+        
+        log.info("【房态同步异常处理】定时任务执行完成，成功：{}，失败：{}", successCount, failCount);
+        
+    } catch (Exception e) {
+        log.error("【房态同步异常处理】定时任务执行异常", e);
+    }
+}
+```
+
+---
+
+## 三、XML 配置文件规范
+
+### 3.1 文件位置
+
+```
+{项目根目录}/data/task/{UUID}.xml
+```
+
+**示例**：
+```
+rental/data/task/0bc7924a-e6f9-a86e-267e-41adc86427f9.xml
+```
+
+### 3.2 UUID 生成规则
+
+- 使用标准 UUID 格式（8-4-4-4-12）
+- 每个任务唯一
+- 建议使用在线 UUID 生成器或编程生成
+
+**生成方式**：
+```java
+UUID uuid = UUID.randomUUID();
+System.out.println(uuid.toString());
+// 输出：0bc7924a-e6f9-a86e-267e-41adc86427f9
+```
+
+**重要提示**：
+- `TaskGuid` 的值必须与 XML 文件名保持一致
+- 例如：文件名为 `0bc7924a-e6f9-a86e-267e-41adc86427f9.xml`，则 `<TaskGuid>` 也应为 `0bc7924a-e6f9-a86e-267e-41adc86427f9`
+
+### 3.3 XML 文件模板
+
+```xml
+<?xml version="1.0" encoding="utf-8"?>
+<Task>
+    <!-- 任务唯一标识 -->
+    <TaskGuid>0bc7924a-e6f9-a86e-267e-41adc86427f9</TaskGuid>
+    
+    <!-- 任务名称 -->
+    <TaskName>房态数据同步异常定时任务</TaskName>
+    
+    <!-- 创建人（可选） -->
+    <CreateBy></CreateBy>
+    
+    <!-- 任务描述 -->
+    <Description>房态数据同步异常定时任务</Description>
+    
+    <!-- 任务级别：PRODUCT（生产环境） -->
+    <Level>PRODUCT</Level>
+    
+    <!-- 任务类型：ASYNC（异步） -->
+    <Type>ASYNC</Type>
+    
+    <!-- 是否启用：1=启用，0=禁用 -->
+    <Enable>1</Enable>
+    
+    <!-- 触发器配置（Cron表达式） -->
+    <Triggers>
+        <Trigger>0 1 0 * * ?</Trigger>  <!-- 每天凌晨1分执行 -->
+    </Triggers>
+    
+    <!-- 系统参数配置 -->
+    <SystemParameters>
+        <SystemParam Name="serviceType" Value="service"/>
+        <SystemParam Name="appCode" Value="8501"/>
+        <SystemParam Name="requestType" Value="POST"/>
+        <SystemParam Name="jobName" Value="RoomStatusSyncExceptionJob"/>  <!-- Java类名 -->
+    </SystemParameters>
+</Task>
+```
+
+### 3.4 配置项说明
+
+| 配置项 | 是否必需 | 说明 | 示例值 |
+|--------|---------|------|--------|
+| `TaskGuid` | 必需 | 任务唯一标识（UUID） | `0bc7924a-e6f9-a86e-267e-41adc86427f9` |
+| `TaskName` | 必需 | 任务名称（中文） | `房态数据同步异常定时任务` |
+| `CreateBy` | 可选 | 创建人 | 可为空 |
+| `Description` | 必需 | 任务描述 | `房态数据同步异常定时任务` |
+| `Level` | 必需 | 任务级别 | `PRODUCT`（生产环境） |
+| `Type` | 必需 | 任务类型 | `ASYNC`（异步） |
+| `Enable` | 必需 | 是否启用 | `1`（启用）/ `0`（禁用） |
+| `Triggers/Trigger` | 必需 | Cron 表达式 | `0 1 0 * * ?` |
+| `SystemParameters` | 必需 | 系统参数配置 | 见下表 |
+
+#### SystemParameters 配置项
+
+| 参数名 | 是否必需 | 说明 | 示例值 |
+|--------|---------|------|--------|
+| `serviceType` | 必需 | 服务类型 | `service` |
+| `appCode` | 必需 | 应用编码 | `8501` |
+| `requestType` | 必需 | 请求类型 | `POST` |
+| `jobName` | 必需 | Java 类名（**只写类名，不含包名**） | `RoomStatusSyncExceptionJob` |
+
+**重要说明**：
+- `jobName` 只需要填写 **类名**，不需要包含完整的包路径
+- ✅ 正确：`RoomStatusSyncExceptionJob`
+- ❌ 错误：`com.mysoft.rental.caretaker.job.schedule.RoomStatusSyncExceptionJob`
+- `appCode` 通常固定为 `8501`，不同系统可能不同
+
+### 3.5 Cron 表达式
+
+**格式**：`秒 分 时 日 月 周 [年]`
+
+**常用示例**：
+
+| 表达式 | 说明 |
+|--------|------|
+| `0 0/10 * * * ?` | 每 10 分钟执行一次 |
+| `0 0 0 * * ?` | 每天凌晨 0 点执行 |
+| `0 0 2 * * ?` | 每天凌晨 2 点执行 |
+| `0 0 0/1 * * ?` | 每小时整点执行 |
+| `0 0 12 * * ?` | 每天中午 12 点执行 |
+| `0 0 0 1 * ?` | 每月 1 号凌晨执行 |
+| `0 0 0 ? * MON` | 每周一凌晨执行 |
+| `0 0 0 1 1 ?` | 每年 1 月 1 日凌晨执行 |
+
+**Cron 表达式工具**：
+- 在线生成器：https://cron.qqe2.com/
+- 在线验证器：https://crontab.guru/
+
+---
+
+## 四、开发流程
+
+### 4.1 创建定时任务的步骤
+
+**步骤 1：编写 Java 类**
+```java
+@Slf4j
+@Component
+public class DataSyncJob {
+    
+    @Autowired
+    private DataSyncService dataSyncService;
+    
+    public void execute() {
+        log.info("开始执行【数据同步】定时任务");
+        try {
+            dataSyncService.sync();
+            log.info("【数据同步】定时任务执行完成");
+        } catch (Exception e) {
+            log.error("【数据同步】定时任务执行异常", e);
+        }
+    }
+}
+```
+
+**步骤 2：生成 UUID**
+```java
+String uuid = UUID.randomUUID().toString();
+// 0bc7924a-e6f9-a86e-267e-41adc86427f9
+```
+
+**步骤 3：创建 XML 配置文件**
+- 文件路径：`data/task/0bc7924a-e6f9-a86e-267e-41adc86427f9.xml`
+- 填写配置信息（参考模板）
+- 关键配置：
+  - `TaskGuid`：与文件名保持一致
+  - `TaskName`：任务中文名称
+  - `Enable`：设置为 `1`（启用）
+  - `Trigger`：Cron 表达式
+  - `jobName`：Java 类名（只写类名，不含包名）
+
+**步骤 4：配置 Cron 表达式**
+- 根据业务需求设置执行频率
+- 使用在线工具生成和验证
+
+**步骤 5：测试验证**
+- 本地测试任务执行逻辑
+- 验证 Cron 表达式是否符合预期
+- 检查日志输出是否完整
+
+**步骤 6：部署上线**
+- 提交代码和 XML 配置文件
+- 服务重启后自动加载任务
+- 监控任务执行情况
+
+### 4.2 文件对应关系
+
+```
+Java 类
+├── 类名：RoomStatusSyncExceptionJob
+├── 包路径：com.mysoft.rental.caretaker.job.schedule
+└── 文件：RoomStatusSyncExceptionJob.java
+
+        ↓ 对应
+
+XML 配置
+├── 文件名：0bc7924a-e6f9-a86e-267e-41adc86427f9.xml
+├── 路径：data/task/0bc7924a-e6f9-a86e-267e-41adc86427f9.xml
+├── <TaskGuid>：0bc7924a-e6f9-a86e-267e-41adc86427f9
+├── <TaskName>：房态数据同步异常定时任务
+└── <SystemParam Name="jobName">：RoomStatusSyncExceptionJob（只写类名）
+```
+
+**关键对应关系**：
+1. XML **文件名** = `<TaskGuid>` 的值
+2. `<SystemParam Name="jobName">` = Java **类名**（不含包名）
+3. 一个定时任务 = 1 个 Java 类 + 1 个 XML 配置文件
+
+### 4.3 完整示例
+
+假设要创建一个"每天凌晨清理过期数据"的定时任务：
+
+**第一步：编写 Java 类**
+
+文件：`com.mysoft.rental.caretaker.job.schedule.ExpiredDataCleanJob.java`
+
+```java
+package com.mysoft.rental.caretaker.job.schedule;
+
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+/**
+ * 过期数据清理定时任务
+ *
+ * @author yanghui
+ * @description 每天凌晨清理超过30天的过期数据
+ * @date 2026-01-11
+ */
+@Slf4j
+@Component
+public class ExpiredDataCleanJob {
+    
+    @Autowired
+    private DataCleanService dataCleanService;
+    
+    public void execute() {
+        log.info("开始执行【过期数据清理】定时任务");
+        
+        try {
+            int count = dataCleanService.cleanExpiredData(30);
+            log.info("【过期数据清理】定时任务执行完成，清理了 {} 条数据", count);
+        } catch (Exception e) {
+            log.error("【过期数据清理】定时任务执行异常", e);
+        }
+    }
+}
+```
+
+**第二步：生成 UUID**
+
+```java
+UUID.randomUUID().toString()
+// 假设生成：1a2b3c4d-5e6f-7a8b-9c0d-1e2f3a4b5c6d
+```
+
+**第三步：创建 XML 配置**
+
+文件：`data/task/1a2b3c4d-5e6f-7a8b-9c0d-1e2f3a4b5c6d.xml`
+
+```xml
+<?xml version="1.0" encoding="utf-8"?>
+<Task>
+    <TaskGuid>1a2b3c4d-5e6f-7a8b-9c0d-1e2f3a4b5c6d</TaskGuid>
+    <TaskName>过期数据清理定时任务</TaskName>
+    <CreateBy>yanghui</CreateBy>
+    <Description>每天凌晨清理超过30天的过期数据</Description>
+    <Level>PRODUCT</Level>
+    <Type>ASYNC</Type>
+    <Enable>1</Enable>
+    <Triggers>
+        <Trigger>0 0 2 * * ?</Trigger>  <!-- 每天凌晨2点执行 -->
+    </Triggers>
+    <SystemParameters>
+        <SystemParam Name="serviceType" Value="service"/>
+        <SystemParam Name="appCode" Value="8501"/>
+        <SystemParam Name="requestType" Value="POST"/>
+        <SystemParam Name="jobName" Value="ExpiredDataCleanJob"/>
+    </SystemParameters>
+</Task>
+```
+
+**完成！**
+- Java 类名：`ExpiredDataCleanJob`
+- XML 文件名：`1a2b3c4d-5e6f-7a8b-9c0d-1e2f3a4b5c6d.xml`
+- TaskGuid：`1a2b3c4d-5e6f-7a8b-9c0d-1e2f3a4b5c6d`
+- jobName：`ExpiredDataCleanJob`（只写类名）
+- 执行时间：每天凌晨 2 点
+
+---
+
+## 五、最佳实践
+
+### 5.1 任务执行时间选择
+
+**原则**：避开业务高峰期
+
+| 任务类型 | 推荐执行时间 | Cron 示例 |
+|---------|-------------|----------|
+| 数据统计任务 | 凌晨 2-5 点 | `0 0 2 * * ?` |
+| 数据同步任务 | 每小时或每 10 分钟 | `0 0/10 * * * ?` |
+| 数据清理任务 | 凌晨 3 点 | `0 0 3 * * ?` |
+| 报表生成任务 | 凌晨 1 点 | `0 0 1 * * ?` |
+| 实时监控任务 | 每 5 分钟 | `0 0/5 * * * ?` |
+
+### 5.2 批量处理
+
+**问题**：大量数据处理可能导致任务超时或内存溢出
+
+**解决方案**：分批处理
+
+```java
+public void execute() {
+    log.info("开始执行【数据处理】定时任务");
+    
+    try {
+        int batchSize = 100;  // 每批处理数量
+        int offset = 0;
+        int totalCount = 0;
+        
+        while (true) {
+            // 分页查询数据
+            List<Data> dataList = xxxService.queryDataByPage(offset, batchSize);
+            if (CollectionUtils.isEmpty(dataList)) {
+                break;  // 没有数据了，退出循环
+            }
+            
+            // 批量处理
+            for (Data data : dataList) {
+                try {
+                    xxxService.process(data);
+                    totalCount++;
+                } catch (Exception e) {
+                    log.error("处理数据[{}]失败", data.getId(), e);
+                }
+            }
+            
+            offset += batchSize;
+            
+            // 避免长时间占用，适当休眠
+            Thread.sleep(100);
+        }
+        
+        log.info("【数据处理】定时任务执行完成，共处理 {} 条数据", totalCount);
+        
+    } catch (Exception e) {
+        log.error("【数据处理】定时任务执行异常", e);
+    }
+}
+```
+
+### 5.3 幂等性保证
+
+**问题**：任务重复执行可能导致数据重复处理
+
+**解决方案**：
+
+**方式一：状态标识**
+```java
+public void execute() {
+    // 查询待处理数据（status = 'PENDING'）
+    List<Data> dataList = xxxService.queryPendingData();
+    
+    for (Data data : dataList) {
+        try {
+            // 更新状态为处理中
+            data.setStatus("PROCESSING");
+            xxxService.update(data);
+            
+            // 业务处理
+            xxxService.process(data);
+            
+            // 更新状态为已完成
+            data.setStatus("COMPLETED");
+            xxxService.update(data);
+            
+        } catch (Exception e) {
+            // 更新状态为失败
+            data.setStatus("FAILED");
+            xxxService.update(data);
+            log.error("处理失败", e);
+        }
+    }
+}
+```
+
+**方式二：分布式锁**
+```java
+@Autowired
+private BaseDistributedLockFactory lockFactory;
+
+public void execute() {
+    BaseDistributedLock lock = lockFactory.build("data-sync-job");
+    
+    try {
+        // 尝试获取锁，避免重复执行
+        if (lock.tryLock(1, TimeUnit.SECONDS)) {
+            // 执行任务
+            executeCore();
+        } else {
+            log.warn("【数据同步】定时任务正在执行中，跳过本次调度");
+        }
+    } finally {
+        if (lock.isLocked() && lock.isHeldByCurrentThread()) {
+            lock.unlock();
+        }
+    }
+}
+```
+
+### 5.4 超时控制
+
+**问题**：任务执行时间过长可能影响下次调度
+
+**解决方案**：
+
+```java
+public void execute() {
+    log.info("开始执行【数据处理】定时任务");
+    
+    long startTime = System.currentTimeMillis();
+    long timeout = 30 * 60 * 1000;  // 30分钟超时
+    
+    try {
+        List<Data> dataList = xxxService.queryData();
+        
+        for (Data data : dataList) {
+            // 检查是否超时
+            if (System.currentTimeMillis() - startTime > timeout) {
+                log.warn("【数据处理】定时任务执行超时，剩余数据将在下次执行");
+                break;
+            }
+            
+            try {
+                xxxService.process(data);
+            } catch (Exception e) {
+                log.error("处理数据[{}]失败", data.getId(), e);
+            }
+        }
+        
+        log.info("【数据处理】定时任务执行完成");
+        
+    } catch (Exception e) {
+        log.error("【数据处理】定时任务执行异常", e);
+    }
+}
+```
+
+### 5.5 任务监控
+
+**建议**：记录任务执行统计信息
+
+```java
+public void execute() {
+    log.info("开始执行【数据处理】定时任务");
+    
+    long startTime = System.currentTimeMillis();
+    int successCount = 0;
+    int failCount = 0;
+    
+    try {
+        List<Data> dataList = xxxService.queryData();
+        log.info("查询到 {} 条待处理数据", dataList.size());
+        
+        for (Data data : dataList) {
+            try {
+                xxxService.process(data);
+                successCount++;
+            } catch (Exception e) {
+                failCount++;
+                log.error("处理数据[{}]失败", data.getId(), e);
+            }
+        }
+        
+        long duration = System.currentTimeMillis() - startTime;
+        log.info("【数据处理】定时任务执行完成，耗时：{}ms，成功：{}，失败：{}", 
+                 duration, successCount, failCount);
+        
+        // 可选：将统计信息记录到数据库
+        xxxService.recordJobStatistics(successCount, failCount, duration);
+        
+    } catch (Exception e) {
+        log.error("【数据处理】定时任务执行异常", e);
+    }
+}
+```
+
+---
+
+## 六、检查清单
+
+### 6.1 Java 类检查
+
+在提交代码前，请确认：
+
+- [ ] 类名符合命名规范（以 Job 结尾）
+- [ ] 包路径正确（`**.job.schedule`）
+- [ ] 添加了 `@Component` 和 `@Slf4j` 注解
+- [ ] 执行方法为 `public void`
+- [ ] 添加了完整的异常处理（捕获所有异常）
+- [ ] 添加了任务开始和结束的日志
+- [ ] 添加了 JavaDoc 注释（类和方法）
+- [ ] 考虑了批量处理和超时控制
+- [ ] 考虑了幂等性问题
+
+### 6.2 XML 配置检查
+
+在提交配置前，请确认：
+
+- [ ] XML 文件位于 `data/task/` 目录
+- [ ] `TaskGuid` 格式正确且唯一
+- [ ] `TaskName` 和 `Description` 准确描述任务
+- [ ] `Level` 设置为 `PRODUCT`
+- [ ] `Type` 设置为 `ASYNC`
+- [ ] `Enable` 设置正确（1=启用，0=禁用）
+- [ ] `Trigger` 中的 Cron 表达式经过验证
+- [ ] `SystemParameters` 中的 `jobName` 为正确的 Java 类名（不含包名）
+- [ ] `appCode` 设置正确（通常为 `8501`）
+- [ ] XML 格式正确，能够被解析
+
+---
+
+## 七、常见问题
+
+### Q1: 定时任务执行失败会影响下次调度吗？
+- **不会**，只要不抛出异常。
+- 在 `execute()` 方法中捕获所有异常，确保方法正常返回。
+- 失败通过日志记录，便于问题排查。
+
+### Q2: 如何临时禁用定时任务？
+- 修改 XML 配置文件中的 `<Enable>` 为 `0`（禁用）。
+- 重启服务后生效。
+- 无需修改 Java 代码。
+
+### Q3: 如何调整定时任务的执行频率？
+- 修改 XML 配置文件中 `<Triggers>` 里的 `<Trigger>` 表达式。
+- 重启服务后生效。
+- 建议使用在线工具验证 Cron 表达式。
+
+### Q4: 定时任务的执行时间选择有什么建议？
+- **避开业务高峰期**（如工作日 9:00-18:00）
+- **数据统计/清理任务**：建议凌晨 2-5 点执行
+- **实时监控任务**：根据业务需求设置短周期（如每 5 分钟）
+- **批量处理任务**：预留足够的执行时间，避免与下次调度冲突
+
+### Q5: 如何处理大量数据？
+- 使用**分批处理**，每批处理固定数量（如 100 条）
+- 添加**超时控制**，避免单次执行时间过长
+- 使用**状态标识**，记录处理进度，支持断点续传
+- 适当添加 `Thread.sleep()`，避免长时间占用资源
+
+### Q6: 定时任务需要单元测试吗？
+- **建议编写单元测试**
+- 测试核心业务逻辑，而非调度逻辑
+- 可以直接调用 `execute()` 方法进行测试
+
+```java
+@SpringBootTest
+public class DataSyncJobTest {
+    
+    @Autowired
+    private DataSyncJob dataSyncJob;
+    
+    @Test
+    public void testExecute() {
+        // 准备测试数据
+        // ...
+        
+        // 执行任务
+        dataSyncJob.execute();
+        
+        // 验证结果
+        // ...
+    }
+}
+```
+
+### Q7: XML 配置文件可以动态修改吗？
+- **可以**，修改后重启服务生效。
+- 有些系统支持热加载，无需重启。
+- 建议通过配置管理平台统一管理。
+
+### Q8: Level 和 Type 应该填什么值？
+- **Level**：固定填写 `PRODUCT`（生产环境级别）
+- **Type**：固定填写 `ASYNC`（异步执行）
+- 这两个配置通常不需要修改
+
+### Q9: jobName 为什么只写类名不写包名？
+- 这是框架的约定，系统会自动扫描所有 `**.job.schedule` 包下的类
+- 通过类名就能唯一定位到具体的 Job 类
+- 避免配置过长，提高可读性
+
+### Q10: 一个 XML 文件可以配置多个触发器吗？
+- 理论上 `<Triggers>` 节点下可以配置多个 `<Trigger>`
+- 建议每个任务只配置一个触发器，保持简洁
+- 如需不同频率，可以创建多个任务
+
+---
+
+## 八、相关文档
+
+- Cron 表达式详解
+- Quartz 调度器使用指南
+- 分布式锁使用规范
+
+---
+
+**文档版本**：v1.1  
+**最后更新**：2026-01-11  
+**更新说明**：
+- v1.1: 修正 XML 配置文件模板，使用实际的配置结构（Task/TaskGuid/SystemParameters 等）
+- v1.0: 初始版本
+
+**维护人**：开发团队
+