增加了仓位推动的日志打印

Administrator

3 days ago bd3a9f2256030b8f41f944568ca7705de7d7fdd8

 src/main/java/com/xcong/excoin/modules/gateApi/GateTradeExecutor.java

@@ -1,7 +1,6 @@
package com.xcong.excoin.modules.gateApi;

import io.gate.gateapi.ApiClient;
import io.gate.gateapi.GateApiException;
import io.gate.gateapi.api.FuturesApi;
import io.gate.gateapi.models.FuturesInitialOrder;
import io.gate.gateapi.models.FuturesOrder;
@@ -24,8 +23,11 @@
 * 下单 REST API 调用可能耗时数百毫秒，若同步执行会阻塞 WS 回调线程，导致心跳超时误判。
 * 本类将所有 REST 调用提交到独立线程池异步执行。
 *
 * <h3>回调设计</h3>
 * 每个下单方法接受 onSuccess/onFailure 两个 Runnable。
 * 基底开仓时 onSuccess 用于标记基底已开，网格触发时通常为 null（成交状态由仓位推送驱动）。
 *
 * <h3>线程模型</h3>
 * 单线程 ThreadPoolExecutor + 有界队列 64 + CallerRunsPolicy：
 * <ul>
 *   <li><b>单线程</b>：保证下单顺序（开多→开空→止盈单），避免并发竞争</li>
 *   <li><b>有界队列 64</b>：防止堆积。极端行情下最多累积 64 个任务</li>
@@ -35,9 +37,9 @@
 *
 * <h3>调用链</h3>
 * <pre>
 *   GateGridTradeService.onKline → executor.openLong/openShort → REST API
 *   GateGridTradeService.onPositionUpdate → executor.openLong/openShort → REST API
 *   (每一次开仓后) → executor.placeTakeProfit → REST API
 *   GateGridTradeService.onKline → executor.openLong/openShort (基底双开 + 网格触发)
 *   GateGridTradeService.onPositionUpdate → executor.placeTakeProfit (开仓成交后设止盈)
 *   GateGridTradeService.stopGrid → executor.cancelAllPriceTriggeredOrders
 * </pre>
 *
 * @author Administrator
