#log

Junjie

1 天以前 1cb18ad19e48be2b944b005db1b950a667725fc6

 src/main/java/com/zy/common/utils/NavigateUtils.java

@@ -27,6 +27,7 @@
import com.zy.asrs.service.StationCycleCapacityService;
import com.zy.asrs.service.StationPathPolicyService;
import com.zy.core.News;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Scheduled;
import com.zy.core.model.StationObjModel;
import com.zy.core.model.command.StationCommand;
@@ -53,6 +54,7 @@
import java.util.LinkedHashMap;

@Component
@Slf4j
public class NavigateUtils {

    private static final long STATION_PATH_SLOW_LOG_THRESHOLD_MS = 500L;
@@ -111,29 +113,59 @@
                                                                 Integer endStationId,
                                                                 Integer currentTaskNo,
                                                                 Double pathLenFactor) {
        StationPathResolvedPolicy resolvedPolicy = resolveStationPathPolicy(startStationId, endStationId);
        StationPathRuntimeSnapshot runtimeSnapshot = loadStationPathRuntimeSnapshot(currentTaskNo);
        StationPathSearchContext context = buildStationPathSearchContext(
                startStationId,
                endStationId,
                resolvedPolicy,
                StationPathCalcMode.REROUTE,
                runtimeSnapshot
        );
        if (context.allList.isEmpty()) {
            return new ArrayList<>();
        }
        long totalStartNs = System.nanoTime();
        log.info("站点路径候选计算入口，startStationId={}，endStationId={}，taskNo={}，pathLenFactor={}",
                startStationId, endStationId, currentTaskNo, pathLenFactor);
        try {
            StationPathResolvedPolicy resolvedPolicy = resolveStationPathPolicy(startStationId, endStationId);
            log.info("站点路径候选策略解析完成，startStationId={}，endStationId={}，taskNo={}，matchedRule={}，ruleCode={}，profileCode={}，costMs={}",
                    startStationId,
                    endStationId,
                    currentTaskNo,
                    resolvedPolicy != null && resolvedPolicy.matchedRule(),
                    resolvedPolicy == null || resolvedPolicy.getRuleEntity() == null ? null : resolvedPolicy.getRuleEntity().getRuleCode(),
                    resolvedPolicy == null ? null : resolvedPolicy.getDefaultProfileCode(),
                    elapsedMillis(totalStartNs));
            StationPathRuntimeSnapshot runtimeSnapshot = loadStationPathRuntimeSnapshot(currentTaskNo);
            StationPathSearchContext context = buildStationPathSearchContext(
                    startStationId,
                    endStationId,
                    resolvedPolicy,
                    StationPathCalcMode.REROUTE,
                    runtimeSnapshot
            );
            if (context.allList.isEmpty()) {
                log.warn("站点路径候选计算结束，原因=empty_search_context，startStationId={}，endStationId={}，taskNo={}，totalCostMs={}",
                        startStationId, endStationId, currentTaskNo, elapsedMillis(totalStartNs));
                return new ArrayList<>();
            }

        List<List<NavigateNode>> orderedPathList = orderStationPathCandidates(
                context.allList,
                context.resolvedPolicy,
                currentTaskNo,
                pathLenFactor,
                startStationId,
                endStationId,
                runtimeSnapshot
        );
        return normalizeCandidatePaths(orderedPathList);
            long orderStartNs = System.nanoTime();
            List<List<NavigateNode>> orderedPathList = orderStationPathCandidates(
                    context.allList,
                    context.resolvedPolicy,
                    currentTaskNo,
                    pathLenFactor,
                    startStationId,
                    endStationId,
                    runtimeSnapshot
            );
            List<List<NavigateNode>> normalizedPathList = normalizeCandidatePaths(orderedPathList);
            log.info("站点路径候选计算结束，startStationId={}，endStationId={}，taskNo={}，rawCandidateCount={}，orderedPathCount={}，normalizedPathCount={}，orderCostMs={}，totalCostMs={}",
                    startStationId,
                    endStationId,
                    currentTaskNo,
                    context.allList.size(),
                    orderedPathList == null ? null : orderedPathList.size(),
                    normalizedPathList.size(),
                    elapsedMillis(orderStartNs),
                    elapsedMillis(totalStartNs));
            return normalizedPathList;
        } catch (Exception e) {
            log.error("站点路径候选计算异常，startStationId={}，endStationId={}，taskNo={}，pathLenFactor={}，costMs={}",
                    startStationId, endStationId, currentTaskNo, pathLenFactor, elapsedMillis(totalStartNs), e);
            throw e;
        }
    }

    public Map<Integer, Set<Integer>> loadUndirectedStationGraphSnapshot() {
@@ -2685,6 +2717,8 @@
        }
        Integer lev = startStation.getStationLev();
        stepCostMap.put("loadStartStation", elapsedMillis(stepStartNs));
        log.info("站点路径搜索上下文加载起点完成，startStationId={}，endStationId={}，mode={}，lev={}，costMs={}",
                startStationId, endStationId, calcMode, lev, stepCostMap.get("loadStartStation"));

        stepStartNs = System.nanoTime();
        NavigateSolution navigateSolution = new NavigateSolution();
