1

zyy3

2025-10-13 d4352284dc9049fa0d954b562ebb4632b34f4aee

 trading-order-huobi/src/main/java/com.yami.trading.huobi/data/job/AbstractGetDataJob.java

@@ -17,6 +17,7 @@

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;

@@ -55,179 +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) {
                    //延时几次 缓存frequency
                    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);
                    if (frequency == null) { //首次计算 缓存
                    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);
                        AdjustmentValueCache.getFrequency().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));
                        }

                        delayValue.setValue(delayValue.getValue().subtract(currentValue_frequency));
                        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);
                        }*/
                        //计算延时加大精度
                        Integer delayDecimal = 10;
                        // 保存原始总值用于计算随机分配
                        BigDecimal totalValue = delayValue.getValue();
                        // 计算已分配次数(从缓存中获取)
                        Integer allocatedCount = AdjustmentValueCache.getAllocatedCount().get(symbol);
                        if (allocatedCount == null) {
                            allocatedCount = 0;
                            // 首次分配时保存总值到缓存，用于后续计算
                            AdjustmentValueCache.getTotalValue().put(symbol, totalValue);
                        } else {
                            //不是首次
                            totalValue = AdjustmentValueCache.getTotalValue().get(symbol);
                        }

                        // ########## 新增：判断调整方向（正向/负向）##########
                        boolean isPositiveAdjustment = totalValue.compareTo(BigDecimal.ZERO) > 0; // 正向调整（>0）
                        boolean isNegativeAdjustment = totalValue.compareTo(BigDecimal.ZERO) < 0; // 负向调整（<0）

                        BigDecimal currentValue_frequency;
                        // 计算剩余分配次数
                        int remainingAllocations = frequency - allocatedCount;

                        if (remainingAllocations > 1) {
                            BigDecimal average = totalValue.divide(new BigDecimal(frequency), delayDecimal, RoundingMode.HALF_UP);
                            BigDecimal randomFactor;

                            // 根据调整方向动态调整负因子概率
                            double negativeProbability = isNegativeAdjustment ? 0.6 : 0.3;
                            if (Math.random() <= negativeProbability) {
                                // 负因子：范围 [-0.5, 0)
                                double randomNeg = -0.5 + Math.random() * 0.5; // 简化计算：max - min = 0 - (-0.5) = 0.5
                                randomFactor = new BigDecimal(randomNeg).setScale(delayDecimal, RoundingMode.HALF_UP);
                            // 更新当前值：带符号累加
                            if (currentValue == null) {
                                AdjustmentValueCache.getCurrentValue().put(symbol, currentValueFrequency);
                            } else {
                                // 正因子：范围 [0.3, 1.7)
                                double randomPos = 0.3 + Math.random() * 1.4; // 简化计算：max - min = 1.7 - 0.3 = 1.4
                                randomFactor = new BigDecimal(randomPos).setScale(delayDecimal, RoundingMode.HALF_UP);
                                AdjustmentValueCache.getCurrentValue().put(symbol, currentValue.add(currentValueFrequency).setScale(decimal, RoundingMode.HALF_UP));
                            }

                            currentValue_frequency = average.multiply(randomFactor).setScale(delayDecimal, RoundingMode.HALF_UP);
                            // 更新延迟值：带符号减法
                            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);

                            // 核心修改1：根据调整方向动态约束累计值
                            BigDecimal currentAccumulated = AdjustmentValueCache.getAccumulatedValue().getOrDefault(symbol, BigDecimal.ZERO);
                            BigDecimal tempAccumulated = currentAccumulated.add(currentValue_frequency);
                            if (isPositiveAdjustment) {
                                // 正向调整：累计值不能为负
                                if (tempAccumulated.compareTo(BigDecimal.ZERO) < 0) {
                                    currentValue_frequency = BigDecimal.ONE.divide(new BigDecimal("10").pow(delayDecimal), delayDecimal, RoundingMode.HALF_UP);
                                }
                            } else if (isNegativeAdjustment) {
                                // 负向调整：累计值不能小于目标值（避免过度减值）
                                if (tempAccumulated.compareTo(totalValue) < 0) {
                                    currentValue_frequency = totalValue.subtract(currentAccumulated).divide(new BigDecimal(2), delayDecimal, RoundingMode.HALF_UP);
                                }
                            int nextIndex = currentIndex + 1;
                            AdjustmentValueCache.getCurrentAllocationIndex().put(symbol, nextIndex);

                            if (nextIndex >= frequency) {
                                cleanUpKLineCache(symbol);
                            }

                            //剩余的待分配值
                            BigDecimal remainingValue = totalValue.subtract(currentAccumulated);
                            //本次分配后剩余的待分配值
                            BigDecimal tempDelayValue = remainingValue.subtract(currentValue_frequency);

                            // 提取公共变量（剩余值的80%）
                            BigDecimal remaining80Percent = remainingValue.multiply(new BigDecimal("0.8"))
                                    .setScale(delayDecimal, RoundingMode.HALF_UP);

                            // 统一判断“是否需要修正剩余值”
                            boolean needFixRemaining = (isPositiveAdjustment && tempDelayValue.compareTo(BigDecimal.ZERO) < 0)
                                    || (isNegativeAdjustment && tempDelayValue.compareTo(totalValue) > 0);
                            if (needFixRemaining) {
                                // 直接使用公共变量，避免重复计算
                                currentValue_frequency = remaining80Percent;
                            if (!item.getAdjustmentValue().equals(AdjustmentValueCache.getCurrentValue().get(symbol))) {
                                item.setAdjustmentValue(AdjustmentValueCache.getCurrentValue().get(symbol));
                                itemService.saveOrUpdate(item);
                            }

                            // 直接使用公共变量作为maxAllowed，无需重复计算
                            if ((isPositiveAdjustment && currentValue_frequency.compareTo(remaining80Percent) > 0)
                                    || (isNegativeAdjustment && currentValue_frequency.compareTo(remaining80Percent) < 0)) {
                                currentValue_frequency = remaining80Percent;
                            }

                        } else {
                            // 最后一次分配兜底（支持负值）
                            BigDecimal accumulated = AdjustmentValueCache.getAccumulatedValue().getOrDefault(symbol, BigDecimal.ZERO);
                            currentValue_frequency = totalValue.subtract(accumulated).setScale(delayDecimal, RoundingMode.HALF_UP);

                            // 正向调整：最后一次分配值不能为负；负向调整：不能为正（无重复，无需优化）
                            if (isPositiveAdjustment && currentValue_frequency.compareTo(BigDecimal.ZERO) < 0) {
                                currentValue_frequency = BigDecimal.ZERO.setScale(delayDecimal, RoundingMode.HALF_UP);
                            } else if (isNegativeAdjustment && currentValue_frequency.compareTo(BigDecimal.ZERO) > 0) {
                                currentValue_frequency = BigDecimal.ZERO.setScale(delayDecimal, RoundingMode.HALF_UP);
                            }
                        }


                        // 更新累计值
                        BigDecimal newAccumulated = AdjustmentValueCache.getAccumulatedValue().getOrDefault(symbol, BigDecimal.ZERO)
                                .add(currentValue_frequency);
                        AdjustmentValueCache.getAccumulatedValue().put(symbol, newAccumulated);
                        // 更新分配次数
                        AdjustmentValueCache.getAllocatedCount().put(symbol, allocatedCount + 1);

                        // 更新当前值
                        if (currentValue == null) {
                            AdjustmentValueCache.getCurrentValue().put(symbol, currentValue_frequency);
                        } else {
                            AdjustmentValueCache.getCurrentValue().put(symbol,
                                    currentValue.add(currentValue_frequency));
                        }

                        // 更新延迟值
                        delayValue.setValue(delayValue.getValue().subtract(currentValue_frequency));
                        delayValue.setSecond(Arith.sub(delayValue.getSecond(), Arith.div(this.interval, 1000.0D)));
                        AdjustmentValueCache.getDelayValue().put(symbol, delayValue);

                        // 如果是最后一次分配，清理缓存
                        if (remainingAllocations <= 1) {
                            AdjustmentValueCache.getAllocatedCount().remove(symbol);
                            AdjustmentValueCache.getTotalValue().remove(symbol);
                            AdjustmentValueCache.getAccumulatedValue().remove(symbol);
                            AdjustmentValueCache.getFrequency().remove(symbol);

                            AdjustmentValueCache.getDelayValue().remove(symbol);
                        }

                        // 保存更新
                        if (!item.getAdjustmentValue().equals(AdjustmentValueCache.getCurrentValue().get(symbol))) {
                            item.setAdjustmentValue(AdjustmentValueCache.getCurrentValue().get(symbol));
                            itemService.saveOrUpdate(item);
                        }
                    }
                }
@@ -290,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);
    }
}