feat(gateApi): 添加加仓停止阈值功能以控制加仓执行次数

Administrator

7 days ago 2797bf55755816fbd1e7c4f6d982a51b5901f492

feat(gateApi): 添加加仓停止阈值功能以控制加仓执行次数

- 在 GateConfig 中新增 addPositionStopThreshold 字段及其 getter 和 builder 方法
- 在 GateConfigDTO 中添加对应的停止阈值字段和映射逻辑
- 在 GateConfigPersistenceService 中加入停止阈值的数据持久化处理
- 在 GateGridTradeService 中实现加仓执行次数统计机制（accumulatedLongAddCount/accumulatedShortAddCount）
- 新增 getEffectiveAddCount、recordAddExecution 和 computeAddQty 方法来管理加仓执行逻辑
- 修改 calculateEntryQuantity 方法使用统一的加仓量计算逻辑
- 更新止损追单日志输出以显示加仓执行次数和停止阈值信息
- 在止损追单时记录真正的加仓执行次数（仅当产生额外加仓量时）

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

@@ -121,6 +121,8 @@
    private final int maxPositionPerSide;
    /** 加仓启动阈值：前N次止损不触发加仓，默认 1（第1次止损不加仓，第2次起按公式计算） */
    private final int addPositionStartThreshold;
    /** 加仓停止阈值：启动加仓后按「加仓执行次数」计数，超过该值后加仓张数恢复为基础张数；0=不限制 */
    private final int addPositionStopThreshold;
    /** 止盈挂单模式：关闭 */
    public static final String EXCESS_TP_OFF = "off";
    /** 止盈挂单模式：集中止盈（挂在对手第一止损位） */
@@ -184,6 +186,7 @@
        this.addPositionQuantity = builder.addPositionQuantity;
        this.maxPositionPerSide = builder.maxPositionPerSide;
        this.addPositionStartThreshold = builder.addPositionStartThreshold;
        this.addPositionStopThreshold = builder.addPositionStopThreshold;
        this.placeExcessTakeProfit = builder.placeExcessTakeProfit;
        this.dualStopLossEnabled = builder.dualStopLossEnabled;
        this.longStopLossPrice = builder.longStopLossPrice;
@@ -297,6 +300,8 @@
    public int getMaxPositionPerSide() { return maxPositionPerSide; }
    /** @return 加仓启动阈值：前N次止损不触发加仓 */
    public int getAddPositionStartThreshold() { return addPositionStartThreshold; }
    /** @return 加仓停止阈值：启动加仓后加仓执行次数上限，超过后加仓张数恢复基础张数；0=不限制 */
    public int getAddPositionStopThreshold() { return addPositionStopThreshold; }
    /** @return 止盈挂单模式：off=关闭 / concentrated=集中止盈 / dispersed=分散止盈 */
    public String getPlaceExcessTakeProfit() { return placeExcessTakeProfit; }
    /** @return 自定义止损开关：true=启用自定义止损触发价，false=使用默认阶梯止损 */
@@ -423,6 +428,8 @@
        private int maxPositionPerSide = 0;
        /** 加仓启动阈值：前N次止损不触发加仓，调整后的 effectiveCount = max(0, count - threshold)。默认 1 */
        private int addPositionStartThreshold = 1;
        /** 加仓停止阈值：启动加仓后按加仓执行次数计数，超过该值后加仓张数恢复基础张数，0=不限制。默认 0 */
        private int addPositionStopThreshold = 0;
        /** 止盈挂单模式：off=关闭 / concentrated=集中止盈 / dispersed=分散止盈，默认 off */
        private String placeExcessTakeProfit = EXCESS_TP_OFF;
        /** 自定义止损开关：true=启用自定义止损触发价，false=使用默认阶梯止损。默认 false */
@@ -500,6 +507,8 @@
        public Builder maxPositionPerSide(int maxPositionPerSide) { this.maxPositionPerSide = maxPositionPerSide; return this; }
        /** 设置加仓启动阈值：前N次止损不触发加仓，0=立即启动 */
        public Builder addPositionStartThreshold(int addPositionStartThreshold) { this.addPositionStartThreshold = addPositionStartThreshold; return this; }
        /** 设置加仓停止阈值：启动加仓后加仓执行次数上限，0=不限制 */
        public Builder addPositionStopThreshold(int addPositionStopThreshold) { this.addPositionStopThreshold = addPositionStopThreshold; return this; }
        /** 设置止盈挂单模式：off / concentrated / dispersed */
        public Builder placeExcessTakeProfit(String placeExcessTakeProfit) { this.placeExcessTakeProfit = placeExcessTakeProfit; return this; }
        /** 设置自定义止损开关：true=启用自定义止损触发价 */

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

