refactor(gateApi): 优化网格交易服务的订单ID管理

Administrator

2026-07-13 80a4a7c778b82aed3901e2caa676b0d7847cbe82

refactor(gateApi): 优化网格交易服务的订单ID管理

- 将单一订单ID改为订单ID列表以支持同一网格多个挂单
- 修改止损触发处理方法以接收订单ID参数并精确移除对应订单
- 更新网格元素中的订单ID字段为列表结构并添加相应操作方法
- 调整订单状态检查逻辑从单一ID检查改为列表非空检查
- 修复止损追单时不判断挂单状态导致的重复下单问题
- 更新订单索引维护逻辑以支持多订单ID场景
- 添加兼容性方法确保旧代码调用不受影响

 src/main/java/com/xcong/excoin/modules/gateApi/GateGridTradeService.java

@@ -612,21 +612,21 @@
        GridElement longStopLossElem = GridElement.findByLongStopLossOrderId(orderId);
//        if (longStopLossElem != null && longPositionSize.compareTo(BigDecimal.ZERO) > 0 && StrUtil.isNotEmpty(tradeId) && !tradeId.equals("0")) {
        if (longStopLossElem != null && StrUtil.isNotEmpty(tradeId) && !tradeId.equals("0")) {
            handleLongStopLossTriggered(longStopLossElem);
            handleLongStopLossTriggered(longStopLossElem, orderId);
            return;
        }
        GridElement shortStopLossElem = GridElement.findByShortStopLossOrderId(orderId);
