From d4352284dc9049fa0d954b562ebb4632b34f4aee Mon Sep 17 00:00:00 2001
From: zyy3 <zyy3@zy.com>
Date: Mon, 13 Oct 2025 20:51:34 +0800
Subject: [PATCH] 1
---
trading-order-huobi/src/main/java/com.yami.trading.huobi/data/job/AbstractGetDataJob.java | 228 +++++++++++++++++++++++++++++++++++++++++++++++++++-----
1 files changed, 206 insertions(+), 22 deletions(-)
diff --git a/trading-order-huobi/src/main/java/com.yami.trading.huobi/data/job/AbstractGetDataJob.java b/trading-order-huobi/src/main/java/com.yami.trading.huobi/data/job/AbstractGetDataJob.java
index df096f9..77050f9 100644
--- a/trading-order-huobi/src/main/java/com.yami.trading.huobi/data/job/AbstractGetDataJob.java
+++ b/trading-order-huobi/src/main/java/com.yami.trading.huobi/data/job/AbstractGetDataJob.java
@@ -17,7 +17,9 @@
import java.math.BigDecimal;
import java.math.RoundingMode;
+import java.util.ArrayList;
import java.util.List;
+import java.util.Random;
public abstract class AbstractGetDataJob implements Runnable {
@@ -44,6 +46,8 @@
public abstract String getName();
+ // 在类中定义静态Random实例
+ private static final Random random = new Random();
public abstract void realtimeHandle(String symbols);
@@ -52,46 +56,175 @@
try {
String symbol = realtime.getSymbol();
- Integer decimal = itemService.getDecimal(symbol);
+ Integer decimal = itemService.getDecimal(symbol); // 虚拟币通常8位小数，需保留足够精度
Item item = this.itemService.findBySymbol(symbol);
BigDecimal currentValue = AdjustmentValueCache.getCurrentValue().get(symbol);
AdjustmentValue delayValue = AdjustmentValueCache.getDelayValue().get(symbol);
+
if (delayValue != null) {
- // 延时几次
- int frequency = (int) Arith.div(Arith.mul(delayValue.getSecond(), 1000.0D), this.interval);
+ if (delayValue.getValue().compareTo(BigDecimal.ZERO) == 0 || delayValue.getSecond() <= 0) {
+ cleanUpKLineCache(symbol); // 清理缓存，跳过后续计算
+ return;
+ }
+ // K线场景专属参数（可根据周期动态调整）
+ double baseFluctuation = 0.1;
+ int trendConsistencyRate = 70; // 70%概率保持与前一个值的波动方向一致（模拟趋势）
+ int maxAdjacentFluctuation = 5; // 相邻值波动不超过前一个值的5%（避免视觉跳变）
+
+ Integer frequency = AdjustmentValueCache.getFrequency().get(symbol);
+ List<BigDecimal> preAllocationList = AdjustmentValueCache.getPreAllocationList().get(symbol);
+ Integer currentIndex = AdjustmentValueCache.getCurrentAllocationIndex().get(symbol);
+ List<Boolean> upDownTrend = AdjustmentValueCache.getUpDownTrend().getOrDefault(symbol, new ArrayList<>());
+
+ if (frequency == null) {
+ frequency = (int) Arith.div(Arith.mul(delayValue.getSecond(), 1000.0D), this.interval);
+ AdjustmentValueCache.getFrequency().put(symbol, frequency);
+
+ if (frequency > 1) {
+ preAllocationList = new ArrayList<>(frequency);
+ BigDecimal totalValue = delayValue.getValue(); // 支持正负值
+ // 核心修改1：用绝对值算平均值（避免负数波动范围反向），最后补回原符号
+ BigDecimal totalAbs = totalValue.abs();
+ BigDecimal averageAbs = totalAbs.divide(new BigDecimal(frequency), decimal + 4, RoundingMode.HALF_UP);
+ BigDecimal average = averageAbs.multiply(totalValue.signum() == 1 ? BigDecimal.ONE : BigDecimal.ONE.negate());
+ BigDecimal sum = BigDecimal.ZERO;
+
+ // 优化1：最后k个值分散偏差（k=频率的2%，最少5个，确保最后一根K线无异常）
+ int lastK = Math.max(5, frequency / 50);
+ int normalCount = frequency - lastK;
+
+ // 优化2：前n-k个值——模拟真实行情波动（兼容正负）
+ for (int i = 0; i < normalCount; i++) {
+ BigDecimal randomValue;
+ if (i == 0) {
+ // 第一个值：基于带符号平均值波动，保留原符号
+ randomValue = generateTruncatedGaussianValue(average, baseFluctuation, decimal + 4);
+ } else {
+ boolean lastUp = upDownTrend.get(i - 1);
+ boolean keepTrend = Math.random() * 100 <= trendConsistencyRate;
+
+ if (keepTrend) {
+ // 核心修改2：按前值绝对值算波动幅度，避免负数趋势误判
+ BigDecimal lastVal = preAllocationList.get(i - 1);
+ double fluctRange = lastVal.abs().multiply(new BigDecimal(baseFluctuation * 1.2)).doubleValue();
+
+ if (lastUp) {
+ // 前一个上涨（无论正负，比前值大即为涨）：波动范围[0, fluctRange]
+ randomValue = generateDirectionalValue(lastVal, 0.0, fluctRange, decimal + 4);
+ } else {
+ // 前一个下跌（比前值小即为跌）：波动范围[-fluctRange, 0]
+ randomValue = generateDirectionalValue(lastVal, -fluctRange, 0.0, decimal + 4);
+ }
+ } else {
+ // 反转趋势：基于带符号平均值波动
+ randomValue = generateTruncatedGaussianValue(average, baseFluctuation, decimal + 4);
+ }
+
+ // 核心修改3：相邻波动约束——用前值绝对值算最大波动，超限时按符号截断
+ BigDecimal lastValue = preAllocationList.get(i - 1);
+ BigDecimal maxAdjacent = lastValue.abs()
+ .multiply(new BigDecimal(maxAdjacentFluctuation / 100.0))
+ .setScale(decimal + 4, RoundingMode.HALF_UP);
+ BigDecimal adjacentDiff = randomValue.subtract(lastValue);
+
+ if (adjacentDiff.abs().compareTo(maxAdjacent) > 0) {
+ randomValue = lastValue.add(
+ adjacentDiff.signum() == 1 ? maxAdjacent : maxAdjacent.negate()
+ );
+ }
+ }
+
+ preAllocationList.add(randomValue);
+ sum = sum.add(randomValue);
+ // 核心修改4：涨跌趋势改为“与前值对比”（而非平均值），兼容正负
+ boolean currentUp = (i == 0)
+ ? randomValue.compareTo(average) > 0
+ : randomValue.compareTo(preAllocationList.get(i - 1)) > 0;
+ upDownTrend.add(currentUp);
+ }
+
+ // 优化4：最后k个值——兼容负数总和
+ BigDecimal remaining = totalValue.subtract(sum);
+ // 用剩余值绝对值算平均，补回符号
+ BigDecimal remainingAbs = remaining.abs();
+ BigDecimal avgLastKAbs = remainingAbs.divide(new BigDecimal(lastK), decimal + 4, RoundingMode.HALF_UP);
+ BigDecimal avgLastK = avgLastKAbs.multiply(remaining.signum() == 1 ? BigDecimal.ONE : BigDecimal.ONE.negate());
+
+ for (int i = 0; i < lastK - 1; i++) {
+ BigDecimal smallFluctValue = generateTruncatedGaussianValue(avgLastK, baseFluctuation / 3, decimal + 4);
+ preAllocationList.add(smallFluctValue);
+ sum = sum.add(smallFluctValue);
+ upDownTrend.add(smallFluctValue.compareTo(preAllocationList.get(preAllocationList.size() - 2)) > 0);
+ }
+
+ // 最后1个值：兼容负数偏差
+ BigDecimal finalValue = totalValue.subtract(sum);
+ BigDecimal maxFinalFluct = avgLastK.abs()
+ .multiply(new BigDecimal(baseFluctuation / 5))
+ .setScale(decimal + 4, RoundingMode.HALF_UP);
+
+ if (finalValue.abs().compareTo(maxFinalFluct) > 0) {
+ // 超限时按符号截断，保留原方向
+ finalValue = maxFinalFluct.multiply(finalValue.signum() == 1 ? BigDecimal.ONE : BigDecimal.ONE.negate());
+ BigDecimal prevLastValue = preAllocationList.get(preAllocationList.size() - 1);
+ preAllocationList.set(preAllocationList.size() - 1, prevLastValue.add(totalValue.subtract(sum).subtract(finalValue)));
+ }
+ preAllocationList.add(finalValue);
+ upDownTrend.add(finalValue.compareTo(preAllocationList.get(preAllocationList.size() - 2)) > 0);
+
+ // 缓存更新
+ AdjustmentValueCache.getPreAllocationList().put(symbol, preAllocationList);
+ AdjustmentValueCache.getCurrentAllocationIndex().put(symbol, 0);
+ AdjustmentValueCache.getUpDownTrend().put(symbol, upDownTrend);
+ currentIndex = 0;
+ }
+ }
+
+ // 后续分配逻辑：兼容正负延时值
if (frequency <= 1) {
+ // 单次分配：直接用带符号值，避免符号丢失
+ BigDecimal delayVal = delayValue.getValue().setScale(decimal, RoundingMode.HALF_UP);
if (currentValue == null) {
- AdjustmentValueCache.getCurrentValue().put(symbol, delayValue.getValue());
+ AdjustmentValueCache.getCurrentValue().put(symbol, delayVal);
} else {
- AdjustmentValueCache.getCurrentValue().put(symbol,
- delayValue.getValue().add(currentValue));
+ AdjustmentValueCache.getCurrentValue().put(symbol, currentValue.add(delayVal).setScale(decimal, RoundingMode.HALF_UP));
}
-
if (!item.getAdjustmentValue().equals(AdjustmentValueCache.getCurrentValue().get(symbol))) {
item.setAdjustmentValue(AdjustmentValueCache.getCurrentValue().get(symbol));
itemService.saveOrUpdate(item);
}
- AdjustmentValueCache.getDelayValue().remove(symbol);
+ cleanUpKLineCache(symbol);
} else {
- // 本次调整值
- BigDecimal currentValue_frequency = delayValue.getValue().divide(new BigDecimal(frequency), decimal, RoundingMode.HALF_UP);
+ // 按预分配列表取值（列表已兼容正负）
+ if (preAllocationList != null && currentIndex != null && currentIndex < preAllocationList.size()) {
+ BigDecimal currentValueFrequency = preAllocationList.get(currentIndex).setScale(decimal, RoundingMode.HALF_UP);
- if (currentValue == null) {
- AdjustmentValueCache.getCurrentValue().put(symbol, currentValue_frequency);
- } else {
- AdjustmentValueCache.getCurrentValue().put(symbol,
- currentValue.add(currentValue_frequency));
- }
+ // 更新当前值：带符号累加
+ if (currentValue == null) {
+ AdjustmentValueCache.getCurrentValue().put(symbol, currentValueFrequency);
+ } else {
+ AdjustmentValueCache.getCurrentValue().put(symbol, currentValue.add(currentValueFrequency).setScale(decimal, RoundingMode.HALF_UP));
+ }
- delayValue.setValue(delayValue.getValue().subtract(currentValue_frequency));
- delayValue.setSecond(Arith.sub(delayValue.getSecond(), Arith.div(this.interval, 1000.0D)));
- AdjustmentValueCache.getDelayValue().put(symbol, delayValue);
+ // 更新延迟值：带符号减法
+ BigDecimal updatedDelayVal = delayValue.getValue().subtract(currentValueFrequency).setScale(decimal, RoundingMode.HALF_UP);
+ delayValue.setValue(updatedDelayVal);
+ delayValue.setSecond(Arith.sub(delayValue.getSecond(), Arith.div(this.interval, 1000.0D)));
+ AdjustmentValueCache.getDelayValue().put(symbol, delayValue);
- if (!item.getAdjustmentValue().equals(AdjustmentValueCache.getCurrentValue().get(symbol))) {
- item.setAdjustmentValue(AdjustmentValueCache.getCurrentValue().get(symbol));
- itemService.saveOrUpdate(item);
+ int nextIndex = currentIndex + 1;
+ AdjustmentValueCache.getCurrentAllocationIndex().put(symbol, nextIndex);
+
+ if (nextIndex >= frequency) {
+ cleanUpKLineCache(symbol);
+ }
+
+ if (!item.getAdjustmentValue().equals(AdjustmentValueCache.getCurrentValue().get(symbol))) {
+ item.setAdjustmentValue(AdjustmentValueCache.getCurrentValue().get(symbol));
+ itemService.saveOrUpdate(item);
+ }
}
}
}
@@ -154,4 +287,55 @@
this.dataDBService.saveAsyn(realtime);
}
+
+
+ // ------------------------------ 工具方法 ------------------------------
+ /**
+ * 生成截断正态分布值（限制在平均值±fluctuation范围内，模拟真实小波动）
+ */
+ private BigDecimal generateTruncatedGaussianValue(BigDecimal average, double fluctuation, int scale) {
+ double factor = nextGaussian() * 0.25; // 标准差0.25，99.7%概率在±0.75内（更集中）
+ factor = Math.max(-1.0, Math.min(1.0, factor)); // 截断极端值
+ BigDecimal fluctuationValue = average.multiply(new BigDecimal(factor * fluctuation))
+ .setScale(scale, RoundingMode.HALF_UP);
+ return average.add(fluctuationValue);
+ }
+
+ /**
+ * 生成指定方向的波动值（如[0, +0.1]表示只涨不跌）
+ */
+ private BigDecimal generateDirectionalValue(BigDecimal average, double minFactor, double maxFactor, int scale) {
+ double factor = minFactor + Math.random() * (maxFactor - minFactor);
+ BigDecimal fluctuationValue = average.multiply(new BigDecimal(factor))
+ .setScale(scale, RoundingMode.HALF_UP);
+ return average.add(fluctuationValue);
+ }
+
+ /**
+ * K线场景专属缓存清理（含波动方向列表）
+ */
+ private void cleanUpKLineCache(String symbol) {
+ AdjustmentValueCache.getDelayValue().remove(symbol);
+ AdjustmentValueCache.getFrequency().remove(symbol);
+ AdjustmentValueCache.getPreAllocationList().remove(symbol);
+ AdjustmentValueCache.getCurrentAllocationIndex().remove(symbol);
+ AdjustmentValueCache.getUpDownTrend().remove(symbol); // 新增：清理波动方向缓存
+ }
+
+ /**
+ * 获取K线周期（根据symbol或配置判断，示例返回1=1min，5=5min等）
+ */
+ private int getKLineCycle(String symbol) {
+ // 实际场景可从配置或symbol后缀获取（如BTC-USDT-1MIN → 1）
+ return 1;
+ }
+
+ /**
+ * 正态分布随机数生成（均值0，标准差1）
+ */
+ private static double nextGaussian() {
+ double u1 = Math.random();
+ double u2 = Math.random();
+ return Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
+ }
}
--
Gitblit v1.9.3