From 664b83f528c0fa690e2900a8a260137393ca5225 Mon Sep 17 00:00:00 2001
From: Administrator <15274802129@163.com>
Date: Sun, 01 Nov 2026 10:37:48 +0800
Subject: [PATCH] feat(gate): 实现仓位止盈补仓功能
---
src/main/java/com/xcong/excoin/modules/gateApi/GateGridTradeService.java | 465 ++++++++++++++++++++++++++++++++++++++++++++++++++-------
1 files changed, 406 insertions(+), 59 deletions(-)
diff --git a/src/main/java/com/xcong/excoin/modules/gateApi/GateGridTradeService.java b/src/main/java/com/xcong/excoin/modules/gateApi/GateGridTradeService.java
index 0114d96..8bdf627 100644
--- a/src/main/java/com/xcong/excoin/modules/gateApi/GateGridTradeService.java
+++ b/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 */
@@ -166,6 +170,10 @@
private final Map<String, Integer> tpOppositeShortOrderGridMap = new ConcurrentHashMap<>();
/** 止盈触发对向加仓：空仓止盈→多仓开仓单ID → 网格ID（成交后在该网格-1挂多仓止损） */
private final Map<String, Integer> tpOppositeLongOrderGridMap = new ConcurrentHashMap<>();
+ /** 仓位止盈补仓：多仓止盈→多仓开仓单ID → 张数（成交后按原多仓止损位重挂全持仓止损） */
+ private final Map<String, Integer> tpReplenishLongOrderMap = new ConcurrentHashMap<>();
+ /** 仓位止盈补仓：空仓止盈→空仓开仓单ID → 张数（成交后按原空仓止损位重挂全持仓止损） */
+ private final Map<String, Integer> tpReplenishShortOrderMap = new ConcurrentHashMap<>();
private volatile BigDecimal lastKlinePrice;
private volatile BigDecimal markPrice = BigDecimal.ZERO;
@@ -420,9 +428,13 @@
shortActive = false;
accumulatedLongLossCount = 0;
accumulatedShortLossCount = 0;
+ accumulatedLongAddCount = 0;
+ accumulatedShortAddCount = 0;
lastLongStopLossGridId = Integer.MAX_VALUE;
lastShortStopLossGridId = Integer.MAX_VALUE;
dualStopLossModeActive.set(false);
+ tpReplenishLongOrderMap.clear();
+ tpReplenishShortOrderMap.clear();
shortPriceQueue.clear();
longPriceQueue.clear();
totalShortPriceQueue.clear();
@@ -815,6 +827,12 @@
handleTpOppositeShortAddFilled(shortGridElement, tpOppositeGridId);
return;
}
+ // 仓位止盈补仓的空仓开仓单成交 → 取消原空仓止损并在原位置按最新持仓重挂
+ Integer replenishQty = tpReplenishShortOrderMap.remove(orderId);
+ if (replenishQty != null) {
+ handleReplenishShortAddFilled(shortGridElement, orderId, replenishQty);
+ return;
+ }
int filledQty = Integer.parseInt(shortGridElement.getShortTraderParam().getQuantity());
shortEntryTraderIdParam(shortGridElement, orderId, false);
@@ -866,6 +884,12 @@
handleTpOppositeLongAddFilled(longGridElement, tpOppositeGridId);
return;
}
+ // 仓位止盈补仓的多仓开仓单成交 → 取消原多仓止损并在原位置按最新持仓重挂
+ Integer replenishQty = tpReplenishLongOrderMap.remove(orderId);
+ if (replenishQty != null) {
+ handleReplenishLongAddFilled(longGridElement, orderId, replenishQty);
+ return;
+ }
int filledQty = Integer.parseInt(longGridElement.getLongTraderParam().getQuantity());
longEntryTraderIdParam(longGridElement, orderId, false);
@@ -915,6 +939,8 @@
* @param orderId 止盈单 ID
*/
private void handleLongTakeProfitTriggered(GridElement tpElem, String orderId) {
+ // 清理前读取本次止盈单张数（仓位止盈补仓用；清理后该记录会被移除）
+ Integer tpSize = tpElem.getLongTakeProfitOrderSize(orderId);
// 清理前判断：当前是否为该方向最后一个止盈单（最后一个不触发对向加仓）
boolean isLastTp = GridElement.getLongTakeProfitCount() <= 1;
// 清理止盈单状态（移除已成交的这笔止盈单）
@@ -924,6 +950,11 @@
// 止盈依次上移：先取消之前挂的对向空开仓单，再挂新单
cancelTpOppositeShortEntries();
+
+ // 仓位止盈补仓：在对侧（空仓）止损位挂同方向（多仓）开仓单，张数 = 本次止盈单张数
+ if (config.isTpPositionReplenishEnabled()) {
+ replenishAfterTp(true, tpSize);
+ }
if (!config.isTpTriggerOppositeAddEnabled()) {
return;
@@ -953,6 +984,8 @@
* @param orderId 止盈单 ID
*/
private void handleShortTakeProfitTriggered(GridElement tpElem, String orderId) {
+ // 清理前读取本次止盈单张数（仓位止盈补仓用；清理后该记录会被移除）
+ Integer tpSize = tpElem.getShortTakeProfitOrderSize(orderId);
// 清理前判断：当前是否为该方向最后一个止盈单（最后一个不触发对向加仓）
boolean isLastTp = GridElement.getShortTakeProfitCount() <= 1;
// 清理止盈单状态（移除已成交的这笔止盈单）
@@ -962,6 +995,11 @@
// 止盈依次下移：先取消之前挂的对向多开仓单，再挂新单
cancelTpOppositeLongEntries();
+
+ // 仓位止盈补仓：在对侧（多仓）止损位挂同方向（空仓）开仓单，张数 = 本次止盈单张数
+ if (config.isTpPositionReplenishEnabled()) {
+ replenishAfterTp(false, tpSize);
+ }
if (!config.isTpTriggerOppositeAddEnabled()) {
return;
@@ -982,6 +1020,192 @@
return;
}
placeOppositeAddLongEntry(target, tpElem, qty);
+ }
+
+ /**
+ * 仓位止盈补仓：任意方向止盈触发时，在对侧止损位挂与止盈方向一致、张数 = 本次止盈单张数的条件开仓单。
+ * <p>开仓单走<b>专用分支</b>：成交后取消补仓方向原有的止损单，并在与原来相同的位置
+ * 按最新总持仓重挂止损（不动止盈），详见 {@link #handleReplenishLongAddFilled} /
+ * {@link #handleReplenishShortAddFilled}。</p>
+ *
+ * @param isLong true=多仓止盈（挂多仓开仓单），false=空仓止盈（挂空仓开仓单）
+ * @param tpSize 本次触发止盈单的张数（null 或 <=0 则跳过）
+ */
+ private void replenishAfterTp(boolean isLong, Integer tpSize) {
+ if (tpSize == null || tpSize <= 0) {
+ log.warn("[Gate] 仓位止盈补仓跳过: 止盈单张数无效, isLong:{}, tpSize:{}", isLong, tpSize);
+ return;
+ }
+ // 对侧止损位：多仓止盈 → 空仓第一止损位；空仓止盈 → 多仓第一止损位
+ GridElement slElem = isLong ? findFirstShortStopLossGrid() : findFirstLongStopLossGrid();
+ if (slElem == null) {
+ log.warn("[Gate] 仓位止盈补仓: 未找到对侧止损位, isLong:{}", isLong);
+ return;
+ }
+ // 方向与止盈方向一致：多仓止盈 → 多开仓（价格≥触发价 NUMBER_1）；空仓止盈 → 空开仓（价格≤触发价 NUMBER_2）
+ if (isLong) {
+ placeReplenishLongEntry(slElem, tpSize);
+ } else {
+ placeReplenishShortEntry(slElem, tpSize);
+ }
+ log.info("[Gate] 仓位止盈补仓: {}止盈触发, 对侧止损位 gridId:{}, 挂{}开仓{}张",
+ isLong ? "多仓" : "空仓", slElem.getId(), isLong ? "多" : "空", tpSize);
+ }
+
+ /**
+ * 仓位止盈补仓：在对侧止损位挂多仓条件开仓单（价格≥触发价），成交走专用分支 {@link #handleReplenishLongAddFilled}。
+ */
+ private void placeReplenishLongEntry(GridElement target, int qty) {
+ target.setHasLongOrder(true);
+ executor.placeConditionalEntryOrder(
+ target.getGridPrice(),
+ FuturesPriceTrigger.RuleEnum.NUMBER_1,
+ String.valueOf(qty),
+ orderId -> {
+ tpReplenishLongOrderMap.put(orderId, qty);
+ target.getLongTraderParam().setQuantity(String.valueOf(qty));
+ longEntryTraderIdParam(target, orderId, true);
+ log.info("[Gate] 仓位止盈补仓多开仓单已挂, 目标gridId:{}, 数量:{}张, orderId:{}",
+ target.getId(), qty, orderId);
+ },
+ () -> {
+ if (!target.hasLongOrderIds()) {
+ target.setHasLongOrder(false);
+ }
+ GridElement.refreshIndices();
+ log.warn("[Gate] 仓位止盈补仓多开仓单挂单失败, 目标gridId:{}", target.getId());
+ }
+ );
+ }
+
+ /**
+ * 仓位止盈补仓：在对侧止损位挂空仓条件开仓单（价格≤触发价），成交走专用分支 {@link #handleReplenishShortAddFilled}。
+ */
+ private void placeReplenishShortEntry(GridElement target, int qty) {
+ target.setHasShortOrder(true);
+ executor.placeConditionalEntryOrder(
+ target.getGridPrice(),
+ FuturesPriceTrigger.RuleEnum.NUMBER_2,
+ negate(String.valueOf(qty)),
+ orderId -> {
+ tpReplenishShortOrderMap.put(orderId, qty);
+ target.getShortTraderParam().setQuantity(String.valueOf(qty));
+ shortEntryTraderIdParam(target, orderId, true);
+ log.info("[Gate] 仓位止盈补仓空开仓单已挂, 目标gridId:{}, 数量:{}张, orderId:{}",
+ target.getId(), qty, orderId);
+ },
+ () -> {
+ if (!target.hasShortOrderIds()) {
+ target.setHasShortOrder(false);
+ }
+ GridElement.refreshIndices();
+ log.warn("[Gate] 仓位止盈补仓空开仓单挂单失败, 目标gridId:{}", target.getId());
+ }
+ );
+ }
+
+ /**
+ * 仓位止盈补仓：多仓开仓单成交（专用分支）。
+ * 先取消多仓原有全部止损单（保留止盈），再在与原来相同的位置按最新总持仓重挂止损。
+ *
+ * @param elem 补仓开仓单所在的网格元素
+ * @param orderId 已成交的开仓单 ID
+ * @param filledQty 本次成交张数（挂单时记录）
+ */
+ private void handleReplenishLongAddFilled(GridElement elem, String orderId, int filledQty) {
+ longEntryTraderIdParam(elem, orderId, false);
+
+ // 最新总持仓：REST/本地/本次成交取最大，规避时序竞态
+ int posSize = Math.max(Math.max(queryPositionSize(Position.ModeEnum.DUAL_LONG), longPositionSize.intValue()), filledQty);
+ // 原多仓止损位（最靠近入场的那个）
+ GridElement anchorSl = findNearestLongStopLossGrid();
+ if (anchorSl == null) {
+ log.warn("[Gate] 仓位止盈补仓: 未找到原多仓止损位, 跳过重挂, 当前持仓:{}张", posSize);
+ return;
+ }
+ // 反推原入场网格：止损挂在 entry-2-i，最近止损位 = entry-2 → entry = 最近止损位 + 2
+ int anchorEntryGridId = anchorSl.getId() + 2;
+ // 取消原多仓止损（保留止盈），并在原位置重挂全持仓止损
+ cancelAllLongStopLossesOnly();
+ lastLongStopLossGridId = Integer.MAX_VALUE;
+ extendLongStopLoss(posSize, anchorEntryGridId);
+
+ // 埋点: ENTRY_FILLED（补仓成交）
+ emitStats("ENTRY_FILLED", mapOf(
+ "direction", "long",
+ "gridId", elem.getId(),
+ "filledQty", filledQty,
+ "source", "tp_replenish"
+ ));
+ log.info("[Gate] 仓位止盈补仓多开仓成交, gridId:{}, 当前持仓:{}张, 止损按原位置gridId:{}重挂",
+ elem.getId(), posSize, anchorSl.getId());
+ }
+
+ /**
+ * 仓位止盈补仓：空仓开仓单成交（专用分支）。
+ * 先取消空仓原有全部止损单（保留止盈），再在与原来相同的位置按最新总持仓重挂止损。
+ *
+ * @param elem 补仓开仓单所在的网格元素
+ * @param orderId 已成交的开仓单 ID
+ * @param filledQty 本次成交张数（挂单时记录）
+ */
+ private void handleReplenishShortAddFilled(GridElement elem, String orderId, int filledQty) {
+ shortEntryTraderIdParam(elem, orderId, false);
+
+ // 最新总持仓：REST/本地/本次成交取最大，规避时序竞态
+ int posSize = Math.max(Math.max(queryPositionSize(Position.ModeEnum.DUAL_SHORT), shortPositionSize.intValue()), filledQty);
+ // 原空仓止损位（最靠近入场的那个）
+ GridElement anchorSl = findNearestShortStopLossGrid();
+ if (anchorSl == null) {
+ log.warn("[Gate] 仓位止盈补仓: 未找到原空仓止损位, 跳过重挂, 当前持仓:{}张", posSize);
+ return;
+ }
+ // 反推原入场网格：止损挂在 entry+2+i，最近止损位 = entry+2 → entry = 最近止损位 - 2
+ int anchorEntryGridId = anchorSl.getId() - 2;
+ // 取消原空仓止损（保留止盈），并在原位置重挂全持仓止损
+ cancelAllShortStopLossesOnly();
+ lastShortStopLossGridId = Integer.MAX_VALUE;
+ extendShortStopLoss(posSize, anchorEntryGridId);
+
+ // 埋点: ENTRY_FILLED（补仓成交）
+ emitStats("ENTRY_FILLED", mapOf(
+ "direction", "short",
+ "gridId", elem.getId(),
+ "filledQty", filledQty,
+ "source", "tp_replenish"
+ ));
+ log.info("[Gate] 仓位止盈补仓空开仓成交, gridId:{}, 当前持仓:{}张, 止损按原位置gridId:{}重挂",
+ elem.getId(), posSize, anchorSl.getId());
+ }
+
+ /**
+ * 找到最靠近入场方向的多仓止损网格（ID 最大者）。
+ */
+ private GridElement findNearestLongStopLossGrid() {
+ GridElement nearest = null;
+ for (GridElement e : config.getGridElements()) {
+ if (e.hasLongStopLossOrders()) {
+ if (nearest == null || e.getId() > nearest.getId()) {
+ nearest = e;
+ }
+ }
+ }
+ return nearest;
+ }
+
+ /**
+ * 找到最靠近入场方向的空仓止损网格（ID 最小者）。
+ */
+ private GridElement findNearestShortStopLossGrid() {
+ GridElement nearest = null;
+ for (GridElement e : config.getGridElements()) {
+ if (e.hasShortStopLossOrders()) {
+ if (nearest == null || e.getId() < nearest.getId()) {
+ nearest = e;
+ }
+ }
+ }
+ return nearest;
}
/**
@@ -1098,7 +1322,7 @@
ORDER_TYPE_CLOSE_SHORT,
String.valueOf(qty),
profitId -> {
- slElem.addShortStopLossOrderId(profitId);
+ slElem.addShortStopLossOrderId(profitId, qty);
GridElement.refreshIndices();
log.info("[Gate] 对向加仓空仓止损已挂, 开仓gridId:{}, 止损gridId:{}, 数量:{}张, stopLossId:{}",
oppositeGridId, stopLossGridId, qty, profitId);
@@ -1126,7 +1350,7 @@
ORDER_TYPE_CLOSE_LONG,
negate(String.valueOf(qty)),
profitId -> {
- slElem.addLongStopLossOrderId(profitId);
+ slElem.addLongStopLossOrderId(profitId, qty);
GridElement.refreshIndices();
log.info("[Gate] 对向加仓多仓止损已挂, 开仓gridId:{}, 止损gridId:{}, 数量:{}张, stopLossId:{}",
oppositeGridId, stopLossGridId, qty, profitId);
@@ -1320,7 +1544,7 @@
ORDER_TYPE_CLOSE_LONG,
negate(baseQty),
profitId -> {
- longElem.addLongStopLossOrderId(profitId);
+ longElem.addLongStopLossOrderId(profitId, Integer.parseInt(baseQty));
GridElement.refreshIndices();
log.info("[Gate] 自定义多仓止损已挂, 目标价:{}, 匹配gridId:{}, 触发价:{}, stopLossId:{}",
longPrice, longElem.getId(), triggerPrice, profitId);
@@ -1341,7 +1565,7 @@
ORDER_TYPE_CLOSE_SHORT,
baseQty,
profitId -> {
- shortElem.addShortStopLossOrderId(profitId);
+ shortElem.addShortStopLossOrderId(profitId, Integer.parseInt(baseQty));
GridElement.refreshIndices();
log.info("[Gate] 自定义空仓止损已挂, 目标价:{}, 匹配gridId:{}, 触发价:{}, stopLossId:{}",
shortPrice, shortElem.getId(), triggerPrice, profitId);
@@ -1384,7 +1608,7 @@
ORDER_TYPE_CLOSE_SHORT,
size,
profitId -> {
- elem.addShortStopLossOrderId(profitId);
+ elem.addShortStopLossOrderId(profitId, Integer.parseInt(size));
GridElement.refreshIndices();
log.info("[Gate] 空仓止损已挂, gridId:{}, 触发价:{}, stopLossId:{}", finalId, triggerPrice, profitId);
}
@@ -1411,7 +1635,7 @@
ORDER_TYPE_CLOSE_LONG,
negate(size),
profitId -> {
- elem.addLongStopLossOrderId(profitId);
+ elem.addLongStopLossOrderId(profitId, Integer.parseInt(size));
GridElement.refreshIndices();
log.info("[Gate] 多仓止损已挂, gridId:{}, 触发价:{}, stopLossId:{}", finalId, triggerPrice, profitId);
}
@@ -1472,12 +1696,17 @@
private void longTakeProfitTraderIdParam(
GridElement baseElement,String profitId, boolean flag
) {
+ longTakeProfitTraderIdParam(baseElement, profitId, flag, 0);
+ }
+ private void longTakeProfitTraderIdParam(
+ GridElement baseElement,String profitId, boolean flag, int size
+ ) {
TraderParam tp = baseElement.getLongTraderParam();
if (flag && profitId != null) {
- // 挂单成功：追加到止盈单列表（支持基础止盈 + 超额止盈并行挂单）
+ // 挂单成功：追加到止盈单列表（支持基础止盈 + 超额止盈并行挂单），并记录该单张数
tp.setTakeProfitOrderId(profitId);
tp.setTakeProfitPlaced(true);
- baseElement.addLongTakeProfitOrderId(profitId);
+ baseElement.addLongTakeProfitOrderId(profitId, size);
} else {
// 清理：profitId 非空移除指定止盈单，为空清空该网格全部止盈单
tp.setTakeProfitPlaced(false);
@@ -1496,12 +1725,17 @@
private void shortTakeProfitTraderIdParam(
GridElement baseElement,String profitId, boolean flag
) {
+ shortTakeProfitTraderIdParam(baseElement, profitId, flag, 0);
+ }
+ private void shortTakeProfitTraderIdParam(
+ GridElement baseElement,String profitId, boolean flag, int size
+ ) {
TraderParam tp = baseElement.getShortTraderParam();
if (flag && profitId != null) {
- // 挂单成功：追加到止盈单列表（支持基础止盈 + 超额止盈并行挂单）
+ // 挂单成功：追加到止盈单列表（支持基础止盈 + 超额止盈并行挂单），并记录该单张数
tp.setTakeProfitOrderId(profitId);
tp.setTakeProfitPlaced(true);
- baseElement.addShortTakeProfitOrderId(profitId);
+ baseElement.addShortTakeProfitOrderId(profitId, size);
} else {
// 清理：profitId 非空移除指定止盈单，为空清空该网格全部止盈单
tp.setTakeProfitPlaced(false);
@@ -1765,7 +1999,7 @@
// String quantity = String.valueOf(config.getBaseQuantity());
- String quantity = calculateEntryQuantity(true, false);
+ String quantity = calculateEntryQuantity(true, false, 0);
// 向下检查是否已有多单挂在更低价格网格，有则跳过（防止价格回升后重复挂单）
boolean hasLongOrderBelow = false;
GridElement checkDownCursor = GridElement.findById(newEntryGrid.getDownId());
@@ -1839,7 +2073,7 @@
// String quantity = String.valueOf(Math.max(queryPositionSize(Position.ModeEnum.DUAL_LONG), longPositionSize.intValue()) + Integer.parseInt(config.getQuantity()));
// String quantity = String.valueOf(config.getBaseQuantity());
- String quantity = calculateEntryQuantity(false, false);
+ String quantity = calculateEntryQuantity(false, false, 0);
// 向上检查是否已有空单挂在更高价格网格，有则跳过（防止价格回落后重复挂单）
boolean hasShortOrderAbove = false;
GridElement checkUpCursor = GridElement.findById(newEntryGrid.getUpId());
@@ -1907,6 +2141,75 @@
}
/**
+ * 根据 {@code stopLossCountMode} 计算当前有效的加仓执行次数（与止损次数的统计口径一致）。
+ * <p>加仓执行次数 = 真正产生额外加仓量（addMultiplier > 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 > 0，即 addQty > 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,37 +2225,37 @@
* <li>{@code respectCurrentPosition=true}：{@code upperLimit = maxPositionPerSide - 当前持仓}
* （止损追单，保证单边总持仓 ≤ maxPositionPerSide）</li>
* </ul>
+ * <p>加仓停止阈值 {@code addPositionStopThreshold}：</p>
+ * <ul>
+ * <li>{@code 0} = 不限制；</li>
+ * <li>{@code > 0} 时按「加仓执行次数」（真正产生额外加仓量 addMultiplier > 0 的执行）计数，
+ * 达到该次数后不再追加加仓量 {@code addQty}，下单量回到 {@code baseQuantity}。</li>
+ * </ul>
*
* @param isLong {@code true}=多仓方向，{@code false}=空仓方向
* @param respectCurrentPosition {@code true}=按「单边总持仓 ≤ maxPositionPerSide」扣减当前持仓；{@code false}=仅限制单次下单量
+ * @param stopLossSize 本次触发网格的全部止损单张数（仅止损追单场景传入，用于修正 REST 持仓时序竞态；其余场景传 0）
* @return 实际下单张数（字符串）
*/
- private String calculateEntryQuantity(boolean isLong, boolean respectCurrentPosition) {
+ 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) {
int upperLimit = maxPerSide;
if (respectCurrentPosition) {
// 止损追单：单边总持仓不得超过 maxPerSide，追单量 = maxPerSide - 当前持仓。
- // 止损单刚成交、WS 持仓推送尚未到达，必须用 REST 实时查询绕过 WS 缓存时序竞态，
- // 否则会取到滞后的旧持仓（如止损前仍为 10），把追单量错误扣减。
+ // 止损单刚成交、REST 查询可能仍返回止损前持仓（时序竞态），
+ // 减去本网格全部止损张数得到止损后的真实持仓，避免追单量被错误扣减。
int currentPos = isLong
? queryPositionSize(Position.ModeEnum.DUAL_LONG)
: queryPositionSize(Position.ModeEnum.DUAL_SHORT);
+ if (stopLossSize > 0) {
+ currentPos = Math.max(0, currentPos - stopLossSize);
+ }
upperLimit = maxPerSide - currentPos;
}
if (upperLimit <= 0) {
@@ -1966,6 +2269,8 @@
}
private void handleLongStopLossTriggered(GridElement gridElement, String orderId) {
+ // 本网格全部止损单覆盖张数（含刚触发的这一单），用于追单时修正 REST 持仓的时序竞态
+ int gridStopLossSize = gridElement.getLongStopLossTotalSize();
gridElement.removeLongStopLossOrderId(orderId);
int gridId = gridElement.getId();
@@ -1998,15 +2303,18 @@
// 止损追单：同一网格可有多笔挂单，不判断 isHasLongOrder，直接挂单
BigDecimal triggerPrice = newEntryGrid.getGridPrice();
- String size = calculateEntryQuantity(true, true);
- log.info("[Gate] 多仓止损追单 有效次数:{}, 基础:{}张 → 实际:{}张, 模式:{}",
- getEffectiveStopLossCount(true), config.getBaseQuantity(), size, config.getStopLossCountMode());
+ String size = calculateEntryQuantity(true, true, gridStopLossSize);
+ 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 位置的所有多单
@@ -2031,6 +2339,8 @@
}
private void handleShortStopLossTriggered(GridElement gridElement, String orderId) {
+ // 本网格全部止损单覆盖张数（含刚触发的这一单），用于追单时修正 REST 持仓的时序竞态
+ int gridStopLossSize = gridElement.getShortStopLossTotalSize();
gridElement.removeShortStopLossOrderId(orderId);
int gridId = gridElement.getId();
@@ -2061,15 +2371,18 @@
// 止损追单：同一网格可有多笔挂单，不判断 isHasShortOrder，直接挂单
BigDecimal triggerPrice = newEntryGrid.getGridPrice();
- String size = calculateEntryQuantity(false, true);
- log.info("[Gate] 空仓止损追单 有效次数:{}, 基础:{}张 → 实际:{}张, 模式:{}",
- getEffectiveStopLossCount(false), config.getBaseQuantity(), size, config.getStopLossCountMode());
+ String size = calculateEntryQuantity(false, true, gridStopLossSize);
+ 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 位置的所有空单
@@ -2313,22 +2626,27 @@
// ========== 止损追单（新逻辑：3 个固定位置，每个位置挂多个 1 张止损单） ==========
/**
- * 多仓止损追单 — 网格数量 = baseQuantity/quantity，从近到远分配。
- * aCount<0跳过, aCount=0→主=2, aCount=1→主=2,辅0=1, aCount>=2→主=aCount,辅依次填1
+ * 多仓止损追单 — 把当前多头持仓<b>全量</b>拆分为多笔止损单，挂在靠近入场的连续网格上。
+ * 网格数 gridCount = baseQuantity / quantity；最近网格挂大部分张数、其余网格各挂 1 笔 quantity 张，
+ * 不足一格的余数单独在更远一网格挂一笔。所有异步挂单完成后通过计数器重置防重入标记；
+ * 期间若有入场单成交则打 pendingStopLossReExtend 待重挂。
*/
private void extendLongStopLoss(int filledQty, int gridId) {
int qty = Integer.parseInt(config.getQuantity());
int baseQty = Integer.parseInt(config.getBaseQuantity());
int gridCount = baseQty / qty;
GridElement entryElem = GridElement.findById(gridId);
- if (gridCount <= 0 || filledQty < qty) {
+ if (gridCount <= 0 || filledQty <= 0) {
// 早期返回需重置防重入标记
if (entryElem != null) { entryElem.setExtendStopLossInProgress(false); }
return;
}
- // [Gate] 止损只针对初始开仓仓位(baseQuantity)，加仓部分只做止盈
- int totalOrders = filledQty / qty;
+ // [Gate] 止损覆盖全持仓：加仓部分同样受止损保护，不再只保初始仓位。
+ // 取 max 是为了在 REST 时序竞态导致 filledQty 偏小时，至少保住 baseQuantity 的基础仓位
+ int slSize = Math.max(filledQty, baseQty);
+ int totalOrders = slSize / qty;
+ int remainder = slSize % qty;
int[] orders = new int[gridCount];
if (gridCount == 1) {
@@ -2352,6 +2670,7 @@
for (int i = 0; i < gridCount; i++) {
if (orders[i] > 0) { totalOrdersToPlace += orders[i]; }
}
+ if (remainder > 0) { totalOrdersToPlace += 1; }
if (totalOrdersToPlace == 0) {
if (entryElem != null) { entryElem.setExtendStopLossInProgress(false); }
return;
@@ -2362,7 +2681,7 @@
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,
+ placeStopLossOrders(sgId, orders[i], String.valueOf(qty), FuturesPriceTrigger.RuleEnum.NUMBER_2,
ORDER_TYPE_CLOSE_LONG, true, remainCount, entryElem);
if (detail.length() > 0) {
detail.append(" ");
@@ -2370,28 +2689,43 @@
detail.append(sgId).append("x").append(orders[i]);
}
}
+ // 不足一个网格量的余数：单独挂一张止损
+ if (remainder > 0) {
+ int sgId = gridId - 2 - totalOrders;
+ placeStopLossOrders(sgId, 1, String.valueOf(remainder), FuturesPriceTrigger.RuleEnum.NUMBER_2,
+ ORDER_TYPE_CLOSE_LONG, true, remainCount, entryElem);
+ if (detail.length() > 0) {
+ detail.append(" ");
+ }
+ detail.append(sgId).append("x").append(remainder);
+ }
log.info("[Gate] 多仓追挂止损, 成交{}张, gridId:{}, 网格数:{}, 分配:{}",
filledQty, gridId, gridCount, detail);
}
/**
- * 空仓止损追单 — 网格数量 = baseQuantity/quantity，从近到远分配。
- * aCount<0跳过, aCount=0→主=2, aCount=1→主=2,辅0=1, aCount>=2→主=aCount,辅依次填1
+ * 空仓止损追单 — 把当前空头持仓<b>全量</b>拆分为多笔止损单，挂在靠近入场的连续网格上。
+ * 网格数 gridCount = baseQuantity / quantity；最近网格挂大部分张数、其余网格各挂 1 笔 quantity 张，
+ * 不足一格的余数单独在更远一网格挂一笔。所有异步挂单完成后通过计数器重置防重入标记；
+ * 期间若有入场单成交则打 pendingStopLossReExtend 待重挂。
*/
private void extendShortStopLoss(int filledQty, int gridId) {
int qty = Integer.parseInt(config.getQuantity());
int baseQty = Integer.parseInt(config.getBaseQuantity());
int gridCount = baseQty / qty;
GridElement entryElem = GridElement.findById(gridId);
- if (gridCount <= 0 || filledQty < qty) {
+ if (gridCount <= 0 || filledQty <= 0) {
// 早期返回需重置防重入标记
if (entryElem != null) { entryElem.setExtendStopLossInProgress(false); }
return;
}
- // [Gate] 止损只针对初始开仓仓位(baseQuantity)，加仓部分只做止盈
- int totalOrders = filledQty / qty;
+ // [Gate] 止损覆盖全持仓：加仓部分同样受止损保护，不再只保初始仓位。
+ // 取 max 是为了在 REST 时序竞态导致 filledQty 偏小时，至少保住 baseQuantity 的基础仓位
+ int slSize = Math.max(filledQty, baseQty);
+ int totalOrders = slSize / qty;
+ int remainder = slSize % qty;
int[] orders = new int[gridCount];
if (gridCount == 1) {
@@ -2415,6 +2749,7 @@
for (int i = 0; i < gridCount; i++) {
if (orders[i] > 0) { totalOrdersToPlace += orders[i]; }
}
+ if (remainder > 0) { totalOrdersToPlace += 1; }
if (totalOrdersToPlace == 0) {
if (entryElem != null) { entryElem.setExtendStopLossInProgress(false); }
return;
@@ -2425,13 +2760,23 @@
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,
+ placeStopLossOrders(sgId, orders[i], String.valueOf(qty), FuturesPriceTrigger.RuleEnum.NUMBER_1,
ORDER_TYPE_CLOSE_SHORT, false, remainCount, entryElem);
if (detail.length() > 0) {
detail.append(" ");
}
detail.append(sgId).append("x").append(orders[i]);
}
+ }
+ // 不足一个网格量的余数：单独挂一张止损
+ if (remainder > 0) {
+ int sgId = gridId + 2 + totalOrders;
+ placeStopLossOrders(sgId, 1, String.valueOf(remainder), FuturesPriceTrigger.RuleEnum.NUMBER_1,
+ ORDER_TYPE_CLOSE_SHORT, false, remainCount, entryElem);
+ if (detail.length() > 0) {
+ detail.append(" ");
+ }
+ detail.append(sgId).append("x").append(remainder);
}
log.info("[Gate] 空仓追挂止损, 成交{}张, gridId:{}, 网格数:{}, 分配:{}",
@@ -2469,7 +2814,7 @@
/**
* 在指定网格位置挂 count 个独立止损单，每个 size 张。
*/
- private void placeStopLossOrders(int gridId, int count, int qty,
+ private void placeStopLossOrders(int gridId, int count, String qtyStr,
FuturesPriceTrigger.RuleEnum rule,
String orderType, boolean isLong,
AtomicInteger remainCount,
@@ -2502,17 +2847,17 @@
return;
}
BigDecimal triggerPrice = elem.getGridPrice();
+ String size = isLong ? negate(qtyStr) : qtyStr;
for (int i = 0; i < count; i++) {
- String size = isLong ? negate(String.valueOf(qty)) : String.valueOf(qty);
int finalGridId = gridId;
int finalI = i;
executor.placeTakeProfit(
triggerPrice, rule, orderType, size,
profitId -> {
if (isLong) {
- elem.addLongStopLossOrderId(profitId);
+ elem.addLongStopLossOrderId(profitId, Integer.parseInt(qtyStr));
} else {
- elem.addShortStopLossOrderId(profitId);
+ elem.addShortStopLossOrderId(profitId, Integer.parseInt(qtyStr));
}
GridElement.refreshIndices();
log.info("[Gate] {}止损追加, gridId:{}, 触发价:{}, 第{}单, stopLossId:{}",
@@ -2932,9 +3277,9 @@
executor.placeTakeProfit(triggerPrice, rule, orderType, size,
profitId -> {
if (isLong) {
- longTakeProfitTraderIdParam(tpElem, profitId, true);
+ longTakeProfitTraderIdParam(tpElem, profitId, true, excessQty);
} else {
- shortTakeProfitTraderIdParam(tpElem, profitId, true);
+ shortTakeProfitTraderIdParam(tpElem, profitId, true, excessQty);
}
log.info("[Gate] {}止盈挂单, gridId:{}, 触发价:{}, 数量:{}, takeProfitId:{}",
isLong ? "多仓" : "空仓", finalTpGridId, triggerPrice, finalSize, profitId);
@@ -3022,6 +3367,7 @@
if (qty <= 0) {
continue;
}
+ final int fqty = qty;
final GridElement elem = gridList.get(i);
final int gid = elem.getId();
final BigDecimal triggerPrice = elem.getGridPrice();
@@ -3032,9 +3378,9 @@
executor.placeTakeProfit(triggerPrice, rule, orderType, size,
profitId -> {
if (isLong) {
- longTakeProfitTraderIdParam(elem, profitId, true);
+ longTakeProfitTraderIdParam(elem, profitId, true, fqty);
} else {
- shortTakeProfitTraderIdParam(elem, profitId, true);
+ shortTakeProfitTraderIdParam(elem, profitId, true, fqty);
}
log.info("[Gate] 分散止盈 {} gridId:{}, 触发价:{}, 数量:{}, tpId:{}",
isLong ? "多仓" : "空仓", gid, triggerPrice, size, profitId);
@@ -3094,6 +3440,7 @@
break;
}
BigDecimal qty = perGrid.min(remaining);
+ final int fqty = qty.intValue();
final GridElement fe = elem;
final int gid = id;
final BigDecimal triggerPrice = elem.getGridPrice();
@@ -3104,9 +3451,9 @@
executor.placeTakeProfit(triggerPrice, rule, orderType, size,
profitId -> {
if (isLong) {
- longTakeProfitTraderIdParam(fe, profitId, true);
+ longTakeProfitTraderIdParam(fe, profitId, true, fqty);
} else {
- shortTakeProfitTraderIdParam(fe, profitId, true);
+ shortTakeProfitTraderIdParam(fe, profitId, true, fqty);
}
log.info("[Gate] 基础止盈 {} gridId:{}, 触发价:{}, 数量:{}, tpId:{}",
isLong ? "多仓" : "空仓", gid, triggerPrice, size, profitId);
@@ -3133,9 +3480,9 @@
executor.placeTakeProfit(triggerPrice, rule, orderType, size,
profitId -> {
if (isLong) {
- longTakeProfitTraderIdParam(tpElem, profitId, true);
+ longTakeProfitTraderIdParam(tpElem, profitId, true, qty);
} else {
- shortTakeProfitTraderIdParam(tpElem, profitId, true);
+ shortTakeProfitTraderIdParam(tpElem, profitId, true, qty);
}
log.info("[Gate] 止损{}→对手超额止盈 gridId:{}, 量:{}, tpId:{}", times, gridId, qty, profitId);
}
@@ -3160,8 +3507,8 @@
String size = isLong ? negate(String.valueOf(tpQty)) : String.valueOf(tpQty);
executor.placeTakeProfit(triggerPrice, rule, orderType, size,
profitId -> {
- if (isLong) longTakeProfitTraderIdParam(tpElem, profitId, true);
- else shortTakeProfitTraderIdParam(tpElem, profitId, true);
+ if (isLong) longTakeProfitTraderIdParam(tpElem, profitId, true, tpQty);
+ else shortTakeProfitTraderIdParam(tpElem, profitId, true, tpQty);
log.info("[Gate] 止损次数{}→对手{}止盈 gridId:{}, 量:{}, tpId:{}",
times, isLong ? "多仓" : "空仓", tpGridId, size, profitId);
}
--
Gitblit v1.9.1