遗传算法

src/main/java/com/aps/entity/Algorithm/BOMBuildResult.java

+package com.aps.entity.Algorithm;
+
+import com.aps.entity.basic.Order;
+
+import java.util.List;
+
+/**
+ * 作者：佟礼
+ * 时间：2025-12-08
+ */
+public class BOMBuildResult {
+    private List<OrderMaterialRequirement> materialRequirements;
+    private List<Order> childOrders;
+
+    public BOMBuildResult(List<OrderMaterialRequirement> materialRequirements, List<Order> childOrders) {
+        this.materialRequirements = materialRequirements;
+        this.childOrders = childOrders;
+    }
+
+    public List<OrderMaterialRequirement> getMaterialRequirements() {
+        return materialRequirements;
+    }
+
+    public List<Order> getChildOrders() {
+        return childOrders;
+    }
+}

src/main/java/com/aps/entity/Algorithm/OrderMaterialRequirement.java

+package com.aps.entity.Algorithm;
+
+import com.aps.entity.basic.MaterialType;
+import lombok.Data;
+
+import java.math.BigDecimal;
+import java.time.LocalDateTime;
+import java.util.List;
+
+/**
+ * 订单物料需求
+ */
+@Data
+public class OrderMaterialRequirement {
+
+        private String orderId;
+        private int operationId;
+        private String childorderId;
+        private String materialId;
+        private MaterialType materialType;
+
+        /**
+         * 需求总数
+         */
+        private double requiredQuantity;
+
+        /**
+         * 已配数量
+         */
+        private double ypQty;
+
+        /**
+         * 缺件数量
+         */
+        private double qjQty;
+
+        /**
+         * 占用库存
+         */
+        private double useStock;
+
+        /**
+         * 占用在途数量
+         */
+        private double useTransit;
+
+        /**
+         * 层级
+         */
+        private int level;
+
+        /**
+         * 预计到货时间
+         */
+        private LocalDateTime arrivalTime;
+
+        /**
+         * 预计可用时间
+         */
+        private LocalDateTime useTime;
+
+        /**
+         * 采购开始时间
+         */
+        private LocalDateTime purchaseStartTime;
+
+        /**
+         * 采购结束时间
+         */
+        private LocalDateTime purchaseEndTime;
+
+        /**
+         * 创建或使用的半成品订单ID
+         */
+        private List<Integer> productOrderID;
+}

src/main/java/com/aps/entity/basic/Entry.java

