From 9471cefc44c3cbbc5588f784d7e1360b5c4e0fc4 Mon Sep 17 00:00:00 2001
From: Administrator <15274802129@163.com>
Date: Tue, 04 Aug 2026 21:25:50 +0800
Subject: [PATCH] fix(gateApi): 修复网格交易中订单数量计算逻辑
---
src/main/java/com/xcong/excoin/modules/gateApi/GridElement.java | 331 ++++++++++++++++++++++++++++++++++++++++++++----------
1 files changed, 269 insertions(+), 62 deletions(-)
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 75359b5..c5ef00f 100644
--- a/src/main/java/com/xcong/excoin/modules/gateApi/GridElement.java
+++ b/src/main/java/com/xcong/excoin/modules/gateApi/GridElement.java
@@ -7,34 +7,56 @@
import java.util.concurrent.ConcurrentHashMap;
/**
- * 网格元素，表示网格交易策略中的一个价格层级。
+ * 网格价格层级，策略的最小操作单元。
*
- * <p>每个网格层级包含该价格位置上的多仓和空仓挂单信息，
- * 通过编号和网格价格唯一标识一个网格层级。
+ * <h3>定位</h3>
+ * 每个 GridElement 对应网格中的一个价格点，同时持有该点的多仓和空仓挂单状态。
+ * 与传统的"价格队列+Map"模式不同，GridElement 将价格、方向、状态、订单ID 聚合到一个对象中，
+ * 并维护全局静态 HashMap 索引实现 O(1) 双向查询。
*
- * <h3>关键字段</h3>
- * <ul>
- * <li><b>编号</b>：网格层级的唯一标识</li>
- * <li><b>网格价格</b>：该层级对应的触发价格</li>
- * <li><b>多仓挂单</b>：是否已有多头挂单、多头挂单参数</li>
- * <li><b>空仓挂单</b>：是否有空头挂单、空头挂单参数</li>
- * </ul>
+ * <h3>ID 体系与链表</h3>
+ * <pre>
+ * ID ≦ -1: 空仓队列区域（降序），ID 自减，gridPrice 递减
+ * ID = 0: 基座位置，gridPrice = shortBaseEntryPrice
+ * ID ≧ 1: 多仓队列区域（升序），ID 自增，gridPrice 递增
+ *
+ * 链表: ... ← -3 ← -2 ← -1 ← 0 → 1 → 2 → 3 → ...
+ * (通过 upId/downId + INDEX 实现 O(1) 遍历)
+ * </pre>
+ *
+ * <h3>字段分组</h3>
+ * <table>
+ * <tr><th>类别</th><th>字段</th><th>说明</th></tr>
+ * <tr><td>标识</td><td>id, gridPrice, upId, downId</td><td>编号、价格、双向链表指针</td></tr>
+ * <tr><td>多仓订单</td><td>hasLongOrder, longOrderId, longTraderParam</td><td>是否有挂单、订单ID、完整参数</td></tr>
+ * <tr><td>空仓订单</td><td>hasShortOrder, shortOrderId, shortTraderParam</td><td>是否有挂单、订单ID、完整参数</td></tr>
+ * <tr><td>止盈</td><td>longTakeProfitOrderId, shortTakeProfitOrderId</td><td>止盈条件单ID</td></tr>
+ * </table>
+ *
+ * <h3>6 个全局 O(1) 索引</h3>
+ * <pre>
+ * INDEX → findById(int) ID → 元素
+ * PRICE_INDEX → findByPrice(BigDecimal) 价格 → 元素
+ * LONG_ORDER_ID_INDEX → findByLongOrderId(String) 多仓挂单ID → 元素
+ * SHORT_ORDER_ID_INDEX → findByShortOrderId(String) 空仓挂单ID → 元素
+ * LONG_TP_ORDER_ID_INDEX→ findByLongTakeProfitOrderId(String) 多止盈ID → 元素
+ * SHORT_TP_ORDER_ID_INDEX→ findByShortTakeProfitOrderId(String) 空止盈ID → 元素
+ * </pre>
+ * 索引通过 {@link #rebuildIndex(List)}（全量重建）或 {@link #refreshIndices()}（增量刷新）
+ * 维护，每次操作后自动打印全量网格状态到控制台。
+ *
+ * <h3>何时填充 TraderParam</h3>
+ * 初始化时 {@code updateGridElements()} 为每个元素预填充 longTraderParam 和 shortTraderParam
+ * （含 direction/entryPrice/takeProfitPrice/quantity），订单ID字段在挂单成功后由
+ * {@link GateGridTradeService} 的 4 个辅助方法写入。
*
* <h3>使用示例</h3>
* <pre>
- * GridElement element = GridElement.builder()
- * .id(1)
- * .gridPrice(new BigDecimal("2300.0"))
- * .build();
- *
- * // 挂多仓单
- * TraderParam longParam = TraderParam.builder()
- * .direction(TraderParam.Direction.LONG)
- * .entryPrice(new BigDecimal("2293.7"))
- * .takeProfitPrice(new BigDecimal("2301.6"))
- * .build();
- * element.setHasLongOrder(true);
- * element.setLongTraderParam(longParam);
+ * GridElement elem = GridElement.findById(1);
+ * boolean hasLong = elem.isHasLongOrder(); // 是否挂了多单
+ * BigDecimal tpPrice = elem.getLongTraderParam().getTakeProfitPrice(); // 止盈价
+ * elem.getUp(); // 上一个网格（O(1)）
+ * elem.getDown(); // 下一个网格（O(1)）
* </pre>
*
* @author Administrator
@@ -57,14 +79,36 @@
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 */
private String shortTakeProfitOrderId;
+ /** 多仓止损订单 ID 列表（支持一个网格多个止损单） */
+ private List<String> longStopLossOrderIds = new ArrayList<>();
+ /** 空仓止损订单 ID 列表（支持一个网格多个止损单） */
+ private List<String> shortStopLossOrderIds = new ArrayList<>();
+
+ /**
+ * 止损追单是否正在进行中（防重入标记）。
+ * 同一网格存在多个入场单且相近时间成交时，确保只有第一次 extend 触发止损挂单，
+ * 后续入场单成交仅移除订单记录，不再重复触发 cancelAll + extend 流程。
+ * 异步回调全部完成后由 placeStopLossOrders 中计数器归零时重置。
+ */
+ private volatile boolean extendStopLossInProgress = false;
+
+ /**
+ * 是否有待重挂的止损追单请求。
+ * 当入场单成交因 extendStopLossInProgress=true 被跳过时置为 true，
+ * 延展完成后由回调检查此标记并触发一次仓位重查+重挂，确保止损覆盖最新持仓数。
+ */
+ private volatile boolean pendingStopLossReExtend = false;
+
+ /** 索引重建锁，保证 refreshIndices() 与计数读取之间互斥，避免 clear→rebuild 窗口期读到 0 */
+ private static final Object INDEX_LOCK = new Object();
/** 全局 ID 索引，由 {@link GateConfig#setGridElements(List)} 触发重建，O(1) 查找 */
private static final Map<Integer, GridElement> INDEX = new ConcurrentHashMap<>();
@@ -78,6 +122,10 @@
private static final Map<String, GridElement> LONG_TP_ORDER_ID_INDEX = new ConcurrentHashMap<>();
/** 全局空仓止盈订单 ID 索引，由 {@link GateConfig#setGridElements(List)} 触发重建，O(1) 查找 */
private static final Map<String, GridElement> SHORT_TP_ORDER_ID_INDEX = new ConcurrentHashMap<>();
+ /** 全局多仓止损订单 ID 索引 */
+ private static final Map<String, GridElement> LONG_SL_ORDER_ID_INDEX = new ConcurrentHashMap<>();
+ /** 全局空仓止损订单 ID 索引 */
+ private static final Map<String, GridElement> SHORT_SL_ORDER_ID_INDEX = new ConcurrentHashMap<>();
/**
* 根据 ID 快速查找网格元素（O(1)）。
@@ -139,6 +187,30 @@
return SHORT_TP_ORDER_ID_INDEX.get(orderId);
}
+ /** @return 当前多仓止盈单数量（与 refreshIndices 互斥，避免清空窗口读到 0） */
+ public static int getLongTakeProfitCount() {
+ synchronized (INDEX_LOCK) { return LONG_TP_ORDER_ID_INDEX.size(); }
+ }
+
+ /** @return 当前空仓止盈单数量（与 refreshIndices 互斥，避免清空窗口读到 0） */
+ public static int getShortTakeProfitCount() {
+ synchronized (INDEX_LOCK) { return SHORT_TP_ORDER_ID_INDEX.size(); }
+ }
+
+ /**
+ * 根据多仓止损订单 ID 快速查找网格元素（O(1)）。
+ */
+ public static GridElement findByLongStopLossOrderId(String orderId) {
+ return LONG_SL_ORDER_ID_INDEX.get(orderId);
+ }
+
+ /**
+ * 根据空仓止损订单 ID 快速查找网格元素（O(1)）。
+ */
+ public static GridElement findByShortStopLossOrderId(String orderId) {
+ return SHORT_SL_ORDER_ID_INDEX.get(orderId);
+ }
+
/**
* 从列表中重建全局 ID 索引和价格索引。
* 由 {@link GateConfig#setGridElements(List)} 在每次列表变更后调用。
@@ -150,10 +222,13 @@
SHORT_ORDER_ID_INDEX.clear();
LONG_TP_ORDER_ID_INDEX.clear();
SHORT_TP_ORDER_ID_INDEX.clear();
+ LONG_SL_ORDER_ID_INDEX.clear();
+ SHORT_SL_ORDER_ID_INDEX.clear();
for (GridElement e : elements) {
INDEX.put(e.getId(), e);
putDynamicIndices(e);
}
+ logAll();
}
/**
@@ -163,14 +238,67 @@
* 使快速查找方法获取到最新数据。
*/
public static void refreshIndices() {
- PRICE_INDEX.clear();
- LONG_ORDER_ID_INDEX.clear();
- SHORT_ORDER_ID_INDEX.clear();
- LONG_TP_ORDER_ID_INDEX.clear();
- SHORT_TP_ORDER_ID_INDEX.clear();
- for (GridElement e : INDEX.values()) {
- putDynamicIndices(e);
+ synchronized (INDEX_LOCK) {
+ PRICE_INDEX.clear();
+ LONG_ORDER_ID_INDEX.clear();
+ SHORT_ORDER_ID_INDEX.clear();
+ LONG_TP_ORDER_ID_INDEX.clear();
+ SHORT_TP_ORDER_ID_INDEX.clear();
+ LONG_SL_ORDER_ID_INDEX.clear();
+ SHORT_SL_ORDER_ID_INDEX.clear();
+ for (GridElement e : INDEX.values()) {
+ putDynamicIndices(e);
+ }
}
+ // logAll 在锁外执行，不阻塞计数查询
+ logAll();
+ }
+
+ /**
+ * 打印全部网格数据到日志。
+ */
+ public static void logAll() {
+ List<GridElement> sorted = new ArrayList<>(INDEX.values());
+ sorted.sort((a, b) -> Integer.compare(a.getId(), b.getId()));
+ StringBuilder sb = new StringBuilder("\n========== 网格数据 ==========\n");
+ for (GridElement e : sorted) {
+ if (e.isHasLongOrder() || e.isHasShortOrder()
+ || e.hasLongStopLossOrders() || e.hasShortStopLossOrders()){
+ sb.append(String.format(
+ " ID=%4d 价格=%s up=%s down=%s 多仓=%s(%s) 空仓=%s(%s) 多止盈=%s 空止盈=%s 多止损=%s 空止损=%s\n",
+ e.getId(),
+ e.getGridPrice(),
+ e.getUpId(),
+ e.getDownId(),
+ e.isHasLongOrder() ? "有" : "无",
+ e.hasLongOrderIds() ? String.join(",", e.getLongOrderIds()) : "-",
+ e.isHasShortOrder() ? "有" : "无",
+ e.hasShortOrderIds() ? String.join(",", e.getShortOrderIds()) : "-",
+ e.getLongTakeProfitOrderId() != null ? e.getLongTakeProfitOrderId() : "-",
+ e.getShortTakeProfitOrderId() != null ? e.getShortTakeProfitOrderId() : "-",
+ e.hasLongStopLossOrders() ? String.join(",", e.getLongStopLossOrderIds()) : "-",
+ e.hasShortStopLossOrders() ? String.join(",", e.getShortStopLossOrderIds()) : "-"
+ ));
+ }
+ }
+ sb.append(String.format(
+ "------------------------------------------------------------\n" +
+ " 索引统计: ID=%d 价格=%d 多仓订单ID=%d 空仓订单ID=%d 多止盈ID=%d 空止盈ID=%d 多止损ID=%d 空止损ID=%d\n",
+ INDEX.size(),
+ PRICE_INDEX.size(),
+ LONG_ORDER_ID_INDEX.size(),
+ SHORT_ORDER_ID_INDEX.size(),
+ LONG_TP_ORDER_ID_INDEX.size(),
+ SHORT_TP_ORDER_ID_INDEX.size(),
+ LONG_SL_ORDER_ID_INDEX.size(),
+ SHORT_SL_ORDER_ID_INDEX.size()
+ ));
+ sb.append(String.format(" 多仓订单ID索引: %s\n", LONG_ORDER_ID_INDEX.keySet()));
+ sb.append(String.format(" 空仓订单ID索引: %s\n", SHORT_ORDER_ID_INDEX.keySet()));
+ sb.append(String.format(" 多止盈ID索引: %s\n", LONG_TP_ORDER_ID_INDEX.keySet()));
+ sb.append(String.format(" 空止盈ID索引: %s\n", SHORT_TP_ORDER_ID_INDEX.keySet()));
+ sb.append("================================\n");
+ System.out.println(sb);
}
/**
@@ -179,10 +307,10 @@
*
* @return 已挂多仓条件单的 GridElement 列表
*/
- public static List<GridElement> findAllLongOrders(BigDecimal currentPrice) {
+ public static List<GridElement> findAllShortOrders(BigDecimal currentPrice) {
List<GridElement> result = new ArrayList<>();
for (GridElement e : INDEX.values()) {
- if (e.isHasLongOrder() && e.getGridPrice().compareTo(currentPrice) < 0) {
+ if (e.isHasShortOrder() && e.getGridPrice().compareTo(currentPrice) < 0 && e.getShortTakeProfitOrderId() == null) {
result.add(e);
}
}
@@ -195,10 +323,10 @@
*
* @return 已挂空仓条件单的 GridElement 列表
*/
- public static List<GridElement> findAllShortOrders(BigDecimal currentPrice) {
+ public static List<GridElement> findAllLongOrders(BigDecimal currentPrice) {
List<GridElement> result = new ArrayList<>();
for (GridElement e : INDEX.values()) {
- if (e.isHasShortOrder() && e.getGridPrice().compareTo(currentPrice) < 0) {
+ if (e.isHasLongOrder() && e.getGridPrice().compareTo(currentPrice) > 0 && e.getLongTakeProfitOrderId() == null) {
result.add(e);
}
}
@@ -207,17 +335,23 @@
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);
}
if (e.getShortTakeProfitOrderId() != null) {
SHORT_TP_ORDER_ID_INDEX.put(e.getShortTakeProfitOrderId(), e);
+ }
+ for (String slId : e.getLongStopLossOrderIds()) {
+ LONG_SL_ORDER_ID_INDEX.put(slId, e);
+ }
+ for (String slId : e.getShortStopLossOrderIds()) {
+ SHORT_SL_ORDER_ID_INDEX.put(slId, e);
}
}
@@ -244,10 +378,12 @@
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);
}
// ==================== 网格层级编号 ====================
@@ -306,19 +442,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 ====================
@@ -333,6 +493,45 @@
public String getShortTakeProfitOrderId() { return shortTakeProfitOrderId; }
/** 设置空仓止盈订单 ID */
public void setShortTakeProfitOrderId(String shortTakeProfitOrderId) { this.shortTakeProfitOrderId = shortTakeProfitOrderId; }
+
+ // ==================== 多仓止损订单 ID ====================
+
+ // ==================== 多仓止损订单 ID 列表 ====================
+
+ /** @return 多仓止损订单 ID 列表 */
+ public List<String> getLongStopLossOrderIds() { return longStopLossOrderIds; }
+ /** 添加一个多仓止损订单 ID */
+ public void addLongStopLossOrderId(String orderId) { longStopLossOrderIds.add(orderId); }
+ /** 移除一个多仓止损订单 ID */
+ public boolean removeLongStopLossOrderId(String orderId) { return longStopLossOrderIds.remove(orderId); }
+ /** 清空所有多仓止损订单 ID */
+ public void clearLongStopLossOrderIds() { longStopLossOrderIds.clear(); }
+ /** @return 是否有止损单 */
+ public boolean hasLongStopLossOrders() { return !longStopLossOrderIds.isEmpty(); }
+
+ // ==================== 空仓止损订单 ID 列表 ====================
+
+ /** @return 空仓止损订单 ID 列表 */
+ public List<String> getShortStopLossOrderIds() { return shortStopLossOrderIds; }
+ /** 添加一个空仓止损订单 ID */
+ public void addShortStopLossOrderId(String orderId) { shortStopLossOrderIds.add(orderId); }
+ /** 移除一个空仓止损订单 ID */
+ public boolean removeShortStopLossOrderId(String orderId) { return shortStopLossOrderIds.remove(orderId); }
+ /** 清空所有空仓止损订单 ID */
+ public void clearShortStopLossOrderIds() { shortStopLossOrderIds.clear(); }
+ /** @return 是否有止损单 */
+ public boolean hasShortStopLossOrders() { return !shortStopLossOrderIds.isEmpty(); }
+
+ // ==================== 止损追单防重入标记 ====================
+
+ /** @return 止损追单是否正在进行中 */
+ public boolean isExtendStopLossInProgress() { return extendStopLossInProgress; }
+ /** 设置止损追单进行标记 */
+ public void setExtendStopLossInProgress(boolean v) { this.extendStopLossInProgress = v; }
+ /** @return 是否有待重挂请求 */
+ public boolean isPendingStopLossReExtend() { return pendingStopLossReExtend; }
+ /** 设置待重挂标记 */
+ public void setPendingStopLossReExtend(boolean v) { this.pendingStopLossReExtend = v; }
public static Builder builder() {
return new Builder();
@@ -364,14 +563,18 @@
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 */
private String shortTakeProfitOrderId;
+ /** 多仓止损订单 ID 列表 */
+ private List<String> longStopLossOrderIds;
+ /** 空仓止损订单 ID 列表 */
+ private List<String> shortStopLossOrderIds;
/** 设置网格层级编号 */
public Builder id(int id) { this.id = id; return this; }
@@ -389,14 +592,18 @@
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 */
public Builder shortTakeProfitOrderId(String shortTakeProfitOrderId) { this.shortTakeProfitOrderId = shortTakeProfitOrderId; return this; }
+ /** 设置多仓止损订单 ID 列表 */
+ public Builder longStopLossOrderIds(List<String> longStopLossOrderIds) { this.longStopLossOrderIds = longStopLossOrderIds; return this; }
+ /** 设置空仓止损订单 ID 列表 */
+ public Builder shortStopLossOrderIds(List<String> shortStopLossOrderIds) { this.shortStopLossOrderIds = shortStopLossOrderIds; return this; }
public GridElement build() {
return new GridElement(this);
--
Gitblit v1.9.1