feat: 移除不必要的日志

wlzboy

2026-01-24 b2bd9fb71ee17d0ec73429f03dc87c87a0a38325

feat: 移除不必要的日志

 ruoyi-admin/src/main/resources/logback.xml

@@ -7,13 +7,17 @@
    <!-- 单个日志文件最大大小 -->
    <property name="log.maxFileSize" value="100MB" />
    <!-- 日志文件总大小上限 -->
    <property name="log.totalSizeCap" value="10GB" />
    <property name="log.totalSizeCap" value="5GB" />

    <!-- 控制台输出 -->
    <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>${log.pattern}</pattern>
        </encoder>
        <!-- 过滤器：只输出INFO及以上级别到控制台，不显示DEBUG日志 -->
        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
            <level>INFO</level>
        </filter>
    </appender>
    
    <!-- 系统日志输出 -->
@@ -128,6 +132,11 @@
        <!-- MyBatis日志控制 -->
        <logger name="org.mybatis" level="error" />
        <logger name="org.apache.ibatis" level="error" />
        <!-- 禁止输出数据库SQL执行日志 -->
        <logger name="com.ruoyi.system.mapper" level="error" />
        <logger name="java.sql" level="error" />
        <logger name="jdbc.sqltiming" level="error" />
        <logger name="jdbc.resultsettable" level="error" />
        <!-- HTTP客户端日志控制 -->
        <logger name="org.apache.http" level="error" />
        
@@ -149,11 +158,11 @@
    </springProfile>
    
    <!-- 默认根日志器配置（如果没有指定profile） -->
    <root level="info">
    <!-- <root level="info">
        <appender-ref ref="console" />
        <appender-ref ref="file_info" />
        <appender-ref ref="file_error" />
    </root>
    </root> -->
    
    <!--系统用户操作日志-->
    <logger name="sys-user" level="info">

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

@@ -76,7 +76,7 @@
     */
    @Override
    public int syncLegacyTransferOrders(int daysAgo) {
        log.info("开始同步{}天前的旧系统转运单数据", daysAgo);
//        log.info("开始同步{}天前的旧系统转运单数据", daysAgo);
        
        try {
            // 参数验证
@@ -98,7 +98,7 @@
                return 0;
            }
            
            log.info("查询到{}条转运单数据，开始同步...", transferOrders.size());
//            log.info("查询到{}条转运单数据，开始同步...", transferOrders.size());
            
            int successCount = 0;
            int totalCount = transferOrders.size();
@@ -116,12 +116,12 @@
                        continue;
                    }
                    
                    log.debug("正在处理第{}/{}条转运单: ServiceOrdID={}, DispatchOrdID={}", 
                             processedCount, totalCount, serviceOrdID, dispatchOrdID);
//                    log.debug("正在处理第{}/{}条转运单: ServiceOrdID={}, DispatchOrdID={}",
//                             processedCount, totalCount, serviceOrdID, dispatchOrdID);
                    
                    // 检查是否已同步
                    if (isTransferOrderSynced(serviceOrdID, dispatchOrdID)) {
                        log.debug("转运单已同步，跳过: ServiceOrdID={}, DispatchOrdID={}", serviceOrdID, dispatchOrdID);
//                        log.debug("转运单已同步，跳过: ServiceOrdID={}, DispatchOrdID={}", serviceOrdID, dispatchOrdID);
                        //进行更新操作
                        updateTransferOrder(serviceOrdID, dispatchOrdID, order);
                        continue;
@@ -146,7 +146,7 @@
                }
            }
            
            log.info("同步完成，共处理{}条转运单，成功同步{}条转运单数据", totalCount, successCount);