@@ -30,7 +30,7 @@ public class Entry {
      * 原订单ID
      */
     public String OrderId ;
-
+    private Integer routingId;
     private Long routingDetailId;
     private Long taskSeq;
     private String routingDetailName;

src/main/java/com/aps/entity/basic/Material.java

 package com.aps.entity.basic;
 import lombok.Data;
+
+import java.math.BigDecimal;
 import java.time.LocalDateTime;
 import java.util.ArrayList;
 import java.util.List;
@@ -12,7 +14,7 @@ public class Material {
     /**
      * 物料ID
      */
-    private int Id;
+    private String Id;
 
     /**
      * 物料名称
@@ -35,6 +37,7 @@ public class Material {
     private int PurchaseLeadTime;
 
 
+
     /**
      * 物料类型
      */

src/main/java/com/aps/entity/basic/MaterialRequirement.java

@@ -17,7 +17,7 @@ public class MaterialRequirement {
     /**
      * 物料ID
      */
-    private int MaterialId;
+    private String MaterialId;
 
     /**
      * 物料类型
@@ -27,7 +27,7 @@ public class MaterialRequirement {
     /**
      * 该工序需要的物料数量
      */
-    private BigDecimal RequiredQuantity;
+    private double RequiredQuantity;
 
     @Override
     public String toString() {

src/main/java/com/aps/entity/basic/Order.java

@@ -4,6 +4,7 @@ import lombok.Data;
 
 import java.time.LocalDateTime;
 import java.time.OffsetDateTime;
+import java.util.List;
 
 /**
  * 订单定义
@@ -14,6 +15,7 @@ public class Order {
     private String OrderId;
     private int productId;
     private String materialId;
+    private Integer routingId;
 
     private double quantity = 100; // 100个
     private double sYQuantity;
@@ -26,4 +28,6 @@ public class Order {
     private boolean canInterrupt = false;
     private double actualPriority;
     private String mainId;
+/*使用这个半成品的成品工单*/
+    public List<String> FinishOrderId ;
 }
\ No newline at end of file

src/main/java/com/aps/service/Algorithm/GeneticDecoder.java

@@ -271,6 +271,8 @@ public class GeneticDecoder {
 
             int machineAvailableTime = lastGeneOnMachine.getEndTime();
 
+
+
             if (setupTime > 0) {
                 if (_globalParam.is_smoothSetup()) {
 

src/main/java/com/aps/service/Algorithm/MaterialRequirementService.java

+package com.aps.service.Algorithm;
+
+import com.aps.common.util.SnowFlackIdWorker;
+import com.aps.entity.*;
+import com.aps.entity.Algorithm.BOMBuildResult;
+import com.aps.entity.Algorithm.OrderMaterialRequirement;
+import com.aps.entity.basic.*;
+import com.aps.mapper.RoutingHeaderMapper;
+import com.aps.mapper.RoutingSupportingReplaceMapper;
+import com.aps.mapper.RoutingsupportingMapper;
+import com.aps.service.LanuchService;
+import com.aps.service.ProdEquipSpecialCalService;
+import com.aps.service.RoutingDetailConnectService;
+import com.aps.service.RoutingHeaderService;
+import com.aps.service.impl.LanuchServiceImpl;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.util.CollectionUtils;
+
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.time.LocalDateTime;
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * 作者：佟礼
+ * 时间：2025-12-08
+ */
+@Service
+public class MaterialRequirementService {
+
+    private List<Material> _materials;
+
+    private List<Entry> _allOperations;
+
+    private  List<RoutingHeader> headers;
+
+    private  List<Routingsupporting> routingsupportings;
+
+    private  List<RoutingSupportingReplace> routingsupportingreplaces;
+
+    @Autowired
+    RoutingDetailConnectService routingDetailConnectService;
+
+
+    private final List<Order> orders;
+
+    @Autowired
+    RoutingHeaderMapper routingHeaderMapper;
+
+    @Autowired
+    RoutingSupportingReplaceMapper routingSupportingReplaceMapper;
+
+    @Autowired
+    RoutingsupportingMapper routingsupportingMapper;
+
+
+
+    private  LocalDateTime baseTime ;
+
+    public MaterialRequirementService(List<Material> materials,List<Order> _orders,List<Entry> allOperations)
+    {
+
+        this.orders = _orders;
+        _allOperations=allOperations;
+        _materials=materials;
+    }
+
+    /**
+     * 构建多级BOM需求网络
+     * @return 所有物料需求列表
+     */
+    private List<OrderMaterialRequirement> buildMultiLevelRequirementNetwork(LocalDateTime _baseTime) {
+        baseTime=_baseTime;
+        List<OrderMaterialRequirement> allRequirements = new ArrayList<>();
+        List<Order> childorders = new ArrayList<>();
+
+        List<Integer> routingIds = _allOperations.stream()
+                .map(Entry::getRoutingId)
+                .distinct()
+                .collect(Collectors.toList());
+
+        LambdaQueryWrapper<RoutingHeader> wrapper = new LambdaQueryWrapper<>();
+        wrapper.in(RoutingHeader::getId, routingIds)
+                .eq(RoutingHeader::getIsDeleted, 0)
+                .eq(RoutingHeader::getApprovalStatus, 1); // 添加 is_deleted=0 过滤条件
+        headers = routingHeaderMapper.selectList(wrapper);
+
+        LambdaQueryWrapper<Routingsupporting> routingsupportingwrapper = new LambdaQueryWrapper<>();
+        routingsupportingwrapper.in(Routingsupporting::getRoutingHeaderId, routingIds)
+                .eq(Routingsupporting::getIsdeleted, 0);
+
+        routingsupportings = routingsupportingMapper.selectList(routingsupportingwrapper);
+
+        LambdaQueryWrapper<RoutingSupportingReplace> routingsupportingreplacewrapper = new LambdaQueryWrapper<>();
+        routingsupportingreplacewrapper.in(RoutingSupportingReplace::getStrsupid, routingIds)
+                .eq(RoutingSupportingReplace::getIsdeleted, 0);
+
+        routingsupportingreplaces = routingSupportingReplaceMapper.selectList(routingsupportingreplacewrapper);
+
+
+
+        for (Order demand : orders) {
+            // 跳过已有父订单的需求
+            if (demand.getFinishOrderId() != null && !demand.getFinishOrderId().isEmpty()) {
+                continue;
+            }
+
+            // 递归展开BOM层级（通过结果对象接收out参数数据）
+            BOMBuildResult result = buildOrderBOM(demand.getRoutingId(),"", demand.getOrderId(), "",
+                    demand.getQuantity(), 0);
+            allRequirements.addAll(result.getMaterialRequirements());
+            childorders.addAll(result.getChildOrders());
+        }
+
+        // 将子订单添加到全局订单列表
+//        if (_orders != null) {
+//            _orders.addAll(childorders);
+//        }
+
+        return allRequirements;
+    }
+
+    /**
+     * 构建订单BOM
+     * @param parent 父项ID
+     * @param materialID 物料ID
+     * @param mainorderId 主订单ID
+     * @param childorderId 子订单ID
+     * @param parentQuantity 父项数量（Java中用double替代decimal，若需高精度可用BigDecimal）
+     * @param level 层级
+     * @return 包含物料需求列表和子订单列表的结果对象（替代C#的out参数）
+     */
+    public BOMBuildResult buildOrderBOM(int parent, String materialID, String mainorderId,
+                                        String childorderId, double parentQuantity, int level) {
+
+        RoutingHeader routingHeaders=  headers.stream()
+                .filter(t->t.getId()==parent|| t.getMaterialId().equals(materialID))
+                .findFirst()
+                .orElse(null);
+        List<RoutingHeader>  headers1;
+        // 若未找到产品，返回空结果（根据业务可调整为抛出异常）
+        if (routingHeaders==null) {
+
+
+        }
+
+        List<OrderMaterialRequirement> materialRequirements = new ArrayList<>();
+        List<Order> childorders2 = new ArrayList<>();
+
+       // 遍历产品的工序，递归构建工序BOM
+
+        List<Entry> Operations= _allOperations.stream()
+                .filter(t->t.getOrderId()==mainorderId)
+                .collect(Collectors.toList());
+
+
+
+
+         if (Operations != null) {
+            for (Entry operation : Operations) {
+                // 调用BuildOperationBOM方法（返回结果对象替代out参数）
+                BOMBuildResult operationResult = buildOperationBOM(mainorderId, childorderId,
+                        parentQuantity, operation, level);
+//                // 合并物料需求和子订单
+                materialRequirements.addAll(operationResult.getMaterialRequirements());
+                childorders2.addAll(operationResult.getChildOrders());
+            }
+        }
+
+       // return new BOMBuildResult(materialRequirements, childorders2);
+        return  null;
+    }
+
+    private  void CreateChild(Order order,String materialID)
+    {
+        String sceneId="";
+        LambdaQueryWrapper<RoutingHeader> wrapper = new LambdaQueryWrapper<>();
+        wrapper.in(RoutingHeader::getMaterialId, materialID)
+                .eq(RoutingHeader::getIsDeleted, 0)
+                .eq(RoutingHeader::getApprovalStatus, 1); // 添加 is_deleted=0 过滤条件
+       RoutingHeader headers1 = routingHeaderMapper.selectOne(wrapper);
+if(headers==null)
+{
+    return;
+}
+        headers.add(headers1);
+
+//        List<Integer> routingIds = headers1.stream()
+//                .map(RoutingHeader::getId)
+//                .distinct()
+//                .collect(Collectors.toList());
+
+        Integer  routingIds =headers1.getId();
+
+        LambdaQueryWrapper<Routingsupporting> routingsupportingwrapper = new LambdaQueryWrapper<>();
+        routingsupportingwrapper.in(Routingsupporting::getRoutingHeaderId, routingIds)
+                .eq(Routingsupporting::getIsdeleted, 0);
+
+        List<Routingsupporting> routingsupportings1 = routingsupportingMapper.selectList(routingsupportingwrapper);
+        routingsupportings.addAll(routingsupportings1);
+        LambdaQueryWrapper<RoutingSupportingReplace> routingsupportingreplacewrapper = new LambdaQueryWrapper<>();
+        routingsupportingreplacewrapper.in(RoutingSupportingReplace::getStrsupid, routingIds)
+                .eq(RoutingSupportingReplace::getIsdeleted, 0);
+
+        List<RoutingSupportingReplace> routingsupportingreplaces1 = routingSupportingReplaceMapper.selectList(routingsupportingreplacewrapper);
+
+        routingsupportingreplaces.addAll(routingsupportingreplaces1);
+
+        LanuchServiceImpl lanuchService=new LanuchServiceImpl();
+        List<RoutingDetail> RoutingDetails= lanuchService.getRoutingDetails(routingIds);
+        List<RoutingDetailEquip> routingDetailEquips = lanuchService.getRoutingDetailEquip(routingIds);
+
+        ProdLaunchOrder prodOrderMain= convertToLaunchOrder(order,"");
+
+        List<ProdProcessExec> processExecList = RoutingDetails.stream()
+                .map(detail -> lanuchService.createProcessExec(prodOrderMain, detail, sceneId))
+                .collect(Collectors.toList());
+
+        List<ProdEquipment> ProdEquipmentList=  lanuchService.batchInsertEquipMent(routingDetailEquips, sceneId,processExecList,false);
+
+
+
+        Map<Long, String> routingDetailIdToExecIdMap = processExecList.stream()
+                .collect(Collectors.toMap(
+                        ProdProcessExec::getRoutingDetailId,
+                        ProdProcessExec::getExecId,
+                        (existing, replacement) -> existing));
+
+        LambdaQueryWrapper<RoutingDetailConnect> routingDetailConnectwrapper = new LambdaQueryWrapper<>();
+        routingDetailConnectwrapper.eq(RoutingDetailConnect::getRoutingHeaderId, routingIds)
+                .eq(RoutingDetailConnect::getIsdeleted, 0); // 添加 isdeleted=0 过滤条件
+
+        List<RoutingDetailConnect> connections = routingDetailConnectService.list(routingDetailConnectwrapper);
+
+
+        List<ProdOrderProcess>  ProdOrderProcesslist=  connections.stream()
+                .map(connection -> lanuchService.createProcessRelation(prodOrderMain, connection, sceneId, routingDetailIdToExecIdMap))
+                .collect(Collectors.toList());
+
+    }
+
+    private ProdLaunchOrder convertToLaunchOrder(Order order, String sceneId) {
+        try {
+            ProdLaunchOrder launchOrder = new ProdLaunchOrder();
+            launchOrder.setOrderId(order.getOrderId());
+            launchOrder.setSceneId(sceneId);
+            launchOrder.setSerie("");
+            launchOrder.setCreateUser("GA");
+            launchOrder.setMaterialCode("");
+//            launchOrder.setStartDate(order.get);
+            launchOrder.setEndDate(order.getDueDate());
+//            launchOrder.setOrderPriority(order.getPrioritry());
+            launchOrder.setOrderPriority(order.getPriority());
+            launchOrder.setQuantity(order.getQuantity());
+            launchOrder.setMaterialId(order.getMaterialId());
+
+
+            launchOrder.setRoutingId(order.getRoutingId());
+            launchOrder.setRoutingCode("");
+
+
+            return launchOrder;
+        } catch (Exception e) {
+
+            return null;
+        }
+    }
+
+
+
+    /**
+     * 构建工序BOM需求
+     * @param orderId 主订单ID
+     * @param childorderId 子订单ID
+     * @param parentQuantity 父项数量
+     * @param operation 工序对象
+     * @param level 层级
+     * @return 包含物料需求列表和子订单列表的结果对象（替代C#的out参数）
+     */
+    public BOMBuildResult buildOperationBOM(String orderId, String childorderId, double parentQuantity,
+                                            Entry operation, int level) {
+        List<OrderMaterialRequirement> materialRequirements = new ArrayList<>();
+        List<Order> _childorders = new ArrayList<>();
+
+        List<Routingsupporting> MaterialRequirements=  routingsupportings.stream()
+                .filter(t->t.getRoutingDetailId()==operation.getRoutingDetailId())
+                .collect(Collectors.toList());
+
+        if (MaterialRequirements != null) {
+            for (Routingsupporting component : MaterialRequirements) {
+                OrderMaterialRequirement orderMaterial = new OrderMaterialRequirement();
+                materialRequirements.add(orderMaterial);
+
+                orderMaterial.setOrderId(orderId);
+                orderMaterial.setOperationId(operation.getId());
+                orderMaterial.setChildorderId(StringUtils.isBlank(childorderId) ? orderId : childorderId);
+
+                double allneeded = parentQuantity * component.getMainQty().doubleValue();
+                orderMaterial.setRequiredQuantity(allneeded);
+                double needed = allneeded;
+
+                // 查找物料（流式处理替代First）
+                Material material = _materials.stream()
+                        .filter(m -> m.getId().equals(component.getMaterialId()))
+                        .findFirst()
+                        .orElse(null);
+                if (material == null) {
+                    continue;
+                }
+
+                orderMaterial.setMaterialType(material.getMaterialType());
+                orderMaterial.setMaterialId(material.getId());
+
+                // 扣减现有库存
+                double availableNow = material.getCurrentStock();
+                double useStock = Math.min(needed, availableNow);
+                material.setCurrentStock(material.getCurrentStock() - useStock);
+                orderMaterial.setUseStock(useStock);
+                needed -= useStock;
+
+                if (needed <= 0) {
+                    continue;
+                }
+
+                // 处理在途物料
+                double accumulated = 0;
+                LocalDateTime earliestTime = null;
+                double useTransit = 0;
+
+                // 按到货时间排序在途物料
+                List<MaterialSupply> sortedInTransit = material.getInTransit().stream()
+                        .filter(t -> t.getQuantity() > 0)
+                        .sorted(Comparator.comparing(MaterialSupply::getArrivalTime))
+                        .collect(Collectors.toList());
+
+                for (MaterialSupply supply : sortedInTransit) {
+                    double useq = Math.min(needed, supply.getQuantity());
+                    useTransit += useq;
+                    needed -= useq;
+                    supply.setQuantity(supply.getQuantity() - useq);
+
+                    if (needed <= 0) {
+                        earliestTime = supply.getArrivalTime();
+                        break;
+                    }
+                }
+
+                orderMaterial.setUseTransit(useTransit);
+                orderMaterial.setArrivalTime(earliestTime);
+                orderMaterial.setLevel(level);
+
+                if (needed > 0) {
+                    orderMaterial.setYpQty(allneeded - needed);
+                    orderMaterial.setQjQty(needed);
+
+                    if (material.getMaterialType() == MaterialType.RawMaterial) {
+                        // 处理原材料采购时间
+                        orderMaterial.setPurchaseStartTime(baseTime);
+                        // 采购结束时间 = 采购开始时间 + 采购提前期（天）
+                        LocalDateTime purchaseEndTime = baseTime.plusDays(material.getPurchaseLeadTime());
+                        orderMaterial.setPurchaseEndTime(purchaseEndTime);
+                    } else {
+                        // 处理半成品/成品的现有订单
+
+
+                        List<Order> orders2 = orders.stream()
+                                .filter(t -> t.getMaterialId().equals(material.getId())  && t.getSYQuantity() > 0)
+                                .sorted(Comparator.comparing(Order::getDueDate))
+                                .collect(Collectors.toList());
+
+                        if (!orders2.isEmpty()) {
+                            for (Order order : orders2) {
+                                if (order.getFinishOrderId() == null) {
+                                    order.setFinishOrderId(new ArrayList<>());
+                                }
+                                order.getFinishOrderId().add(orderId);
+                                orderMaterial.getProductOrderID().add(order.getId());
+
+                                double useq = Math.min(needed, order.getSYQuantity());
+                                needed -= useq;
+                                order.setSYQuantity(order.getSYQuantity() - useq);
+
+                                if (order.getFinishOrderId().size() == 1) {
+                                    // 递归构建BOM
+                                    int l = level + 1;
+                                    BOMBuildResult childResult = buildOrderBOM(0, material.getId(),
+                                            orderId, order.getOrderId(),
+                                            order.getQuantity(), l);
+                                    materialRequirements.addAll(childResult.getMaterialRequirements());
+                                    _childorders.addAll(childResult.getChildOrders());
+                                }
+
+                                if (needed <= 0) {
+                                    break;
+                                }
+                            }
+                        }
+
+                        // 更新已配和缺件数量
+                        orderMaterial.setYpQty(allneeded - needed);
+                        orderMaterial.setQjQty(needed);
+
+                        if (needed > 0) {
+                            // 创建新的子订单
+                            Order childorder = new Order();
+                            String OrderId = UUID.randomUUID().toString().replace("-", "");
+
+                            childorder.setOrderId(OrderId);
+                            childorder.setMaterialId(material.getId());
+                            childorder.setQuantity((int) orderMaterial.getQjQty());
+                            childorder.setFinishOrderId(new ArrayList<>());
+                            childorder.getFinishOrderId().add(orderId);
+                            _childorders.add(childorder);
+
+                            orderMaterial.getProductOrderID().add(childorder.getId());
+
+                            // 递归构建BOM
+                            int l = level + 1;
+                            BOMBuildResult childResult = buildOrderBOM(0, material.getId(),
+                                    orderId, childorder.getOrderId(),
+                                    childorder.getQuantity(), l);
+                            materialRequirements.addAll(childResult.getMaterialRequirements());
+                            _childorders.addAll(childResult.getChildOrders());
+                        }
+                    }
+                }
+
+                // 计算预计可用时间
+                LocalDateTime arrivalTime = orderMaterial.getArrivalTime();
+                LocalDateTime purchaseEndTime = orderMaterial.getPurchaseEndTime();
+                LocalDateTime useTime = null;
+
+                if (arrivalTime == null) {
+                    useTime = purchaseEndTime;
+                } else {
+                    if (purchaseEndTime != null && purchaseEndTime.isAfter(arrivalTime)) {
+                        useTime = purchaseEndTime;
+                    } else {
+                        useTime = arrivalTime;
+                    }
+                }
+                orderMaterial.setUseTime(useTime);
+            }
+        }
+
+        return new BOMBuildResult(materialRequirements, _childorders);
+    }
+}

src/main/java/com/aps/service/Algorithm/RoutingDataService.java

+package com.aps.service.Algorithm;
+
+import com.aps.entity.*;
+import com.aps.entity.Algorithm.DependencyType;
+import com.aps.entity.Algorithm.IDAndChildID.GroupResult;
+import com.aps.entity.Algorithm.IDAndChildID.NodeInfo;
+import com.aps.entity.Algorithm.OperationDependency;
+import com.aps.entity.basic.Entry;
+import com.aps.entity.basic.MachineOption;
+import com.aps.service.*;
+import com.aps.service.plan.SceneService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * 作者：佟礼
+ * 时间：2025-12-09
+ */
+@Service
+public class RoutingDataService {
+
+    @Autowired
+    private ProdLaunchOrderService _prodLaunchOrderService;
+
+    @Autowired
+    private ProdProcessExecService _prodProcessExecService;
+
+    @Autowired
+    private ProdEquipmentService _prodEquipmentService;
+
+    @Autowired
+    private PlanResourceService _PlanResourceService;
+
+    @Autowired
+    private SceneService _sceneService;
+
+    @Autowired
+    private ProdOrderProcessService _prodOrderProcessService;
+
+    @Autowired
+    private  RoutingDiscreteParamService _routingDiscreteParamService;
+    @Autowired
+    private  DiscreteParameterMatrixService _discreteParameterMatrixService;
+
+    public Map<Integer, Object> InitEntrys(String SceneId, List<ProdEquipment> ProdEquipments, List<ProdLaunchOrder> ProdLaunchOrders)
+    {
+        Map<Integer, Object> list=new HashMap<>();
+        List<ProdProcessExec> ProdProcessExecs=  _prodProcessExecService.lambdaQuery()
+                .eq(ProdProcessExec::getSceneId,SceneId)
+                .list();
+
+// 获取op列表中所有的routingDetailId
+        List<Long> routingDetailIds = ProdProcessExecs.stream()
+                .map(ProdProcessExec::getRoutingDetailId)
+                .filter(Objects::nonNull)
+                .distinct()
+                .collect(Collectors.toList());
+
+// 查询RoutingDiscreteParam中routingDetailId在上述列表中的所有记录
+        List<RoutingDiscreteParam> routingDiscreteParams = _routingDiscreteParamService.lambdaQuery()
+                .in(RoutingDiscreteParam::getRoutingDetailId, routingDetailIds)
+                .eq(RoutingDiscreteParam::getIsDeleted, 0)
+                .list();
+
+
+        List<ProdOrderProcess> ProdOrderProcesss = _prodOrderProcessService.lambdaQuery()
+                .eq(ProdOrderProcess::getSceneId,SceneId)
+                .list();
+
+       return CreateEntry( SceneId,  ProdEquipments,  ProdLaunchOrders, routingDiscreteParams, ProdOrderProcesss, ProdProcessExecs,null );
+
+    }
+
+    public Map<Integer, Object> CreateEntry(String SceneId, List<ProdEquipment> ProdEquipments, List<ProdLaunchOrder> ProdLaunchOrders,List<RoutingDiscreteParam> routingDiscreteParams,List<ProdOrderProcess> ProdOrderProcesss,List<ProdProcessExec> ProdProcessExecs,List<GroupResult> existingResults)
+    {
+        Map<Integer, Object> list=new HashMap<>();
+        List<String> soutceExecId = ProdOrderProcesss.stream()
+                .map(ProdOrderProcess::getExecId)
+                .distinct() // 提取Exec_ID
+                .collect(Collectors.toList());
+
+        List<String> targetExecId = ProdOrderProcesss.stream()
+                .map(ProdOrderProcess::getTargetExecId)
+                .distinct() // 提取TARGET_Exec_ID
+                .collect(Collectors.toList());
+
+        List<String> ExecIdNoChild=  ProdProcessExecs.stream()
+                .filter(e -> !soutceExecId.contains(e.getExecId())&&!targetExecId.contains(e.getExecId()))  // 过滤条件
+                .map(ProdProcessExec::getExecId)
+                .distinct()
+                .collect(Collectors.toList());
+
+        if(ExecIdNoChild!=null&&ExecIdNoChild.size()>0)
+        {
+            for (String ExecId : ExecIdNoChild) {
+                soutceExecId.add(ExecId);
+                targetExecId.add("");
+            }
+        }
+        List<GroupResult> results;
+        int index=0;
+        if(existingResults==null||existingResults.size()==0) {
+            results = IdGroupingWithDualSerial.groupAndOrderIds(soutceExecId, targetExecId);
+        }else {
+            index=existingResults.size();
+            results = IdGroupingWithDualSerial.addNewDataWithIsolatedGroup(existingResults,soutceExecId, targetExecId);
+        }
+
+        List<Entry> entrys=new ArrayList<>();
+
+        for (int i = index; i < results.size(); i++) {
+            GroupResult groupResult = results.get(i);
+            List<NodeInfo> nodeInfoList = groupResult.getNodeInfoList();
+            // System.out.println("分组" + (i + 1) + "顺序：" + nodeInfoList);
+            for (NodeInfo nodeInfo : nodeInfoList) {
+//                System.out.printf("原始ID：%s → 全局序号：%d，分组内序号：%d，新父ID列表：%s，新子ID列表：%s%n",
+//                        nodeInfo.getOriginalId(),
+//                        nodeInfo.getGlobalSerial(),
+//                        nodeInfo.getGroupSerial(),
+//                        nodeInfo.getNewParentIds().isEmpty() ? "无" : nodeInfo.getNewParentIds(),
+//                        nodeInfo.getNewChildIds());
+
+                Entry entry = new Entry();
+
+                entry.setId(nodeInfo.getGlobalSerial());
+                entry.setGroupId(i + 1);
+                entry.setSequence(nodeInfo.getGroupSerial());
+                entry.setExecId(nodeInfo.getOriginalId());
+                ProdProcessExec op= ProdProcessExecs.stream()
+                        .filter(t->t.getExecId().equals(entry.getExecId()))
+                        .findFirst().orElse(null);
+                if(nodeInfo.getNewParentIds()!=null)
+                {
+
+                    List<OperationDependency> OperationDependency=new ArrayList<>();
+                    for (int id : nodeInfo.getNewParentIds()) {
+                        OperationDependency od=new OperationDependency();
+                        od.setPrevOperationId(id);
+
+                        if (op != null) {
+                            od.setDependencyType(DependencyType.fromValueSafe(op.getConnectProperty()));
+                        } else {
+                            od.setDependencyType(DependencyType.FinishToStart);
+                        }
+                        OperationDependency.add(od);
+                    }
+                    entry.setPrevEntryIds(OperationDependency);
+                }
+
+
+
+                if(nodeInfo.getNewChildIds()!=null)
+                {
+                    List<OperationDependency> OperationDependency=new ArrayList<>();
+                    for (int id : nodeInfo.getNewChildIds()) {
+                        OperationDependency od=new OperationDependency();
+                        od.setNextOperationId(id);
+                        // 记录属性
+                        if (op != null) {
+                            od.setDependencyType(DependencyType.fromValueSafe(op.getConnectProperty()));
+                        } else {
+                            od.setDependencyType(DependencyType.FinishToStart);
+                        }
+
+
+
+                        OperationDependency.add(od);
+                    }
+                    entry.setNextEntryIds(OperationDependency);
+                }
+
+
+
+                if(op!=null)
+                {
+                    entry.setDiscreteParameter(routingDiscreteParams.stream().filter(t -> t.getRoutingDetailId().equals(op.getRoutingDetailId())).collect(Collectors.toList()));
+                    entry.setEquipTypeID(op.getMachineId());
+                    entry.setOrderId(op.getOrderId());
+                    entry.setQuantity(op.getPlanQty());
+                    entry.setRoutingId(op.getRoutingId());
+                    entry.setRoutingDetailId(op.getRoutingDetailId());
+                    entry.setTaskSeq(op.getTaskSeq());
+                    entry.setRoutingDetailName(op.getRoutingDetailName());
+                    ProdLaunchOrder order = ProdLaunchOrders.stream()
+                            .filter(t -> t.getOrderId().equals(op.getOrderId()))
+                            .findFirst().orElse(null);
+                    if (order != null) {
+                        entry.setProductId(order.getMaterialId());
+                    }
+                    List<ProdEquipment> Equipments = ProdEquipments.stream()
+                            .filter(t -> t.getExecId().equals(op.getExecId()))
+                            .collect(Collectors.toList());
+                    if (Equipments != null && Equipments.size() > 0) {
+                        List<MachineOption> mos = new ArrayList<>();
+                        for (ProdEquipment e : Equipments) {
+                            MachineOption mo = new MachineOption();
+                            mo.setMachineId(e.getEquipId());
+                            mo.setProcessingTime(e.getSpeed());
+                            mo.setContantTime(op.getConstTime());
+                            mo.setSetupTime(op.getChangeLineTime());
+                            mo.setTeardownTime(op.getPostprocessingTime());
+                            mo.setPreTime(e.getSetupTime());
+
+                            mos.add(mo);
+                        }
+                        entry.setMachineOptions(mos);
+                    }
+                }
+                entry.setPriority(1);
+                entrys.add(entry);
+            }
+            // 输出每个节点的详细信息
+
+            System.out.println("------------------------");
+        }
+        list.put(1,entrys);
+        list.put(2,results);
+
+        return  list;
+
+    }
+}

src/main/java/com/aps/service/impl/LanuchServiceImpl.java

@@ -633,7 +633,7 @@ public class LanuchServiceImpl implements LanuchService {
      ◦ @return 工序列表
 
      */
-    private List<RoutingDetail> getRoutingDetails(Integer routingHeaderId) {
+    public List<RoutingDetail> getRoutingDetails(Integer routingHeaderId) {
         LambdaQueryWrapper<RoutingDetail> wrapper = new LambdaQueryWrapper<>();
         wrapper.eq(RoutingDetail::getRoutingHeaderId, routingHeaderId)
                 .eq(RoutingDetail::getIsDeleted, 0) // 添加 is_deleted=0 过滤条件
@@ -661,7 +661,7 @@ public class LanuchServiceImpl implements LanuchService {
      ◦ @param sceneId       场景ID
 
      */
-    private void batchInsertProcessExec(ProdLaunchOrder prodOrderMain,
+    public void batchInsertProcessExec(ProdLaunchOrder prodOrderMain,
                                         List<RoutingDetail> routingDetails,
                                         String sceneId, List<RoutingDetailEquip> routingDetailEquip)  {
 
@@ -670,7 +670,7 @@ public class LanuchServiceImpl implements LanuchService {
                 .map(detail -> createProcessExec(prodOrderMain, detail, sceneId))
                 .collect(Collectors.toList());
 
-        batchInsertEquipMent(routingDetailEquip, sceneId,processExecList);
+        batchInsertEquipMent(routingDetailEquip, sceneId,processExecList,true);
 
         // 批量插入
         if (!CollectionUtils.isEmpty(processExecList)) {
@@ -699,7 +699,7 @@ public class LanuchServiceImpl implements LanuchService {
      ◦ @return 工序执行记录
 
      */
-    private ProdProcessExec createProcessExec(ProdLaunchOrder prodOrderMain,
+    public ProdProcessExec createProcessExec(ProdLaunchOrder prodOrderMain,
                                               RoutingDetail detail,
                                               String sceneId) {
         ProdProcessExec prodProcessExec = new ProdProcessExec();
@@ -790,6 +790,10 @@ public class LanuchServiceImpl implements LanuchService {
         log.info("完成{}个工单的工序关系生成", prodOrderMains.size());
     }
 
+
+
+
+
     /**
      ◦ 生成工序关联关系
 
@@ -873,7 +877,7 @@ public class LanuchServiceImpl implements LanuchService {
      ◦ @return 工序关系
 
      */
-    private ProdOrderProcess createProcessRelation(ProdLaunchOrder prodOrderMain,
+    public ProdOrderProcess createProcessRelation(ProdLaunchOrder prodOrderMain,
                                                    RoutingDetailConnect connection,
                                                    String sceneId,
                                                    Map<Long, String> routingDetailIdToExecIdMap) {
@@ -934,14 +938,14 @@ public class LanuchServiceImpl implements LanuchService {
      ◦ 设备对照表
 
      */
-    private void batchInsertEquipMent(
+    public List<ProdEquipment> batchInsertEquipMent(
             List<RoutingDetailEquip> routingDetailEquips,
-            String sceneId,List<ProdProcessExec> processExecList) {
+            String sceneId,List<ProdProcessExec> processExecList,Boolean isSave) {
 
 
         if (CollectionUtils.isEmpty(routingDetailEquips)) {
             log.warn("工艺设备列表为空，跳过设备对照表生成");
-            return;
+            return null;
         }
 
 
@@ -997,12 +1001,11 @@ public class LanuchServiceImpl implements LanuchService {
         }
 
         // 批量保存
-        if (!prodEquipments.isEmpty()) {
+        if (!prodEquipments.isEmpty()&&isSave) {
             prodEquipmentService.saveBatch(prodEquipments);
         }
 
-
-
+return prodEquipments;
     }
 
     /**
@@ -1014,7 +1017,7 @@ public class LanuchServiceImpl implements LanuchService {
      ◦ @return 工序列表
 
      */
-    private List<RoutingDetailEquip> getRoutingDetailEquip(Integer routingHeaderId) {
+    public List<RoutingDetailEquip> getRoutingDetailEquip(Integer routingHeaderId) {
 
 
         List<RoutingDetailEquip> detailEquips = routingDetailEquipService.lambdaQuery()

src/main/java/com/aps/service/plan/PlanResultService.java

@@ -15,6 +15,7 @@ import com.aps.entity.basic.*;
 import com.aps.service.*;
 import com.aps.service.Algorithm.GeneticAlgorithm;
 import com.aps.service.Algorithm.IdGroupingWithDualSerial;
+import com.aps.service.Algorithm.RoutingDataService;
 import com.aps.service.Algorithm.ScheduleOperationService;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -69,6 +70,9 @@ public class PlanResultService {
     @Autowired
     private  DiscreteParameterMatrixService _discreteParameterMatrixService;
 
+    @Autowired
+    private RoutingDataService _routingDataService;
+
     private  LocalDateTime baseTime = LocalDateTime.of(2025, 11, 1, 0, 0, 0);
 
     public List<ScheduleChromosome> execute() {
@@ -289,7 +293,9 @@ order.setDueDate(LocalDateTime.of(2025, 12, 1,0,0,0));
             List<Order> orders=new ArrayList<>();
             for (ProdLaunchOrder lo : ProdLaunchOrders) {
                 Order order=new Order();
+
                 order.setOrderId(lo.getOrderId());
+                order.setRoutingId(lo.getRoutingId());
                 order.setMaterialId(lo.getMaterialId());
                 order.setDueDate(lo.getEndDate());
                 order.setQuantity(lo.getQuantity());
@@ -752,161 +758,9 @@ order.setDueDate(LocalDateTime.of(2025, 12, 1,0,0,0));
 
     private Map<Integer, Object> InitEntrys(String SceneId,List<ProdEquipment> ProdEquipments,List<ProdLaunchOrder> ProdLaunchOrders)
     {
-        Map<Integer, Object> list=new HashMap<>();
-        List<ProdProcessExec> ProdProcessExecs=  _prodProcessExecService.lambdaQuery()
-                .eq(ProdProcessExec::getSceneId,SceneId)
-                .list();
-
-// 获取op列表中所有的routingDetailId
-        List<Long> routingDetailIds = ProdProcessExecs.stream()
-                .map(ProdProcessExec::getRoutingDetailId)
-                .filter(Objects::nonNull)
-                .distinct()
-                .collect(Collectors.toList());
-
-// 查询RoutingDiscreteParam中routingDetailId在上述列表中的所有记录
-        List<RoutingDiscreteParam> routingDiscreteParams = _routingDiscreteParamService.lambdaQuery()
-                .in(RoutingDiscreteParam::getRoutingDetailId, routingDetailIds)
-                .eq(RoutingDiscreteParam::getIsDeleted, 0)
-                .list();
-
-
-        List<ProdOrderProcess> ProdOrderProcesss = _prodOrderProcessService.lambdaQuery()
-                .eq(ProdOrderProcess::getSceneId,SceneId)
-                .list();
-
-        List<String> soutceExecId = ProdOrderProcesss.stream()
-                .map(ProdOrderProcess::getExecId)
-                .distinct() // 提取Exec_ID
-                .collect(Collectors.toList());
-
-        List<String> targetExecId = ProdOrderProcesss.stream()
-                .map(ProdOrderProcess::getTargetExecId)
-                .distinct() // 提取TARGET_Exec_ID
-                .collect(Collectors.toList());
-
-        List<String> ExecIdNoChild=  ProdProcessExecs.stream()
-                .filter(e -> !soutceExecId.contains(e.getExecId())&&!targetExecId.contains(e.getExecId()))  // 过滤条件
-                .map(ProdProcessExec::getExecId)
-                .distinct()
-                .collect(Collectors.toList());
-
-        if(ExecIdNoChild!=null&&ExecIdNoChild.size()>0)
-        {
-            for (String ExecId : ExecIdNoChild) {
-                soutceExecId.add(ExecId);
-                targetExecId.add("");
-            }
-        }
-
-
-        List<GroupResult> results= IdGroupingWithDualSerial.groupAndOrderIds(soutceExecId,targetExecId);
-
-
-        List<Entry> entrys=new ArrayList<>();
+        return  _routingDataService.InitEntrys(SceneId,ProdEquipments,ProdLaunchOrders);
 
-        for (int i = 0; i < results.size(); i++) {
-            GroupResult groupResult = results.get(i);
-            List<NodeInfo> nodeInfoList = groupResult.getNodeInfoList();
-           // System.out.println("分组" + (i + 1) + "顺序：" + nodeInfoList);
-            for (NodeInfo nodeInfo : nodeInfoList) {
-//                System.out.printf("原始ID：%s → 全局序号：%d，分组内序号：%d，新父ID列表：%s，新子ID列表：%s%n",
-//                        nodeInfo.getOriginalId(),
-//                        nodeInfo.getGlobalSerial(),
-//                        nodeInfo.getGroupSerial(),
-//                        nodeInfo.getNewParentIds().isEmpty() ? "无" : nodeInfo.getNewParentIds(),
-//                        nodeInfo.getNewChildIds());
-
-                Entry entry = new Entry();
-
-                entry.setId(nodeInfo.getGlobalSerial());
-                entry.setGroupId(i + 1);
-                entry.setSequence(nodeInfo.getGroupSerial());
-                entry.setExecId(nodeInfo.getOriginalId());
-
-                if(nodeInfo.getNewParentIds()!=null)
-                {
-                    List<OperationDependency> OperationDependency=new ArrayList<>();
-                    for (int id : nodeInfo.getNewParentIds()) {
-                        OperationDependency od=new OperationDependency();
-                        od.setPrevOperationId(id);
-                        OperationDependency.add(od);
-                    }
-                    entry.setPrevEntryIds(OperationDependency);
-                }
-
-                ProdProcessExec op= ProdProcessExecs.stream()
-                        .filter(t->t.getExecId().equals(entry.getExecId()))
-                                .findFirst().orElse(null);
-
-                if(nodeInfo.getNewChildIds()!=null)
-                {
-                    List<OperationDependency> OperationDependency=new ArrayList<>();
-                    for (int id : nodeInfo.getNewChildIds()) {
-                        OperationDependency od=new OperationDependency();
-                        od.setNextOperationId(id);
-
-                        // 记录属性
-                        if (op != null) {
-                            od.setDependencyType(DependencyType.fromValueSafe(op.getConnectProperty()));
-                        } else {
-                            od.setDependencyType(DependencyType.FinishToStart);
-                        }
-
-
-
-                        OperationDependency.add(od);
-                    }
-                    entry.setNextEntryIds(OperationDependency);
-                }
-
-
-
-                if(op!=null)
-                {
-                    entry.setDiscreteParameter(routingDiscreteParams.stream().filter(t -> t.getRoutingDetailId().equals(op.getRoutingDetailId())).collect(Collectors.toList()));
-                    entry.setEquipTypeID(op.getMachineId());
-                    entry.setOrderId(op.getOrderId());
-                    entry.setQuantity(op.getPlanQty());
-                    entry.setRoutingDetailId(op.getRoutingDetailId());
-                    entry.setTaskSeq(op.getTaskSeq());
-                    entry.setRoutingDetailName(op.getRoutingDetailName());
-                    ProdLaunchOrder order = ProdLaunchOrders.stream()
-                            .filter(t -> t.getOrderId().equals(op.getOrderId()))
-                            .findFirst().orElse(null);
-                    if (order != null) {
-                        entry.setProductId(order.getMaterialId());
-                    }
-                    List<ProdEquipment> Equipments = ProdEquipments.stream()
-                            .filter(t -> t.getExecId().equals(op.getExecId()))
-                            .collect(Collectors.toList());
-                    if (Equipments != null && Equipments.size() > 0) {
-                        List<MachineOption> mos = new ArrayList<>();
-                        for (ProdEquipment e : Equipments) {
-                            MachineOption mo = new MachineOption();
-                            mo.setMachineId(e.getEquipId());
-                            mo.setProcessingTime(e.getSpeed());
-                             mo.setContantTime(op.getConstTime());
-                             mo.setSetupTime(op.getChangeLineTime());
-                             mo.setTeardownTime(op.getPostprocessingTime());
-                             mo.setPreTime(e.getSetupTime());
-
-                            mos.add(mo);
-                        }
-                        entry.setMachineOptions(mos);
-                    }
-                }
-                entry.setPriority(1);
-                entrys.add(entry);
-            }
-            // 输出每个节点的详细信息
-
-            System.out.println("------------------------");
-        }
-        list.put(1,entrys);
-        list.put(2,results);
 
-        return  list;
 
     }