feat: 优化内存

wlzboy

2026-01-12 45d90d1e7ba86286e998d1ac4d2cba8e98cd059b

 ruoyi-system/src/main/java/com/ruoyi/system/service/impl/TaskStatusSyncServiceImpl.java

@@ -1,14 +1,14 @@
package com.ruoyi.system.service.impl;

import com.ruoyi.common.config.LegacySystemConfig;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.LongUtil;
import com.ruoyi.system.domain.DispatchOrd;
import com.ruoyi.system.domain.SysTask;
import com.ruoyi.system.domain.SysTaskEmergency;
import com.ruoyi.system.domain.enums.TaskStatus;
import com.ruoyi.system.mapper.SysTaskMapper;
import com.ruoyi.system.service.IDispatchOrdService;
import com.ruoyi.system.service.ISysTaskEmergencyService;
import com.ruoyi.system.service.ITaskStatusSyncService;
import com.ruoyi.system.service.*;
import com.ruoyi.system.utils.TaskStatusConverter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -35,6 +35,9 @@
    
    @Autowired
    private SysTaskMapper sysTaskMapper;

    @Autowired
    private ISysTaskService taskService;
    
    @Autowired
    private ISysTaskEmergencyService sysTaskEmergencyService;
@@ -49,7 +52,6 @@
     * @return 是否同步成功
     */
    @Override
    @Transactional
    public boolean syncTaskStatusFromLegacy(Long taskId) {
        if (!legacyConfig.isEnabled()) {
            log.info("旧系统同步已禁用，跳过状态同步，任务ID: {}", taskId);
@@ -98,7 +100,9 @@
            return false;
        }
    }
    

    @Autowired
    private IServiceOrderService serviceOrderService;
    /**
     * 批量同步已同步调度单的任务状态（从旧系统到新系统）
     * 使用分页查询，批量查询SQL Server数据库，减少网络请求次数
@@ -108,13 +112,13 @@
    @Override
    public int batchSyncTaskStatusFromLegacy() {
        if (!legacyConfig.isEnabled()) {
            log.info("旧系统同步已禁用");
//            log.info("旧系统同步已禁用");
            return 0;
        }
        
        try {
            int totalSuccessCount = 0;
            int pageSize = 10; // 每页200条
            int pageSize = 10; // 每页10条
            int offset = 0;
            
            while (true) {
@@ -122,87 +126,76 @@
                List<SysTaskEmergency> syncedTasks = sysTaskEmergencyService.selectSyncedTasksForStatusUpdate(offset, pageSize);
                
                if (syncedTasks == null || syncedTasks.isEmpty()) {
                    log.info("没有更多需要同步状态的任务，offset: {}", offset);
//                    log.info("没有更多需要同步状态的任务，offset: {}", offset);
                    break; // 没有更多数据，退出循环
                }
                
                log.info("开始同步状态第 {} 页，任务数量: {}", (offset / pageSize) + 1, syncedTasks.size());
//                log.info("开始同步状态第 {} 页，任务数量: {}", (offset / pageSize) + 1, syncedTasks.size());
                
                // 2. 提取调度单ID列表
                List<Long> dispatchOrdIDs = new ArrayList<>();

                Map<Long, SysTaskEmergency> dispatchIdToTaskMap = new HashMap<>();
                


                for (SysTaskEmergency emergency : syncedTasks) {
                    Long dispatchOrdId = emergency.getLegacyDispatchOrdId();
                    if (dispatchOrdId != null && dispatchOrdId > 0) {
                        dispatchOrdIDs.add(dispatchOrdId);
                        dispatchIdToTaskMap.put(dispatchOrdId, emergency);
                    if (LongUtil.isNotEmpty(emergency.getTaskId())) {

                        if(!dispatchIdToTaskMap.containsKey(dispatchOrdId)) {
                            dispatchIdToTaskMap.put(emergency.getTaskId(), emergency);
                        }
                    }
                    Long serviceOrdId = emergency.getLegacyServiceOrdId();
                    if(LongUtil.isNotEmpty(serviceOrdId)){
                        if(!dispatchIdToTaskMap.containsKey(emergency.getTaskId())) {
                            dispatchIdToTaskMap.put(emergency.getTaskId(), emergency);
                        }
                    }
                }
                
                if (dispatchOrdIDs.isEmpty()) {
                    log.warn("本页没有有效的调度单ID");
                if (dispatchIdToTaskMap.size()<=0) {
//                    log.warn("本页没有有效的调度单ID");
                    offset += pageSize;
                    continue;
                }
                
                // 3. 批量查询旧系统调度单状态（直接查询SQL Server数据库）
                List<DispatchOrd> dispatchOrds = dispatchOrdService.selectDispatchOrdStatesByIDs(dispatchOrdIDs);
                
                if (dispatchOrds == null || dispatchOrds.isEmpty()) {
                    log.warn("未查询到旧系统调度单状态");
                    offset += pageSize;
                    continue;
                }
                
                // 4. 构建调度单ID到状态的映射
                Map<Long, Integer> dispatchIdToStateMap = new HashMap<>();
                for (DispatchOrd dispatchOrd : dispatchOrds) {
                    try {
                        Long dispatchOrdId = Long.parseLong(dispatchOrd.getDispatchOrdID());
                        Integer dispatchOrdState = Integer.parseInt(dispatchOrd.getDispatchOrdState());
                        if (dispatchOrdState != null) {
                            dispatchIdToStateMap.put(dispatchOrdId, dispatchOrdState);
                dispatchIdToTaskMap.forEach((taskId, emergency) -> {
                    Long dispatchOrdId = emergency.getLegacyDispatchOrdId();
                    Long serviceOrdId = emergency.getLegacyServiceOrdId();
                    if(LongUtil.isNotEmpty(dispatchOrdId)){
                       Integer state =dispatchOrdService.selectDispatchOrdStateByID(dispatchOrdId);
                        syncTaskStatusWithLegacyState(taskId, state);
                    }
                    else if(LongUtil.isNotEmpty(serviceOrdId)){
                        try {
                            Integer serviceOrdState = serviceOrderService.selectServiceOrderStateById(serviceOrdId);
                            if (serviceOrdState == 4) {
                                //取消
                                Map<String, Object> cancelInfo = serviceOrderService.selectCancelInfoById(serviceOrdId);
                                String cancelReasonText = (String) cancelInfo.get("ServiceOrdCancelReasonTXT");
                                String cancelReason = (String) cancelInfo.get("ServiceOrdCancelReason");
                                taskService.saveCancel(taskId, cancelReason, cancelReasonText, DateUtils.getNowDate());
                            }
                        }catch (Exception ex){
                            log.error("查询旧系统状态失败，任务ID: {}, ServiceOrdID: {}", taskId, serviceOrdId);
                        }
                    } catch (NumberFormatException e) {
                        log.error("解析调度单ID失败: {}", dispatchOrd.getDispatchOrdID(), e);

//                        syncTaskStatusWithLegacyState(taskId, state);
                    }
                }
                
                // 5. 遍历任务，同步状态
                int pageSuccessCount = 0;
                for (Map.Entry<Long, SysTaskEmergency> entry : dispatchIdToTaskMap.entrySet()) {
                    Long dispatchOrdId = entry.getKey();
                    SysTaskEmergency emergency = entry.getValue();
                    
                    // 获取旧系统状态
                    Integer legacyStatus = dispatchIdToStateMap.get(dispatchOrdId);
                    if (legacyStatus == null) {
                        log.warn("未找到调度单状态，DispatchOrdID: {}", dispatchOrdId);
                        continue;
                    }
                    
                    // 同步单个任务状态
                    boolean result = syncTaskStatusWithLegacyState(emergency.getTaskId(), legacyStatus);
                    if (result) {
                        pageSuccessCount++;
                    }
                }
                
                totalSuccessCount += pageSuccessCount;
                log.info("状态第 {} 页同步完成，总数: {}, 成功: {}", 
                    (offset / pageSize) + 1, syncedTasks.size(), pageSuccessCount);
                
                });

//
                // 如果本页数据少于每页大小，说明已经是最后一页
                if (syncedTasks.size() < pageSize) {
                    log.info("已到达最后一页，状态同步结束");
//                    log.info("已到达最后一页，状态同步结束");
                    break;
                }
                
                offset += pageSize; // 下一页
            }
            
            log.info("批量同步任务状态完成，总成功数: {}", totalSuccessCount);
//            log.info("批量同步任务状态完成，总成功数: {}", totalSuccessCount);
            return totalSuccessCount;
            
        } catch (Exception e) {
@@ -219,7 +212,6 @@
     * @param legacyStatus 旧系统状态码
     * @return 是否成功
     */
    @Transactional
    private boolean syncTaskStatusWithLegacyState(Long taskId, Integer legacyStatus) {
        try {
            // 查询任务信息
@@ -281,6 +273,7 @@
                default:
                    break;
            }

            
            sysTaskMapper.updateSysTask(task);