//            log.info("同步完成，共处理{}条转运单，成功同步{}条转运单数据", totalCount, successCount);
            return successCount;
            
        } catch (Exception e) {

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

@@ -164,7 +164,7 @@
            // 2. 检查是否已同步过
            SysTaskPayment existPayment = sysTaskPaymentMapper.selectByPid(paidMoney.getId());
            if (existPayment != null) {
                log.info("旧系统支付记录已同步，paidMoneyId: {}, paymentId: {}", paidMoney.getId(), existPayment.getId());
//                log.info("旧系统支付记录已同步，paidMoneyId: {}, paymentId: {}", paidMoney.getId(), existPayment.getId());
                return true;
            }
            

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

@@ -224,23 +224,23 @@
            // 转换为新系统状态
            TaskStatus newStatus = TaskStatusConverter.convertFromLegacyStatus(legacyStatus);
            if (newStatus == null) {
                log.debug("旧系统状态码 > 10 或无法转换，跳过同步，任务ID: {}, 状态码: {} ({})",
                    taskId, legacyStatus, TaskStatusConverter.getLegacyStatusDescription(legacyStatus));
//                log.debug("旧系统状态码 > 10 或无法转换，跳过同步，任务ID: {}, 状态码: {} ({})",
//                    taskId, legacyStatus, TaskStatusConverter.getLegacyStatusDescription(legacyStatus));
                return false;
            }
            
            // 检查状态是否变化
            if (newStatus.getCode().equals(task.getTaskStatus())) {
                log.debug("变化，任务ID: {}, 当前状态: {}", taskId, newStatus.getInfo());
                // log.debug("变化，任务ID: {}, 当前状态: {}", taskId, newStatus.getInfo());
                return true;
            }
            
            // 比较新旧系统状态的优先级，防止状态倒退
            TaskStatus currentStatus = TaskStatus.getByCode(task.getTaskStatus());
            if (currentStatus != null && !shouldSyncStatus(currentStatus, newStatus, legacyStatus)) {
                log.info("【旧系统更新到新系统】 旧系统状态落后于新系统状态，跳过同步，任务ID: {}, 新系统状态: {} ({}), 旧系统状态: {} ({})",
                    taskId, task.getTaskStatus(), currentStatus.getInfo(), 
                    newStatus.getCode(), TaskStatusConverter.getLegacyStatusDescription(legacyStatus));
                // log.info("【旧系统更新到新系统】 旧系统状态落后于新系统状态，跳过同步，任务ID: {}, 新系统状态: {} ({}), 旧系统状态: {} ({})",
                //     taskId, task.getTaskStatus(), currentStatus.getInfo(), 
                //     newStatus.getCode(), TaskStatusConverter.getLegacyStatusDescription(legacyStatus));
                return false;
            }
            
@@ -277,9 +277,9 @@
            
            sysTaskMapper.updateSysTask(task);
            
            log.info("任务状态同步成功，任务ID: {}, 旧状态: {}, 新状态: {}, 旧系统状态码: {} ({})", 
                taskId, oldStatus, newStatus.getCode(), legacyStatus, 
                TaskStatusConverter.getLegacyStatusDescription(legacyStatus));
//            log.info("任务状态同步成功，任务ID: {}, 旧状态: {}, 新状态: {}, 旧系统状态码: {} ({})",
//                taskId, oldStatus, newStatus.getCode(), legacyStatus,
//                TaskStatusConverter.getLegacyStatusDescription(legacyStatus));
            
            return true;
            

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

@@ -118,14 +118,14 @@
                logger.warn("查询活跃车辆ID耗时过长: {}ms, 开始时间: {}, 建议检查 tb_vehicle_gps 表的索引（需要 vehicle_id 和 collect_time 组合索引）", 
                    queryTime, startTime);
            }
            logger.info("查询到 {} 辆活跃车辆，查询耗时: {}ms", vehicleIds != null ? vehicleIds.size() : 0, queryTime);
//            logger.info("查询到 {} 辆活跃车辆，查询耗时: {}ms", vehicleIds != null ? vehicleIds.size() : 0, queryTime);
            
            if (vehicleIds == null || vehicleIds.isEmpty()) {
                logger.info("没有找到活跃车辆");
//                logger.info("没有找到活跃车辆");
                return 0;
            }
            
            logger.info("找到 {} 辆活跃车辆，开始分批逐辆计算...", vehicleIds.size());
//            logger.info("找到 {} 辆活跃车辆，开始分批逐辆计算...", vehicleIds.size());
            
            int successCount = 0;
            int failedCount = 0;
@@ -135,7 +135,7 @@
                int batchEnd = Math.min(batchStart + BATCH_SIZE, vehicleIds.size());
                List<Long> batchVehicleIds = vehicleIds.subList(batchStart, batchEnd);
                
                logger.info("处理批次 {}-{}/{}", batchStart + 1, batchEnd, vehicleIds.size());