@@ -69,6 +69,8 @@
    private int maxPositionPerSide;
    /** 加仓启动阈值：前N次止损不触发加仓，默认 1 */
    private int addPositionStartThreshold;
    /** 加仓停止阈值：启动加仓后按「加仓执行次数」计数，超过该值后加仓张数恢复为基础张数；0=不限制 */
    private int addPositionStopThreshold;
    /** 止盈挂单模式：off=关闭 / concentrated=集中止盈 / dispersed=分散止盈，默认 off */
    private String placeExcessTakeProfit;
    /** 自定义止损开关：true=启用自定义止损触发价，false=使用默认阶梯止损。null=未设置(默认false) */
@@ -117,6 +119,7 @@
                .addPositionQuantity(config.getAddPositionQuantity())
                .maxPositionPerSide(config.getMaxPositionPerSide())
                .addPositionStartThreshold(config.getAddPositionStartThreshold())
                .addPositionStopThreshold(config.getAddPositionStopThreshold())
                .placeExcessTakeProfit(config.getPlaceExcessTakeProfit())
                .dualStopLossEnabled(config.isDualStopLossEnabled())
                .longStopLossPrice(config.getLongStopLossPrice())
@@ -151,6 +154,7 @@
        m.put("addPositionQuantity", addPositionQuantity);
        m.put("maxPositionPerSide", maxPositionPerSide);
        m.put("addPositionStartThreshold", addPositionStartThreshold);
        m.put("addPositionStopThreshold", addPositionStopThreshold);
        m.put("placeExcessTakeProfit", placeExcessTakeProfit);
        m.put("dualStopLossEnabled", dualStopLossEnabled);
        m.put("longStopLossPrice", longStopLossPrice);
@@ -192,6 +196,7 @@
                .addPositionQuantity(1)
                .maxPositionPerSide(0)
                .addPositionStartThreshold(1)
                .addPositionStopThreshold(0)
                .placeExcessTakeProfit("off")
                .dualStopLossEnabled(false)
                .longStopLossPrice(null)

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

@@ -111,6 +111,7 @@
                .addPositionQuantity(dto.getAddPositionQuantity() > 0 ? dto.getAddPositionQuantity() : 1)
                .maxPositionPerSide(dto.getMaxPositionPerSide())
                .addPositionStartThreshold(dto.getAddPositionStartThreshold() >= 0 ? dto.getAddPositionStartThreshold() : 1)
                .addPositionStopThreshold(dto.getAddPositionStopThreshold() >= 0 ? dto.getAddPositionStopThreshold() : 0)
                .placeExcessTakeProfit(normalizeTakeProfitMode(dto.getPlaceExcessTakeProfit()))
                .dualStopLossEnabled(nvl(dto.getDualStopLossEnabled(), false))
                .longStopLossPrice(dto.getLongStopLossPrice())

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

@@ -155,6 +155,10 @@
    private volatile int accumulatedLongLossCount = 0;
    /** 空头累计止损次数（始终递增，加仓订单成交后归零） */
    private volatile int accumulatedShortLossCount = 0;
    /** 多头加仓执行次数（每次真正产生额外加仓量 addMultiplier>0 的多仓止损追单 +1，用于加仓停止阈值判断） */
    private volatile int accumulatedLongAddCount = 0;
    /** 空头加仓执行次数（每次真正产生额外加仓量 addMultiplier>0 的空仓止损追单 +1，用于加仓停止阈值判断） */
    private volatile int accumulatedShortAddCount = 0;
    /** 最近触发止损的多头网格ID */
    private volatile int lastLongStopLossGridId = Integer.MAX_VALUE;
    /** 最近触发止损的空头网格ID */
@@ -420,6 +424,8 @@
        shortActive = false;
        accumulatedLongLossCount = 0;
        accumulatedShortLossCount = 0;
        accumulatedLongAddCount = 0;
        accumulatedShortAddCount = 0;
        lastLongStopLossGridId = Integer.MAX_VALUE;
        lastShortStopLossGridId = Integer.MAX_VALUE;
        dualStopLossModeActive.set(false);
