ETF收益修改

zyy

2025-12-23 812e291010042cb7c202a1a5a37226e261e94aa7

ETF收益修改

 trading-order-service/src/main/java/com/yami/trading/service/UsStockTradingDayCalculator.java

New file
@@ -0,0 +1,200 @@
package com.yami.trading.service;

import java.time.*;
import java.time.temporal.ChronoUnit;
import java.util.*;

/**
 * 美股交易日统计工具（适配java.util.Date）
 */
public class UsStockTradingDayCalculator {
    // 美股纽约时区
    private static final ZoneId NEW_YORK_ZONE = ZoneId.of("America/New_York");
    // UTC时区（Date转ZonedDateTime的基准）
    private static final ZoneId UTC_ZONE = ZoneId.of("UTC");

    // ==================== 基础版：仅排除周末 ====================
    /**
     * 计算两个Date之间的美股交易日天数（仅排除周六/周日）
     * @param startDate 开始日期（java.util.Date）
     * @param endDate 结束日期（java.util.Date）
     * @return 美股交易日天数
     */
    public static int countUsStockTradingDays(Date startDate, Date endDate) {
        // 1. 参数校验
        if (startDate == null || endDate == null) {
            throw new IllegalArgumentException("startDate error");
        }
        if (startDate.after(endDate)) {
            throw new IllegalArgumentException("endDate error");
        }

        // 2. 将Date转换为纽约时区的LocalDate（核心：按纽约时间算日期）
        LocalDate startLocalDate = convertDateToNyLocalDate(startDate);
        LocalDate endLocalDate = convertDateToNyLocalDate(endDate);

        // 3. 遍历日期并统计交易日（非周六/周日）
        int tradingDays = 0;
        LocalDate currentDate = startLocalDate;
        while (!currentDate.isAfter(endLocalDate)) {
            DayOfWeek dayOfWeek = currentDate.getDayOfWeek();
            // 非周六、非周日即为交易日
            if (dayOfWeek != DayOfWeek.SATURDAY && dayOfWeek != DayOfWeek.SUNDAY) {
                tradingDays++;
            }
            currentDate = currentDate.plusDays(1);
        }
        return tradingDays;
    }

    // ==================== 进阶版：排除周末+美股法定节假日 ====================
    /**
     * 计算两个Date之间的美股交易日天数（排除周六/周日+美股法定节假日）
     * @param startDate 开始日期
     * @param endDate 结束日期
     * @return 美股交易日天数
     */
    public static int countUsStockTradingDaysWithHolidays(Date startDate, Date endDate) {
        // 基础参数校验
        if (startDate == null || endDate == null) {
            throw new IllegalArgumentException("开始日期和结束日期不能为空");
        }
        if (startDate.after(endDate)) {
            throw new IllegalArgumentException("开始日期不能晚于结束日期");
        }

        // 转换为纽约时区的LocalDate
        LocalDate startLocalDate = convertDateToNyLocalDate(startDate);
        LocalDate endLocalDate = convertDateToNyLocalDate(endDate);

        // 预加载周期内涉及年份的美股节假日
        Set<LocalDate> holidays = new HashSet<>();
        for (int year = startLocalDate.getYear(); year <= endLocalDate.getYear(); year++) {
            holidays.addAll(getUsStockHolidays(year));
        }

        // 遍历统计（非周末+非节假日）
        int tradingDays = 0;
        LocalDate currentDate = startLocalDate;
        while (!currentDate.isAfter(endLocalDate)) {
            DayOfWeek dayOfWeek = currentDate.getDayOfWeek();
            if (dayOfWeek != DayOfWeek.SATURDAY && dayOfWeek != DayOfWeek.SUNDAY
                    && !holidays.contains(currentDate)) {
                tradingDays++;
            }
            currentDate = currentDate.plusDays(1);
        }
        return tradingDays;
    }

    // ==================== 工具方法：Date转纽约时区LocalDate ====================
    /**
     * 将java.util.Date转换为纽约时区的LocalDate
     * @param date 待转换的Date
     * @return 纽约时区的LocalDate
     */
    private static LocalDate convertDateToNyLocalDate(Date date) {
        // Date -> Instant -> ZonedDateTime(UTC) -> ZonedDateTime(纽约) -> LocalDate
        Instant instant = date.toInstant();
        ZonedDateTime utcZoned = instant.atZone(UTC_ZONE);
        ZonedDateTime nyZoned = utcZoned.withZoneSameInstant(NEW_YORK_ZONE);
        return nyZoned.toLocalDate();
    }