//                logger.info("处理批次 {}-{}/{}", batchStart + 1, batchEnd, vehicleIds.size());
                
                // 逐辆计算，包含错误处理和重试机制
                for (int i = 0; i < batchVehicleIds.size(); i++) {
@@ -154,20 +154,20 @@
                    
                    // 每处理10辆车输出一次进度
                    if ((overallIndex + 1) % 10 == 0) {
                        logger.info("批量计算进度: {}/{}, 成功: {}, 失败: {}",
                                   overallIndex + 1, vehicleIds.size(), successCount, failedCount);
//                        logger.info("批量计算进度: {}/{}, 成功: {}, 失败: {}",
//                                   overallIndex + 1, vehicleIds.size(), successCount, failedCount);
                    }
                }
                
                // 批次结束后，主动触发GC建议（不强制）
                if (batchEnd < vehicleIds.size()) {
                    System.gc();
                    logger.debug("批次 {}-{} 处理完成，已建议JVM回收内存", batchStart + 1, batchEnd);
//                    logger.debug("批次 {}-{} 处理完成，已建议JVM回收内存", batchStart + 1, batchEnd);
                }
            }
            
            logger.info("批量分段里程计算完成 - 时间范围: {} 到 {}, 总车辆数: {}, 成功: {}, 失败: {}",
                       startTime, endTime, vehicleIds.size(), successCount, failedCount);
//            logger.info("批量分段里程计算完成 - 时间范围: {} 到 {}, 总车辆数: {}, 成功: {}, 失败: {}",
//                       startTime, endTime, vehicleIds.size(), successCount, failedCount);
            return successCount;
            
        } catch (Exception e) {
@@ -185,14 +185,14 @@
            cal.add(Calendar.DAY_OF_MONTH, -lookbackDays);
            Date startTime = cal.getTime();
            
            logger.info("开始补偿计算 - 回溯天数: {}, 时间范围: {} 到 {}", lookbackDays, startTime, endTime);
//            logger.info("开始补偿计算 - 回溯天数: {}, 时间范围: {} 到 {}", lookbackDays, startTime, endTime);

            String startTimeStr=DateUtils.formatDate(startTime, DateUtils.YYYY_MM_DD_HH_MM_SS);
            // 查询所有活跃车辆
            List<Long> vehicleIds = vehicleGpsMapper.selectActiveVehicleIds(startTimeStr);
            
            if (vehicleIds == null || vehicleIds.isEmpty()) {
                logger.info("没有找到活跃车辆");
//                logger.info("没有找到活跃车辆");
                return 0;
            }
            
@@ -212,13 +212,13 @@
                        List<VehicleGps> uncalculatedGps = vehicleGpsMapper.selectUncalculatedGps(vehicleId, startTimeStr, endTimeStr);
                    
                    if (uncalculatedGps == null || uncalculatedGps.isEmpty()) {
                        logger.debug("车辆 {} 没有未计算的GPS数据", vehicleId);
//                        logger.debug("车辆 {} 没有未计算的GPS数据", vehicleId);
                        continue;
                    }
                    
                    totalUncalculated += uncalculatedGps.size();
                    logger.info("车辆 {} 发现 {} 个未计算的GPS点，开始补偿计算...", 
                               vehicleId, uncalculatedGps.size());
//                    logger.info("车辆 {} 发现 {} 个未计算的GPS点，开始补偿计算...",
//                               vehicleId, uncalculatedGps.size());
                    
                    // 获取未计算GPS数据的时间范围
                    Date uncalculatedStartTime = parseDateTime(uncalculatedGps.get(0).getCollectTime());
@@ -228,16 +228,16 @@
                    Long lastCalculatedGpsId = segmentMileageMapper.selectLastCalculatedGpsId(vehicleId, uncalculatedStartTime);
                    
                    if (lastCalculatedGpsId != null) {
                        logger.info("车辆 {} 找到最后一个已处理的GPS点ID: {}，将与未处理数据一起计算", vehicleId, lastCalculatedGpsId);
//                        logger.info("车辆 {} 找到最后一个已处理的GPS点ID: {}，将与未处理数据一起计算", vehicleId, lastCalculatedGpsId);
                        
                        // 将最后一个已处理的GPS点加入列表前面，作为前置点
                        VehicleGps lastCalculatedGps = vehicleGpsMapper.selectVehicleGpsById(lastCalculatedGpsId);
                        if (lastCalculatedGps != null) {
                            uncalculatedGps.add(0, lastCalculatedGps); // 插入到列表最前面
                            logger.info("已将GPS点 {} 作为前置点加入计算列表", lastCalculatedGpsId);
//                            logger.info("已将GPS点 {} 作为前置点加入计算列表", lastCalculatedGpsId);
                        }
                    } else {
                        logger.info("车辆 {} 没有找到已处理的前置 GPS点，从第一个未处理点开始计算", vehicleId);
//                        logger.info("车辆 {} 没有找到已处理的前置 GPS点，从第一个未处理点开始计算", vehicleId);
                    }
                    
                    // 重新计算该车辆在该时间范围的分段里程
@@ -247,7 +247,7 @@
                    
                        if (segmentCount > 0) {
                            successCount++;
                            logger.info("车辆 {} 补偿计算完成，生成 {} 个分段记录", vehicleId, segmentCount);
//                            logger.info("车辆 {} 补偿计算完成，生成 {} 个分段记录", vehicleId, segmentCount);
                        }
                    } catch (Exception e) {
                        logger.error("车辆 {} 补偿计算失败", vehicleId, e);
@@ -257,12 +257,12 @@
                // 每批次结束后，主动建议GC（不需要显式清空引用，局部变量会自动释放）
                if (batchEnd < vehicleIds.size()) {
                    System.gc();
                    logger.debug("补偿计算批次 {}-{} 完成，已建议JVM回收内存", batchStart + 1, batchEnd);
//                    logger.debug("补偿计算批次 {}-{} 完成，已建议JVM回收内存", batchStart + 1, batchEnd);
                }
            }
            
            logger.info("补偿计算完成 - 总车辆数: {}, 未计算GPS点数: {}, 成功车辆数: {}", 
                       vehicleIds.size(), totalUncalculated, successCount);
