1

ruoyi-admin/src/main/java/com/ruoyi/web/controller/jarvis/TencentDocConfigController.java

@@ -96,9 +96,31 @@ public class TencentDocConfigController extends BaseController {
                 Integer currentProgress = redisCache.getCacheObject(syncProgressKey);
                 if (currentProgress != null) {
                     config.put("currentProgress", currentProgress);
-                    config.put("nextStartRow", currentProgress + 1);
+                    
-                    config.put("progressHint", String.format("已同步到第 %d 行，下次将从第 %d 行继续", 
+                    // 根据回溯机制计算下次起始行
-                        currentProgress, currentProgress + 1));
+                    int threshold = startRow + 100;
+                    int nextStartRow;
+                    String progressHint;
+                    
+                    if (currentProgress <= (startRow + 49)) {
+                        // 进度较小，下次从配置起始行开始
+                        nextStartRow = startRow;
+                        progressHint = String.format("已同步到第 %d 行，下次将从第 %d 行重新开始（进度较小）", 
+                            currentProgress, nextStartRow);
+                    } else if (currentProgress > threshold) {
+                        // 进度较大，下次回溯100行
+                        nextStartRow = currentProgress - 100;
+                        progressHint = String.format("已同步到第 %d 行，下次将从第 %d 行开始（回溯100行，防止遗漏）", 
+                            currentProgress, nextStartRow);
+                    } else {
+                        // 进度在阈值范围内，下次从配置起始行开始
+                        nextStartRow = startRow;
+                        progressHint = String.format("已同步到第 %d 行，下次将从第 %d 行重新开始", 
+                            currentProgress, nextStartRow);
+                    }
+                    
+                    config.put("nextStartRow", nextStartRow);
+                    config.put("progressHint", progressHint);
                 } else {
                     config.put("currentProgress", null);
                     config.put("nextStartRow", startRow);

ruoyi-admin/src/main/java/com/ruoyi/web/controller/jarvis/TencentDocController.java

@@ -42,6 +42,9 @@ public class TencentDocController extends BaseController {
     @Autowired
     private com.ruoyi.jarvis.service.ITencentDocTokenService tencentDocTokenService;
 
+    @Autowired
+    private com.ruoyi.jarvis.config.TencentDocConfig tencentDocConfig;
+
     /** Redis key前缀，用于存储上次处理的最大行数 */
     private static final String LAST_PROCESSED_ROW_KEY_PREFIX = "tendoc:last_row:";
 
@@ -530,19 +533,38 @@ public class TencentDocController extends BaseController {
                 }
             }
 
-            // 计算本次同步的起始行
+            // 计算本次同步的起始行（带回溯机制）
+            // 确保 configStartRow 不为 null
+            int effectiveStartRow = configStartRow != null ? configStartRow : (headerRow + 1);
+            
             int startRow;
             if (forceStartRow != null) {
                 // 强制指定行（手动指定）
                 startRow = forceStartRow;
                 log.info("使用强制指定的起始行: {}", startRow);
-            } else if (lastMaxRow != null && lastMaxRow >= configStartRow) {
+            } else if (lastMaxRow != null && lastMaxRow >= effectiveStartRow) {
-                // 有上次进度，且大于等于配置的起始行，则从上次进度+1继续（增量同步）
+                // 计算回溯阈值：配置起始行 + 100
-                startRow = lastMaxRow + 1;
+                int threshold = effectiveStartRow + 100;
-                log.info("继续上次进度，从第 {} 行开始（上次到 {} 行）", startRow, lastMaxRow);
+                
+                if (lastMaxRow <= (effectiveStartRow + 49)) {
+                    // 进度较小（一批数据内），重新从配置起始行开始
+                    startRow = effectiveStartRow;
+                    log.info("上次进度 {} 较小（≤{}），重新从第 {} 行开始", 
+                        lastMaxRow, effectiveStartRow + 49, startRow);
+                } else if (lastMaxRow > threshold) {
+                    // 进度较大（超过阈值），往回退100行，防止遗漏
+                    startRow = lastMaxRow - 100;
+                    log.info("上次进度 {} 较大（>{}），回溯100行，从第 {} 行开始（防止遗漏）", 
+                        lastMaxRow, threshold, startRow);
+                } else {
+                    // 进度在阈值范围内，重新从配置起始行开始
+                    startRow = effectiveStartRow;
+                    log.info("上次进度 {} 在阈值范围内（{}-{}），重新从第 {} 行开始", 
+                        lastMaxRow, effectiveStartRow + 50, threshold, startRow);
+                }
             } else {
                 // 首次同步或配置被重置，使用配置的起始行
-                startRow = configStartRow != null ? configStartRow : (headerRow + 1);
+                startRow = effectiveStartRow;
                 log.info("首次同步或配置已重置，从配置的起始行开始: {}", startRow);
             }
 
@@ -819,8 +841,24 @@ public class TencentDocController extends BaseController {
                 log.info("更新上次处理的最大行数 - 文件ID: {}, 工作表ID: {}, 最大行: {}", fileId, sheetId, currentMaxRow);
             }
 
-            // 计算下次同步的起始行
+            // 计算下次同步的起始行（根据回溯机制）
-            int nextStartRow = currentMaxRow + 1;
+            int threshold = effectiveStartRow + 100;
+            int nextStartRow;
+            String nextSyncHint;
+            
+            if (currentMaxRow <= (effectiveStartRow + 49)) {
+                // 进度较小，下次从配置起始行开始
+                nextStartRow = effectiveStartRow;
+                nextSyncHint = String.format("下次将从第 %d 行重新开始（进度较小）", nextStartRow);
+            } else if (currentMaxRow > threshold) {
+                // 进度较大，下次回溯100行
+                nextStartRow = currentMaxRow - 100;
+                nextSyncHint = String.format("下次将从第 %d 行开始（回溯100行，防止遗漏）", nextStartRow);
+            } else {
+                // 进度在阈值范围内，下次从配置起始行开始
+                nextStartRow = effectiveStartRow;
+                nextSyncHint = String.format("下次将从第 %d 行重新开始", nextStartRow);
+            }
             
             JSONObject result = new JSONObject();
             result.put("startRow", startRow);
@@ -839,11 +877,11 @@ public class TencentDocController extends BaseController {
                 "✓ 同步完成：成功填充 %d 条，跳过 %d 条，错误 %d 条\n" +
                 "  本次范围：第 %d-%d 行\n" +
                 "  当前进度：第 %d 行\n" +
-                "  下次将从第 %d 行继续（增量同步）",
+                "  %s",
                 filledCount, skippedCount, errorCount,
                 startRow, currentMaxRow,
                 currentMaxRow,
-                nextStartRow
+                nextSyncHint
             );
             result.put("message", message);