@@ -1907,6 +1913,75 @@
    }

    /**
     * 根据 {@code stopLossCountMode} 计算当前有效的加仓执行次数（与止损次数的统计口径一致）。
     * <p>加仓执行次数 = 真正产生额外加仓量（addMultiplier &gt; 0）的止损追单累计次数，
     * 用于加仓停止阈值判断。</p>
     *
     * @param isLong {@code true}=多仓方向，{@code false}=空仓方向
     * @return 有效加仓执行次数
     */
    private int getEffectiveAddCount(boolean isLong) {
        if ("single".equals(config.getStopLossCountMode())) {
            return isLong ? accumulatedLongAddCount : accumulatedShortAddCount;
        }
        // "dual" — 双向总次数
        return accumulatedLongAddCount + accumulatedShortAddCount;
    }

    /**
     * 记录一次加仓执行（用于加仓停止阈值判断）。
     * <p>仅当本次追单的加仓公式<b>真正产生了额外加仓量</b>（addMultiplier &gt; 0，即 addQty &gt; 0）时计数；
     * 只挂基础张数的追单不计入。判断依据 {@link #computeAddQty(boolean)} 与
     * {@link #calculateEntryQuantity(boolean, boolean, int)} 共用同一套计数状态，
     * 同一处理器内止损次数不变，二者结果一致。</p>
     *
     * @param isLong {@code true}=多仓方向，{@code false}=空仓方向
     */
    private void recordAddExecution(boolean isLong) {
        if (computeAddQty(isLong) <= 0) {
            // 本次未产生额外加仓量（addMultiplier = 0），不计入执行次数
            return;
        }
        if (isLong) {
            accumulatedLongAddCount++;
        } else {
            accumulatedShortAddCount++;
        }
    }

    /**
     * 计算本次追单的额外加仓量（addQty），供 {@link #calculateEntryQuantity(boolean, boolean, int)}
     * 与 {@link #recordAddExecution(boolean)} 共用，保证「加仓执行」判定与下单计算同源。
     * <pre>
     * effectiveCount = max(0, 累计止损次数 - addPositionStartThreshold)   ← 启动阈值
     * divisor        = addPositionInterval + 1
     * addMultiplier  = floor(effectiveCount / divisor)
     * addQty         = addMultiplier × addPositionQuantity
     * </pre>
     * 加仓停止阈值：加仓执行次数达到 {@code addPositionStopThreshold} 后 addMultiplier 强制归零
     * （addQty = 0），回到基础张数；0 = 不限制。
     *
     * @param isLong {@code true}=多仓方向，{@code false}=空仓方向
     * @return 额外加仓张数（0 表示本次不加仓）
     */
    private int computeAddQty(boolean isLong) {
        int effectiveCount = getEffectiveStopLossCount(isLong);
        int startThreshold = config.getAddPositionStartThreshold();
        if (startThreshold > 0) {
            effectiveCount = Math.max(0, effectiveCount - startThreshold);
        }
        // 加仓停止阈值：按「加仓执行次数」（真正产生额外加仓量的执行）计数，
        // 已达到停止阈值则加仓量归零，回到基础张数
        int stopThreshold = config.getAddPositionStopThreshold();
        boolean addStopped = stopThreshold > 0 && getEffectiveAddCount(isLong) >= stopThreshold;
        // divisor = interval + 1：interval=0→每次加仓, interval=1→每2次加仓(2,4,6...), interval=3→每4次加仓(4,8,12...)
        int interval = config.getAddPositionInterval();
        int divisor = interval + 1;
        int addMultiplier = (!addStopped && interval >= 0) ? effectiveCount / divisor : 0;
        return addMultiplier * config.getAddPositionQuantity();
    }

    /**
     * 根据加仓配置计算入场/追单时的实际下单量。
     * <p>公式：</p>
     * <pre>
@@ -1922,6 +1997,12 @@
     *   <li>{@code respectCurrentPosition=true}：{@code upperLimit = maxPositionPerSide - 当前持仓}
     *       （止损追单，保证单边总持仓 ≤ maxPositionPerSide）</li>
     * </ul>
     * <p>加仓停止阈值 {@code addPositionStopThreshold}：</p>
     * <ul>
     *   <li>{@code 0} = 不限制；</li>
     *   <li>{@code > 0} 时按「加仓执行次数」（真正产生额外加仓量 addMultiplier &gt; 0 的执行）计数，
     *       达到该次数后不再追加加仓量 {@code addQty}，下单量回到 {@code baseQuantity}。</li>
     * </ul>
     *
     * @param isLong                 {@code true}=多仓方向，{@code false}=空仓方向
     * @param respectCurrentPosition {@code true}=按「单边总持仓 ≤ maxPositionPerSide」扣减当前持仓；{@code false}=仅限制单次下单量
@@ -1930,19 +2011,9 @@
     */
    private String calculateEntryQuantity(boolean isLong, boolean respectCurrentPosition, int stopLossSize) {
        int baseQty = Integer.parseInt(config.getBaseQuantity());
        int interval = config.getAddPositionInterval();
        int addQtyPerUnit = config.getAddPositionQuantity();
        int maxPerSide = config.getMaxPositionPerSide();

        int effectiveCount = getEffectiveStopLossCount(isLong);
        int startThreshold = config.getAddPositionStartThreshold();
        if (startThreshold > 0) {
            effectiveCount = Math.max(0, effectiveCount - startThreshold);
        }
        // divisor = interval + 1：interval=0→每次加仓, interval=1→每2次加仓(2,4,6...), interval=3→每4次加仓(4,8,12...)
        int divisor = interval + 1;
        int addMultiplier = interval >= 0 ? effectiveCount / divisor : 0;
        int addQty = addMultiplier * addQtyPerUnit;
        // 额外加仓量由 computeAddQty 统一计算（含启动/停止阈值与间隔公式）
        int addQty = computeAddQty(isLong);
        int totalQty = baseQty + addQty;

        if (maxPerSide > 0) {
@@ -2003,14 +2074,17 @@
        // 止损追单：同一网格可有多笔挂单，不判断 isHasLongOrder，直接挂单
        BigDecimal triggerPrice = newEntryGrid.getGridPrice();
        String size = calculateEntryQuantity(true, true, Integer.parseInt(config.getQuantity()));
        log.info("[Gate] 多仓止损追单 有效次数:{}, 基础:{}张 → 实际:{}张, 模式:{}",
                getEffectiveStopLossCount(true), config.getBaseQuantity(), size, config.getStopLossCountMode());
        log.info("[Gate] 多仓止损追单 有效次数:{}, 加仓执行:{}, 停止阈值:{}, 基础:{}张 → 实际:{}张, 模式:{}",
                getEffectiveStopLossCount(true), getEffectiveAddCount(true), config.getAddPositionStopThreshold(),
                config.getBaseQuantity(), size, config.getStopLossCountMode());
        if (Integer.parseInt(size) <= 0) {
            log.warn("[Gate] 多仓止损追单 当前持仓已达单边上限({}), 跳过挂单", config.getMaxPositionPerSide());
        } else {
            newEntryGrid.getLongTraderParam().setQuantity(size);
            placeEntryOrderWithPreFlag(newEntryGrid, true, triggerPrice,
                    FuturesPriceTrigger.RuleEnum.NUMBER_1, size);
            // 记录加仓执行次数：仅当本次真正产生了额外加仓量（addMultiplier > 0）时计数
            recordAddExecution(true);
        }

        // 取消 gridId+2 位置的所有多单
@@ -2066,14 +2140,17 @@
        // 止损追单：同一网格可有多笔挂单，不判断 isHasShortOrder，直接挂单
        BigDecimal triggerPrice = newEntryGrid.getGridPrice();
        String size = calculateEntryQuantity(false, true, Integer.parseInt(config.getQuantity()));
        log.info("[Gate] 空仓止损追单 有效次数:{}, 基础:{}张 → 实际:{}张, 模式:{}",
                getEffectiveStopLossCount(false), config.getBaseQuantity(), size, config.getStopLossCountMode());
        log.info("[Gate] 空仓止损追单 有效次数:{}, 加仓执行:{}, 停止阈值:{}, 基础:{}张 → 实际:{}张, 模式:{}",
                getEffectiveStopLossCount(false), getEffectiveAddCount(false), config.getAddPositionStopThreshold(),
                config.getBaseQuantity(), size, config.getStopLossCountMode());
        if (Integer.parseInt(size) <= 0) {
            log.warn("[Gate] 空仓止损追单 当前持仓已达单边上限({}), 跳过挂单", config.getMaxPositionPerSide());
        } else {
            newEntryGrid.getShortTraderParam().setQuantity(size);
            placeEntryOrderWithPreFlag(newEntryGrid, false, triggerPrice,
                    FuturesPriceTrigger.RuleEnum.NUMBER_2, negate(size));
            // 记录加仓执行次数：仅当本次真正产生了额外加仓量（addMultiplier > 0）时计数
            recordAddExecution(false);
        }

        // 取消 gridId-2 位置的所有空单