feat(gateApi): 添加止盈触发对向加仓功能

Administrator

2026-09-23 5f3873f1c0de56fc9edf532f457c0277614a9798

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

@@ -19,6 +19,7 @@
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;

@@ -160,6 +161,11 @@
    private volatile int lastShortStopLossGridId = Integer.MAX_VALUE;
    /** 自定义止损模式激活标记：true=尚未发生第一次止损触发，第一次触发后置 false（触发未触发侧重挂默认） */
    private final AtomicBoolean dualStopLossModeActive = new AtomicBoolean(false);

    /** 止盈触发对向加仓：多仓止盈→空仓开仓单ID → 网格ID（成交后在该网格+1挂空仓止损） */
    private final Map<String, Integer> tpOppositeShortOrderGridMap = new ConcurrentHashMap<>();
    /** 止盈触发对向加仓：空仓止盈→多仓开仓单ID → 网格ID（成交后在该网格-1挂多仓止损） */
    private final Map<String, Integer> tpOppositeLongOrderGridMap = new ConcurrentHashMap<>();

    private volatile BigDecimal lastKlinePrice;
    private volatile BigDecimal markPrice = BigDecimal.ZERO;
@@ -786,9 +792,27 @@
            return;
        }

        // 止盈单成交 → 清理止盈状态，并按配置触发对向加仓
        GridElement longTpElem = GridElement.findByLongTakeProfitOrderId(orderId);
        if (longTpElem != null && StrUtil.isNotEmpty(tradeId) && !tradeId.equals("0")) {
            handleLongTakeProfitTriggered(longTpElem, orderId);
            return;
        }
        GridElement shortTpElem = GridElement.findByShortTakeProfitOrderId(orderId);
        if (shortTpElem != null && StrUtil.isNotEmpty(tradeId) && !tradeId.equals("0")) {
            handleShortTakeProfitTriggered(shortTpElem, orderId);
            return;
        }

        GridElement shortGridElement = GridElement.findByShortOrderId(orderId);
        if (shortGridElement != null) {
            if (StrUtil.isNotEmpty(tradeId) && !tradeId.equals("0") ){
                // 止盈触发的对向加仓空仓开仓单成交 → 在网格+1挂空仓止损
                Integer tpOppositeGridId = tpOppositeShortOrderGridMap.remove(orderId);
                if (tpOppositeGridId != null) {
                    handleTpOppositeShortAddFilled(shortGridElement, tpOppositeGridId);
                    return;
                }
                int filledQty = Integer.parseInt(shortGridElement.getShortTraderParam().getQuantity());
                shortEntryTraderIdParam(shortGridElement, orderId, false);

@@ -831,6 +855,12 @@
        if (longGridElement != null) {
            if (StrUtil.isNotEmpty(tradeId) && !tradeId.equals("0")){

                // 止盈触发的对向加仓多仓开仓单成交 → 在网格-1挂多仓止损
                Integer tpOppositeGridId = tpOppositeLongOrderGridMap.remove(orderId);
                if (tpOppositeGridId != null) {
                    handleTpOppositeLongAddFilled(longGridElement, tpOppositeGridId);
                    return;
                }
                int filledQty = Integer.parseInt(longGridElement.getLongTraderParam().getQuantity());
                longEntryTraderIdParam(longGridElement, orderId, false);

@@ -871,6 +901,233 @@


    /**
     * 多仓止盈单成交：清理止盈状态，并按配置在对向（空仓）挂开仓单。
     *
     * @param tpElem  触发止盈的网格元素
     * @param orderId 止盈单 ID
     */
    private void handleLongTakeProfitTriggered(GridElement tpElem, String orderId) {
        // 清理前判断：当前是否为该方向最后一个止盈单（最后一个不触发对向加仓）
        boolean isLastTp = GridElement.getLongTakeProfitCount() <= 1;
        // 清理止盈单状态（已成交）
        longTakeProfitTraderIdParam(tpElem, null, false);
        log.info("[Gate] 多仓止盈触发 gridId:{}, orderId:{}, 剩余止盈:{}", tpElem.getId(), orderId,
                GridElement.getLongTakeProfitCount());

        // 止盈依次上移：先取消之前挂的对向空开仓单，再挂新单
        cancelTpOppositeShortEntries();

        if (!config.isTpTriggerOppositeAddEnabled()) {
            return;
        }
        if (isLastTp) {
            log.info("[Gate] 多仓止盈为最后一个, 不触发对向加仓, gridId:{}", tpElem.getId());
            return;
        }
        int qty = config.getTpTriggerOppositeAddQuantity();
        if (qty <= 0) {
            return;
        }
        // 多仓止盈在 gridId=N 成交，对向空仓开仓单挂在 gridId=N-1
        int targetGridId = tpElem.getId() - 1;
        GridElement target = GridElement.findById(targetGridId);
        if (target == null) {
            log.warn("[Gate] 止盈触发对向加仓: 目标网格不存在, 止盈gridId:{}, 目标gridId:{}", tpElem.getId(), targetGridId);
            return;
        }
        placeOppositeAddShortEntry(target, tpElem, qty);
    }

    /**
     * 空仓止盈单成交：清理止盈状态，并按配置在对向（多仓）挂开仓单。
     *
     * @param tpElem  触发止盈的网格元素
     * @param orderId 止盈单 ID
     */
    private void handleShortTakeProfitTriggered(GridElement tpElem, String orderId) {
        // 清理前判断：当前是否为该方向最后一个止盈单（最后一个不触发对向加仓）
        boolean isLastTp = GridElement.getShortTakeProfitCount() <= 1;
        // 清理止盈单状态（已成交）
        shortTakeProfitTraderIdParam(tpElem, null, false);
        log.info("[Gate] 空仓止盈触发 gridId:{}, orderId:{}, 剩余止盈:{}", tpElem.getId(), orderId,
                GridElement.getShortTakeProfitCount());

        // 止盈依次下移：先取消之前挂的对向多开仓单，再挂新单
        cancelTpOppositeLongEntries();

        if (!config.isTpTriggerOppositeAddEnabled()) {
            return;
        }
        if (isLastTp) {
            log.info("[Gate] 空仓止盈为最后一个, 不触发对向加仓, gridId:{}", tpElem.getId());
            return;
        }
        int qty = config.getTpTriggerOppositeAddQuantity();
        if (qty <= 0) {
            return;
        }
        // 空仓止盈在 gridId=N 成交，对向多仓开仓单挂在 gridId=N+1
        int targetGridId = tpElem.getId() + 1;
        GridElement target = GridElement.findById(targetGridId);
        if (target == null) {
            log.warn("[Gate] 止盈触发对向加仓: 目标网格不存在, 止盈gridId:{}, 目标gridId:{}", tpElem.getId(), targetGridId);
            return;
        }
        placeOppositeAddLongEntry(target, tpElem, qty);
    }

    /**
     * 取消所有已挂未成交的对向空仓开仓单（止盈依次上移时，取消旧位置的开仓单）。
     */
    private void cancelTpOppositeShortEntries() {
        if (tpOppositeShortOrderGridMap.isEmpty()) {
            return;
        }
        List<String> orderIds = new ArrayList<>(tpOppositeShortOrderGridMap.keySet());
        tpOppositeShortOrderGridMap.clear();
        for (String oid : orderIds) {
            GridElement elem = GridElement.findByShortOrderId(oid);
            if (elem != null) {
                elem.removeShortOrderId(oid);
                elem.setHasShortOrder(elem.hasShortOrderIds());
            }
            executor.cancelConditionalOrder(oid, o -> {});
            log.info("[Gate] 取消对向空开仓单, orderId:{}", oid);
        }
        GridElement.refreshIndices();
    }

    /**
     * 取消所有已挂未成交的对向多仓开仓单（止盈依次下移时，取消旧位置的开仓单）。
     */
    private void cancelTpOppositeLongEntries() {
        if (tpOppositeLongOrderGridMap.isEmpty()) {
            return;
        }
        List<String> orderIds = new ArrayList<>(tpOppositeLongOrderGridMap.keySet());
        tpOppositeLongOrderGridMap.clear();
        for (String oid : orderIds) {
            GridElement elem = GridElement.findByLongOrderId(oid);
            if (elem != null) {
                elem.removeLongOrderId(oid);
                elem.setHasLongOrder(elem.hasLongOrderIds());
            }
            executor.cancelConditionalOrder(oid, o -> {});
            log.info("[Gate] 取消对向多开仓单, orderId:{}", oid);
        }
        GridElement.refreshIndices();
    }

    /**
     * 在目标网格挂空仓对向开仓单，并记录订单ID→网格ID映射，供成交后挂止损。
     */
    private void placeOppositeAddShortEntry(GridElement target, GridElement tpElem, int qty) {
        target.setHasShortOrder(true);
        executor.placeConditionalEntryOrder(
                target.getGridPrice(),
                FuturesPriceTrigger.RuleEnum.NUMBER_2,
                negate(String.valueOf(qty)),
                orderId -> {
                    tpOppositeShortOrderGridMap.put(orderId, target.getId());
                    shortEntryTraderIdParam(target, orderId, true);
                    log.info("[Gate] 多仓止盈触发对向加仓, 止盈gridId:{}, 空仓开仓gridId:{}, 数量:{}张, orderId:{}",
                            tpElem.getId(), target.getId(), qty, orderId);
                },
                () -> {
                    if (!target.hasShortOrderIds()) {
                        target.setHasShortOrder(false);
                    }
                    GridElement.refreshIndices();
                    log.warn("[Gate] 多仓止盈触发对向加仓挂单失败, 止盈gridId:{}, 目标gridId:{}",
                            tpElem.getId(), target.getId());
                }
        );
    }

    /**
     * 在目标网格挂多仓对向开仓单，并记录订单ID→网格ID映射，供成交后挂止损。
     */
    private void placeOppositeAddLongEntry(GridElement target, GridElement tpElem, int qty) {
        target.setHasLongOrder(true);
        executor.placeConditionalEntryOrder(
                target.getGridPrice(),
                FuturesPriceTrigger.RuleEnum.NUMBER_1,
                String.valueOf(qty),
                orderId -> {
                    tpOppositeLongOrderGridMap.put(orderId, target.getId());
                    longEntryTraderIdParam(target, orderId, true);
                    log.info("[Gate] 空仓止盈触发对向加仓, 止盈gridId:{}, 多仓开仓gridId:{}, 数量:{}张, orderId:{}",
                            tpElem.getId(), target.getId(), qty, orderId);
                },
                () -> {
                    if (!target.hasLongOrderIds()) {
                        target.setHasLongOrder(false);
                    }
                    GridElement.refreshIndices();
                    log.warn("[Gate] 空仓止盈触发对向加仓挂单失败, 止盈gridId:{}, 目标gridId:{}",
                            tpElem.getId(), target.getId());
                }
        );
    }

    /**
     * 对向加仓空仓开仓单成交：在网格+1 挂空仓止损。
     *
     * @param elem           开仓单成交的网格元素
     * @param oppositeGridId 记录的对向开仓网格ID
     */
    private void handleTpOppositeShortAddFilled(GridElement elem, int oppositeGridId) {
        int qty = Integer.parseInt(elem.getShortTraderParam().getQuantity());
        int stopLossGridId = oppositeGridId + 1;
        GridElement slElem = GridElement.findById(stopLossGridId);
        if (slElem == null) {
            log.warn("[Gate] 对向加仓止损位置不存在, 开仓gridId:{}, 止损gridId:{}", oppositeGridId, stopLossGridId);
            return;
        }
        executor.placeTakeProfit(
                slElem.getGridPrice(),
                FuturesPriceTrigger.RuleEnum.NUMBER_1,
                ORDER_TYPE_CLOSE_SHORT,
                String.valueOf(qty),
                profitId -> {
                    slElem.addShortStopLossOrderId(profitId);
                    GridElement.refreshIndices();
                    log.info("[Gate] 对向加仓空仓止损已挂, 开仓gridId:{}, 止损gridId:{}, 数量:{}张, stopLossId:{}",
                            oppositeGridId, stopLossGridId, qty, profitId);
                }
        );
    }

    /**
     * 对向加仓多仓开仓单成交：在网格-1 挂多仓止损。
     *
     * @param elem           开仓单成交的网格元素
     * @param oppositeGridId 记录的对向开仓网格ID
     */
    private void handleTpOppositeLongAddFilled(GridElement elem, int oppositeGridId) {
        int qty = Integer.parseInt(elem.getLongTraderParam().getQuantity());
        int stopLossGridId = oppositeGridId - 1;
        GridElement slElem = GridElement.findById(stopLossGridId);
        if (slElem == null) {
            log.warn("[Gate] 对向加仓止损位置不存在, 开仓gridId:{}, 止损gridId:{}", oppositeGridId, stopLossGridId);
            return;
        }
        executor.placeTakeProfit(
                slElem.getGridPrice(),
                FuturesPriceTrigger.RuleEnum.NUMBER_2,
                ORDER_TYPE_CLOSE_LONG,
                negate(String.valueOf(qty)),
                profitId -> {
                    slElem.addLongStopLossOrderId(profitId);
                    GridElement.refreshIndices();
                    log.info("[Gate] 对向加仓多仓止损已挂, 开仓gridId:{}, 止损gridId:{}, 数量:{}张, stopLossId:{}",
                            oppositeGridId, stopLossGridId, qty, profitId);
                }
        );
    }


    /**
     * 查询交易所当前持仓张数（绝对值）。加仓/开仓后重挂止盈止损时调用，
     * 绕过本地 WS 推送缓存避免时序竞态，直接拿到交易所权威数据。
     *