@@ -84,55 +86,38 @@
    }

    /**
     * 异步市价开多。
     * <p>创建 IOC 市价单（price=0），数量为正数。成功后调用 onSuccess 回调。
     *
     * @param quantity  数量（正数，如 "10"）
     * @param onSuccess 成功后回调，在交易线程中执行
     * 异步市价开多。quantity 为正数（如 "10"）。
     */
    public void openLong(String quantity, Runnable onSuccess) {
        executor.execute(() -> {
            try {
                FuturesOrder order = new FuturesOrder();
                order.setContract(contract);
                order.setSize(quantity);
                order.setPrice("0");
                order.setTif(FuturesOrder.TifEnum.IOC);
                order.setText("t-grid-long");
                FuturesOrder result = futuresApi.createFuturesOrder(SETTLE, order, null);
                log.info("[TradeExec] 开多成功, 价格:{}, id:{}", result.getFillPrice(), result.getId());
                if (onSuccess != null) {
                    onSuccess.run();
                }
            } catch (Exception e) {
                log.error("[TradeExec] 开多失败", e);
            }
        });
    public void openLong(String quantity, Runnable onSuccess, Runnable onFailure) {
        openPosition(quantity, "t-grid-long", "开多", onSuccess, onFailure);
    }

    /**
     * 异步市价开空。
     * <p>创建 IOC 市价单（price=0），size 需为负数。
     *
     * @param negQuantity 负数数量（如 "-10"）
     * @param onSuccess   成功后回调
     * 异步市价开空。quantity 为负数（如 "-10"）。
     */
    public void openShort(String negQuantity, Runnable onSuccess) {
    public void openShort(String quantity, Runnable onSuccess, Runnable onFailure) {
        openPosition(quantity, "t-grid-short", "开空", onSuccess, onFailure);
    }

    private void openPosition(String size, String text, String label, Runnable onSuccess, Runnable onFailure) {
        executor.execute(() -> {
            try {
                FuturesOrder order = new FuturesOrder();
                order.setContract(contract);
                order.setSize(negQuantity);
                order.setSize(size);
                order.setPrice("0");
                order.setTif(FuturesOrder.TifEnum.IOC);
                order.setText("t-grid-short");
                order.setText(text);
                FuturesOrder result = futuresApi.createFuturesOrder(SETTLE, order, null);
                log.info("[TradeExec] 开空成功, 价格:{}, id:{}", result.getFillPrice(), result.getId());
                log.info("[TradeExec] {}成功, 价格:{}, id:{}", label, result.getFillPrice(), result.getId());
                if (onSuccess != null) {
                    onSuccess.run();
                }
            } catch (Exception e) {
                log.error("[TradeExec] 开空失败", e);
                log.error("[TradeExec] {}失败", label, e);
                if (onFailure != null) {
                    onFailure.run();
                }
            }
        });
    }
@@ -140,38 +125,25 @@
    /**
     * 异步创建止盈条件单。
     * <p>使用 Gate 的 PriceTriggeredOrder：服务器监控价格，达到触发价后自动平仓。
     * 如果账户已有同方向同规则的条件单（label=UNIQUE），自动清除后重试一次。
     * 每次只平指定张数（size），多次触发的止盈单互不影响。
     *
     * @param triggerPrice 触发价格
     * @param rule         触发规则（NUMBER_1: ≥ 触发价，NUMBER_2: ≤ 触发价）
     * @param orderType    stop 类型（close-long-position / close-short-position）
     * @param autoSize     双仓平仓方向（close_long / close_short）
     * @param size         平仓张数（正=平空，负=平多）
     */
    public void placeTakeProfit(BigDecimal triggerPrice,
                                 FuturesPriceTrigger.RuleEnum rule,
                                 String orderType,
                                 String autoSize) {
                                 String size) {
        executor.execute(() -> {
            FuturesPriceTriggeredOrder order = buildTriggeredOrder(triggerPrice, rule, orderType, autoSize);
            FuturesPriceTriggeredOrder order = buildTriggeredOrder(triggerPrice, rule, orderType, size);
            try {
                TriggerOrderResponse response = futuresApi.createPriceTriggeredOrder(SETTLE, order);
                log.info("[TradeExec] 止盈单已创建, 触发价:{}, 类型:{}, id:{}",
                        triggerPrice, orderType, response.getId());
            } catch (GateApiException e) {
                if ("AUTO_USER_EXIST_POSITION_ORDER".equals(e.getErrorLabel())) {
                    log.warn("[TradeExec] 止盈单已存在，清除旧单后重试");
                    try {
                        futuresApi.cancelPriceTriggeredOrderList(SETTLE, contract);
                        TriggerOrderResponse response = futuresApi.createPriceTriggeredOrder(SETTLE, order);
                        log.info("[TradeExec] 止盈单重试成功, 触发价:{}, id:{}", triggerPrice, response.getId());
                    } catch (Exception retryEx) {
                        log.error("[TradeExec] 止盈单重试失败", retryEx);
                    }
                } else {
                    log.error("[TradeExec] 止盈单创建失败, 触发价:{}", triggerPrice, e);
                }
                log.info("[TradeExec] 止盈单已创建, 触发价:{}, 类型:{}, size:{}, id:{}",
                        triggerPrice, orderType, size, response.getId());
            } catch (Exception e) {
                log.error("[TradeExec] 止盈单创建失败, 触发价:{}", triggerPrice, e);
                log.error("[TradeExec] 止盈单创建失败, 触发价:{}, size:{}", triggerPrice, size, e);
            }
        });
    }
@@ -198,7 +170,7 @@
    private FuturesPriceTriggeredOrder buildTriggeredOrder(BigDecimal triggerPrice,
                                                            FuturesPriceTrigger.RuleEnum rule,
                                                            String orderType,
                                                            String autoSize) {
                                                            String size) {
        FuturesPriceTrigger trigger = new FuturesPriceTrigger();
        trigger.setStrategyType(FuturesPriceTrigger.StrategyTypeEnum.NUMBER_0);
        trigger.setPriceType(FuturesPriceTrigger.PriceTypeEnum.NUMBER_0);
@@ -208,11 +180,10 @@

        FuturesInitialOrder initial = new FuturesInitialOrder();
        initial.setContract(contract);
        initial.setSize(0L);
        initial.setSize(Long.parseLong(size));
        initial.setPrice("0");
        initial.setTif(FuturesInitialOrder.TifEnum.IOC);
        initial.setReduceOnly(true);
        initial.setAutoSize(autoSize);

        FuturesPriceTriggeredOrder order = new FuturesPriceTriggeredOrder();
        order.setTrigger(trigger);