//        if (shortStopLossElem != null && shortPositionSize.compareTo(BigDecimal.ZERO) > 0 && StrUtil.isNotEmpty(tradeId) && !tradeId.equals("0")) {
        if (shortStopLossElem != null && StrUtil.isNotEmpty(tradeId) && !tradeId.equals("0")) {
            handleShortStopLossTriggered(shortStopLossElem);
            handleShortStopLossTriggered(shortStopLossElem, orderId);
            return;
        }

        GridElement shortGridElement = GridElement.findByShortOrderId(orderId);
        if (shortGridElement != null) {
            if (shortGridElement.isHasShortOrder() && StrUtil.isNotEmpty(tradeId) && !tradeId.equals("0") ){
            if (StrUtil.isNotEmpty(tradeId) && !tradeId.equals("0") ){
                int filledQty = Integer.parseInt(shortGridElement.getShortTraderParam().getQuantity());
                shortEntryTraderIdParam(shortGridElement, null, false);
                shortEntryTraderIdParam(shortGridElement, orderId, false);
                // [Gate-需求2] 加仓后先撤空仓所有止盈+止损，再查交易所持仓后重挂
                cancelAllShortTakeProfitsAndStopLosses();
                // REST 查询可能因交易所延迟返回旧值，与 WS 本地缓存取最大值兜底
@@ -700,10 +700,10 @@
        }
        GridElement longGridElement = GridElement.findByLongOrderId(orderId);
        if (longGridElement != null) {
            if (longGridElement.isHasLongOrder() && StrUtil.isNotEmpty(tradeId) && !tradeId.equals("0")){
            if (StrUtil.isNotEmpty(tradeId) && !tradeId.equals("0")){

                int filledQty = Integer.parseInt(longGridElement.getLongTraderParam().getQuantity());
                longEntryTraderIdParam(longGridElement, null, false);
                longEntryTraderIdParam(longGridElement, orderId, false);
                // [Gate-需求2] 加仓后先撤多仓所有止盈+止损，再查交易所持仓后重挂
                cancelAllLongTakeProfitsAndStopLosses();
                // REST 查询可能因交易所延迟返回旧值，与 WS 本地缓存取最大值兜底
@@ -1007,8 +1007,14 @@
        TraderParam tp = baseElement.getLongTraderParam();
        tp.setEntryOrderId(entryId);
        tp.setEntryOrderPlaced(flag);
        baseElement.setHasLongOrder(flag);
        baseElement.setLongOrderId(entryId);
        if (flag && entryId != null) {
            baseElement.addLongOrderId(entryId);
            baseElement.setHasLongOrder(true);
        } else if (!flag && entryId != null) {
            baseElement.removeLongOrderId(entryId);
            // 只有列表全部清空才关闭预置标志，避免还有未成交挂单时被 processGrid 误判
            baseElement.setHasLongOrder(baseElement.hasLongOrderIds());
        }
        GridElement.refreshIndices();
    }

@@ -1018,8 +1024,14 @@
        TraderParam tp = baseElement.getShortTraderParam();
        tp.setEntryOrderId(entryId);
        tp.setEntryOrderPlaced(flag);
        baseElement.setHasShortOrder(flag);
        baseElement.setShortOrderId(entryId);
        if (flag && entryId != null) {
            baseElement.addShortOrderId(entryId);
            baseElement.setHasShortOrder(true);
        } else if (!flag && entryId != null) {
            baseElement.removeShortOrderId(entryId);
            // 只有列表全部清空才关闭预置标志，避免还有未成交挂单时被 processGrid 误判
            baseElement.setHasShortOrder(baseElement.hasShortOrderIds());
        }
        GridElement.refreshIndices();
    }

@@ -1212,11 +1224,12 @@
                                ? cancelGridElement.getLongTraderParam().getQuantity()
                                : config.getBaseQuantity();
                        if (cancelGridElement != null && cancelGridElement.isHasLongOrder()) {
                            String longOrderId = cancelGridElement.getLongOrderId();
                            executor.cancelConditionalOrder(longOrderId, oid -> {
                                longEntryTraderIdParam(cancelGridElement, null, false);
                                log.info("[Gate] 多仓仓位归零, 取消gridId:{}的多单,{}", cancelGridElement.getId(),longOrderId);
                            });
                            for (String longOrderId : new ArrayList<>(cancelGridElement.getLongOrderIds())) {
                                executor.cancelConditionalOrder(longOrderId, oid -> {
                                    longEntryTraderIdParam(cancelGridElement, longOrderId, false);
                                    log.info("[Gate] 多仓仓位归零, 取消gridId:{}的多单,{}", cancelGridElement.getId(), longOrderId);
                                });
                            }
                        }
//                        log.info("[Gate-2] 多仓仓位归零 空仓队列触发, 匹配：{}，当前价：{}", matched, currentPrice);
                        if (!newEntryGrid.isHasLongOrder()) {
@@ -1266,11 +1279,12 @@
                         * 看是否有空仓挂单，有就取消
                         */
                        if (cancelGridElement != null && cancelGridElement.isHasShortOrder()) {
                            String shortOrderId = cancelGridElement.getShortOrderId();
                            executor.cancelConditionalOrder(shortOrderId, oid -> {
                                shortEntryTraderIdParam(cancelGridElement, null, false);
                                log.info("[Gate] 空仓仓位归零, 取消gridId:{}的多单{}", cancelGridElement.getId(),shortOrderId);
                            });
                            for (String shortOrderId : new ArrayList<>(cancelGridElement.getShortOrderIds())) {
                                executor.cancelConditionalOrder(shortOrderId, oid -> {
                                    shortEntryTraderIdParam(cancelGridElement, shortOrderId, false);
                                    log.info("[Gate] 空仓仓位归零, 取消gridId:{}的多单{}", cancelGridElement.getId(), shortOrderId);
                                });
                            }
                        }
//                        log.info("[Gate-4] 空仓仓位归零 多仓队列触发, 匹配：{}，当前价：{}", matched, currentPrice);
                        if (!newEntryGrid.isHasShortOrder()){
@@ -1289,8 +1303,8 @@
        }
    }

    private void handleLongStopLossTriggered(GridElement gridElement) {
        gridElement.clearLongStopLossOrderIds();
    private void handleLongStopLossTriggered(GridElement gridElement, String orderId) {
        gridElement.removeLongStopLossOrderId(orderId);

        accumulatedLongLossCount++;
        int gridId = gridElement.getId();
@@ -1304,52 +1318,48 @@
            return;
        }

        // [Gate-BugFix] 防止与"仓位归零"重复下单：若该网格已有挂单则跳过
        if (!newEntryGrid.isHasLongOrder()) {
            BigDecimal triggerPrice = newEntryGrid.getGridPrice();

            // 止损触发后持仓在减少，取REST和WS缓存中较小值更准确
            int posSize = Math.min(queryPositionSize(Position.ModeEnum.DUAL_LONG), longPositionSize.intValue());
            int maxPos = config.getMaxPositionSize();
            // 止损阶梯：止损次数≤阈值时挂单量=单笔数量，超过后恢复默认逻辑(quantity*2)
            int targetAmount;
            if (config.getStopLossCount() > 0 && accumulatedLongLossCount <= config.getStopLossCount()) {
                targetAmount = Integer.parseInt(config.getQuantity());
        // 止损追单：同一网格可有多笔挂单，不判断 isHasLongOrder，直接挂单
        BigDecimal triggerPrice = newEntryGrid.getGridPrice();
        int posSize = Math.min(queryPositionSize(Position.ModeEnum.DUAL_LONG), longPositionSize.intValue());
        int maxPos = config.getMaxPositionSize();
        int targetAmount;
        if (config.getStopLossCount() > 0 && accumulatedLongLossCount <= config.getStopLossCount()) {
            targetAmount = Integer.parseInt(config.getQuantity());
        } else {
            targetAmount = Integer.parseInt(config.getQuantity()) * 2;
        }
        int addSize;
        if (maxPos > 0) {
            int remainingRoom = maxPos - posSize;
            if (remainingRoom <= 0) {
                log.warn("[Gate] 多仓止损触发 gridId:{}, 当前持仓{}/{}已达上限，跳过追单",
                        gridId, posSize, maxPos);
                addSize = 0;
            } else {
                targetAmount = Integer.parseInt(config.getQuantity()) * 2; // quantity + 本次止损量
                addSize = Math.min(remainingRoom, targetAmount);
            }
            int addSize;
            if (maxPos > 0) {
                int remainingRoom = maxPos - posSize;
                if (remainingRoom <= 0) {
                    log.warn("[Gate] 多仓止损触发 gridId:{}, 当前持仓{}/{}已达上限，跳过追单",
                            gridId, posSize, maxPos);
                    addSize = 0;
                } else {
                    addSize = Math.min(remainingRoom, targetAmount);
                }
            } else {
                addSize = targetAmount;
            }
            if (addSize > 0) {
                String size = String.valueOf(addSize);
                log.info("[Gate] 多仓止损触发 gridId:{}, 止损次数:{}, 在gridId:{}补{}张多单(当前{}/上限{})",
                        gridId, accumulatedLongLossCount, newEntryGridId, size, posSize, maxPos > 0 ? maxPos : "无");
                newEntryGrid.getLongTraderParam().setQuantity(size);
                placeEntryOrderWithPreFlag(newEntryGrid, true, triggerPrice,
                        FuturesPriceTrigger.RuleEnum.NUMBER_1, size);
            }
        }else{
            log.warn("[Gate] 多仓止损触发 gridId:{}, 目标gridId:{}已有挂单，跳过重复下单", gridId, newEntryGridId);
        } else {
            addSize = targetAmount;
        }
        if (addSize > 0) {
            String size = String.valueOf(addSize);
            log.info("[Gate] 多仓止损触发 gridId:{}, 止损次数:{}, 在gridId:{}补{}张多单(当前{}/上限{})",
                    gridId, accumulatedLongLossCount, newEntryGridId, size, posSize, maxPos > 0 ? maxPos : "无");
            newEntryGrid.getLongTraderParam().setQuantity(size);
            placeEntryOrderWithPreFlag(newEntryGrid, true, triggerPrice,
                    FuturesPriceTrigger.RuleEnum.NUMBER_1, size);
        }

        // 取消 gridId+2 位置的所有多单
        int cancelGridId = gridId + 2;
        GridElement cancelGrid = GridElement.findById(cancelGridId);
        if (cancelGrid != null && cancelGrid.isHasLongOrder()) {
            executor.cancelConditionalOrder(cancelGrid.getLongOrderId(), oid -> {
                longEntryTraderIdParam(cancelGrid, null, false);
                log.info("[Gate] 多仓止损触发, 取消gridId:{}的多单", cancelGridId);
            });
            for (String cancelOrderId : new ArrayList<>(cancelGrid.getLongOrderIds())) {
                executor.cancelConditionalOrder(cancelOrderId, oid -> {
                    longEntryTraderIdParam(cancelGrid, cancelOrderId, false);
                    log.info("[Gate] 多仓止损触发, 取消gridId:{}的多单,{}", cancelGridId, cancelOrderId);
                });
            }
        }

        // 止损触发时，取消最远的多仓止盈订单
@@ -1371,8 +1381,8 @@
        }
    }

    private void handleShortStopLossTriggered(GridElement gridElement) {
        gridElement.clearShortStopLossOrderIds();
    private void handleShortStopLossTriggered(GridElement gridElement, String orderId) {
        gridElement.removeShortStopLossOrderId(orderId);

        accumulatedShortLossCount++;
        int gridId = gridElement.getId();
@@ -1386,55 +1396,48 @@
            return;
        }

        // [Gate-BugFix] 防止与"仓位归零"重复下单：若该网格已有挂单则跳过
        if (!newEntryGrid.isHasShortOrder()) {
            BigDecimal triggerPrice = newEntryGrid.getGridPrice();

            // 止损触发后持仓在减少，取REST和WS缓存中较小值更准确
            int posSize = Math.min(queryPositionSize(Position.ModeEnum.DUAL_SHORT), shortPositionSize.intValue());
            int maxPos = config.getMaxPositionSize();
            // 止损阶梯：止损次数≤阈值时挂单量=单笔数量，超过后恢复默认逻辑(quantity*2)
            int targetAmount;
            if (config.getStopLossCount() > 0 && accumulatedShortLossCount <= config.getStopLossCount()) {
                targetAmount = Integer.parseInt(config.getQuantity());
        // 止损追单：同一网格可有多笔挂单，不判断 isHasShortOrder，直接挂单
        BigDecimal triggerPrice = newEntryGrid.getGridPrice();
        int posSize = Math.min(queryPositionSize(Position.ModeEnum.DUAL_SHORT), shortPositionSize.intValue());
        int maxPos = config.getMaxPositionSize();
        int targetAmount;
        if (config.getStopLossCount() > 0 && accumulatedShortLossCount <= config.getStopLossCount()) {
            targetAmount = Integer.parseInt(config.getQuantity());
        } else {
            targetAmount = Integer.parseInt(config.getQuantity()) * 2;
        }
        int addSize;
        if (maxPos > 0) {
            int remainingRoom = maxPos - posSize;
            if (remainingRoom <= 0) {
                log.warn("[Gate] 空仓止损触发 gridId:{}, 当前持仓{}/{}已达上限，跳过追单",
                        gridId, posSize, maxPos);
                addSize = 0;
            } else {
                targetAmount = Integer.parseInt(config.getQuantity()) * 2; // quantity + 本次止损量
                addSize = Math.min(remainingRoom, targetAmount);
            }
            int addSize;
            if (maxPos > 0) {
                int remainingRoom = maxPos - posSize;
                if (remainingRoom <= 0) {
                    log.warn("[Gate] 空仓止损触发 gridId:{}, 当前持仓{}/{}已达上限，跳过追单",
                            gridId, posSize, maxPos);
                    addSize = 0;
                } else {
                    addSize = Math.min(remainingRoom, targetAmount);
                }
            } else {
                addSize = targetAmount;
            }
            if (addSize > 0) {
                String size = String.valueOf(addSize);
                log.info("[Gate] 空仓止损触发 gridId:{}, 止损次数:{}, 在gridId:{}补{}张空单(当前{}/上限{})",
                        gridId, accumulatedShortLossCount, newEntryGridId, size, posSize, maxPos > 0 ? maxPos : "无");
                newEntryGrid.getShortTraderParam().setQuantity(size);
                placeEntryOrderWithPreFlag(newEntryGrid, false, triggerPrice,
                        FuturesPriceTrigger.RuleEnum.NUMBER_2, negate(size));
            }
        }else{
            log.warn("[Gate] 空仓止损触发 gridId:{}, 目标gridId:{}已有挂单，跳过重复下单", gridId, newEntryGridId);
        } else {
            addSize = targetAmount;
        }
        if (addSize > 0) {
            String size = String.valueOf(addSize);
            log.info("[Gate] 空仓止损触发 gridId:{}, 止损次数:{}, 在gridId:{}补{}张空单(当前{}/上限{})",
                    gridId, accumulatedShortLossCount, newEntryGridId, size, posSize, maxPos > 0 ? maxPos : "无");
            newEntryGrid.getShortTraderParam().setQuantity(size);
            placeEntryOrderWithPreFlag(newEntryGrid, false, triggerPrice,
                    FuturesPriceTrigger.RuleEnum.NUMBER_2, negate(size));
        }




        // 取消 gridId-2 位置的所有空单
        int cancelGridId = gridId - 2;
        GridElement cancelGrid = GridElement.findById(cancelGridId);
        if (cancelGrid != null && cancelGrid.isHasShortOrder()) {
            executor.cancelConditionalOrder(cancelGrid.getShortOrderId(), oid -> {
                shortEntryTraderIdParam(cancelGrid, null, false);
                log.info("[Gate] 空仓止损触发, 取消gridId:{}的空单", cancelGridId);
            });
            for (String cancelOrderId : new ArrayList<>(cancelGrid.getShortOrderIds())) {
                executor.cancelConditionalOrder(cancelOrderId, oid -> {
                    shortEntryTraderIdParam(cancelGrid, cancelOrderId, false);
                    log.info("[Gate] 空仓止损触发, 取消gridId:{}的空单,{}", cancelGridId, cancelOrderId);
                });
            }
        }

        // 止损触发时，取消最远的空仓止盈订单
@@ -1786,15 +1789,18 @@
                    }
                },
                () -> {
                    // 仅当列表为空（无其他有效订单）时才清预置标志，避免误伤其他并发挂单
                    if (isLong) {
                        gridElement.setHasLongOrder(false);
                        gridElement.setLongOrderId(null);
                        if (!gridElement.hasLongOrderIds()) {
                            gridElement.setHasLongOrder(false);
                        }
                    } else {
                        gridElement.setHasShortOrder(false);
                        gridElement.setShortOrderId(null);
                        if (!gridElement.hasShortOrderIds()) {
                            gridElement.setHasShortOrder(false);
                        }
                    }
                    GridElement.refreshIndices();
                    log.warn("[Gate] 条件单创建失败，回滚标志位 gridId:{}, isLong:{}", gridElement.getId(), isLong);
                    log.warn("[Gate] 条件单创建失败 gridId:{}, isLong:{}", gridElement.getId(), isLong);
                }
        );
    }

 src/main/java/com/xcong/excoin/modules/gateApi/GridElement.java

@@ -79,10 +79,10 @@
    private Integer upId;
    /** 下一个网格编号，null 表示无下一级 */
    private Integer downId;
    /** 多仓挂单订单 ID */
    private String longOrderId;
    /** 空仓挂单订单 ID */
    private String shortOrderId;
    /** 多仓挂单订单 ID 列表（支持同一网格多个挂单，由止损追单产生） */
    private List<String> longOrderIds = new ArrayList<>();
    /** 空仓挂单订单 ID 列表（支持同一网格多个挂单，由止损追单产生） */
    private List<String> shortOrderIds = new ArrayList<>();
    /** 多仓止盈订单 ID */
    private String longTakeProfitOrderId;
    /** 空仓止盈订单 ID */
@@ -256,9 +256,9 @@
                        e.getUpId(),
                        e.getDownId(),
                        e.isHasLongOrder() ? "有" : "无",
                        e.getLongOrderId() != null ? e.getLongOrderId() : "-",
                        e.hasLongOrderIds() ? String.join(",", e.getLongOrderIds()) : "-",
                        e.isHasShortOrder() ? "有" : "无",
                        e.getShortOrderId() != null ? e.getShortOrderId() : "-",
                        e.hasShortOrderIds() ? String.join(",", e.getShortOrderIds()) : "-",
                        e.getLongTakeProfitOrderId() != null ? e.getLongTakeProfitOrderId() : "-",
                        e.getShortTakeProfitOrderId() != null ? e.getShortTakeProfitOrderId() : "-",
                        e.hasLongStopLossOrders() ? String.join(",", e.getLongStopLossOrderIds()) : "-",
@@ -320,11 +320,11 @@

    private static void putDynamicIndices(GridElement e) {
        PRICE_INDEX.put(e.getGridPrice(), e);
        if (e.getLongOrderId() != null) {
            LONG_ORDER_ID_INDEX.put(e.getLongOrderId(), e);
        for (String oId : e.getLongOrderIds()) {
            LONG_ORDER_ID_INDEX.put(oId, e);
        }
        if (e.getShortOrderId() != null) {
            SHORT_ORDER_ID_INDEX.put(e.getShortOrderId(), e);
        for (String oId : e.getShortOrderIds()) {
            SHORT_ORDER_ID_INDEX.put(oId, e);
        }
        if (e.getLongTakeProfitOrderId() != null) {
            LONG_TP_ORDER_ID_INDEX.put(e.getLongTakeProfitOrderId(), e);
@@ -363,10 +363,10 @@
        this.shortTraderParam = builder.shortTraderParam;
        this.upId = builder.upId;
        this.downId = builder.downId;
        this.longOrderId = builder.longOrderId;
        this.shortOrderId = builder.shortOrderId;
        this.longTakeProfitOrderId = builder.longTakeProfitOrderId;
        this.shortTakeProfitOrderId = builder.shortTakeProfitOrderId;
        if (builder.longOrderIds != null) this.longOrderIds.addAll(builder.longOrderIds);
        if (builder.shortOrderIds != null) this.shortOrderIds.addAll(builder.shortOrderIds);
        if (builder.longStopLossOrderIds != null) this.longStopLossOrderIds.addAll(builder.longStopLossOrderIds);
        if (builder.shortStopLossOrderIds != null) this.shortStopLossOrderIds.addAll(builder.shortStopLossOrderIds);
    }
@@ -427,19 +427,43 @@
    /** 设置下一个网格编号 */
    public void setDownId(Integer downId) { this.downId = downId; }

    // ==================== 多仓挂单订单 ID ====================
    // ==================== 多仓挂单订单 ID 列表 ====================

    /** @return 多仓挂单订单 ID */
    public String getLongOrderId() { return longOrderId; }
    /** 设置多仓挂单订单 ID */
    public void setLongOrderId(String longOrderId) { this.longOrderId = longOrderId; }
    /** @return 多仓挂单订单 ID 列表 */
    public List<String> getLongOrderIds() { return longOrderIds; }
    /** 添加多仓挂单订单 ID */
    public void addLongOrderId(String orderId) { if (orderId != null) longOrderIds.add(orderId); }
    /** 移除多仓挂单订单 ID */
    public boolean removeLongOrderId(String orderId) { return longOrderIds.remove(orderId); }
    /** 清空多仓挂单订单 ID */
    public void clearLongOrderIds() { longOrderIds.clear(); }
    /** @return 是否有挂单 ID（列表非空） */
    public boolean hasLongOrderIds() { return !longOrderIds.isEmpty(); }
    /** @deprecated 返回最后一个订单ID，用于单订单场景的兼容 */
    @Deprecated
    public String getLongOrderId() { return longOrderIds.isEmpty() ? null : longOrderIds.get(longOrderIds.size() - 1); }
    /** @deprecated 添加到列表，用于兼容旧调用 */
    @Deprecated
    public void setLongOrderId(String orderId) { if (orderId != null) longOrderIds.add(orderId); }

    // ==================== 空仓挂单订单 ID ====================
    // ==================== 空仓挂单订单 ID 列表 ====================

    /** @return 空仓挂单订单 ID */
    public String getShortOrderId() { return shortOrderId; }
    /** 设置空仓挂单订单 ID */
    public void setShortOrderId(String shortOrderId) { this.shortOrderId = shortOrderId; }
    /** @return 空仓挂单订单 ID 列表 */
    public List<String> getShortOrderIds() { return shortOrderIds; }
    /** 添加空仓挂单订单 ID */
    public void addShortOrderId(String orderId) { if (orderId != null) shortOrderIds.add(orderId); }
    /** 移除空仓挂单订单 ID */
    public boolean removeShortOrderId(String orderId) { return shortOrderIds.remove(orderId); }
    /** 清空空仓挂单订单 ID */
    public void clearShortOrderIds() { shortOrderIds.clear(); }
    /** @return 是否有挂单 ID（列表非空） */
    public boolean hasShortOrderIds() { return !shortOrderIds.isEmpty(); }
    /** @deprecated 返回最后一个订单ID，用于单订单场景的兼容 */
    @Deprecated
    public String getShortOrderId() { return shortOrderIds.isEmpty() ? null : shortOrderIds.get(shortOrderIds.size() - 1); }
    /** @deprecated 添加到列表，用于兼容旧调用 */
    @Deprecated
    public void setShortOrderId(String orderId) { if (orderId != null) shortOrderIds.add(orderId); }

    // ==================== 多仓止盈订单 ID ====================

@@ -513,10 +537,10 @@
        private Integer upId;
        /** 下一个网格编号，默认 null（无下一级） */
        private Integer downId;
        /** 多仓挂单订单 ID */
        private String longOrderId;
        /** 空仓挂单订单 ID */
        private String shortOrderId;
        /** 多仓挂单订单 ID 列表 */
        private List<String> longOrderIds;
        /** 空仓挂单订单 ID 列表 */
        private List<String> shortOrderIds;
        /** 多仓止盈订单 ID */
        private String longTakeProfitOrderId;
        /** 空仓止盈订单 ID */
@@ -542,10 +566,10 @@
        public Builder upId(Integer upId) { this.upId = upId; return this; }
        /** 设置下一个网格编号 */
        public Builder downId(Integer downId) { this.downId = downId; return this; }
        /** 设置多仓挂单订单 ID */
        public Builder longOrderId(String longOrderId) { this.longOrderId = longOrderId; return this; }
        /** 设置空仓挂单订单 ID */
        public Builder shortOrderId(String shortOrderId) { this.shortOrderId = shortOrderId; return this; }
        /** 设置多仓挂单订单 ID 列表 */
        public Builder longOrderIds(List<String> longOrderIds) { this.longOrderIds = longOrderIds; return this; }
        /** 设置空仓挂单订单 ID 列表 */
        public Builder shortOrderIds(List<String> shortOrderIds) { this.shortOrderIds = shortOrderIds; return this; }
        /** 设置多仓止盈订单 ID */
        public Builder longTakeProfitOrderId(String longTakeProfitOrderId) { this.longTakeProfitOrderId = longTakeProfitOrderId; return this; }
        /** 设置空仓止盈订单 ID */