From d88653508842b676a68f7f0103e176a57b077a0a Mon Sep 17 00:00:00 2001
From: Administrator <15274802129@163.com>
Date: Mon, 13 Jul 2026 18:14:01 +0800
Subject: [PATCH] refactor(gateApi): 优化网格交易服务的订单ID管理
---
src/main/java/com/xcong/excoin/modules/gateApi/GateGridTradeService.java | 226 +++++++++++++++++++------------------
src/main/java/com/xcong/excoin/modules/gateApi/GridElement.java | 84 +++++++++-----
2 files changed, 170 insertions(+), 140 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 b0ccd11..a127064 100644
--- a/src/main/java/com/xcong/excoin/modules/gateApi/GateGridTradeService.java
+++ b/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);
}
);
}
diff --git a/src/main/java/com/xcong/excoin/modules/gateApi/GridElement.java b/src/main/java/com/xcong/excoin/modules/gateApi/GridElement.java
index f77840f..6ffbefd 100644
--- a/src/main/java/com/xcong/excoin/modules/gateApi/GridElement.java
+++ b/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 */
--
Gitblit v1.9.1