package com.xcong.excoin.modules.okxApi; import java.math.BigDecimal; import java.util.ArrayList; import java.util.List; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; /** * 网格价格层级，策略的最小操作单元。 * *

定位

* 每个 GridElement 对应网格中的一个价格点，同时持有该点的多仓和空仓挂单状态。 * 与传统的"价格队列+Map"模式不同，GridElement 将价格、方向、状态、订单ID 聚合到一个对象中， * 并维护全局静态 HashMap 索引实现 O(1) 双向查询。 * *

ID 体系与链表

* 
 *   ID ≦ -1:  空仓队列区域（降序），ID 自减，gridPrice 递减
 *   ID  =  0:  基座位置，gridPrice = shortBaseEntryPrice
 *   ID ≧  1:  多仓队列区域（升序），ID 自增，gridPrice 递增
 *
 *   链表: ... ← -3 ← -2 ← -1 ← 0 → 1 → 2 → 3 → ...
 *         (通过 upId/downId + INDEX 实现 O(1) 遍历)
 *
* *

字段分组

* * * * * * *
类别字段说明
标识id, gridPrice, upId, downId编号、价格、双向链表指针
多仓订单hasLongOrder, longOrderId, longTraderParam是否有挂单、订单ID、完整参数
空仓订单hasShortOrder, shortOrderId, shortTraderParam是否有挂单、订单ID、完整参数
止盈longTakeProfitOrderId, shortTakeProfitOrderId止盈条件单ID
* *

6 个全局 O(1) 索引

* 
 *   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 → 元素
 *
* 索引通过 {@link #rebuildIndex(List)}（全量重建）或 {@link #refreshIndices()}（增量刷新） * 维护，每次操作后自动打印全量网格状态到控制台。 * *

何时填充 TraderParam

* 初始化时 {@code updateGridElements()} 为每个元素预填充 longTraderParam 和 shortTraderParam * （含 direction/entryPrice/takeProfitPrice/quantity），订单ID字段在挂单成功后由 * *

使用示例

* 
 *   GridElement elem = GridElement.findById(1);
 *   boolean hasLong = elem.isHasLongOrder();           // 是否挂了多单
 *   BigDecimal tpPrice = elem.getLongTraderParam().getTakeProfitPrice();  // 止盈价
 *   elem.getUp();     // 上一个网格（O(1)）
 *   elem.getDown();   // 下一个网格（O(1)）
 *
* * @author Administrator */ public class GridElement { /** 网格层级编号 */ private int id; /** 网格触发价格 */ private BigDecimal gridPrice; /** 是否存在多仓挂单 */ private boolean hasLongOrder; /** 是否存在空仓挂单 */ private boolean hasShortOrder; /** 多仓挂单参数 */ private TraderParam longTraderParam; /** 空仓挂单参数 */ private TraderParam shortTraderParam; /** 上一个网格编号，null 表示无上一级 */ private Integer upId; /** 下一个网格编号，null 表示无下一级 */ private Integer downId; /** 多仓挂单订单 ID */ private String longOrderId; /** 空仓挂单订单 ID */ private String shortOrderId; /** 多仓止盈订单 ID */ private String longTakeProfitOrderId; /** 空仓止盈订单 ID */ private String shortTakeProfitOrderId; /** 多仓止损订单 ID */ private String longStopLossOrderId; /** 空仓止损订单 ID */ private String shortStopLossOrderId; /** 全局 ID 索引，由 { GateConfig#setGridElements(List)} 触发重建，O(1) 查找 */ private static final Map INDEX = new ConcurrentHashMap<>(); /** 全局价格索引，由 { GateConfig#setGridElements(List)} 触发重建，O(1) 查找 */ private static final Map PRICE_INDEX = new ConcurrentHashMap<>(); /** 全局多仓订单 ID 索引，由 { GateConfig#setGridElements(List)} 触发重建，O(1) 查找 */ private static final Map LONG_ORDER_ID_INDEX = new ConcurrentHashMap<>(); /** 全局空仓订单 ID 索引，由 { GateConfig#setGridElements(List)} 触发重建，O(1) 查找 */ private static final Map SHORT_ORDER_ID_INDEX = new ConcurrentHashMap<>(); /** 全局多仓止盈订单 ID 索引，由 { GateConfig#setGridElements(List)} 触发重建，O(1) 查找 */ private static final Map LONG_TP_ORDER_ID_INDEX = new ConcurrentHashMap<>(); /** 全局空仓止盈订单 ID 索引，由 { GateConfig#setGridElements(List)} 触发重建，O(1) 查找 */ private static final Map SHORT_TP_ORDER_ID_INDEX = new ConcurrentHashMap<>(); /** 全局多仓止损订单 ID 索引 */ private static final Map LONG_SL_ORDER_ID_INDEX = new ConcurrentHashMap<>(); /** 全局空仓止损订单 ID 索引 */ private static final Map SHORT_SL_ORDER_ID_INDEX = new ConcurrentHashMap<>(); /** * 根据 ID 快速查找网格元素（O(1)）。 * * @param id 网格层级编号 * @return 对应的 GridElement，不存在则返回 null */ public static GridElement findById(int id) { return INDEX.get(id); } /** * 根据价格快速查找网格元素（O(1)）。 * * @param price 网格价格 * @return 对应的 GridElement，不存在则返回 null */ public static GridElement findByPrice(BigDecimal price) { return PRICE_INDEX.get(price); } /** * 根据多仓挂单订单 ID 快速查找网格元素（O(1)）。 * * @param orderId 多仓挂单订单 ID * @return 对应的 GridElement，不存在则返回 null */ public static GridElement findByLongOrderId(String orderId) { return LONG_ORDER_ID_INDEX.get(orderId); } /** * 根据空仓挂单订单 ID 快速查找网格元素（O(1)）。 * * @param orderId 空仓挂单订单 ID * @return 对应的 GridElement，不存在则返回 null */ public static GridElement findByShortOrderId(String orderId) { return SHORT_ORDER_ID_INDEX.get(orderId); } /** * 根据多仓止盈订单 ID 快速查找网格元素（O(1)）。 * * @param orderId 多仓止盈订单 ID * @return 对应的 GridElement，不存在则返回 null */ public static GridElement findByLongTakeProfitOrderId(String orderId) { return LONG_TP_ORDER_ID_INDEX.get(orderId); } /** * 根据空仓止盈订单 ID 快速查找网格元素（O(1)）。 * * @param orderId 空仓止盈订单 ID * @return 对应的 GridElement，不存在则返回 null */ public static GridElement findByShortTakeProfitOrderId(String orderId) { return SHORT_TP_ORDER_ID_INDEX.get(orderId); } /** @return 当前多仓止盈单数量 */ public static int getLongTakeProfitCount() { return LONG_TP_ORDER_ID_INDEX.size(); } /** @return 当前空仓止盈单数量 */ public static int getShortTakeProfitCount() { 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 索引和价格索引。 * 由 { GateConfig#setGridElements(List)} 在每次列表变更后调用。 */ public static void rebuildIndex(List elements) { INDEX.clear(); 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 : elements) { INDEX.put(e.getId(), e); putDynamicIndices(e); } logAll(); } /** * 刷新动态索引（价格索引、多仓/空仓订单 ID 索引）。 * 在对 GridElement 的 {@link #longOrderId}、{@link #shortOrderId}、 * {@link #longTraderParam}、{@link #shortTraderParam} 等字段修改后调用， * 使快速查找方法获取到最新数据。 */ 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(); LONG_SL_ORDER_ID_INDEX.clear(); SHORT_SL_ORDER_ID_INDEX.clear(); for (GridElement e : INDEX.values()) { putDynamicIndices(e); } logAll(); } /** * 打印全部网格数据到日志。 */ public static void logAll() { List 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.getLongStopLossOrderId() != null || e.getShortStopLossOrderId() != null){ 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.getLongOrderId() != null ? e.getLongOrderId() : "-", e.isHasShortOrder() ? "有" : "无", e.getShortOrderId() != null ? e.getShortOrderId() : "-", e.getLongTakeProfitOrderId() != null ? e.getLongTakeProfitOrderId() : "-", e.getShortTakeProfitOrderId() != null ? e.getShortTakeProfitOrderId() : "-", e.getLongStopLossOrderId() != null ? e.getLongStopLossOrderId() : "-", e.getShortStopLossOrderId() != null ? e.getShortStopLossOrderId() : "-" )); } } 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); } /** * 获取所有已挂多仓条件单的网格元素。 * 小于空仓仓位线的多单 * * @return 已挂多仓条件单的 GridElement 列表 */ public static List findAllShortOrders(BigDecimal currentPrice) { List result = new ArrayList<>(); for (GridElement e : INDEX.values()) { if (e.isHasShortOrder() && e.getGridPrice().compareTo(currentPrice) < 0 && e.getShortTakeProfitOrderId() == null) { result.add(e); } } return result; } /** * 获取所有已挂空仓条件单的网格元素。 * 大于多仓仓位线的空单 * * @return 已挂空仓条件单的 GridElement 列表 */ public static List findAllLongOrders(BigDecimal currentPrice) { List result = new ArrayList<>(); for (GridElement e : INDEX.values()) { if (e.isHasLongOrder() && e.getGridPrice().compareTo(currentPrice) > 0 && e.getLongTakeProfitOrderId() == null) { result.add(e); } } return result; } private static void putDynamicIndices(GridElement e) { PRICE_INDEX.put(e.getGridPrice(), e); if (e.getLongOrderId() != null) { LONG_ORDER_ID_INDEX.put(e.getLongOrderId(), e); } if (e.getShortOrderId() != null) { SHORT_ORDER_ID_INDEX.put(e.getShortOrderId(), 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); } if (e.getLongStopLossOrderId() != null) { LONG_SL_ORDER_ID_INDEX.put(e.getLongStopLossOrderId(), e); } if (e.getShortStopLossOrderId() != null) { SHORT_SL_ORDER_ID_INDEX.put(e.getShortStopLossOrderId(), e); } } /** * @return 根据 upId 获取上一个网格元素，无上一级则返回 null */ public GridElement getUp() { return upId != null ? INDEX.get(upId) : null; } /** * @return 根据 downId 获取下一个网格元素，无下一级则返回 null */ public GridElement getDown() { return downId != null ? INDEX.get(downId) : null; } private GridElement(Builder builder) { this.id = builder.id; this.gridPrice = builder.gridPrice; this.hasLongOrder = builder.hasLongOrder; this.hasShortOrder = builder.hasShortOrder; this.longTraderParam = builder.longTraderParam; 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; this.longStopLossOrderId = builder.longStopLossOrderId; this.shortStopLossOrderId = builder.shortStopLossOrderId; } // ==================== 网格层级编号 ==================== /** @return 网格层级编号 */ public int getId() { return id; } /** 设置网格层级编号 */ public void setId(int id) { this.id = id; } // ==================== 网格价格 ==================== /** @return 网格触发价格 */ public BigDecimal getGridPrice() { return gridPrice; } /** 设置网格触发价格 */ public void setGridPrice(BigDecimal gridPrice) { this.gridPrice = gridPrice; } // ==================== 多仓挂单标记 ==================== /** @return 是否存在多仓挂单 */ public boolean isHasLongOrder() { return hasLongOrder; } /** 标记是否存在多仓挂单 */ public void setHasLongOrder(boolean hasLongOrder) { this.hasLongOrder = hasLongOrder; } // ==================== 空仓挂单标记 ==================== /** @return 是否存在空仓挂单 */ public boolean isHasShortOrder() { return hasShortOrder; } /** 标记是否存在空仓挂单 */ public void setHasShortOrder(boolean hasShortOrder) { this.hasShortOrder = hasShortOrder; } // ==================== 多仓挂单参数 ==================== /** @return 多仓挂单参数 */ public TraderParam getLongTraderParam() { return longTraderParam; } /** 设置多仓挂单参数 */ public void setLongTraderParam(TraderParam longTraderParam) { this.longTraderParam = longTraderParam; } // ==================== 空仓挂单参数 ==================== /** @return 空仓挂单参数 */ public TraderParam getShortTraderParam() { return shortTraderParam; } /** 设置空仓挂单参数 */ public void setShortTraderParam(TraderParam shortTraderParam) { this.shortTraderParam = shortTraderParam; } // ==================== 上一个网格编号 ==================== /** @return 上一个网格编号，null 表示无上一级 */ public Integer getUpId() { return upId; } /** 设置上一个网格编号 */ public void setUpId(Integer upId) { this.upId = upId; } // ==================== 下一个网格编号 ==================== /** @return 下一个网格编号，null 表示无下一级 */ public Integer getDownId() { return downId; } /** 设置下一个网格编号 */ public void setDownId(Integer downId) { this.downId = downId; } // ==================== 多仓挂单订单 ID ==================== /** @return 多仓挂单订单 ID */ public String getLongOrderId() { return longOrderId; } /** 设置多仓挂单订单 ID */ public void setLongOrderId(String longOrderId) { this.longOrderId = longOrderId; } // ==================== 空仓挂单订单 ID ==================== /** @return 空仓挂单订单 ID */ public String getShortOrderId() { return shortOrderId; } /** 设置空仓挂单订单 ID */ public void setShortOrderId(String shortOrderId) { this.shortOrderId = shortOrderId; } // ==================== 多仓止盈订单 ID ==================== /** @return 多仓止盈订单 ID */ public String getLongTakeProfitOrderId() { return longTakeProfitOrderId; } /** 设置多仓止盈订单 ID */ public void setLongTakeProfitOrderId(String longTakeProfitOrderId) { this.longTakeProfitOrderId = longTakeProfitOrderId; } // ==================== 空仓止盈订单 ID ==================== /** @return 空仓止盈订单 ID */ public String getShortTakeProfitOrderId() { return shortTakeProfitOrderId; } /** 设置空仓止盈订单 ID */ public void setShortTakeProfitOrderId(String shortTakeProfitOrderId) { this.shortTakeProfitOrderId = shortTakeProfitOrderId; } // ==================== 多仓止损订单 ID ==================== /** @return 多仓止损订单 ID */ public String getLongStopLossOrderId() { return longStopLossOrderId; } /** 设置多仓止损订单 ID */ public void setLongStopLossOrderId(String longStopLossOrderId) { this.longStopLossOrderId = longStopLossOrderId; } // ==================== 空仓止损订单 ID ==================== /** @return 空仓止损订单 ID */ public String getShortStopLossOrderId() { return shortStopLossOrderId; } /** 设置空仓止损订单 ID */ public void setShortStopLossOrderId(String shortStopLossOrderId) { this.shortStopLossOrderId = shortStopLossOrderId; } public static Builder builder() { return new Builder(); } /** * GridElement 的流式构造器。 * *

必填项

* {@code id}、{@code gridPrice} 必须设置。 * *

默认值

* hasLongOrder/hasShortOrder 默认为 false，upId/downId/TraderParam 默认为 null */ public static class Builder { /** 网格层级编号（必填） */ private int id; /** 网格触发价格（必填） */ private BigDecimal gridPrice; /** 是否有多仓挂单，默认 false */ private boolean hasLongOrder = false; /** 是否有空仓挂单，默认 false */ private boolean hasShortOrder = false; /** 多仓挂单参数 */ private TraderParam longTraderParam; /** 空仓挂单参数 */ private TraderParam shortTraderParam; /** 上一个网格编号，默认 null（无上一级） */ private Integer upId; /** 下一个网格编号，默认 null（无下一级） */ private Integer downId; /** 多仓挂单订单 ID */ private String longOrderId; /** 空仓挂单订单 ID */ private String shortOrderId; /** 多仓止盈订单 ID */ private String longTakeProfitOrderId; /** 空仓止盈订单 ID */ private String shortTakeProfitOrderId; /** 多仓止损订单 ID */ private String longStopLossOrderId; /** 空仓止损订单 ID */ private String shortStopLossOrderId; /** 设置网格层级编号 */ public Builder id(int id) { this.id = id; return this; } /** 设置网格触发价格 */ public Builder gridPrice(BigDecimal gridPrice) { this.gridPrice = gridPrice; return this; } /** 设置是否存在多仓挂单 */ public Builder hasLongOrder(boolean hasLongOrder) { this.hasLongOrder = hasLongOrder; return this; } /** 设置是否存在空仓挂单 */ public Builder hasShortOrder(boolean hasShortOrder) { this.hasShortOrder = hasShortOrder; return this; } /** 设置多仓挂单参数 */ public Builder longTraderParam(TraderParam longTraderParam) { this.longTraderParam = longTraderParam; return this; } /** 设置空仓挂单参数 */ public Builder shortTraderParam(TraderParam shortTraderParam) { this.shortTraderParam = shortTraderParam; return this; } /** 设置上一个网格编号 */ 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 longTakeProfitOrderId(String longTakeProfitOrderId) { this.longTakeProfitOrderId = longTakeProfitOrderId; return this; } /** 设置空仓止盈订单 ID */ public Builder shortTakeProfitOrderId(String shortTakeProfitOrderId) { this.shortTakeProfitOrderId = shortTakeProfitOrderId; return this; } /** 设置多仓止损订单 ID */ public Builder longStopLossOrderId(String longStopLossOrderId) { this.longStopLossOrderId = longStopLossOrderId; return this; } /** 设置空仓止损订单 ID */ public Builder shortStopLossOrderId(String shortStopLossOrderId) { this.shortStopLossOrderId = shortStopLossOrderId; return this; } public GridElement build() { return new GridElement(this); } } }