src/main/java/com/xcong/excoin/modules/okxNewPrice/OkxKlineWebSocketClient.java

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

import cn.hutool.core.collection.CollUtil;
import cn.hutool.json.JSONException;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
@@ -25,10 +26,7 @@
import java.math.BigDecimal;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicReference;
@@ -340,7 +338,7 @@
                    List<Kline> kline15MinuteData = getKlineDataByInstIdAndBar(instId, "15m");
                    //stream流获取kline15MinuteData中的o数据的集合
                    List<BigDecimal> prices = kline15MinuteData.stream()
                            .map(Kline::getO)
                            .map(Kline::getC)
                            .collect(Collectors.toList());

                    // 生成对应的高、低、收盘价数据
@@ -380,7 +378,7 @@
                    boolean hasUpcomingEvent = false; // 无即将到来的重大事件
                    // 确定市场方向
                    TradingStrategy.Direction direction = tradingStrategy.getDirection(prices, high, low, close, currentPrice);
                    System.out.println("市场方向（15分钟）: " + direction);
                    log.info("市场方向（15分钟）: {}", direction);
//                    if (direction == TradingStrategy.Direction.RANGING){
//                        return;
//                    }
@@ -413,7 +411,7 @@

                            }
                            //先判断账户是否有持空仓
                            String positionShortAccountName = PositionsWs.initAccountName(accountName, CoinEnums.POSSIDE_LONG.getCode());
                            String positionShortAccountName = PositionsWs.initAccountName(accountName, CoinEnums.POSSIDE_SHORT.getCode());
                            BigDecimal imrShort = PositionsWs.getAccountMap(positionShortAccountName).get("imr");
                            if (imrShort != null && imrShort.compareTo(BigDecimal.ZERO) > 0){
                                log.info("账户{}有持空仓", accountName);
@@ -495,33 +493,51 @@
    }

    private List<Kline> getKlineDataByInstIdAndBar(String instId, String bar) {


        LinkedHashMap<String, Object> requestParam = new LinkedHashMap<>();
        requestParam.put("instId",instId);
        requestParam.put("bar",bar);
        requestParam.put("limit","100");
        String result = ExchangeLoginService.getInstance(ExchangeInfoEnum.OKX_UAT.name()).lineHistory(requestParam);
        log.info("加载OKX-KLINE，{}", result);
        JSONObject json = JSON.parseObject(result);
        String data = json.getString("data");
        List<String[]> klinesList = JSON.parseArray(data, String[].class);
        if(CollUtil.isEmpty(klinesList)){
            return  null;
        List<Kline> klineList = new ArrayList<>();
        try {
            LinkedHashMap<String, Object> requestParam = new LinkedHashMap<>();
            requestParam.put("instId", instId);
            requestParam.put("bar", bar);
            requestParam.put("limit", "100");
            String result = ExchangeLoginService.getInstance(ExchangeInfoEnum.OKX_UAT.name()).lineHistory(requestParam);
            log.info("加载OKX-KLINE，{}", result);
            
            JSONObject json = JSON.parseObject(result);
            String data = json.getString("data");
            
            if (data != null) {
                List<String[]> klinesList = JSON.parseArray(data, String[].class);
                if (!CollUtil.isEmpty(klinesList)) {
                    for (String[] s : klinesList) {
                        // 确保数组有足够的元素
                        if (s != null && s.length >= 9) {
                            try {
                                Kline kline = new Kline();
                                kline.setTs(s[0]);
                                kline.setO(new BigDecimal(s[1]));
                                kline.setH(new BigDecimal(s[2]));
                                kline.setL(new BigDecimal(s[3]));
                                kline.setC(new BigDecimal(s[4]));
                                kline.setVol(new BigDecimal(s[5]));
                                kline.setConfirm(s[8]);
                                klineList.add(kline);
                            } catch (NumberFormatException e) {
                                log.error("K线数据转换为BigDecimal失败: {}", Arrays.toString(s), e);
                            }
                        } else {
                            log.warn("K线数据数组长度不足: {}", Arrays.toString(s));
                        }
                    }
                }
            } else {
                log.warn("K线数据为空");
            }
        } catch (JSONException e) {
            log.error("K线数据解析失败", e);
        } catch (Exception e) {
            log.error("获取K线数据异常", e);
        }
        ArrayList<Kline> objects = new ArrayList<>();
        for(String[] s : klinesList) {
            Kline kline = new Kline();
            kline.setTs(s[0]);
            kline.setO(new BigDecimal(s[1]));
            kline.setH(new BigDecimal(s[2]));
            kline.setL(new BigDecimal(s[3]));
            kline.setC(new BigDecimal(s[4]));
            kline.setVol(new BigDecimal(s[5]));
            kline.setConfirm(s[8]);
            objects.add(kline);
        }
        return objects;
        return klineList;
    }

    /**

 src/main/java/com/xcong/excoin/modules/okxNewPrice/indicator/TradingStrategy.java

@@ -7,6 +7,7 @@
import lombok.extern.slf4j.Slf4j;

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

@@ -110,7 +111,7 @@
        calculateIndicators(prices, high, low, close);

        // 检查是否为震荡市场，如果是，则执行区间交易策略
        if (isRangeMarket()) {
        if (isRangeMarket(prices)) {
            log.info("当前市场为震荡行情，执行区间交易策略");
            return generateRangeTradingSignal(currentPrice, volume, hasLongPosition, hasShortPosition);
        }
@@ -128,7 +129,7 @@
        }

        // 开空信号
        if (shouldOpenShort(currentPrice, volume, fiveMinPrices, oneHourPrices, fourHourPrices) && !hasLongPosition && !hasShortPosition) {
        if (shouldOpenShort(currentPrice, prices, volume, fiveMinPrices, oneHourPrices, fourHourPrices) && !hasLongPosition && !hasShortPosition) {
            log.info("生成卖出信号");
            return SignalType.SELL;
        }
@@ -231,10 +232,28 @@

        // 创建临时MA指标用于判断趋势
        MA tempMA = new MA();
        MACD tempMACD = new MACD();
        
        // 计算指标
        tempMA.calculate(prices);
        tempMACD.calculate(prices);

        // 简单的趋势判断：短期MA > 长期MA
        return tempMA.getEma5().compareTo(tempMA.getEma20()) > 0;
        // 优化后的多头趋势判断：
        // 1. MA多头排列：短期MA > 中期MA > 长期MA
        // 2. 所有均线向上发散
        // 3. MACD趋势：DIFF线在DEA线之上
        boolean isMaBullish = tempMA.getEma5().compareTo(tempMA.getEma10()) > 0 && 
                             tempMA.getEma10().compareTo(tempMA.getEma20()) > 0;
        
        // 判断均线向上发散（简单方法：近期均线斜率为正）
        boolean isMaDivergingUp = calculateMaSlope(prices, 5) > 0 && 
                                 calculateMaSlope(prices, 10) > 0 && 
                                 calculateMaSlope(prices, 20) > 0;
                                 
        // MACD趋势判断
        boolean isMacdBullish = tempMACD.getDif().compareTo(tempMACD.getDea()) > 0;

        return isMaBullish && isMaDivergingUp && isMacdBullish;
    }

    /**
@@ -249,12 +268,56 @@

        // 创建临时MA指标用于判断趋势
        MA tempMA = new MA();
        MACD tempMACD = new MACD();
        
        // 计算指标
        tempMA.calculate(prices);
        tempMACD.calculate(prices);

        // 简单的趋势判断：短期MA < 长期MA
        return tempMA.getEma5().compareTo(tempMA.getEma20()) < 0;
        // 优化后的空头趋势判断：
        // 1. MA空头排列：短期MA < 中期MA < 长期MA
        // 2. 所有均线向下发散
        // 3. MACD趋势：DIFF线在DEA线之下
        boolean isMaBearish = tempMA.getEma5().compareTo(tempMA.getEma10()) < 0 && 
                             tempMA.getEma10().compareTo(tempMA.getEma20()) < 0;
        
        // 判断均线向下发散（简单方法：近期均线斜率为负）
        boolean isMaDivergingDown = calculateMaSlope(prices, 5) < 0 && 
                                   calculateMaSlope(prices, 10) < 0 && 
                                   calculateMaSlope(prices, 20) < 0;
                                   
        // MACD趋势判断
        boolean isMacdBearish = tempMACD.getDif().compareTo(tempMACD.getDea()) < 0;

        return isMaBearish && isMaDivergingDown && isMacdBearish;
    }

    /**
     * 计算均线斜率
     * @param prices 价格数据
     * @param period 均线周期
     * @return 均线斜率（正数表示向上，负数表示向下）
     */
    private double calculateMaSlope(List<BigDecimal> prices, int period) {
        if (prices == null || prices.size() < period * 2) {
            return 0; // 数据不足
        }
        
        // 获取最近两个周期的均线值
        int endIndex = prices.size() - 1;
        int startIndex = endIndex - period + 1;
        
        // 计算当前周期的均线
        BigDecimal currentMa = calculateMA(prices.subList(startIndex, endIndex + 1), period);
        
        // 计算前一个周期的均线
        int prevStartIndex = startIndex - period;
        BigDecimal prevMa = calculateMA(prices.subList(prevStartIndex, startIndex), period);
        
        // 计算斜率（简单差值法）
        return currentMa.subtract(prevMa).doubleValue();
    }
    
    /**
     * 成交量验证辅助方法
     * 增强版：当前成交量需大于20周期均量的1.2倍，以过滤无量反弹/回调的假信号
@@ -345,16 +408,80 @@

    /**
     * 检查是否为震荡市场
     * @param prices 价格数据列表
     * @return 是否为震荡市场
     */
    private boolean isRangeMarket() {
        // 高级MA线收敛 + RSI(40-60) + 布林带收窄
        boolean isMaConverged = advancedMA.calculatePercent().compareTo(new BigDecimal(2)) < 0;
        boolean isRsiNeutral = rsi.getRsi().compareTo(new BigDecimal(40)) > 0 &&
                              rsi.getRsi().compareTo(new BigDecimal(60)) < 0;
        boolean isBollNarrow = boll.calculateBandWidth().compareTo(new BigDecimal(0.05)) < 0;

        return isMaConverged && isRsiNeutral && isBollNarrow;
    private boolean isRangeMarket(List<BigDecimal> prices) {
        // 优化的震荡市场判断条件，放宽标准以减少RANGING信号频率
        
        // 1. 高级MA三线收敛（小于3%，放宽条件）
        boolean isMaConverged = advancedMA.calculatePercent().compareTo(new BigDecimal(3)) < 0;
        
        // 2. RSI中性区间（35-65，放宽条件）
        boolean isRsiNeutral = rsi.getRsi().compareTo(new BigDecimal(35)) > 0 &&
                              rsi.getRsi().compareTo(new BigDecimal(65)) < 0;
        
        // 3. BOLL带宽收窄（小于0.06，放宽条件）
        boolean isBollNarrow = boll.calculateBandWidth().compareTo(new BigDecimal(0.06)) < 0;
        
        // 4. MACD柱状图趋近于0（多空力量平衡，放宽条件）
        boolean isMacdBalanced = macd.getMacdBar().abs().compareTo(new BigDecimal(0.02)) < 0;
        
        // 5. KDJ在中间区域波动（25-75，放宽条件）
        boolean isKdjNeutral = kdj.getK().compareTo(new BigDecimal(25)) > 0 && 
                             kdj.getK().compareTo(new BigDecimal(75)) < 0 &&
                             kdj.getD().compareTo(new BigDecimal(25)) > 0 && 
                             kdj.getD().compareTo(new BigDecimal(75)) < 0 &&
                             kdj.getJ().compareTo(new BigDecimal(20)) > 0 && 
                             kdj.getJ().compareTo(new BigDecimal(80)) < 0;
        
        // 6. 价格波动范围较小（最近20根K线最高价与最低价的比值小于1.06，放宽条件）
        boolean isPriceVolatilityLow = calculatePriceVolatility(prices).compareTo(new BigDecimal(1.06)) < 0;
        
        // 综合判断：只需要满足部分条件即可，增加趋势信号的机会
        int rangeConditionsMet = 0;
        if (isMaConverged) {
            rangeConditionsMet++;
        }
        if (isRsiNeutral) {
            rangeConditionsMet++;
        }
        if (isBollNarrow) {
            rangeConditionsMet++;
        }
        if (isMacdBalanced) {
            rangeConditionsMet++;
        }
        if (isKdjNeutral) {
            rangeConditionsMet++;
        }
        if (isPriceVolatilityLow) {
            rangeConditionsMet++;
        }
        
        // 只有满足4个或以上条件才判定为震荡市场
        return rangeConditionsMet >= 4;
    }
    
    /**
     * 计算价格波动率（最近20根K线最高价与最低价的比值）
     * @param prices 价格数据列表
     * @return 价格波动率
     */
    private BigDecimal calculatePriceVolatility(List<BigDecimal> prices) {
        if (prices == null || prices.isEmpty()) {
            return BigDecimal.ONE;
        }
        
        List<BigDecimal> recentPrices = prices.subList(Math.max(0, prices.size() - 20), prices.size());
        if (recentPrices.isEmpty()) {
            return BigDecimal.ONE;
        }
        
        BigDecimal highest = recentPrices.stream().max(BigDecimal::compareTo).orElse(BigDecimal.ONE);
        BigDecimal lowest = recentPrices.stream().min(BigDecimal::compareTo).orElse(BigDecimal.ONE);
        
        return highest.divide(lowest, 10, RoundingMode.HALF_UP);
    }


@@ -368,38 +495,48 @@
     * @param currentPrice 当前价格
     * @return 市场方向
     */
    public Direction getDirection(List<BigDecimal> prices, List<BigDecimal> high,
    public Direction getDirection(List<BigDecimal> prices, List<BigDecimal> high, 
                                List<BigDecimal> low, List<BigDecimal> close,
                                BigDecimal currentPrice) {
        // 计算所有指标
        calculateIndicators(prices, high, low, close);

        // 检查是否为震荡市场
        if (isRangeMarket()) {
        if (isRangeMarket(prices)) {
            return Direction.RANGING;
        }

        // 检查做多方向条件：MA多头排列 + MACD金叉 + RSI中性(30-70) + BOLL价格在上轨和中轨之间
        // 优化后的多头趋势条件：
        // 1. MA多头排列（短期MA > 中期MA > 长期MA）
        // 2. MACD趋势（DIFF在DEA之上，代表多头趋势）
        // 3. 价格在BOLL中轨上方
        // 4. RSI(50-65) 为健康多头区间
        boolean isMaBullish = ma.getEma5().compareTo(ma.getEma10()) > 0 &&
                              ma.getEma10().compareTo(ma.getEma20()) > 0;
        boolean isMacdGoldenCross = macd.getDif().compareTo(macd.getDea()) > 0;
        boolean isRsiNeutral = rsi.getRsi().compareTo(new BigDecimal(30)) > 0 &&
                              rsi.getRsi().compareTo(new BigDecimal(70)) < 0;
        boolean isPriceInUpperMid = currentPrice.compareTo(boll.getMid()) > 0 &&
                                   currentPrice.compareTo(boll.getUpper()) < 0;

        if (isMaBullish && isMacdGoldenCross && isRsiNeutral && isPriceInUpperMid) {
        boolean isMacdBullish = macd.getDif().compareTo(macd.getDea()) > 0;
        boolean isPriceAboveBollMid = currentPrice.compareTo(boll.getMid()) > 0;
        boolean isRsiBullish = rsi.getRsi().compareTo(new BigDecimal(50)) > 0 &&
                              rsi.getRsi().compareTo(new BigDecimal(65)) < 0;
        
        // 检查多头信号（MA多头 + MACD金叉 + 价格在BOLL中轨上方 + RSI(50-65)）
        if (isMaBullish && isMacdBullish && isPriceAboveBollMid && isRsiBullish) {
            return Direction.LONG;
        }

        // 检查做空方向条件：MA空头排列 + MACD死叉 + RSI中性(30-70) + BOLL价格在下轨和中轨之间
        // 优化后的空头趋势条件：
        // 1. MA空头排列（短期MA < 中期MA < 长期MA）
        // 2. MACD趋势（DIFF在DEA之下，代表空头趋势）
        // 3. 价格在BOLL中轨下方
        // 4. RSI(35-50) 为健康空头区间
        boolean isMaBearish = ma.getEma5().compareTo(ma.getEma10()) < 0 &&
                              ma.getEma10().compareTo(ma.getEma20()) < 0;
        boolean isMacdDeathCross = macd.getDif().compareTo(macd.getDea()) < 0;
        boolean isPriceInLowerMid = currentPrice.compareTo(boll.getLower()) > 0 &&
                                   currentPrice.compareTo(boll.getMid()) < 0;

        if (isMaBearish && isMacdDeathCross && isRsiNeutral && isPriceInLowerMid) {
        boolean isMacdBearish = macd.getDif().compareTo(macd.getDea()) < 0;
        boolean isPriceBelowBollMid = currentPrice.compareTo(boll.getMid()) < 0;
        boolean isRsiBearish = rsi.getRsi().compareTo(new BigDecimal(35)) > 0 &&
                              rsi.getRsi().compareTo(new BigDecimal(50)) < 0;
        
        // 检查空头信号（MA空头 + MACD死叉 + 价格在BOLL中轨下方 + RSI(35-50)）
        if (isMaBearish && isMacdBearish && isPriceBelowBollMid && isRsiBearish) {
            return Direction.SHORT;
        }

@@ -408,8 +545,10 @@
    }

    /**
     * 根据用户要求检查是否应该开多仓位
     * 条件：MA金叉 + MACD金叉 + KDJ金叉 + RSI中性 + 价格高于BOLL中轨 + 多周期确认 + 成交量验证
     * 根据优化建议检查是否应该开多仓位
     * 使用主次结合法：
     * - 主信号（趋势）：MA多头排列 + MACD金叉
     * - 辅信号（入场点）：价格回调至BOLL中轨附近获得支撑，且出现KDJ金叉或RSI从低位回升至50以上
     * @param currentPrice 当前价格
     * @param prices 价格数据
     * @param volume 成交量列表
@@ -422,17 +561,40 @@
                                  List<BigDecimal> fiveMinPrices,
                                  List<BigDecimal> oneHourPrices,
                                  List<BigDecimal> fourHourPrices) {
        // MA金叉 (5EMA > 20EMA)
        boolean isMaGoldenCross = ma.getEma5().compareTo(ma.getEma20()) > 0;
        // MACD金叉 (DIF > DEA)
        boolean isMacdGoldenCross = macd.getDif().compareTo(macd.getDea()) > 0;
        // KDJ金叉 (K线上穿D线)
        boolean isKdjGoldenCross = kdj.isGoldenCross();
        // RSI中性 (30-70)
        boolean isRsiNeutral = rsi.getRsi().compareTo(new BigDecimal(30)) > 0 &&
        // 主信号：趋势判断
        // MA多头排列（短期MA > 中期MA > 长期MA）
        boolean isMaBullish = ma.getEma5().compareTo(ma.getEma10()) > 0 && 
                             ma.getEma10().compareTo(ma.getEma20()) > 0;
        // MACD趋势（DIFF在DEA之上）
        boolean isMacdBullish = macd.getDif().compareTo(macd.getDea()) > 0;
        
        // 如果主信号不满足，直接返回false
        if (!(isMaBullish && isMacdBullish)) {
            return false;
        }
        
        // 辅信号：入场点判断
        // 价格在BOLL中轨上方，且未触及上轨（避免追高）
        boolean isPriceInSafeZone = currentPrice.compareTo(boll.getMid()) > 0 && 
                                   currentPrice.compareTo(boll.getUpper()) < 0;
        // 价格靠近BOLL中轨
        boolean isPriceNearBollMid = currentPrice.compareTo(boll.getMid().multiply(new BigDecimal(0.98))) > 0 &&
                                    currentPrice.compareTo(boll.getMid().multiply(new BigDecimal(1.02))) < 0;
        
        // RSI：健康区间30-70，刚从50中线向上
        boolean isRsiHealthy = rsi.getRsi().compareTo(new BigDecimal(30)) > 0 && 
                              rsi.getRsi().compareTo(new BigDecimal(70)) < 0;
        // 价格高于BOLL中轨
        boolean isPriceAboveBollMid = currentPrice.compareTo(boll.getMid()) > 0;
        boolean isRsiAboveMid = rsi.getRsi().compareTo(new BigDecimal(50)) > 0;
        
        // KDJ：金叉或超卖区域
        boolean isKdjGoldenCross = kdj.isGoldenCross();
        boolean isKdjOversold = kdj.getJ().compareTo(new BigDecimal(15)) < 0;
        
        // 入场点条件：价格在安全区域或靠近中轨，且动量健康
        boolean isEntryPointValid = (isPriceInSafeZone || isPriceNearBollMid) && 
                                   (isRsiHealthy && isRsiAboveMid) && 
                                   (isKdjGoldenCross || isKdjOversold);
        
        // 成交量验证
        boolean isVolumeConfirmed = volumeConfirm(volume);
        // 量价背离检测
@@ -440,48 +602,76 @@
        // 多周期确认
        boolean isMultiTimeframeConfirmed = multiTimeframeConfirm(fiveMinPrices, oneHourPrices, fourHourPrices);

        return isMaGoldenCross && isMacdGoldenCross && isKdjGoldenCross &&
               isRsiNeutral && isPriceAboveBollMid && isVolumeConfirmed && 
               !isPriceVolumeDivergence && isMultiTimeframeConfirmed;
        return isEntryPointValid && isVolumeConfirmed && !isPriceVolumeDivergence && isMultiTimeframeConfirmed;
    }

    /**
     * 根据用户要求检查是否应该开空仓位
     * 条件：MA死叉 + MACD死叉 + KDJ死叉 + RSI中性 + 价格低于BOLL中轨 + 多周期确认 + 成交量验证
     * 根据优化建议检查是否应该开空仓位
     * 使用主次结合法：
     * - 主信号（趋势）：MA空头排列 + MACD死叉
     * - 辅信号（入场点）：价格反弹至BOLL中轨附近遇阻，且出现KDJ死叉或RSI从高位回落至50以下
     * @param currentPrice 当前价格
     * @param prices 价格数据
     * @param volume 成交量列表
     * @param fiveMinPrices 5分钟价格数据
     * @param oneHourPrices 1小时价格数据
     * @param fourHourPrices 4小时价格数据
     * @return 是否应该开空
     */
    private boolean shouldOpenShort(BigDecimal currentPrice, List<BigDecimal> volume,
    private boolean shouldOpenShort(BigDecimal currentPrice, List<BigDecimal> prices, List<BigDecimal> volume,
                                   List<BigDecimal> fiveMinPrices,
                                   List<BigDecimal> oneHourPrices,
                                   List<BigDecimal> fourHourPrices) {
        // MA死叉 (5EMA < 20EMA)
        boolean isMaDeathCross = ma.getEma5().compareTo(ma.getEma20()) < 0;
        // MACD死叉 (DIF < DEA)
        boolean isMacdDeathCross = macd.getDif().compareTo(macd.getDea()) < 0;
        // KDJ死叉 (K线下穿D线)
        boolean isKdjDeathCross = kdj.isDeathCross();
        // RSI中性 (30-70)
        boolean isRsiNeutral = rsi.getRsi().compareTo(new BigDecimal(30)) > 0 &&
        // 主信号：趋势判断
        // MA空头排列（短期MA < 中期MA < 长期MA）
        boolean isMaBearish = ma.getEma5().compareTo(ma.getEma10()) < 0 && 
                             ma.getEma10().compareTo(ma.getEma20()) < 0;
        // MACD趋势（DIFF在DEA之下）
        boolean isMacdBearish = macd.getDif().compareTo(macd.getDea()) < 0;
        
        // 如果主信号不满足，直接返回false
        if (!(isMaBearish && isMacdBearish)) {
            return false;
        }
        
        // 辅信号：入场点判断
        // 价格在BOLL中轨下方，且未触及下轨（避免追空）
        boolean isPriceInSafeZone = currentPrice.compareTo(boll.getMid()) < 0 && 
                                   currentPrice.compareTo(boll.getLower()) > 0;
        // 价格靠近BOLL中轨
        boolean isPriceNearBollMid = currentPrice.compareTo(boll.getMid().multiply(new BigDecimal(0.98))) > 0 &&
                                    currentPrice.compareTo(boll.getMid().multiply(new BigDecimal(1.02))) < 0;
        
        // RSI：健康区间30-70，刚从50中线向下
        boolean isRsiHealthy = rsi.getRsi().compareTo(new BigDecimal(30)) > 0 && 
                              rsi.getRsi().compareTo(new BigDecimal(70)) < 0;
        // 价格低于BOLL中轨
        boolean isPriceBelowBollMid = currentPrice.compareTo(boll.getMid()) < 0;
        boolean isRsiBelowMid = rsi.getRsi().compareTo(new BigDecimal(50)) < 0;
        
        // KDJ：死叉或超买区域
        boolean isKdjDeathCross = kdj.isDeathCross();
        boolean isKdjOverbought = kdj.getJ().compareTo(new BigDecimal(85)) > 0;
        
        // 入场点条件：价格在安全区域或靠近中轨，且动量健康
        boolean isEntryPointValid = (isPriceInSafeZone || isPriceNearBollMid) && 
                                   (isRsiHealthy && isRsiBelowMid) && 
                                   (isKdjDeathCross || isKdjOverbought);
        
        // 成交量验证
        boolean isVolumeConfirmed = volumeConfirm(volume);
        // 量价背离检测
        boolean isPriceVolumeDivergence = hasPriceVolumeDivergence(prices, volume);
        // 多周期确认（看跌）
        boolean isMultiTimeframeConfirmed = multiTimeframeBearishConfirm(fiveMinPrices, oneHourPrices, fourHourPrices);

        return isMaDeathCross && isMacdDeathCross && isKdjDeathCross &&
               isRsiNeutral && isPriceBelowBollMid && isVolumeConfirmed && isMultiTimeframeConfirmed;
        return isEntryPointValid && isVolumeConfirmed && !isPriceVolumeDivergence && isMultiTimeframeConfirmed;
    }

    /**
     * 根据用户要求检查是否应该平多仓位
     * 条件：MA死叉 + MACD死叉 + RSI超买 + 价格低于BOLL中轨 + 多周期确认
     * 根据优化建议检查是否应该平多仓位
     * 采用分层止盈止损策略：
     * - 保护止损：价格跌破BOLL中轨
     * - 跟踪止损：价格有效跌破移动平均线
     * - 最终平仓：趋势反转信号（MA空头排列 + MACD死叉）
     * @param currentPrice 当前价格
     * @param volume 成交量列表
     * @param fiveMinPrices 5分钟价格数据
@@ -493,23 +683,31 @@
                                   List<BigDecimal> fiveMinPrices,
                                   List<BigDecimal> oneHourPrices,
                                   List<BigDecimal> fourHourPrices) {
        // MA死叉 (5EMA < 20EMA)
        boolean isMaDeathCross = ma.getEma5().compareTo(ma.getEma20()) < 0;
        // MACD死叉 (DIF < DEA)
        boolean isMacdDeathCross = macd.getDif().compareTo(macd.getDea()) < 0;
        // RSI超买 (>70)
        boolean isRsiOverbought = rsi.isOverbought();
        // 价格低于BOLL中轨
        boolean isPriceBelowBollMid = currentPrice.compareTo(boll.getMid()) < 0;
        // 保护止损：价格跌破BOLL中轨（关键支撑位）
        boolean isStopLossTriggered = currentPrice.compareTo(boll.getMid()) < 0;
        
        // 跟踪止损：价格有效跌破短期均线（5EMA）
        boolean isTrailingStopTriggered = currentPrice.compareTo(ma.getEma5()) < 0;
        
        // 趋势反转信号：MA空头排列 + MACD死叉
        boolean isMaBearish = ma.getEma5().compareTo(ma.getEma10()) < 0 && 
                             ma.getEma10().compareTo(ma.getEma20()) < 0;
        boolean isMacdBearish = macd.getDif().compareTo(macd.getDea()) < 0;
        boolean isTrendReversed = isMaBearish && isMacdBearish;
        
        // 多周期确认（看跌）
        boolean isMultiTimeframeConfirmed = multiTimeframeBearishConfirm(fiveMinPrices, oneHourPrices, fourHourPrices);

        return isMaDeathCross && isMacdDeathCross && isRsiOverbought && isPriceBelowBollMid && isMultiTimeframeConfirmed;
        
        // 平多条件：保护止损触发 或 跟踪止损触发 或 （趋势反转且多周期确认）
        return isStopLossTriggered || isTrailingStopTriggered || (isTrendReversed && isMultiTimeframeConfirmed);
    }

    /**
     * 根据用户要求检查是否应该平空仓位
     * 条件：MA金叉 + MACD金叉 + RSI超卖 + 价格高于BOLL中轨 + 多周期确认
     * 根据优化建议检查是否应该平空仓位
     * 采用分层止盈止损策略：
     * - 保护止损：价格突破BOLL中轨
     * - 跟踪止损：价格有效突破移动平均线
     * - 最终平仓：趋势反转信号（MA多头排列 + MACD金叉）
     * @param currentPrice 当前价格
     * @param volume 成交量列表
     * @param fiveMinPrices 5分钟价格数据
@@ -521,18 +719,23 @@
                                    List<BigDecimal> fiveMinPrices,
                                    List<BigDecimal> oneHourPrices,
                                    List<BigDecimal> fourHourPrices) {
        // MA金叉 (5EMA > 20EMA)
        boolean isMaGoldenCross = ma.getEma5().compareTo(ma.getEma20()) > 0;
        // MACD金叉 (DIF > DEA)
        boolean isMacdGoldenCross = macd.getDif().compareTo(macd.getDea()) > 0;
        // RSI超卖 (<30)
        boolean isRsiOversold = rsi.isOversold();
        // 价格高于BOLL中轨
        boolean isPriceAboveBollMid = currentPrice.compareTo(boll.getMid()) > 0;
        // 保护止损：价格突破BOLL中轨（关键阻力位）
        boolean isStopLossTriggered = currentPrice.compareTo(boll.getMid()) > 0;
        
        // 跟踪止损：价格有效突破短期均线（5EMA）
        boolean isTrailingStopTriggered = currentPrice.compareTo(ma.getEma5()) > 0;
        
        // 趋势反转信号：MA多头排列 + MACD金叉
        boolean isMaBullish = ma.getEma5().compareTo(ma.getEma10()) > 0 && 
                             ma.getEma10().compareTo(ma.getEma20()) > 0;
        boolean isMacdBullish = macd.getDif().compareTo(macd.getDea()) > 0;
        boolean isTrendReversed = isMaBullish && isMacdBullish;
        
        // 多周期确认（看涨）
        boolean isMultiTimeframeConfirmed = multiTimeframeConfirm(fiveMinPrices, oneHourPrices, fourHourPrices);

        return isMaGoldenCross && isMacdGoldenCross && isRsiOversold && isPriceAboveBollMid && isMultiTimeframeConfirmed;
        
        // 平空条件：保护止损触发 或 跟踪止损触发 或 （趋势反转且多周期确认）
        return isStopLossTriggered || isTrailingStopTriggered || (isTrendReversed && isMultiTimeframeConfirmed);
    }

    /**
@@ -565,13 +768,25 @@
        // 2. 价格触及BOLL上轨且KDJ超买 → 卖出信号
        // 3. 价格回归BOLL中轨 → 平仓信号
        
        // 价格触及BOLL下轨
        boolean isPriceNearBollLower = currentPrice.compareTo(boll.getLower()) >= 0 && 
                                      currentPrice.compareTo(boll.getLower().multiply(new BigDecimal("1.005"))) <= 0;
        // 检查KDJ极端超买超卖情况
        boolean isKdjJExtremeOverbought = kdj.getJ().compareTo(new BigDecimal("100")) > 0;
        boolean isKdjJExtremeOversold = kdj.getJ().compareTo(new BigDecimal("10")) < 0;
        
        // 价格触及BOLL上轨
        // 价格触及BOLL下轨（基础条件）
        boolean isPriceNearBollLower = currentPrice.compareTo(boll.getLower()) >= 0 && 
                                      currentPrice.compareTo(boll.getLower().multiply(new BigDecimal("1.01"))) <= 0;
        
        // 价格触及BOLL上轨（基础条件）
        boolean isPriceNearBollUpper = currentPrice.compareTo(boll.getUpper()) <= 0 && 
                                      currentPrice.compareTo(boll.getUpper().multiply(new BigDecimal("0.995"))) >= 0;
                                      currentPrice.compareTo(boll.getUpper().multiply(new BigDecimal("0.99"))) >= 0;
        
        // 当KDJ-J极度超买/超卖时，放宽BOLL边界要求
        if (isKdjJExtremeOverbought) {
            isPriceNearBollUpper = currentPrice.compareTo(boll.getUpper().multiply(new BigDecimal("0.985"))) >= 0;
        }
        if (isKdjJExtremeOversold) {
            isPriceNearBollLower = currentPrice.compareTo(boll.getLower().multiply(new BigDecimal("1.015"))) <= 0;
        }
        
        // 价格回归BOLL中轨附近
        boolean isPriceNearBollMid = currentPrice.compareTo(boll.getMid().multiply(new BigDecimal("0.998"))) >= 0 && 
@@ -583,19 +798,25 @@
        // KDJ超买（使用调整后的阈值）
        boolean isKdjOverbought = kdj.getJ().compareTo(new BigDecimal(85)) > 0;
        
        // 成交量验证（当前成交量大于20周期均值的1.2倍）
        boolean isVolumeValid = volumeConfirm(volume) && 
                               volume.get(volume.size() - 1).compareTo(calculateMA(volume, config.getVolumeMaPeriod()).multiply(new BigDecimal("1.2"))) > 0;
        // RSI超卖（<30）
        boolean isRsiOversold = rsi.getRsi().compareTo(new BigDecimal(30)) < 0;
        
        // 开多逻辑：价格触及BOLL下轨且KDJ超卖且有成交量支持
        if (isPriceNearBollLower && isKdjOversold && isVolumeValid && !hasLongPosition && !hasShortPosition) {
            log.info("区间交易：价格触及BOLL下轨({}), KDJ-J值({})超卖，生成买入信号", boll.getLower(), kdj.getJ());
        // RSI超买（>70）
        boolean isRsiOverbought = rsi.getRsi().compareTo(new BigDecimal(70)) > 0;
        
        // 成交量验证（当前成交量大于20周期均值的1.1倍）
        boolean isVolumeValid = volumeConfirm(volume) && 
                               volume.get(volume.size() - 1).compareTo(calculateMA(volume, config.getVolumeMaPeriod()).multiply(new BigDecimal("1.1"))) > 0;
        
        // 开多逻辑：价格触及BOLL下轨且KDJ超卖且RSI超卖且有成交量支持
        if (isPriceNearBollLower && isKdjOversold && isRsiOversold && isVolumeValid && !hasLongPosition && !hasShortPosition) {
            log.info("区间交易：价格触及BOLL下轨({}), KDJ-J值({})超卖，RSI({})超卖，生成买入信号", boll.getLower(), kdj.getJ(), rsi.getRsi());
            return SignalType.BUY;
        }
        
        // 开空逻辑：价格触及BOLL上轨且KDJ超买且有成交量支持
        if (isPriceNearBollUpper && isKdjOverbought && isVolumeValid && !hasLongPosition && !hasShortPosition) {
            log.info("区间交易：价格触及BOLL上轨({}), KDJ-J值({})超买，生成卖出信号", boll.getUpper(), kdj.getJ());
        // 开空逻辑：价格触及BOLL上轨且KDJ超买且RSI超买且有成交量支持
        if (isPriceNearBollUpper && isKdjOverbought && isRsiOverbought && isVolumeValid && !hasLongPosition && !hasShortPosition) {
            log.info("区间交易：价格触及BOLL上轨({}), KDJ-J值({})超买，RSI({})超买，生成卖出信号", boll.getUpper(), kdj.getJ(), rsi.getRsi());
            return SignalType.SELL;
        }
        

 src/main/java/com/xcong/excoin/modules/okxNewPrice/indicator/macdAndMatrategy/MacdMaStrategy.java

New file
@@ -0,0 +1,378 @@
package com.xcong.excoin.modules.okxNewPrice.indicator.macdAndMatrategy;

import com.xcong.excoin.modules.okxNewPrice.indicator.*;
import java.math.BigDecimal;
import java.util.List;

/**
 * MACD+MA复合交易策略实现类
 * 
 * 【策略核心思想】
 * 结合移动平均线(MA)的趋势判断能力和MACD指标的动量分析能力，构建一个兼顾趋势跟踪和入场时机的复合交易策略。
 * 
 * 【策略主要特点】
 * 1. **趋势导向**：以长期MA(100日)作为ETH市场趋势的主要判断依据
 * 2. **精确入场**：利用MACD指标的动量变化和短期MA(30日)的支撑/阻力作用确定最佳入场点
 * 3. **风险控制**：通过RSI和波动率指标过滤掉风险较高的交易信号，并设置明确的止损止盈
 * 4. **分层离场**：结合技术指标、移动平均线和风险控制构建多重离场机制
 * 5. **动态调整**：MACD周期根据市场波动率自动调整，适应ETH高波动特性
 * 
 * 【核心交易逻辑】
 * 1. **趋势判断**：当前价格高于长期MA(100日)判定为牛市，低于则为熊市
 * 2. **入场条件**：
 *    - 牛市：MACD多头信号(DIF>DEA) 且 价格>短期MA(30日) 且 MACD柱状图>0 且 RSI在合理区间
 *    - 熊市：MACD空头信号(DIF<DEA) 且 价格<短期MA(30日) 且 MACD柱状图<0 且 RSI在合理区间
 * 3. **离场条件**：
 *    - 牛市多头持仓：MACD空头信号(DIF<DEA) 或 价格跌破短期MA 或 触及止损/止盈
 *    - 熊市空头持仓：MACD多头信号(DIF>DEA) 或 价格突破短期MA 或 触及止损/止盈
 * 4. **过滤条件**：
 *    - 高风险过滤：RSI>65时不追多，RSI<35时不追空
 *    - 低波动过滤：波动率<0.5%或>5%时不进行交易
 * 
 * 【适用场景】
 * 专为ETH合约设计，适用于ETH高波动、24/7交易的市场环境，适合中短线趋势交易。
 * 
 * 【风险提示】
 * 1. 策略需要至少200个价格数据点才能有效运行
 * 2. 在极端市场条件下(如黑天鹅事件)可能会产生较大亏损
 * 3. 建议结合其他风险控制手段(如止损设置)使用
 */
public class MacdMaStrategy {
    /**
     * 策略使用的技术指标实例（适配ETH合约特点）
     */
    // MACD指标：用于判断价格动量和趋势变化
    private final MACD macd = new MACD();
    // 30日移动平均线：ETH波动较大，使用更短的周期捕捉趋势变化
    private final MovingAverage ma30 = new MovingAverage(30);
    // 100日移动平均线：ETH作为高波动资产，长期趋势判断使用更短周期
    private final MovingAverage ma100 = new MovingAverage(100);
    // RSI指标(10周期)：ETH波动快，使用更短周期提高响应速度
    private final RSI rsi = new RSI(10);
    // 波动率指标(15周期)：ETH波动频繁，使用更短周期捕捉市场变化
    private final Volatility volatility = new Volatility(15);

    /**
     * 策略配置参数（适配ETH合约特点）
     */
    // 止损比例（ETH波动较大，设置2.5%）
    private final BigDecimal stopLossRatio = new BigDecimal("0.025");
    // 止盈比例（ETH趋势明显，设置6%）
    private final BigDecimal takeProfitRatio = new BigDecimal("0.06");
    // 账户初始余额（USD）
    private BigDecimal accountBalance = new BigDecimal("10000");
    // 每次交易风险比例（ETH合约风险较高，设置0.8%）
    private final BigDecimal riskPerTrade = new BigDecimal("0.008");
    // 杠杆倍数（ETH合约建议使用3-5倍，这里使用4倍）
    private final int leverage = 4;
    
    /**
     * 策略运行状态变量
     */
    // 当前持仓状态：空仓/多头/空头
    private PositionStatus position = PositionStatus.FLAT;
    // 最新价格：用于策略判断
    private BigDecimal lastPrice;
    // 当前市场趋势：牛市/熊市
    private TrendDirection trend;
    // 持仓均价：用于计算盈亏和止损止盈
    private BigDecimal entryPrice;
    // 止损价格：根据止损比例计算
    private BigDecimal stopLossPrice;
    // 止盈价格：根据止盈比例计算
    private BigDecimal takeProfitPrice;
    // 当前持仓数量（ETH）
    private BigDecimal positionSize = BigDecimal.ZERO;
    // 已用保证金（USD）
    private BigDecimal usedMargin = BigDecimal.ZERO;

    /**
     * 策略执行的主入口方法
     * 
     * @param prices 历史价格数据列表
     * @throws IllegalArgumentException 如果价格数据不足200个
     */
    public void execute(List<BigDecimal> prices) {
        // 验证输入数据完整性：策略需要至少200个价格数据点
        if (prices.size() < 200) {
            throw new IllegalArgumentException("至少需要200个价格数据点才能运行该策略");
        }

        // 第一步：更新所有技术指标
        updateIndicators(prices);

        // 第二步：确定当前市场趋势
        determineTrend(prices);

        // 第三步：检查是否需要跳过当前交易
        if (shouldSkipTrade()) {
            return;
        }

        // 第四步：根据持仓状态执行相应的交易逻辑
        if (position == PositionStatus.FLAT) {
            // 空仓状态下检查入场信号
            checkEntrySignal();
        } else {
            // 持仓状态下检查离场信号
            checkExitSignal();
        }
    }

    /**
     * 更新所有技术指标的计算结果
     * 
     * @param prices 历史价格数据列表
     */
    private void updateIndicators(List<BigDecimal> prices) {
        // 先计算波动率指标，因为MACD需要用它来动态调整周期
        volatility.calculate(prices);
        // 计算MACD指标并传入波动率参数，实现动态周期调整
        macd.calculate(prices, volatility.getValue());
        // 计算移动平均线指标
        ma30.calculate(prices);      // 计算30日移动平均线
        ma100.calculate(prices);     // 计算100日移动平均线
        // 计算RSI指标
        rsi.calculate(prices);
        // 更新最新价格
        lastPrice = prices.get(prices.size()-1);
    }

    /**
     * 确定当前市场趋势（牛市/熊市）
     * 
     * @param prices 历史价格数据列表
     */
    private void determineTrend(List<BigDecimal> prices) {
        BigDecimal currentMa100 = ma100.getMa(); // 获取当前100日移动平均线
        // 根据最新价格与100日MA的关系判断趋势：价格高于100日MA为牛市，否则为熊市
        trend = lastPrice.compareTo(currentMa100) > 0 ?
                TrendDirection.BULLISH : TrendDirection.BEARISH;
    }

    /**
     * 检查是否需要跳过当前交易
     * 
     * @return true表示需要跳过交易，false表示可以进行交易
     */
    private boolean shouldSkipTrade() {
        // 波动率过滤：当波动率小于1%时，市场活跃度不足，跳过交易
        if (volatility.getValue().compareTo(new BigDecimal("0.01")) < 0) {
            return true;
        }

        // RSI极端值过滤：
        // 1. 牛市中RSI>65表示超买，避免追高
        // 2. 熊市中RSI<35表示超卖，避免追空
        if (trend == TrendDirection.BULLISH && rsi.getRsi().compareTo(new BigDecimal(65)) > 0) {
            return true;
        }
        if (trend == TrendDirection.BEARISH && rsi.getRsi().compareTo(new BigDecimal(35)) < 0) {
            return true;
        }
        return false;
    }

    /**
     * 检查是否满足入场信号条件
     */
    private void checkEntrySignal() {
        BigDecimal currentMa30 = ma30.getMa(); // 获取当前30日移动平均线

        // 获取MACD的最新值用于判断动量方向
        BigDecimal currentDif = macd.getDif();
        BigDecimal currentDea = macd.getDea();
        BigDecimal macdBar = macd.getMacdBar(); // 获取MACD柱状图值
        
        // 获取RSI的最新值
        BigDecimal currentRsi = rsi.getRsi();
        // 获取波动率的最新值
        BigDecimal currentVolatility = volatility.getValue();

        // 根据市场趋势判断入场条件
        if (trend == TrendDirection.BULLISH) {
            // 牛市入场条件增强：
            // 1. MACD多头信号(DIF>DEA)
            // 2. MACD柱状图为正（确认多头力量）
            // 3. 价格在30日MA之上且有一定偏离（避免假突破）
            // 4. RSI处于合理区间(40-65)，避免在超买区域入场
            // 5. 波动率适中(>0.5%且<5%)，避免极端波动环境
            boolean macdBull = currentDif.compareTo(currentDea) > 0;
            boolean macdBarPositive = macdBar.compareTo(BigDecimal.ZERO) > 0;
            BigDecimal priceMaDiff = lastPrice.subtract(currentMa30);
            boolean priceAboveMAWithStrength = priceMaDiff.compareTo(currentMa30.multiply(new BigDecimal("0.005"))) > 0;
            boolean rsiInRange = currentRsi.compareTo(new BigDecimal(40)) > 0 && currentRsi.compareTo(new BigDecimal(65)) < 0;
            boolean volatilityModerate = currentVolatility.compareTo(new BigDecimal("0.005")) > 0 && 
                                         currentVolatility.compareTo(new BigDecimal("0.05")) < 0;
            
            if (macdBull && macdBarPositive && priceAboveMAWithStrength && rsiInRange && volatilityModerate) {
                enterLong();
            }
        } else {
            // 熊市入场条件增强：
            // 1. MACD空头信号(DIF<DEA)
            // 2. MACD柱状图为负（确认空头力量）
            // 3. 价格在30日MA之下且有一定偏离（避免假突破）
            // 4. RSI处于合理区间(35-60)，避免在超卖区域入场
            // 5. 波动率适中(>0.5%且<5%)，避免极端波动环境
            boolean macdBear = currentDif.compareTo(currentDea) < 0;
            boolean macdBarNegative = macdBar.compareTo(BigDecimal.ZERO) < 0;
            BigDecimal priceMaDiff = currentMa30.subtract(lastPrice);
            boolean priceBelowMAWithStrength = priceMaDiff.compareTo(currentMa30.multiply(new BigDecimal("0.005"))) > 0;
            boolean rsiInRange = currentRsi.compareTo(new BigDecimal(35)) > 0 && currentRsi.compareTo(new BigDecimal(60)) < 0;
            boolean volatilityModerate = currentVolatility.compareTo(new BigDecimal("0.005")) > 0 && 
                                         currentVolatility.compareTo(new BigDecimal("0.05")) < 0;
            
            if (macdBear && macdBarNegative && priceBelowMAWithStrength && rsiInRange && volatilityModerate) {
                enterShort();
            }
        }
    }

    /**
     * 检查是否满足离场信号条件
     */
    private void checkExitSignal() {
        BigDecimal currentMa30 = ma30.getMa(); // 获取当前30日移动平均线

        // 获取MACD的最新值用于判断动量变化
        BigDecimal currentDif = macd.getDif();
        BigDecimal currentDea = macd.getDea();

        if (position == PositionStatus.LONG) {
            // 多头持仓离场条件：
            // 1. MACD转为空头信号(DIF<DEA)
            // 2. 价格跌破30日MA
            // 3. 价格触及止损价格
            // 4. 价格触及止盈价格
            boolean macdExit = currentDif.compareTo(currentDea) < 0;
            boolean priceExit = lastPrice.compareTo(currentMa30) < 0;
            boolean stopLossExit = lastPrice.compareTo(stopLossPrice) <= 0;
            boolean takeProfitExit = lastPrice.compareTo(takeProfitPrice) >= 0;
            
            if (macdExit || priceExit || stopLossExit || takeProfitExit) {
                if (stopLossExit) {
                    System.out.println("触发止损 - ");
                } else if (takeProfitExit) {
                    System.out.println("触发止盈 - ");
                }
                exitPosition();
            }
        } else {
            // 空头持仓离场条件：
            // 1. MACD转为多头信号(DIF>DEA)
            // 2. 价格突破30日MA
            // 3. 价格触及止损价格
            // 4. 价格触及止盈价格
            boolean macdExit = currentDif.compareTo(currentDea) > 0;
            boolean priceExit = lastPrice.compareTo(currentMa30) > 0;
            boolean stopLossExit = lastPrice.compareTo(stopLossPrice) >= 0;
            boolean takeProfitExit = lastPrice.compareTo(takeProfitPrice) <= 0;
            
            if (macdExit || priceExit || stopLossExit || takeProfitExit) {
                if (stopLossExit) {
                    System.out.println("触发止损 - ");
                } else if (takeProfitExit) {
                    System.out.println("触发止盈 - ");
                }
                exitPosition();
            }
        }
    }

    /**
     * 计算基于风险的仓位大小
     * 
     * @return 计算得到的仓位大小（ETH数量）
     */
    private BigDecimal calculatePositionSize() {
        // 计算每次交易可承受的最大风险金额
        BigDecimal maxRiskAmount = accountBalance.multiply(riskPerTrade);
        // 计算单合约风险金额（价格波动 * 数量）
        BigDecimal priceRisk = entryPrice.subtract(stopLossPrice).abs();
        // 计算基础仓位大小（不考虑杠杆）
        BigDecimal basePositionSize = maxRiskAmount.divide(priceRisk, 6, BigDecimal.ROUND_HALF_UP);
        // 应用杠杆计算实际仓位大小
        BigDecimal leveragedPositionSize = basePositionSize.multiply(new BigDecimal(leverage))
                                                           .setScale(4, BigDecimal.ROUND_DOWN);
        return leveragedPositionSize;
    }

    /**
     * 执行开多仓操作
     */
    private void enterLong() {
        position = PositionStatus.LONG; // 更新持仓状态为多头
        entryPrice = lastPrice; // 记录入场价格
        // 多头止损价格 = 入场价格 * (1 - 止损比例)
        stopLossPrice = entryPrice.multiply(BigDecimal.ONE.subtract(stopLossRatio))
                                  .setScale(2, BigDecimal.ROUND_HALF_UP);
        // 多头止盈价格 = 入场价格 * (1 + 止盈比例)
        takeProfitPrice = entryPrice.multiply(BigDecimal.ONE.add(takeProfitRatio))
                                    .setScale(2, BigDecimal.ROUND_HALF_UP);
        
        // 计算仓位大小
        positionSize = calculatePositionSize();
        // 计算已用保证金（不考虑手续费）
        usedMargin = positionSize.multiply(entryPrice).divide(new BigDecimal(leverage), 2, BigDecimal.ROUND_HALF_UP);
        
        // 实际交易中，这里会执行买入操作
        System.out.println("开多仓 @ " + lastPrice + ", 止损价格: " + stopLossPrice + ", 止盈价格: " + takeProfitPrice);
        System.out.println("仓位大小: " + positionSize + " ETH, 已用保证金: " + usedMargin + " USD, 账户余额: " + accountBalance + " USD");
    }

    /**
     * 执行开空仓操作
     */
    private void enterShort() {
        position = PositionStatus.SHORT; // 更新持仓状态为空头
        entryPrice = lastPrice; // 记录入场价格
        // 空头止损价格 = 入场价格 * (1 + 止损比例)
        stopLossPrice = entryPrice.multiply(BigDecimal.ONE.add(stopLossRatio))
                                  .setScale(2, BigDecimal.ROUND_HALF_UP);
        // 空头止盈价格 = 入场价格 * (1 - 止盈比例)
        takeProfitPrice = entryPrice.multiply(BigDecimal.ONE.subtract(takeProfitRatio))
                                    .setScale(2, BigDecimal.ROUND_HALF_UP);
        
        // 计算仓位大小
        positionSize = calculatePositionSize();
        // 计算已用保证金（不考虑手续费）
        usedMargin = positionSize.multiply(entryPrice).divide(new BigDecimal(leverage), 2, BigDecimal.ROUND_HALF_UP);
        
        // 实际交易中，这里会执行卖出操作
        System.out.println("开空仓 @ " + lastPrice + ", 止损价格: " + stopLossPrice + ", 止盈价格: " + takeProfitPrice);
        System.out.println("仓位大小: " + positionSize + " ETH, 已用保证金: " + usedMargin + " USD, 账户余额: " + accountBalance + " USD");
    }

    /**
     * 执行平仓操作
     */
    private void exitPosition() {
        // 计算交易盈亏
        BigDecimal profitLoss;
        if (position == PositionStatus.LONG) {
            // 多头盈亏 = (平仓价格 - 入场价格) * 持仓数量
            profitLoss = lastPrice.subtract(entryPrice).multiply(positionSize);
        } else {
            // 空头盈亏 = (入场价格 - 平仓价格) * 持仓数量
            profitLoss = entryPrice.subtract(lastPrice).multiply(positionSize);
        }
        
        // 更新账户余额
        accountBalance = accountBalance.add(profitLoss).setScale(2, BigDecimal.ROUND_HALF_UP);
        
        // 实际交易中，这里会执行平仓操作
        System.out.println("平仓 @ " + lastPrice + ", 盈亏: " + profitLoss.setScale(2, BigDecimal.ROUND_HALF_UP) + " USD");
        System.out.println("最新账户余额: " + accountBalance + " USD");
        
        // 重置持仓状态
        position = PositionStatus.FLAT;
        positionSize = BigDecimal.ZERO;
        usedMargin = BigDecimal.ZERO;
    }

    // 枚举定义
    enum PositionStatus { FLAT, LONG, SHORT }
    enum TrendDirection { BULLISH, BEARISH }
}


 src/main/java/com/xcong/excoin/modules/okxNewPrice/indicator/macdAndMatrategy/MacdMaStrategyMain.java

New file
@@ -0,0 +1,38 @@
package com.xcong.excoin.modules.okxNewPrice.indicator.macdAndMatrategy;

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

public class MacdMaStrategyMain {
    
    public static void main(String[] args) {
        System.out.println("启动MacdMaStrategy测试...");
        
        // 创建测试价格数据
        List<BigDecimal> prices = generateTestPrices(200);
        
        // 创建策略实例
        MacdMaStrategy strategy = new MacdMaStrategy();
        
        try {
            // 执行策略
            strategy.execute(prices);
            System.out.println("策略执行成功！");
        } catch (Exception e) {
            System.err.println("策略执行失败：" + e.getMessage());
            e.printStackTrace();
        }
        
        System.out.println("测试完成");
    }
    
    private static List<BigDecimal> generateTestPrices(int count) {
        List<BigDecimal> prices = new ArrayList<>();
        // 生成一个简单的上升趋势价格序列
        for (int i = 1; i <= count; i++) {
            prices.add(new BigDecimal("100.00").add(new BigDecimal(i * 0.1)));
        }
        return prices;
    }
}

 src/main/java/com/xcong/excoin/modules/okxNewPrice/indicator/macdAndMatrategy/MovingAverage.java

New file
@@ -0,0 +1,71 @@
package com.xcong.excoin.modules.okxNewPrice.indicator.macdAndMatrategy;

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

/**
 * 移动平均线(Moving Average)指标实现类
 * 
 * 移动平均线是一种趋势跟随型技术指标，通过计算一段时间内价格的平均值，
 * 来平滑价格波动并识别趋势方向。本类实现了简单移动平均线(SMA)的计算。
 * 
 * 【核心功能】
 * 1. 计算指定周期的移动平均线
 * 2. 支持高精度BigDecimal计算，避免浮点数精度损失
 * 3. 提供获取最新计算结果的接口
 * 
 * 【使用场景】
 * - 在MACD+MA策略中，用于判断市场长期趋势(200日MA)和中短期支撑/阻力(50日MA)
 * - 适用于各种时间周期的价格数据
 */
public class MovingAverage {
    /**
     * 移动平均线的计算周期
     */
    private final int period;
    
    /**
     * 移动平均线的最新计算结果
     */
    private BigDecimal ma = BigDecimal.ZERO;

    /**
     * 构造方法
     * 
     * @param period 移动平均线的计算周期
     */
    public MovingAverage(int period) {
        this.period = period;
    }

    /**
     * 计算移动平均线
     * 
     * @param prices 历史价格数据列表
     */
    public void calculate(List<BigDecimal> prices) {
        // 如果价格数据不足计算周期，不进行计算
        if (prices.size() < period) {
            return;
        }

        // 计算最近period个价格的总和
        BigDecimal sum = BigDecimal.ZERO;
        for (int i = prices.size()-period; i < prices.size(); i++) {
            sum = sum.add(prices.get(i));
        }

        // 计算平均值，保留8位小数，四舍五入
        ma = sum.divide(new BigDecimal(period), 8, RoundingMode.HALF_UP);
    }

    /**
     * 获取最新计算的移动平均线值
     *
     * @return 移动平均线值
     */
    public BigDecimal getMa() {
        return ma;
    }
}

 src/main/java/com/xcong/excoin/modules/okxNewPrice/indicator/macdAndMatrategy/Volatility.java

New file
@@ -0,0 +1,120 @@
package com.xcong.excoin.modules.okxNewPrice.indicator.macdAndMatrategy;

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

/**
 * 波动率指标实现类
 * 
 * 波动率是衡量价格波动程度的技术指标，反映市场的活跃度和风险水平。
 * 本类通过计算价格的标准差来衡量波动率，使用高精度BigDecimal计算避免精度损失。
 * 
 * 【核心功能】
 * 1. 计算指定周期内价格的波动率（标准差）
 * 2. 使用牛顿迭代法实现BigDecimal的平方根计算，确保金融计算的高精度要求
 * 3. 提供获取最新计算结果的接口
 * 
 * 【使用场景】
 * - 在MACD+MA策略中，用于过滤低波动率的市场环境（波动率<1%时跳过交易）
 * - 适用于各种时间周期的价格数据，通常使用20日或30日周期
 * 【注意事项】
 * - 波动率指标对市场流动性和交易活跃度敏感
 * - 低波动率可能预示着市场趋势即将发生变化
 */
public class Volatility {
    /**
     * 波动率计算的周期
     */
    private final int period;
    
    /**
     * 最新计算的波动率值
     */
    private BigDecimal volatility = BigDecimal.ZERO;

    /**
     * 构造方法
     * 
     * @param period 波动率计算的周期
     */
    public Volatility(int period) {
        this.period = period;
    }

    /**
     * 计算波动率
     * 
     * @param prices 历史价格数据列表
     */
    public void calculate(List<BigDecimal> prices) {
        // 如果价格数据不足计算周期，不进行计算
        if (prices.size() < period) {
            return;
        }

        BigDecimal sum = BigDecimal.ZERO;
        BigDecimal avg = calculateAverage(prices); // 计算平均价格
        
        // 计算每个价格与平均价格的偏差平方和
        for (int i = prices.size()-period; i < prices.size(); i++) {
            BigDecimal dev = prices.get(i).subtract(avg);
            sum = sum.add(dev.pow(2));
        }
        
        // 计算方差，保留8位小数
        BigDecimal variance = sum.divide(new BigDecimal(period), 8, RoundingMode.HALF_UP);
        
        // 计算标准差（波动率），使用牛顿迭代法确保高精度
        volatility = sqrt(variance, 8);
    }

    /**
     * 计算价格平均值
     * 
     * @param prices 历史价格数据列表
     * @return 平均价格
     */
    private BigDecimal calculateAverage(List<BigDecimal> prices) {
        BigDecimal sum = BigDecimal.ZERO;
        for (int i = prices.size()-period; i < prices.size(); i++) {
            sum = sum.add(prices.get(i));
        }
        return sum.divide(new BigDecimal(period), 8, RoundingMode.HALF_UP);
    }

    /**
     * 计算BigDecimal的平方根（牛顿迭代法）
     * 
     * @param value 要计算平方根的数值
     * @param scale 结果的精度（小数位数）
     * @return 平方根结果
     */
    private BigDecimal sqrt(BigDecimal value, int scale) {
        // 负数没有实数平方根，返回0
        if (value.compareTo(BigDecimal.ZERO) < 0) {
            return BigDecimal.ZERO;
        }
        
        // 使用牛顿迭代法计算平方根
        BigDecimal x = value.divide(new BigDecimal(2), scale, RoundingMode.HALF_UP); // 初始猜测值
        BigDecimal prev;
        
        do {
            prev = x;
            // 牛顿迭代公式：x(n+1) = (x(n) + value/x(n))/2
            x = x.add(value.divide(x, scale, RoundingMode.HALF_UP)).divide(new BigDecimal(2), scale, RoundingMode.HALF_UP);
        } while (x.subtract(prev).abs().compareTo(BigDecimal.ONE.movePointLeft(scale)) > 0); // 直到满足精度要求
        
        return x;
    }

    /**
     * 获取最新的波动率计算结果
     * 
     * @return 波动率值
     */
    public BigDecimal getValue() {
        return volatility;
    }
}

 src/test/java/com/xcong/excoin/modules/okxNewPrice/indicator/macdAndMatrategy/MacdMaStrategyTest.java

New file
@@ -0,0 +1,33 @@
package com.xcong.excoin.modules.okxNewPrice.indicator.macdAndMatrategy;

import org.junit.Test;

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

public class MacdMaStrategyTest {
    
    @Test
    public void testExecute() {
        // 创建测试价格数据
        List<BigDecimal> prices = generateTestPrices(200);
        
        // 创建策略实例
        MacdMaStrategy strategy = new MacdMaStrategy();
        
        // 执行策略
        strategy.execute(prices);
        
        System.out.println("测试执行完成");
    }
    
    private List<BigDecimal> generateTestPrices(int count) {
        List<BigDecimal> prices = new ArrayList<>();
        // 生成一个简单的上升趋势价格序列
        for (int i = 1; i <= count; i++) {
            prices.add(new BigDecimal("100.00").add(new BigDecimal(i * 0.1)));
        }
        return prices;
    }
}