//            logger.info("补偿计算完成 - 总车辆数: {}, 未计算GPS点数: {}, 成功车辆数: {}",
//                       vehicleIds.size(), totalUncalculated, successCount);
            return successCount;
            
        } catch (Exception e) {
@@ -280,7 +280,7 @@
            List<VehicleGps> gpsList = vehicleGpsMapper.selectGpsDataByTimeRange(vehicleId, startTimeStr, endTimeStr);
            
            if (gpsList == null || gpsList.isEmpty()) {
                logger.debug("车辆ID: {} 在时间范围 {} 到 {} 内无GPS数据", vehicleId, startTime, endTime);
//                logger.debug("车辆ID: {} 在时间范围 {} 到 {} 内无GPS数据", vehicleId, startTime, endTime);
                return 0;
            }
            
@@ -307,7 +307,7 @@
        try {
            // 验证输入数据
            if (gpsList == null || gpsList.isEmpty()) {
                logger.debug("车辆ID: {} 在时间范围 {} 到 {} 内无GPS数据", vehicleId, startTime, endTime);
//                logger.debug("车辆ID: {} 在时间范围 {} 到 {} 内无GPS数据", vehicleId, startTime, endTime);
                return 0;
            }
            
@@ -432,7 +432,7 @@
    private boolean isSegmentAlreadyCalculated(Long vehicleId, Date segmentStartTime, List<VehicleGps> segmentGpsList) {
        VehicleGpsSegmentMileage existing = segmentMileageMapper.selectByVehicleIdAndTime(vehicleId, segmentStartTime);
        if (existing != null) {
            logger.debug("车辆 {} 时间段 {} 的分段里程已存在，跳过", vehicleId, segmentStartTime);
//            logger.debug("车辆 {} 时间段 {} 的分段里程已存在，跳过", vehicleId, segmentStartTime);
            return true;
        }
        return false;
@@ -888,7 +888,7 @@
            List<SysTask> activeTasks = sysTaskMapper.selectTaskByVehicleIdAndDate(vehicleId,segmentStartTimeStr,segmentEndTimeStr);
            
            if (activeTasks == null || activeTasks.isEmpty()) {
                logger.info("车辆 {} 在时间段 {} - {} 没有正在执行的任务", vehicleId, segmentStartTime, segmentEndTime);
//                logger.info("车辆 {} 在时间段 {} - {} 没有正在执行的任务", vehicleId, segmentStartTime, segmentEndTime);
                return;
            }
            

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

@@ -467,7 +467,7 @@
            List<VehicleGpsSegmentMileage> segments = segmentMileageMapper.selectSegmentsByDateRange(vehicleId, dayStart, dayEnd);
            
            if (segments == null || segments.isEmpty()) {
                logger.info("车辆ID: {} 在日期: {} 无分段里程数据", vehicleId, statDate);
//                logger.info("车辆ID: {} 在日期: {} 无分段里程数据", vehicleId, statDate);
                return null;
            }