exchange.git - Gitblit

			@@ -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
			@@ -65,6 +87,13 @@
			private String longTakeProfitOrderId;
			/** 空仓止盈订单 ID */
			private String shortTakeProfitOrderId;
			/** 多仓止损订单 ID */
			private String longStopLossOrderId;
			/** 空仓止损订单 ID */
			private String shortStopLossOrderId;

			/** 索引重建锁，保证 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 +107,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 +172,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,6 +207,8 @@
			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);
			@@ -164,14 +223,19 @@
			* 使快速查找方法获取到最新数据。
			*/
			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();
			}

			@@ -183,9 +247,10 @@
			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()){
			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\n",
			" ID=%4d 价格=%s up=%s down=%s 多仓=%s(%s) 空仓=%s(%s) 多止盈=%s 空止盈=%s 多止损=%s 空止损=%s\n",
			e.getId(),
			e.getGridPrice(),
			e.getUpId(),
			@@ -195,19 +260,23 @@
			e.isHasShortOrder() ? "有" : "无",
			e.getShortOrderId() != null ? e.getShortOrderId() : "-",
			e.getLongTakeProfitOrderId() != null ? e.getLongTakeProfitOrderId() : "-",
			e.getShortTakeProfitOrderId() != null ? e.getShortTakeProfitOrderId() : "-"
			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\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()
			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()));
			@@ -223,10 +292,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);
			}
			}
			@@ -239,10 +308,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);
			}
			}
			@@ -262,6 +331,12 @@
			}
			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);
			}
			}

			@@ -292,6 +367,8 @@
			this.shortOrderId = builder.shortOrderId;
			this.longTakeProfitOrderId = builder.longTakeProfitOrderId;
			this.shortTakeProfitOrderId = builder.shortTakeProfitOrderId;
			this.longStopLossOrderId = builder.longStopLossOrderId;
			this.shortStopLossOrderId = builder.shortStopLossOrderId;
			}

			// ==================== 网格层级编号 ====================
			@@ -378,6 +455,20 @@
			/** 设置空仓止盈订单 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();
			}
			@@ -416,6 +507,10 @@
			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; }
			@@ -441,6 +536,10 @@
			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);