@@ -2701,6 +2735,16 @@
            throw new CoolException("未找到该 终点 对应的节点");
        }
        stepCostMap.put("loadStationMapAndNode", elapsedMillis(stepStartNs));
        log.info("站点路径搜索上下文加载地图完成，startStationId={}，endStationId={}，mode={}，mapRows={}，startNode=({},{})，endNode=({},{})，costMs={}",
                startStationId,
                endStationId,
                calcMode,
                stationMap.size(),
                startNode.getX(),
                startNode.getY(),
                endNode.getX(),
                endNode.getY(),
                stepCostMap.get("loadStationMapAndNode"));

        stepStartNs = System.nanoTime();
        StationPathProfileConfig profileConfig = resolvedPolicy.getProfileConfig() == null
@@ -2717,6 +2761,14 @@
        int calcMaxPaths = safeInt(profileConfig.getCalcMaxPaths(), 500);
        int calcMaxCost = safeInt(profileConfig.getCalcMaxCost(), 300);
        List<Integer> guideStationSequence = buildGuideStationSequence(startStationId, endStationId, resolvedPolicy.getRuleConfig());
        log.info("站点路径候选枚举开始，startStationId={}，endStationId={}，mode={}，calcMaxDepth={}，calcMaxPaths={}，calcMaxCost={}，guideStationSequence={}",
                startStationId,
                endStationId,
                calcMode,
                calcMaxDepth,
                calcMaxPaths,
                calcMaxCost,
                JSON.toJSONString(guideStationSequence));
        stepStartNs = System.nanoTime();
        List<List<NavigateNode>> allList = navigateSolution.allSimplePaths(
                stationMap,
@@ -2729,6 +2781,12 @@
        );
        stepCostMap.put("allSimplePaths", elapsedMillis(stepStartNs));
        rawCandidateCount = allList.size();
        log.info("站点路径候选枚举完成，startStationId={}，endStationId={}，mode={}，rawCandidateCount={}，costMs={}",
                startStationId,
                endStationId,
                calcMode,
                rawCandidateCount,
                stepCostMap.get("allSimplePaths"));
        if (allList.isEmpty()) {
            logStationPathSearchContextSlow(startStationId, endStationId, calcMode, lev, rawCandidateCount, filteredCandidateCount, stepCostMap, totalStartNs);
            return StationPathSearchContext.empty(resolvedPolicy);
@@ -2738,6 +2796,14 @@
        allList = filterNonAutoStationPaths(allList, statusMap);
        stepCostMap.put("filterNonAutoStation", elapsedMillis(stepStartNs));
        filteredCandidateCount = allList.size();
        log.info("站点路径候选自动状态过滤完成，startStationId={}，endStationId={}，mode={}，rawCandidateCount={}，filteredCandidateCount={}，statusCount={}，costMs={}",
                startStationId,
                endStationId,
                calcMode,
                rawCandidateCount,
                filteredCandidateCount,
                statusMap.size(),
                stepCostMap.get("filterNonAutoStation"));
        if (allList.isEmpty()) {
            News.info("[WCS Debug] 站点路径候选全部被过滤，存在非自动站点,startStationId={},endStationId={}", startStationId, endStationId);
            logStationPathSearchContextSlow(startStationId, endStationId, calcMode, lev, rawCandidateCount, filteredCandidateCount, stepCostMap, totalStartNs);