    // ==================== 工具方法：获取指定年份的美股法定节假日 ====================
    /**
     * 获取指定年份的美股法定节假日（含调休规则）
     * @param year 年份
     * @return 节假日LocalDate集合
     */
    private static Set<LocalDate> getUsStockHolidays(int year) {
        Set<LocalDate> holidays = new HashSet<>();

        // 1. 新年（1月1日，周末则调休）
        LocalDate newYear = LocalDate.of(year, 1, 1);
        if (newYear.getDayOfWeek() == DayOfWeek.SATURDAY) {
            newYear = newYear.minusDays(1);
        } else if (newYear.getDayOfWeek() == DayOfWeek.SUNDAY) {
            newYear = newYear.plusDays(1);
        }
        holidays.add(newYear);

        // 2. 马丁·路德·金日（1月第三个周一）
        LocalDate mlkDay = LocalDate.of(year, 1, 1);
        while (mlkDay.getDayOfWeek() != DayOfWeek.MONDAY) {
            mlkDay = mlkDay.plusDays(1);
        }
        mlkDay = mlkDay.plusWeeks(2);
        holidays.add(mlkDay);

        // 3. 总统日（2月第三个周一）
        LocalDate presidentsDay = LocalDate.of(year, 2, 1);
        while (presidentsDay.getDayOfWeek() != DayOfWeek.MONDAY) {
            presidentsDay = presidentsDay.plusDays(1);
        }
        presidentsDay = presidentsDay.plusWeeks(2);
        holidays.add(presidentsDay);

        // 4. 阵亡将士纪念日（5月最后一个周一）
        LocalDate memorialDay = LocalDate.of(year, 5, 31);
        while (memorialDay.getDayOfWeek() != DayOfWeek.MONDAY) {
            memorialDay = memorialDay.minusDays(1);
        }
        holidays.add(memorialDay);

        // 5. 独立日（7月4日，周末则调休）
        LocalDate independenceDay = LocalDate.of(year, 7, 4);
        if (independenceDay.getDayOfWeek() == DayOfWeek.SATURDAY) {
            independenceDay = independenceDay.minusDays(1);
        } else if (independenceDay.getDayOfWeek() == DayOfWeek.SUNDAY) {
            independenceDay = independenceDay.plusDays(1);
        }
        holidays.add(independenceDay);

        // 6. 劳工节（9月第一个周一）
        LocalDate laborDay = LocalDate.of(year, 9, 1);
        while (laborDay.getDayOfWeek() != DayOfWeek.MONDAY) {
            laborDay = laborDay.plusDays(1);
        }
        holidays.add(laborDay);

        // 7. 感恩节（11月第四个周四）
        LocalDate thanksgiving = LocalDate.of(year, 11, 1);
        while (thanksgiving.getDayOfWeek() != DayOfWeek.THURSDAY) {
            thanksgiving = thanksgiving.plusDays(1);
        }
        thanksgiving = thanksgiving.plusWeeks(3);
        holidays.add(thanksgiving);

        // 8. 圣诞节（12月25日，周末则调休）
        LocalDate christmas = LocalDate.of(year, 12, 25);
        if (christmas.getDayOfWeek() == DayOfWeek.SATURDAY) {
            christmas = christmas.minusDays(1);
        } else if (christmas.getDayOfWeek() == DayOfWeek.SUNDAY) {
            christmas = christmas.plusDays(1);
        }
        holidays.add(christmas);

        return holidays;
    }

    // ==================== 测试示例 ====================
    public static void main(String[] args) {
        // 测试：2025-12-22（周一） ~ 2025-12-28（周日）
        Calendar cal1 = Calendar.getInstance();
        cal1.set(2025, Calendar.DECEMBER, 22);
        Date start = cal1.getTime();

        Calendar cal2 = Calendar.getInstance();
        cal2.set(2025, Calendar.DECEMBER, 28);
        Date end = cal2.getTime();

        // 基础版：仅排除周末，共5天（22-26日）
        int basicDays = countUsStockTradingDays(start, end);
        // 进阶版：若2025-12-25是圣诞节（周四），则排除，共4天
        int advancedDays = countUsStockTradingDaysWithHolidays(start, end);

        System.out.println("基础版（仅排周末）交易日数：" + basicDays);  // 输出：5
        System.out.println("进阶版（排周末+节假日）交易日数：" + advancedDays);  // 输出：4
    }
}

 trading-order-service/src/main/java/com/yami/trading/service/dz/impl/StockDzServiceImpl.java

@@ -30,6 +30,7 @@
import com.yami.trading.dao.dz.StockDzMapper;
import com.yami.trading.service.MarketOpenChecker;
import com.yami.trading.service.MoneyLogService;
import com.yami.trading.service.UsStockTradingDayCalculator;
import com.yami.trading.service.WalletService;
import com.yami.trading.service.data.DataService;
import com.yami.trading.service.dz.StockDzService;
@@ -46,6 +47,7 @@
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.util.*;

