package com.xcong.excoin.modules.gateApi;
|
|
import java.math.BigDecimal;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.concurrent.ConcurrentHashMap;
|
|
/**
|
* 网格元素，表示网格交易策略中的一个价格层级。
|
*
|
* <p>每个网格层级包含该价格位置上的多仓和空仓挂单信息，
|
* 通过编号和网格价格唯一标识一个网格层级。
|
*
|
* <h3>关键字段</h3>
|
* <ul>
|
* <li><b>编号</b>：网格层级的唯一标识</li>
|
* <li><b>网格价格</b>：该层级对应的触发价格</li>
|
* <li><b>多仓挂单</b>：是否已有多头挂单、多头挂单参数</li>
|
* <li><b>空仓挂单</b>：是否有空头挂单、空头挂单参数</li>
|
* </ul>
|
*
|
* <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);
|
* </pre>
|
*
|
* @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 索引，由 {@link GateConfig#setGridElements(List)} 触发重建，O(1) 查找 */
|
private static final Map<Integer, GridElement> INDEX = new ConcurrentHashMap<>();
|
/** 全局价格索引，由 {@link GateConfig#setGridElements(List)} 触发重建，O(1) 查找 */
|
private static final Map<BigDecimal, GridElement> PRICE_INDEX = new ConcurrentHashMap<>();
|
/** 全局多仓订单 ID 索引，由 {@link GateConfig#setGridElements(List)} 触发重建，O(1) 查找 */
|
private static final Map<String, GridElement> LONG_ORDER_ID_INDEX = new ConcurrentHashMap<>();
|
/** 全局空仓订单 ID 索引，由 {@link GateConfig#setGridElements(List)} 触发重建，O(1) 查找 */
|
private static final Map<String, GridElement> SHORT_ORDER_ID_INDEX = new ConcurrentHashMap<>();
|
/** 全局多仓止盈订单 ID 索引，由 {@link GateConfig#setGridElements(List)} 触发重建，O(1) 查找 */
|
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 快速查找网格元素（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);
|
}
|
|
/**
|
* 从列表中重建全局 ID 索引和价格索引。
|
* 由 {@link GateConfig#setGridElements(List)} 在每次列表变更后调用。
|
*/
|
public static void rebuildIndex(List<GridElement> 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();
|
for (GridElement e : elements) {
|
INDEX.put(e.getId(), e);
|
putDynamicIndices(e);
|
}
|
}
|
|
/**
|
* 刷新动态索引（价格索引、多仓/空仓订单 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();
|
for (GridElement e : INDEX.values()) {
|
putDynamicIndices(e);
|
}
|
}
|
|
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);
|
}
|
}
|
|
/**
|
* @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;
|
}
|
|
// ==================== 网格层级编号 ====================
|
|
/** @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; }
|
|
public static Builder builder() {
|
return new Builder();
|
}
|
|
/**
|
* GridElement 的流式构造器。
|
*
|
* <h3>必填项</h3>
|
* {@code id}、{@code gridPrice} 必须设置。
|
*
|
* <h3>默认值</h3>
|
* 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;
|
|
/** 设置网格层级编号 */
|
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; }
|
|
public GridElement build() {
|
return new GridElement(this);
|
}
|
}
|
}
|
