| | |
|---|
| | | */ |
|---|
| | | public void onKline(BigDecimal closePrice) { |
|---|
| | | |
|---|
| | | log.info("当前价：{}", closePrice); |
|---|
| | | // log.info("当前价：{}", closePrice); |
|---|
| | | |
|---|
| | | lastKlinePrice = closePrice; |
|---|
| | | |
|---|
| | |
|---|
| | | int posSize = Math.max(queryPositionSize(Position.ModeEnum.DUAL_SHORT), shortPositionSize.intValue()); |
|---|
| | | extendShortStopLoss(posSize, shortGridElement.getId()); |
|---|
| | | // [Gate] 止盈挂单：超出基础仓位的部分，挂在多仓第一止损位 |
|---|
| | | // placeExcessTakeProfit(posSize, false); |
|---|
| | | if (config.isPlaceExcessTakeProfit()) { |
|---|
| | | placeExcessTakeProfit(posSize, false); |
|---|
| | | } |
|---|
| | | log.info("[Gate] 空单成交 gridId:{}, 当前持仓:{}张", filledQty, posSize); |
|---|
| | | |
|---|
| | | |
|---|
| | | |
|---|
| | | checkShortStopLongProfit(accumulatedShortLossCount, shortGridElement.getId() + 2); |
|---|
| | | |
|---|
| | | } |
|---|
| | | } |
|---|
| | |
|---|
| | | int posSize = Math.max(queryPositionSize(Position.ModeEnum.DUAL_LONG), longPositionSize.intValue()); |
|---|
| | | extendLongStopLoss(posSize, longGridElement.getId()); |
|---|
| | | // [Gate] 止盈挂单：超出基础仓位的部分，挂在空仓第一止损位 |
|---|
| | | // placeExcessTakeProfit(posSize, true); |
|---|
| | | if (config.isPlaceExcessTakeProfit()) { |
|---|
| | | placeExcessTakeProfit(posSize, true); |
|---|
| | | } |
|---|
| | | log.info("[Gate] 多单成交 gridId:{}, 当前持仓:{}张", filledQty, posSize); |
|---|
| | | |
|---|
| | | |
|---|
| | | checkLongStopShortProfit(accumulatedLongLossCount, longGridElement.getId() -2); |
|---|
| | | |
|---|
| | | } |
|---|
| | | } |
|---|
| | |
|---|
| | | |
|---|
| | | if (newEntryGrid != null) { |
|---|
| | | |
|---|
| | | String quantity = String.valueOf(Math.max(queryPositionSize(Position.ModeEnum.DUAL_SHORT), shortPositionSize.intValue()) + Integer.parseInt(config.getQuantity())); |
|---|
| | | |
|---|
| | | // String quantity = String.valueOf(Math.max(queryPositionSize(Position.ModeEnum.DUAL_SHORT), shortPositionSize.intValue()) + Integer.parseInt(config.getQuantity())); |
|---|
| | | String quantity = String.valueOf(config.getBaseQuantity()); |
|---|
| | | // 向下检查是否已有多单挂在更低价格网格，有则跳过（防止价格回升后重复挂单） |
|---|
| | | boolean hasLongOrderBelow = false; |
|---|
| | | GridElement checkDownCursor = GridElement.findById(newEntryGrid.getDownId()); |
|---|
| | |
|---|
| | | if (newEntryGrid != null) { |
|---|
| | | |
|---|
| | | // String quantity = String.valueOf((accumulatedShortLossCount + 1) * Integer.parseInt(config.getQuantity())); |
|---|
| | | String quantity = String.valueOf(Math.max(queryPositionSize(Position.ModeEnum.DUAL_LONG), longPositionSize.intValue()) + Integer.parseInt(config.getQuantity())); |
|---|
| | | |
|---|
| | | // String quantity = String.valueOf(Math.max(queryPositionSize(Position.ModeEnum.DUAL_LONG), longPositionSize.intValue()) + Integer.parseInt(config.getQuantity())); |
|---|
| | | String quantity = String.valueOf(config.getBaseQuantity()); |
|---|
| | | // 向上检查是否已有空单挂在更高价格网格，有则跳过（防止价格回落后重复挂单） |
|---|
| | | boolean hasShortOrderAbove = false; |
|---|
| | | GridElement checkUpCursor = GridElement.findById(newEntryGrid.getUpId()); |
|---|
| | |
|---|
| | | } |
|---|
| | | } |
|---|
| | | |
|---|
| | | // ========== 加仓计算 ========== |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * 根据 {@code stopLossCountMode} 计算当前有效的止损次数。 |
|---|
| | | * <ul> |
|---|
| | | * <li>{@code "single"}（单向）：返回该方向的累计止损次数</li> |
|---|
| | | * <li>{@code "dual"}（双向）：返回多空双向累计总次数</li> |
|---|
| | | * </ul> |
|---|
| | | * |
|---|
| | | * @param isLong {@code true}=多仓方向，{@code false}=空仓方向 |
|---|
| | | * @return 有效止损次数 |
|---|
| | | */ |
|---|
| | | private int getEffectiveStopLossCount(boolean isLong) { |
|---|
| | | if ("single".equals(config.getStopLossCountMode())) { |
|---|
| | | return isLong ? accumulatedLongLossCount : accumulatedShortLossCount; |
|---|
| | | } |
|---|
| | | // "dual" — 双向总次数 |
|---|
| | | return accumulatedLongLossCount + accumulatedShortLossCount; |
|---|
| | | } |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * 根据加仓配置计算止损追单时的实际下单量。 |
|---|
| | | * <p>公式：</p> |
|---|
| | | * <pre> |
|---|
| | | * divisor = addPositionInterval + 1 |
|---|
| | | * addMultiplier = floor(effectiveStopLossCount / divisor) |
|---|
| | | * addQty = addMultiplier × addPositionQuantity |
|---|
| | | * finalQty = min(baseQuantity + addQty, maxPositionPerSide > 0 ? maxPositionPerSide : ∞) |
|---|
| | | * </pre> |
|---|
| | | * |
|---|
| | | * @param isLong {@code true}=多仓方向，{@code false}=空仓方向 |
|---|
| | | * @return 实际下单张数（字符串） |
|---|
| | | */ |
|---|
| | | private String calculateEntryQuantity(boolean isLong) { |
|---|
| | | int baseQty = Integer.parseInt(config.getBaseQuantity()); |
|---|
| | | int interval = config.getAddPositionInterval(); |
|---|
| | | int addQtyPerUnit = config.getAddPositionQuantity(); |
|---|
| | | int maxPerSide = config.getMaxPositionPerSide(); |
|---|
| | | |
|---|
| | | int effectiveCount = getEffectiveStopLossCount(isLong); |
|---|
| | | int startThreshold = config.getAddPositionStartThreshold(); |
|---|
| | | if (startThreshold > 0) { |
|---|
| | | effectiveCount = Math.max(0, effectiveCount - startThreshold); |
|---|
| | | } |
|---|
| | | // divisor = interval + 1：interval=0→每次加仓, interval=1→每2次加仓(2,4,6...), interval=3→每4次加仓(4,8,12...) |
|---|
| | | int divisor = interval + 1; |
|---|
| | | int addMultiplier = interval >= 0 ? effectiveCount / divisor : 0; |
|---|
| | | int addQty = addMultiplier * addQtyPerUnit; |
|---|
| | | int totalQty = baseQty + addQty; |
|---|
| | | |
|---|
| | | if (maxPerSide > 0 && totalQty > maxPerSide) { |
|---|
| | | totalQty = maxPerSide; |
|---|
| | | } |
|---|
| | | |
|---|
| | | return String.valueOf(totalQty); |
|---|
| | | } |
|---|
| | | |
|---|
| | | private void handleLongStopLossTriggered(GridElement gridElement, String orderId) { |
|---|
| | | gridElement.removeLongStopLossOrderId(orderId); |
|---|
| | | |
|---|
| | |
|---|
| | | } |
|---|
| | | |
|---|
| | | lastLongStopLossGridId = gridId; |
|---|
| | | |
|---|
| | | accumulatedLongLossCount++; |
|---|
| | | log.info("[Gate] 多仓止损触发 gridId:{}, 止损次数:{}{}, 开始追单", |
|---|
| | | gridId, accumulatedLongLossCount, sameGrid ? "(同网格)" : ""); |
|---|
| | |
|---|
| | | |
|---|
| | | // 止损追单：同一网格可有多笔挂单，不判断 isHasLongOrder，直接挂单 |
|---|
| | | BigDecimal triggerPrice = newEntryGrid.getGridPrice(); |
|---|
| | | // String size = String.valueOf(Math.max(queryPositionSize(Position.ModeEnum.DUAL_SHORT), shortPositionSize.intValue()) + Integer.parseInt(config.getQuantity())); |
|---|
| | | String size = String.valueOf(config.getBaseQuantity()); |
|---|
| | | String size = calculateEntryQuantity(true); |
|---|
| | | log.info("[Gate] 多仓止损追单 有效次数:{}, 基础:{}张 → 实际:{}张, 模式:{}", |
|---|
| | | getEffectiveStopLossCount(true), config.getBaseQuantity(), size, config.getStopLossCountMode()); |
|---|
| | | newEntryGrid.getLongTraderParam().setQuantity(size); |
|---|
| | | placeEntryOrderWithPreFlag(newEntryGrid, true, triggerPrice, |
|---|
| | | FuturesPriceTrigger.RuleEnum.NUMBER_1, size); |
|---|
| | |
|---|
| | | longEntryTraderIdParam(cancelGrid, cancelOrderId, false); |
|---|
| | | log.info("[Gate] 多仓止损触发, 取消gridId:{}的多单,{}", cancelGridId, cancelOrderId); |
|---|
| | | }); |
|---|
| | | } |
|---|
| | | } |
|---|
| | | |
|---|
| | | } |
|---|
| | | |
|---|
| | | // ========== 止损触发操作表 ========== |
|---|
| | | /** |
|---|
| | | * value = int[2]: {对手满仓止盈%, 基础仓位阈值%} |
|---|
| | | * <ul> |
|---|
| | | * <li>[0] 对手满仓：挂对手仓位此%做止盈；0=不挂</li> |
|---|
| | | * <li>[1] 基础仓位阈值（占maxPos的%）：对手/己方仓位超出此阈值部分做止盈；0=不挂</li> |
|---|
| | | * </ul> |
|---|
| | | */ |
|---|
| | | private static final Map<Integer, int[]> STOP_LOSS_RULES = new LinkedHashMap<>(); |
|---|
| | | private static final int DEFAULT_STOP_LOSS_PERCENT = 5; |
|---|
| | | |
|---|
| | | static { |
|---|
| | | // times {满仓%, 阈值%} |
|---|
| | | put(1, new int[]{0, 0}); |
|---|
| | | put(2, new int[]{0, 0}); |
|---|
| | | put(3, new int[]{30, 0}); |
|---|
| | | put(4, new int[]{0, 0}); |
|---|
| | | put(5, new int[]{0, 0}); |
|---|
| | | put(6, new int[]{40, 40}); |
|---|
| | | put(7, new int[]{0, 0}); |
|---|
| | | put(8, new int[]{0, 0}); |
|---|
| | | put(9, new int[]{50, 50}); |
|---|
| | | put(10, new int[]{0, 0}); |
|---|
| | | put(11, new int[]{0, 0}); |
|---|
| | | put(12, new int[]{55, 60}); |
|---|
| | | put(13, new int[]{0, 0}); |
|---|
| | | put(14, new int[]{0, 0}); |
|---|
| | | put(15, new int[]{60, 60}); |
|---|
| | | put(16, new int[]{0, 0}); |
|---|
| | | put(17, new int[]{0, 0}); |
|---|
| | | put(18, new int[]{65, 65}); |
|---|
| | | put(19, new int[]{0, 0}); |
|---|
| | | put(20, new int[]{0, 0}); |
|---|
| | | put(21, new int[]{70, 70}); |
|---|
| | | put(22, new int[]{0, 0}); |
|---|
| | | put(23, new int[]{0, 0}); |
|---|
| | | put(24, new int[]{75, 75}); |
|---|
| | | put(25, new int[]{0, 0}); |
|---|
| | | put(26, new int[]{0, 0}); |
|---|
| | | put(27, new int[]{80, 80}); |
|---|
| | | put(28, new int[]{0, 0}); |
|---|
| | | put(29, new int[]{0, 0}); |
|---|
| | | put(30, new int[]{85, 85}); |
|---|
| | | put(31, new int[]{0, 0}); |
|---|
| | | put(32, new int[]{0, 0}); |
|---|
| | | } |
|---|
| | | |
|---|
| | | private static void put(int times, int[] rule) { STOP_LOSS_RULES.put(times, rule); } |
|---|
| | | |
|---|
| | | private static int[] ruleOf(int times) { |
|---|
| | | int[] r = STOP_LOSS_RULES.get(times); |
|---|
| | | return r != null ? r : STOP_LOSS_RULES.get(32); |
|---|
| | | } |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * 多仓止损触发后，查表处理对手盘（空仓）盈止 + 己方盈止 + 激活。 |
|---|
| | | */ |
|---|
| | | private void checkLongStopShortProfit(int times, int gridId) { |
|---|
| | | int[] r = ruleOf(times); |
|---|
| | | int maxPos = config.getMaxPositionSize(); |
|---|
| | | if (maxPos <= 0) { |
|---|
| | | return; |
|---|
| | | } |
|---|
| | | |
|---|
| | | int fullTpPct = r[0]; // 对手满仓 → 止盈% |
|---|
| | | int fullTpPctNum = maxPos * (100- fullTpPct)/ 100; |
|---|
| | | int thresholdPct = r[1]; // 基础仓位阈值% |
|---|
| | | int thresholdPosNum = maxPos * (100- thresholdPct)/ 100; |
|---|
| | | |
|---|
| | | // ---------- 对手盘（空仓）盈止 ---------- |
|---|
| | | int oppPos = Math.max(queryPositionSize(Position.ModeEnum.DUAL_SHORT), shortPositionSize.intValue()); |
|---|
| | | boolean isFullTp = oppPos > fullTpPctNum; |
|---|
| | | if (isFullTp) { |
|---|
| | | // 对手仓位超出阈值：超额整个挂一笔止盈，位置在触发格 - 1 |
|---|
| | | int excess = oppPos - fullTpPctNum; |
|---|
| | | GridElement tpElem = GridElement.findById(gridId); |
|---|
| | | if (tpElem != null) { |
|---|
| | | placeTakeProfitAtGrid(tpElem, false, excess, times); |
|---|
| | | } |
|---|
| | | } |
|---|
| | | |
|---|
| | | // ---------- 己方（多仓）盈止（≥6次） ---------- |
|---|
| | | if (times >= 6 && thresholdPct > 0) { |
|---|
| | | int selfPos = Math.max(queryPositionSize(Position.ModeEnum.DUAL_LONG), longPositionSize.intValue()); |
|---|
| | | int excess = selfPos - thresholdPosNum; |
|---|
| | | if (excess > 0) { |
|---|
| | | int perOrderQty = maxPos * DEFAULT_STOP_LOSS_PERCENT / 100; |
|---|
| | | if (perOrderQty <= 0) { |
|---|
| | | perOrderQty = 1; |
|---|
| | | } |
|---|
| | | int totalOrders = excess / perOrderQty; |
|---|
| | | if (totalOrders <= 0) { |
|---|
| | | totalOrders = 1; |
|---|
| | | } |
|---|
| | | int entryGridId = 0; // 多仓建仓格 |
|---|
| | | for (int i = 0; i < totalOrders; i++) { |
|---|
| | | int tpGridId = entryGridId + 2 * (i + 1); // 朝盈利方向(向上)间隔2格 |
|---|
| | | GridElement tpElem = GridElement.findById(tpGridId); |
|---|
| | | if (tpElem == null) { |
|---|
| | | break; |
|---|
| | | } |
|---|
| | | placeTakeProfitAtGrid(tpElem, true, perOrderQty, times); |
|---|
| | | } |
|---|
| | | log.info("[Gate] 止损{}→己方多仓止盈, excess:{}, 挂{}单, 每单{}张", |
|---|
| | | times, excess, totalOrders, perOrderQty); |
|---|
| | | } |
|---|
| | | } |
|---|
| | | |
|---|
| | | } |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * 空仓止损触发后，查表处理对手盘（多仓）盈止 + 己方盈止。 |
|---|
| | | */ |
|---|
| | | private void checkShortStopLongProfit(int times, int gridId) { |
|---|
| | | int[] r = ruleOf(times); |
|---|
| | | int maxPos = config.getMaxPositionSize(); |
|---|
| | | if (maxPos <= 0) { |
|---|
| | | return; |
|---|
| | | } |
|---|
| | | |
|---|
| | | int fullTpPct = r[0]; // 对手满仓 → 止盈% |
|---|
| | | int fullTpPctNum = maxPos * (100 - fullTpPct) / 100; |
|---|
| | | int thresholdPct = r[1]; // 基础仓位阈值% |
|---|
| | | int thresholdPosNum = maxPos * (100 - thresholdPct) / 100; |
|---|
| | | |
|---|
| | | // ---------- 对手盘（多仓）盈止 ---------- |
|---|
| | | int oppPos = Math.max(queryPositionSize(Position.ModeEnum.DUAL_LONG), longPositionSize.intValue()); |
|---|
| | | boolean isFullTp = oppPos > fullTpPctNum; |
|---|
| | | if (isFullTp) { |
|---|
| | | // 对手仓位超出阈值：超额整个挂一笔止盈，位置在触发格 |
|---|
| | | int excess = oppPos - fullTpPctNum; |
|---|
| | | GridElement tpElem = GridElement.findById(gridId); |
|---|
| | | if (tpElem != null) { |
|---|
| | | placeTakeProfitAtGrid(tpElem, true, excess, times); |
|---|
| | | } |
|---|
| | | } |
|---|
| | | |
|---|
| | | // ---------- 己方（空仓）盈止（≥6次） ---------- |
|---|
| | | if (times >= 6 && thresholdPct > 0) { |
|---|
| | | int selfPos = Math.max(queryPositionSize(Position.ModeEnum.DUAL_SHORT), shortPositionSize.intValue()); |
|---|
| | | int excess = selfPos - thresholdPosNum; |
|---|
| | | if (excess > 0) { |
|---|
| | | int perOrderQty = maxPos * DEFAULT_STOP_LOSS_PERCENT / 100; |
|---|
| | | if (perOrderQty <= 0) { |
|---|
| | | perOrderQty = 1; |
|---|
| | | } |
|---|
| | | int totalOrders = excess / perOrderQty; |
|---|
| | | if (totalOrders <= 0) { |
|---|
| | | totalOrders = 1; |
|---|
| | | } |
|---|
| | | int entryGridId = 0; // 空仓建仓格 |
|---|
| | | for (int i = 0; i < totalOrders; i++) { |
|---|
| | | int tpGridId = entryGridId - 2 * (i + 1); // 朝盈利方向(向下)间隔2格 |
|---|
| | | GridElement tpElem = GridElement.findById(tpGridId); |
|---|
| | | if (tpElem == null) { |
|---|
| | | break; |
|---|
| | | } |
|---|
| | | placeTakeProfitAtGrid(tpElem, false, perOrderQty, times); |
|---|
| | | } |
|---|
| | | log.info("[Gate] 止损{}→己方空仓止盈, excess:{}, 挂{}单, 每单{}张", |
|---|
| | | times, excess, totalOrders, perOrderQty); |
|---|
| | | } |
|---|
| | | } |
|---|
| | | |
|---|
| | |
|---|
| | | |
|---|
| | | // 止损追单：同一网格可有多笔挂单，不判断 isHasShortOrder，直接挂单 |
|---|
| | | BigDecimal triggerPrice = newEntryGrid.getGridPrice(); |
|---|
| | | // String size = String.valueOf(Math.max(queryPositionSize(Position.ModeEnum.DUAL_LONG), longPositionSize.intValue()) + Integer.parseInt(config.getQuantity())); |
|---|
| | | String size = String.valueOf(config.getBaseQuantity()); |
|---|
| | | String size = calculateEntryQuantity(false); |
|---|
| | | log.info("[Gate] 空仓止损追单 有效次数:{}, 基础:{}张 → 实际:{}张, 模式:{}", |
|---|
| | | getEffectiveStopLossCount(false), config.getBaseQuantity(), size, config.getStopLossCountMode()); |
|---|
| | | newEntryGrid.getShortTraderParam().setQuantity(size); |
|---|
| | | placeEntryOrderWithPreFlag(newEntryGrid, false, triggerPrice, |
|---|
| | | FuturesPriceTrigger.RuleEnum.NUMBER_2, negate(size)); |
|---|
| | |
|---|
| | | } |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * 挂单成交后，将超出基础仓位的部分挂止盈单，挂在对向仓位的第一止损位上。 |
|---|
| | | * |
|---|
| | | * <p>遍历所有 GridElement，找到对向仓位第一个有止损单的网格作为止盈挂单位置。 |
|---|
| | | * |
|---|
| | | * <p>例：空仓成交后持仓 8 张，基础 4 张 → 超出 4 张， |
|---|
| | | * 找到多仓第一止损位（如 gridId=-2）→ 在该位置挂空仓止盈单。 |
|---|
| | | * |
|---|
| | | * @param posSize 当前总持仓张数 |
|---|
| | | * @param isLong true=多仓成交，false=空仓成交 |
|---|
| | | */ |
|---|
| | | private void placeExcessTakeProfit(int posSize, boolean isLong) { |
|---|
| | | int baseQty = Integer.parseInt(config.getBaseQuantity()); |
|---|
| | | int excessQty = posSize - baseQty; |
|---|
| | | if (excessQty <= 0) { |
|---|
| | | return; |
|---|
| | | } |
|---|
| | | |
|---|
| | | // 遍历找到对向仓位第一个有止损单的网格 |
|---|
| | | GridElement tpElem = isLong ? findFirstShortStopLossGrid() : findFirstLongStopLossGrid(); |
|---|
| | | if (tpElem == null) { |
|---|
| | | log.warn("[Gate] {}止盈挂单失败：未找到对向仓止损位", isLong ? "多仓" : "空仓"); |
|---|
| | | return; |
|---|
| | | } |
|---|
| | | int tpGridId = tpElem.getId(); |
|---|
| | | |
|---|
| | | BigDecimal triggerPrice = tpElem.getGridPrice(); |
|---|
| | | String orderType = isLong ? ORDER_TYPE_CLOSE_LONG : ORDER_TYPE_CLOSE_SHORT; |
|---|
| | | // 多仓止盈：价格≥触发价时平仓(NUMBER_1)；空仓止盈：价格≤触发价时平仓(NUMBER_2) |
|---|
| | | FuturesPriceTrigger.RuleEnum rule = isLong ? FuturesPriceTrigger.RuleEnum.NUMBER_1 |
|---|
| | | : FuturesPriceTrigger.RuleEnum.NUMBER_2; |
|---|
| | | String size = isLong ? negate(String.valueOf(excessQty)) : String.valueOf(excessQty); |
|---|
| | | |
|---|
| | | // if (isLong && tpElem.getLongTakeProfitOrderId() != null) { |
|---|
| | | // executor.cancelConditionalOrder(tpElem.getLongTakeProfitOrderId(), oid -> { |
|---|
| | | // longTakeProfitTraderIdParam(tpElem, null, false); |
|---|
| | | // log.info("[Gate] 取消旧止盈, gridId:{}, orderId:{}", tpGridId, oid); |
|---|
| | | // }); |
|---|
| | | // } else if (!isLong && tpElem.getShortTakeProfitOrderId() != null) { |
|---|
| | | // executor.cancelConditionalOrder(tpElem.getShortTakeProfitOrderId(), oid -> { |
|---|
| | | // shortTakeProfitTraderIdParam(tpElem, null, false); |
|---|
| | | // log.info("[Gate] 取消旧止盈, gridId:{}, orderId:{}", tpGridId, oid); |
|---|
| | | // }); |
|---|
| | | // } |
|---|
| | | |
|---|
| | | String finalSize = size; |
|---|
| | | int finalTpGridId = tpGridId; |
|---|
| | | executor.placeTakeProfit(triggerPrice, rule, orderType, size, |
|---|
| | | profitId -> { |
|---|
| | | if (isLong) { |
|---|
| | | longTakeProfitTraderIdParam(tpElem, profitId, true); |
|---|
| | | } else { |
|---|
| | | shortTakeProfitTraderIdParam(tpElem, profitId, true); |
|---|
| | | } |
|---|
| | | log.info("[Gate] {}止盈挂单, gridId:{}, 触发价:{}, 数量:{}, takeProfitId:{}", |
|---|
| | | isLong ? "多仓" : "空仓", finalTpGridId, triggerPrice, finalSize, profitId); |
|---|
| | | } |
|---|
| | | ); |
|---|
| | | } |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * 在指定网格挂一笔对手止盈单（非满仓超额止盈，挂在止损触发位的下一格）。 |
|---|
| | | */ |
|---|
| | | private void placeTakeProfitAtGrid(GridElement tpElem, boolean isLong, int qty, int times) { |
|---|