@@ -270,11 +272,34 @@
                    }
                    if (dz.getDayRate() > 0) {
                        Date startTime = dz.getCreateTime();
                        Date now = new Date();
                        Calendar calendar = Calendar.getInstance();
                        calendar.setTime(startTime);
                        calendar.add(Calendar.DATE, dz.getPeriod());
                        // 锁仓截至时间
                        Date resultTime = calendar.getTime();
                        //显示收益不超过 锁仓截至时间
                        if(now.getTime() > resultTime.getTime()){
                            now = resultTime;
                        }
                        // 计算美股交易天数
                        int num = UsStockTradingDayCalculator.countUsStockTradingDays(startTime, now);
                        // 计算相差天数
                        int num = com.yami.trading.common.util.DateUtil.dateNum(startTime, new Date());
                        int days = com.yami.trading.common.util.DateUtil.dateNum(startTime, now);
                        if (days >= dz.getPeriod()) {
                            num--;
                        }
                        num = Math.max(1, Math.min(num, dz.getPeriod()));
                        double dayEarnings = dz.getDayRate() * dz.getVolume();
                        double profitLoss = dayEarnings * num;

                        double dayEarnings = 0; //日收益
                        double profitLoss = 0;  //盈利
                        double volume = dz.getVolume();  //本金
                        for (int i = 0; i < num; i++) {
                            dayEarnings = dz.getDayRate() * volume;
                            profitLoss += dayEarnings;
                            volume += dayEarnings;
                        }

                        DecimalFormat df = new DecimalFormat("#.##");
                        String resultStr = df.format(profitLoss);
                        String resultStr2 = df.format(dayEarnings);
@@ -654,15 +679,15 @@
                throw new YamiShopBindException("股票价格0,请重试");
            }


            Date now = new Date();
            if (!isAdmin) {
                if (stockDz.getPeriod() != null && stockDz.getPeriod() > 0) {
                    Calendar calendar = Calendar.getInstance();
                    calendar.setTime(order.getCreateTime());
                    calendar.add(Calendar.DATE, stockDz.getPeriod());
                    // 锁仓时间
            // 锁仓截至时间
                    Date resultTime = calendar.getTime();

            if (!isAdmin) {
                if (stockDz.getPeriod() != null && stockDz.getPeriod() > 0) {
                    if(now.getTime() < resultTime.getTime()){
                        return Result.failed("未到平仓时间");
                    }
@@ -698,7 +723,14 @@
            if (isETF) {
                //按日收益率结算
                closeAmt = order.getPrice();
                closeAmt = closeAmt + stockDz.getDayRate() * closeAmt * stockDz.getPeriod();
                Date startTime = order.getCreateTime();
                // 计算美股交易天数
                int day = UsStockTradingDayCalculator.countUsStockTradingDays(startTime, resultTime) - 1;
                day = Math.max(1, Math.min(day, stockDz.getPeriod()));
                // 复利总金额 = 本金 × (1 + 日收益率) ^ 交易日数
                closeAmt = closeAmt * Math.pow(1 + stockDz.getDayRate(), day);
                closeAmt = BigDecimal.valueOf(closeAmt).setScale(4, RoundingMode.DOWN).doubleValue();

                closePrice = closeAmt;
                closeAmt = closeAmt - orderFree.doubleValue();
            } else {
@@ -763,4 +795,28 @@
    }


    public static void main(String[] args) {
        double dayEarnings = 0; //日收益
        double profitLoss = 0;  //盈利
        double volume = 6000;  //本金
        double price = volume;
        int num = 11;
        double dayRate = 0.12;
        for (int i = 0; i < num; i++) {
            dayEarnings = dayRate * volume;
            profitLoss += dayEarnings;
            volume += dayEarnings;
        }
        System.out.println("dayEarnings:" + dayEarnings);
        System.out.println("profitLoss:" + profitLoss);
        System.out.println("volume:" + volume);


        // 复利总金额 = 本金 × (1 + 日收益率) ^ 交易日数
        double compoundAmount = price * Math.pow(1 + dayRate, num);
        // 复利总盈亏 = 复利总金额 - 本金
        double profitLoss2 = compoundAmount - price;
        System.out.println("compoundAmount:" + compoundAmount);
        System.out.println("profitLoss2:" + profitLoss2);
    }
}

 trading-order-service/src/main/resources/mapper/dz/StockDzMapper.xml

@@ -67,7 +67,7 @@
        <if test="userId != null and userId != '' ">
            AND t.party_id = #{userId}
        </if>
        ORDER BY  t.create_time DESC
        ORDER BY  t.close_time DESC,t.create_time DESC
    </select>

    <select id="getDzCheckList" resultType="com.yami.trading.bean.dz.dto.ExchangeApplyOrderDzDto" parameterType="map">