refactor(gateApi): 优化网格交易服务的订单取消和止损逻辑

Administrator

2026-07-16 5b157fff37104935f0d68a3d3b36f7551cc5b50e

refactor(gateApi): 优化网格交易服务的订单取消和止损逻辑

- 将多单取消逻辑改为向上遍历取消所有遗留多单，跳过基础入场网格0
- 将空单取消逻辑改为向下遍历取消所有遗留空单，跳过基础入场网格0
- 重构多仓止损追单逻辑，基于网格数量动态分配止损订单位置
- 重构空仓止损追单逻辑，基于网格数量动态分配止损订单位置
- 移除固定的3位置止损分配方式，改用更灵活的网格数量计算
- 添加详细的止损订单分配日志记录功能

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

@@ -1203,15 +1203,20 @@

                    if (newEntryGrid != null) {

                        GridElement cancelGridElement = GridElement.findById(newEntryGrid.getUpId());
                        String quantity = String.valueOf((accumulatedLongLossCount + 1) * Integer.parseInt(config.getQuantity()));
                        if (cancelGridElement != null && cancelGridElement.isHasLongOrder()) {
                            for (String longOrderId : new ArrayList<>(cancelGridElement.getLongOrderIds())) {
                        // 向上遍历取消所有遗留多单（跳过基础入场网格0）
                        GridElement cancelCursor = GridElement.findById(newEntryGrid.getUpId());
                        while (cancelCursor != null && cancelCursor.getId() < 0) {
                            if (cancelCursor.isHasLongOrder()) {
                                for (String longOrderId : new ArrayList<>(cancelCursor.getLongOrderIds())) {
                                    GridElement finalCancelCursor = cancelCursor;
                                executor.cancelConditionalOrder(longOrderId, oid -> {
                                    longEntryTraderIdParam(cancelGridElement, longOrderId, false);
                                    log.info("[Gate] 多仓仓位归零, 取消gridId:{}的多单,{}", cancelGridElement.getId(), longOrderId);
                                        longEntryTraderIdParam(finalCancelCursor, longOrderId, false);
                                        log.info("[Gate] 多仓仓位归零, 取消gridId:{}的多单,{}", finalCancelCursor.getId(), longOrderId);
                                });
                            }
                            }
                            cancelCursor = GridElement.findById(cancelCursor.getUpId());
                        }
//                        log.info("[Gate-2] 多仓仓位归零 空仓队列触发, 匹配：{}，当前价：{}", matched, currentPrice);
                        if (!newEntryGrid.isHasLongOrder()) {
@@ -1252,19 +1257,20 @@

                    if (newEntryGrid != null) {

                        GridElement cancelGridElement = GridElement.findById(newEntryGrid.getDownId());

                        String quantity = String.valueOf((accumulatedShortLossCount + 1) * Integer.parseInt(config.getQuantity()));
                        /**
                         * 看是否有空仓挂单，有就取消
                         */
                        if (cancelGridElement != null && cancelGridElement.isHasShortOrder()) {
                            for (String shortOrderId : new ArrayList<>(cancelGridElement.getShortOrderIds())) {
                        // 向下遍历取消所有遗留空单（跳过基础入场网格0）
                        GridElement cancelCursor = GridElement.findById(newEntryGrid.getDownId());
                        while (cancelCursor != null && cancelCursor.getId() > 0) {
                            if (cancelCursor.isHasShortOrder()) {
                                for (String shortOrderId : new ArrayList<>(cancelCursor.getShortOrderIds())) {
                                    GridElement finalCancelCursor = cancelCursor;
                                executor.cancelConditionalOrder(shortOrderId, oid -> {
                                    shortEntryTraderIdParam(cancelGridElement, shortOrderId, false);
                                    log.info("[Gate] 空仓仓位归零, 取消gridId:{}的多单{}", cancelGridElement.getId(), shortOrderId);
                                        shortEntryTraderIdParam(finalCancelCursor, shortOrderId, false);
                                        log.info("[Gate] 空仓仓位归零, 取消gridId:{}的多单{}", finalCancelCursor.getId(), shortOrderId);
                                });
                            }
                            }
                            cancelCursor = GridElement.findById(cancelCursor.getDownId());
                        }
//                        log.info("[Gate-4] 空仓仓位归零 多仓队列触发, 匹配：{}，当前价：{}", matched, currentPrice);
                        if (!newEntryGrid.isHasShortOrder()){
@@ -1642,56 +1648,107 @@
    // ========== 止损追单（新逻辑：3 个固定位置，每个位置挂多个 1 张止损单） ==========

    /**
     * 多仓止损追单 — 3 个固定位置，从近到远分配合约。
     * A(gridId-2): (filledQty/qty - 2) 个独立止损单，每个 qty 张
     * B(gridId-3): 1 个止损单，qty 张
     * C(gridId-4): 1 个止损单，qty 张
     * 注意：多仓止损在 gridId 负方向，触发价 ≤ 网格价。
     * 多仓止损追单 — 网格数量 = baseQuantity/quantity，从近到远分配。
     * aCount<0跳过, aCount=0→主=2, aCount=1→主=2,辅0=1, aCount>=2→主=aCount,辅依次填1
     */
    private void extendLongStopLoss(int filledQty, int gridId) {
        int qty = Integer.parseInt(config.getQuantity());
        int aCount = Math.max(0, filledQty / qty - 2);
        if (aCount < 0) return;
        int baseQty = Integer.parseInt(config.getBaseQuantity());
        int gridCount = baseQty / qty;
        if (gridCount <= 0 || filledQty < qty) {
            return;
        }

        int a, b, c;
        if (aCount == 0) { a = 2; b = 0; c = 0; }
        else if (aCount == 1) { a = 2; b = 1; c = 0; }
        else { a = aCount; b = 1; c = 1; }
        int totalOrders = filledQty / qty;
        int[] orders = new int[gridCount];

        log.info("[Gate] 多仓追挂止损, 成交{}张, gridId:{}, A({})x{}  B({})x{}  C({})x{}",
                filledQty, gridId, gridId - 2, a, gridId - 3, b, gridId - 4, c);
        if (gridCount == 1) {
            // 只有1个网格，全量放在上面
            orders[0] = totalOrders;
        } else {
            int aCount = Math.max(0, totalOrders - 2);
            if (aCount == 0) {
                orders[0] = 2;
            } else if (aCount == 1) {
                orders[0] = 2;
                orders[1] = 1;
            } else {
                orders[0] = aCount;
                int remainder = totalOrders - aCount;
                for (int i = 1; i < gridCount && remainder > 0; i++) {
                    orders[i] = 1;
                    remainder--;
                }
            }
        }

        if (a > 0) placeStopLossOrders(gridId - 2, a, qty, FuturesPriceTrigger.RuleEnum.NUMBER_2,
        StringBuilder detail = new StringBuilder();
        for (int i = 0; i < gridCount; i++) {
            if (orders[i] > 0) {
                int sgId = gridId - 2 - i;
                placeStopLossOrders(sgId, orders[i], qty, FuturesPriceTrigger.RuleEnum.NUMBER_2,
                ORDER_TYPE_CLOSE_LONG, true);
        if (b > 0) placeStopLossOrders(gridId - 3, b, qty, FuturesPriceTrigger.RuleEnum.NUMBER_2,
                ORDER_TYPE_CLOSE_LONG, true);
        if (c > 0) placeStopLossOrders(gridId - 4, c, qty, FuturesPriceTrigger.RuleEnum.NUMBER_2,
                ORDER_TYPE_CLOSE_LONG, true);
                if (detail.length() > 0) {
                    detail.append("  ");
                }
                detail.append(sgId).append("x").append(orders[i]);
            }
        }

        log.info("[Gate] 多仓追挂止损, 成交{}张, gridId:{}, 网格数:{}, 分配:{}",
                filledQty, gridId, gridCount, detail);
    }

    /**
     * 空仓止损追单 — 3 个固定位置，从近到远分配合约。
     * aCount<0跳过, aCount=0→A=2, aCount=1→A=2,B=1, aCount>=2→A=aCount,B=1,C=1
     * 空仓止损追单 — 网格数量 = baseQuantity/quantity，从近到远分配。
     * aCount<0跳过, aCount=0→主=2, aCount=1→主=2,辅0=1, aCount>=2→主=aCount,辅依次填1
     */
    private void extendShortStopLoss(int filledQty, int gridId) {
        int qty = Integer.parseInt(config.getQuantity());
        int aCount = Math.max(0, filledQty / qty - 2);
        if (aCount < 0) return;
        int baseQty = Integer.parseInt(config.getBaseQuantity());
        int gridCount = baseQty / qty;
        if (gridCount <= 0 || filledQty < qty) {
            return;
        }

        int a, b, c;
        if (aCount == 0) { a = 2; b = 0; c = 0; }
        else if (aCount == 1) { a = 2; b = 1; c = 0; }
        else { a = aCount; b = 1; c = 1; }
        int totalOrders = filledQty / qty;
        int[] orders = new int[gridCount];

        log.info("[Gate] 空仓追挂止损, 成交{}张, gridId:{}, A({})x{}  B({})x{}  C({})x{}",
                filledQty, gridId, gridId + 2, a, gridId + 3, b, gridId + 4, c);
        if (gridCount == 1) {
            // 只有1个网格，全量放在上面
            orders[0] = totalOrders;
        } else {
            int aCount = Math.max(0, totalOrders - 2);
            if (aCount == 0) {
                orders[0] = 2;
            } else if (aCount == 1) {
                orders[0] = 2;
                orders[1] = 1;
            } else {
                orders[0] = aCount;
                int remainder = totalOrders - aCount;
                for (int i = 1; i < gridCount && remainder > 0; i++) {
                    orders[i] = 1;
                    remainder--;
                }
            }
        }

        if (a > 0) placeStopLossOrders(gridId + 2, a, qty, FuturesPriceTrigger.RuleEnum.NUMBER_1,
        StringBuilder detail = new StringBuilder();
        for (int i = 0; i < gridCount; i++) {
            if (orders[i] > 0) {
                int sgId = gridId + 2 + i;
                placeStopLossOrders(sgId, orders[i], qty, FuturesPriceTrigger.RuleEnum.NUMBER_1,
                ORDER_TYPE_CLOSE_SHORT, false);
        if (b > 0) placeStopLossOrders(gridId + 3, b, qty, FuturesPriceTrigger.RuleEnum.NUMBER_1,
                ORDER_TYPE_CLOSE_SHORT, false);
        if (c > 0) placeStopLossOrders(gridId + 4, c, qty, FuturesPriceTrigger.RuleEnum.NUMBER_1,
                ORDER_TYPE_CLOSE_SHORT, false);
                if (detail.length() > 0) {
                    detail.append("  ");
                }
                detail.append(sgId).append("x").append(orders[i]);
            }
        }

        log.info("[Gate] 空仓追挂止损, 成交{}张, gridId:{}, 网格数:{}, 分配:{}",
                filledQty, gridId, gridCount, detail);
    }

    /**