!859 update 优化日期处理方法，简化时间格式化逻辑

* update 优化日期处理方法，简化时间格式化逻辑

ruoyi-common/ruoyi-common-core/src/main/java/org/dromara/common/core/enums/FormatsType.java

@@ -1,152 +0,0 @@
-package org.dromara.common.core.enums;
-
-import lombok.AllArgsConstructor;
-import lombok.Getter;
-import org.dromara.common.core.utils.StringUtils;
-
-/*
- * 日期格式
- * "yyyy"：4位数的年份，例如：2023年表示为"2023"。
- * "yy"：2位数的年份，例如：2023年表示为"23"。
- * "MM"：2位数的月份，取值范围为01到12，例如：7月表示为"07"。
- * "M"：不带前导零的月份，取值范围为1到12，例如：7月表示为"7"。
- * "dd"：2位数的日期，取值范围为01到31，例如：22日表示为"22"。
- * "d"：不带前导零的日期，取值范围为1到31，例如：22日表示为"22"。
- * "EEEE"：星期的全名，例如：星期三表示为"Wednesday"。
- * "E"：星期的缩写，例如：星期三表示为"Wed"。
- * "DDD" 或 "D"：一年中的第几天，取值范围为001到366，例如：第200天表示为"200"。
- * 时间格式
- * "HH"：24小时制的小时数，取值范围为00到23，例如：下午5点表示为"17"。
- * "hh"：12小时制的小时数，取值范围为01到12，例如：下午5点表示为"05"。
- * "mm"：分钟数，取值范围为00到59，例如：30分钟表示为"30"。
- * "ss"：秒数，取值范围为00到59，例如：45秒表示为"45"。
- * "SSS"：毫秒数，取值范围为000到999，例如：123毫秒表示为"123"。
- */
-
-/**
- * 日期格式与时间格式枚举
- */
-@Getter
-@AllArgsConstructor
-public enum FormatsType {
-
-    /**
-     * 例如：2023年表示为"23"
-     */
-    YY("yy"),
-
-    /**
-     * 例如：2023年表示为"2023"
-     */
-    YYYY("yyyy"),
-
-    /**
-     * 例例如，2023年7月可以表示为 "2023-07"
-     */
-    YYYY_MM("yyyy-MM"),
-
-    /**
-     * 例如，日期 "2023年7月22日" 可以表示为 "2023-07-22"
-     */
-    YYYY_MM_DD("yyyy-MM-dd"),
-
-    /**
-     * 例如，当前时间如果是 "2023年7月22日下午3点30分"，则可以表示为 "2023-07-22 15:30"
-     */
-    YYYY_MM_DD_HH_MM("yyyy-MM-dd HH:mm"),
-
-    /**
-     * 例如，当前时间如果是 "2023年7月22日下午3点30分45秒"，则可以表示为 "2023-07-22 15:30:45"
-     */
-    YYYY_MM_DD_HH_MM_SS("yyyy-MM-dd HH:mm:ss"),
-
-    /**
-     * 例如：下午3点30分45秒，表示为 "15:30:45"
-     */
-    HH_MM_SS("HH:mm:ss"),
-
-    /**
-     * 例例如，2023年7月可以表示为 "2023/07"
-     */
-    YYYY_MM_SLASH("yyyy/MM"),
-
-    /**
-     * 例如，日期 "2023年7月22日" 可以表示为 "2023/07/22"
-     */
-    YYYY_MM_DD_SLASH("yyyy/MM/dd"),
-
-    /**
-     * 例如，当前时间如果是 "2023年7月22日下午3点30分45秒"，则可以表示为 "2023/07/22 15:30:45"
-     */
-    YYYY_MM_DD_HH_MM_SLASH("yyyy/MM/dd HH:mm"),
-
-    /**
-     * 例如，当前时间如果是 "2023年7月22日下午3点30分45秒"，则可以表示为 "2023/07/22 15:30:45"
-     */
-    YYYY_MM_DD_HH_MM_SS_SLASH("yyyy/MM/dd HH:mm:ss"),
-
-    /**
-     * 例例如，2023年7月可以表示为 "2023.07"
-     */
-    YYYY_MM_DOT("yyyy.MM"),
-
-    /**
-     * 例如，日期 "2023年7月22日" 可以表示为 "2023.07.22"
-     */
-    YYYY_MM_DD_DOT("yyyy.MM.dd"),
-
-    /**
-     * 例如，当前时间如果是 "2023年7月22日下午3点30分"，则可以表示为 "2023.07.22 15:30"
-     */
-    YYYY_MM_DD_HH_MM_DOT("yyyy.MM.dd HH:mm"),
-
-    /**
-     * 例如，当前时间如果是 "2023年7月22日下午3点30分45秒"，则可以表示为 "2023.07.22 15:30:45"
-     */
-    YYYY_MM_DD_HH_MM_SS_DOT("yyyy.MM.dd HH:mm:ss"),
-
-    /**
-     * 例如，2023年7月可以表示为 "202307"
-     */
-    YYYYMM("yyyyMM"),
-
-    /**
-     * 例如，2023年7月22日可以表示为 "20230722"
-     */
-    YYYYMMDD("yyyyMMdd"),
-
-    /**
-     * 例如，2023年7月22日下午3点可以表示为 "2023072215"
-     */
-    YYYYMMDDHH("yyyyMMddHH"),
-
-    /**
-     * 例如，2023年7月22日下午3点30分可以表示为 "202307221530"
-     */
-    YYYYMMDDHHMM("yyyyMMddHHmm"),
-
-    /**
-     * 例如，2023年7月22日下午3点30分45秒可以表示为 "20230722153045"
-     */
-    YYYYMMDDHHMMSS("yyyyMMddHHmmss");
-
-    /**
-     * 时间格式
-     */
-    private final String timeFormat;
-
-    /**
-     * 根据字符串内容匹配时间格式类型。
-     *
-     * @param str 字符串内容
-     * @return 时间格式类型
-     */
-    public static FormatsType getFormatsType(String str) {
-        for (FormatsType value : values()) {
-            if (StringUtils.contains(str, value.getTimeFormat())) {
-                return value;
-            }
-        }
-        throw new RuntimeException("'FormatsType' not found By " + str);
-    }
-}

ruoyi-common/ruoyi-common-core/src/main/java/org/dromara/common/core/utils/DateUtils.java

@@ -1,344 +1,96 @@
 package org.dromara.common.core.utils;
 
+import cn.hutool.core.convert.Convert;
+import cn.hutool.core.date.BetweenFormatter;
 import cn.hutool.core.date.DateUnit;
 import cn.hutool.core.date.DateUtil;
+import cn.hutool.core.lang.Assert;
 import lombok.AccessLevel;
 import lombok.NoArgsConstructor;
-import org.apache.commons.lang3.time.DateFormatUtils;
-import org.dromara.common.core.enums.FormatsType;
 import org.dromara.common.core.exception.ServiceException;
 
-import java.lang.management.ManagementFactory;
-import java.text.ParseException;
-import java.text.SimpleDateFormat;
-import java.time.*;
-import java.time.format.DateTimeFormatter;
 import java.util.Date;
 import java.util.concurrent.TimeUnit;
 
 /**
  * 时间工具类
  *
- * @author ruoyi
+ * @author AprilWind
  */
 @NoArgsConstructor(access = AccessLevel.PRIVATE)
-public class DateUtils extends org.apache.commons.lang3.time.DateUtils {
-    /**
-     * 日期解析格式集合。
-     */
-    private static final String[] PARSE_PATTERNS = {
-        "yyyy-MM-dd", "yyyy-MM-dd HH:mm:ss", "yyyy-MM-dd HH:mm", "yyyy-MM",
-        "yyyy/MM/dd", "yyyy/MM/dd HH:mm:ss", "yyyy/MM/dd HH:mm", "yyyy/MM",
-        "yyyy.MM.dd", "yyyy.MM.dd HH:mm:ss", "yyyy.MM.dd HH:mm", "yyyy.MM"
-    };
+public class DateUtils extends DateUtil {
 
     /**
-     * 获取当前日期和时间
+     * 计算时间差并格式化（精确到秒）
      *
-     * @return 当前日期和时间的 Date 对象表示
+     * @param start 开始时间(支持 Date/LocalDateTime)
+     * @param end   结束时间(支持 Date/LocalDateTime)
+     * @return 时分秒格式时间差
      */
-    public static Date getNowDate() {
-        return new Date();
+    public static String formatBetweenBySecond(Object start, Object end) {
+        return formatTimeBetween(start, end, BetweenFormatter.Level.SECOND);
     }
 
     /**
-     * 获取当前日期的字符串表示，格式为YYYY-MM-DD
+     * 通用时间差格式化
      *
-     * @return 当前日期的字符串表示
+     * @param startDate 开始时间
+     * @param endDate   结束时间
+     * @param level     精度级别
+     * @return 格式化时长
      */
-    public static String getDate() {
-        return dateTimeNow(FormatsType.YYYY_MM_DD);
+    public static String formatTimeBetween(Object startDate, Object endDate, BetweenFormatter.Level level) {
+        // 非空校验
+        Assert.notNull(startDate, "开始时间不能为空");
+        Assert.notNull(endDate, "结束时间不能为空");
+        Assert.notNull(level, "时间精度级别不能为空");
+
+        // 统一转为Date并校验格式合法性
+        Date start = Convert.toDate(startDate);
+        Date end = Convert.toDate(endDate);
+        Assert.notNull(start, "开始时间格式错误，无法解析为时间");
+        Assert.notNull(end, "结束时间格式错误，无法解析为时间");
+
+        long diffMillis = Math.abs(end.getTime() - start.getTime());
+        return formatBetween(diffMillis, level);
     }
 
     /**
-     * 获取当前日期的字符串表示，格式为yyyyMMdd
-     *
-     * @return 当前日期的字符串表示
-     */
-    public static String getCurrentDate() {
-        return DateFormatUtils.format(new Date(), FormatsType.YYYYMMDD.getTimeFormat());
-    }
-
-    /**
-     * 获取当前日期的路径格式字符串，格式为"yyyy/MM/dd"
-     *
-     * @return 当前日期的路径格式字符串
-     */
-    public static String datePath() {
-        Date now = new Date();
-        return DateFormatUtils.format(now, FormatsType.YYYY_MM_DD_SLASH.getTimeFormat());
-    }
-
-    /**
-     * 获取当前时间的字符串表示，格式为YYYY-MM-DD HH:MM:SS
-     *
-     * @return 当前时间的字符串表示
-     */
-    public static String getTime() {
-        return dateTimeNow(FormatsType.YYYY_MM_DD_HH_MM_SS);
-    }
-
-    /**
-     * 获取当前时间的字符串表示，格式为 "HH:MM:SS"
-     *
-     * @return 当前时间的字符串表示，格式为 "HH:MM:SS"
-     */
-    public static String getTimeWithHourMinuteSecond() {
-        return dateTimeNow(FormatsType.HH_MM_SS);
-    }
-
-    /**
-     * 获取当前日期和时间的字符串表示，格式为YYYYMMDDHHMMSS
-     *
-     * @return 当前日期和时间的字符串表示
-     */
-    public static String dateTimeNow() {
-        return dateTimeNow(FormatsType.YYYYMMDDHHMMSS);
-    }
-
-    /**
-     * 获取当前日期和时间的指定格式的字符串表示
-     *
-     * @param format 日期时间格式，例如"YYYY-MM-DD HH:MM:SS"
-     * @return 当前日期和时间的字符串表示
-     */
-    public static String dateTimeNow(final FormatsType format) {
-        return parseDateToStr(format, new Date());
-    }
-
-    /**
-     * 将指定日期格式化为 YYYY-MM-DD 格式的字符串
-     *
-     * @param date 要格式化的日期对象
-     * @return 格式化后的日期字符串
-     */
-    public static String formatDate(final Date date) {
-        return parseDateToStr(FormatsType.YYYY_MM_DD, date);
-    }
-
-    /**
-     * 将指定日期格式化为 YYYY-MM-DD HH:MM:SS 格式的字符串
-     *
-     * @param date 要格式化的日期对象
-     * @return 格式化后的日期时间字符串
-     */
-    public static String formatDateTime(final Date date) {
-        return parseDateToStr(FormatsType.YYYY_MM_DD_HH_MM_SS, date);
-    }
-
-    /**
-     * 将 LocalDateTime 格式化为 YYYY-MM-DD HH:MM:SS 格式的字符串
-     *
-     * @param dateTime 要格式化的 LocalDateTime 对象
-     * @return 格式化后的日期时间字符串
-     */
-    public static String formatDateTime(final LocalDateTime dateTime) {
-        return dateTime.format(DateTimeFormatter.ofPattern(FormatsType.YYYY_MM_DD_HH_MM_SS.getTimeFormat()));
-    }
-
-    /**
-     * 将指定日期按照指定格式进行格式化
-     *
-     * @param format 要使用的日期时间格式，例如"YYYY-MM-DD HH:MM:SS"
-     * @param date   要格式化的日期对象
-     * @return 格式化后的日期时间字符串
-     */
-    public static String parseDateToStr(final FormatsType format, final Date date) {
-        return new SimpleDateFormat(format.getTimeFormat()).format(date);
-    }
-
-    /**
-     * 将指定格式的日期时间字符串转换为 Date 对象
-     *
-     * @param format 要解析的日期时间格式，例如"YYYY-MM-DD HH:MM:SS"
-     * @param ts     要解析的日期时间字符串
-     * @return 解析后的 Date 对象
-     * @throws RuntimeException 如果解析过程中发生异常
-     */
-    public static Date parseDateTime(final FormatsType format, final String ts) {
-        try {
-            return new SimpleDateFormat(format.getTimeFormat()).parse(ts);
-        } catch (ParseException e) {
-            throw new ServiceException("日期时间解析失败：" + ts, e);
-        }
-    }
-
-    /**
-     * 将对象转换为日期对象
-     *
-     * @param str 要转换的对象，通常是字符串
-     * @return 转换后的日期对象，如果转换失败或输入为null，则返回null
-     */
-    public static Date parseDate(Object str) {
-        if (str == null) {
-            return null;
-        }
-        try {
-            return parseDate(str.toString(), PARSE_PATTERNS);
-        } catch (ParseException e) {
-            return null;
-        }
-    }
-
-    /**
-     * 获取服务器启动时间
-     *
-     * @return 服务器启动时间的 Date 对象表示
-     */
-    public static Date getServerStartDate() {
-        long time = ManagementFactory.getRuntimeMXBean().getStartTime();
-        return new Date(time);
-    }
-
-    /**
-     * 计算两个时间之间的时间差，并以指定单位返回（绝对值）
-     *
-     * @param start 起始时间
-     * @param end   结束时间
-     * @param unit  所需返回的时间单位（DAYS、HOURS、MINUTES、SECONDS、MILLISECONDS、MICROSECONDS、NANOSECONDS）
-     * @return 时间差的绝对值，以指定单位表示
-     */
-    public static long difference(Date start, Date end, TimeUnit unit) {
-        // 计算时间差，单位为毫秒，取绝对值避免负数
-        long diffInMillis = Math.abs(end.getTime() - start.getTime());
-
-        // 根据目标单位转换时间差
-        return switch (unit) {
-            case DAYS -> diffInMillis / TimeUnit.DAYS.toMillis(1);
-            case HOURS -> diffInMillis / TimeUnit.HOURS.toMillis(1);
-            case MINUTES -> diffInMillis / TimeUnit.MINUTES.toMillis(1);
-            case SECONDS -> diffInMillis / TimeUnit.SECONDS.toMillis(1);
-            case MILLISECONDS -> diffInMillis;
-            case MICROSECONDS -> TimeUnit.MILLISECONDS.toMicros(diffInMillis);
-            case NANOSECONDS -> TimeUnit.MILLISECONDS.toNanos(diffInMillis);
-        };
-    }
-
-    /**
-     * 计算两个日期之间的时间差，并以天、小时和分钟的格式返回
-     *
-     * @param endDate 结束日期
-     * @param nowDate 当前日期
-     * @return 表示时间差的字符串，格式为"天 小时 分钟"
-     */
-    public static String getDatePoor(Date endDate, Date nowDate) {
-        long diffInMillis = endDate.getTime() - nowDate.getTime();
-        long day = TimeUnit.MILLISECONDS.toDays(diffInMillis);
-        long hour = TimeUnit.MILLISECONDS.toHours(diffInMillis) % 24;
-        long min = TimeUnit.MILLISECONDS.toMinutes(diffInMillis) % 60;
-        return String.format("%d天 %d小时 %d分钟", day, hour, min);
-    }
-
-    /**
-     * 计算两个时间点的差值（天、小时、分钟、秒），当值为0时不显示该单位
-     *
-     * @param endDate 结束时间
-     * @param nowDate 当前时间
-     * @return 时间差字符串，格式为 "x天 x小时 x分钟 x秒"，若为 0 则不显示
-     */
-    public static String getTimeDifference(Date endDate, Date nowDate) {
-        long diffInMillis = endDate.getTime() - nowDate.getTime();
-        long day = TimeUnit.MILLISECONDS.toDays(diffInMillis);
-        long hour = TimeUnit.MILLISECONDS.toHours(diffInMillis) % 24;
-        long min = TimeUnit.MILLISECONDS.toMinutes(diffInMillis) % 60;
-        long sec = TimeUnit.MILLISECONDS.toSeconds(diffInMillis) % 60;
-        // 构建时间差字符串，条件是值不为0才显示
-        StringBuilder result = new StringBuilder();
-        if (day > 0) {
-            result.append(String.format("%d天 ", day));
-        }
-        if (hour > 0) {
-            result.append(String.format("%d小时 ", hour));
-        }
-        if (min > 0) {
-            result.append(String.format("%d分钟 ", min));
-        }
-        if (sec > 0) {
-            result.append(String.format("%d秒", sec));
-        }
-        return !result.isEmpty() ? result.toString().trim() : "0秒";
-    }
-
-    /**
-     * 计算两个 LocalDateTime 时间点的差值（天、小时、分钟、秒），当值为0时不显示该单位
-     *
-     * @param endDate 结束时间
-     * @param nowDate 当前时间
-     * @return 时间差字符串，格式为 "x天 x小时 x分钟 x秒"，若为 0 则不显示
-     */
-    public static String getTimeDifference(LocalDateTime endDate, LocalDateTime nowDate) {
-        long diffInMillis = java.time.Duration.between(nowDate, endDate).toMillis();
-        long day = TimeUnit.MILLISECONDS.toDays(diffInMillis);
-        long hour = TimeUnit.MILLISECONDS.toHours(diffInMillis) % 24;
-        long min = TimeUnit.MILLISECONDS.toMinutes(diffInMillis) % 60;
-        long sec = TimeUnit.MILLISECONDS.toSeconds(diffInMillis) % 60;
-        StringBuilder result = new StringBuilder();
-        if (day > 0) {
-            result.append(String.format("%d天 ", day));
-        }
-        if (hour > 0) {
-            result.append(String.format("%d小时 ", hour));
-        }
-        if (min > 0) {
-            result.append(String.format("%d分钟 ", min));
-        }
-        if (sec > 0) {
-            result.append(String.format("%d秒", sec));
-        }
-        return !result.isEmpty() ? result.toString().trim() : "0秒";
-    }
-
-    /**
-     * 将 LocalDateTime 对象转换为 Date 对象
-     *
-     * @param temporalAccessor 要转换的 LocalDateTime 对象
-     * @return 转换后的 Date 对象
-     */
-    public static Date toDate(LocalDateTime temporalAccessor) {
-        ZonedDateTime zdt = temporalAccessor.atZone(ZoneId.systemDefault());
-        return Date.from(zdt.toInstant());
-    }
-
-    /**
-     * 将 LocalDate 对象转换为 Date 对象
-     *
-     * @param temporalAccessor 要转换的 LocalDate 对象
-     * @return 转换后的 Date 对象
-     */
-    public static Date toDate(LocalDate temporalAccessor) {
-        LocalDateTime localDateTime = LocalDateTime.of(temporalAccessor, LocalTime.of(0, 0, 0));
-        ZonedDateTime zdt = localDateTime.atZone(ZoneId.systemDefault());
-        return Date.from(zdt.toInstant());
-    }
-
-    /**
-     * 校验日期范围
+     * 校验日期范围及最大时间跨度
      *
      * @param startDate 开始日期
      * @param endDate   结束日期
-     * @param maxValue  最大时间跨度的限制值
-     * @param unit      时间跨度的单位，可选择 "DAYS"、"HOURS" 或 "MINUTES"
+     * @param maxValue  最大时间跨度限制值
+     * @param unit      时间单位
      */
-    public static void validateDateRange(Date startDate, Date endDate, int maxValue, TimeUnit unit) {
-        // 校验结束日期不能早于开始日期
-        if (endDate.before(startDate)) {
+    public static void validateDateRange(Object startDate, Object endDate, int maxValue, TimeUnit unit) {
+        // 基础非空校验
+        Assert.notNull(startDate, "开始日期不能为空");
+        Assert.notNull(endDate, "结束日期不能为空");
+        Assert.notNull(unit, "时间单位不能为空");
+
+        // 统一转换并校验时间合法性
+        Date start = Convert.toDate(startDate);
+        Date end = Convert.toDate(endDate);
+        Assert.notNull(start, "开始日期格式错误，无法解析为时间");
+        Assert.notNull(end, "结束日期格式错误，无法解析为时间");
+
+        // 校验结束时间不能早于开始时间
+        if (end.before(start)) {
             throw new ServiceException("结束日期不能早于开始日期");
         }
 
-        // 计算时间跨度
-        long diffInMillis = endDate.getTime() - startDate.getTime();
-
-        // 根据单位转换时间跨度
+        long diffMillis = end.getTime() - start.getTime();
         long diff = switch (unit) {
-            case DAYS -> TimeUnit.MILLISECONDS.toDays(diffInMillis);
-            case HOURS -> TimeUnit.MILLISECONDS.toHours(diffInMillis);
-            case MINUTES -> TimeUnit.MILLISECONDS.toMinutes(diffInMillis);
-            default -> throw new IllegalArgumentException("不支持的时间单位");
+            case DAYS -> TimeUnit.MILLISECONDS.toDays(diffMillis);
+            case HOURS -> TimeUnit.MILLISECONDS.toHours(diffMillis);
+            case MINUTES -> TimeUnit.MILLISECONDS.toMinutes(diffMillis);
+            default -> throw new IllegalArgumentException("不支持的时间单位：" + unit.name());
         };
 
-        // 校验时间跨度不超过最大限制
         if (diff > maxValue) {
-            throw new ServiceException("最大时间跨度为 {} {}", maxValue, unit.toString().toLowerCase());
+            String msg = String.format("最大时间跨度为 %d %s", maxValue, unit.name().toLowerCase());
+            throw new ServiceException(msg);
         }
     }
 
@@ -349,7 +101,7 @@ public class DateUtils extends org.apache.commons.lang3.time.DateUtils {
      * @return 时间段描述
      */
     public static String getTodayHour(Date date) {
-        int hour = DateUtil.hour(date, true);
+        int hour = hour(date, true);
         if (hour <= 6) {
             return "凌晨";
         } else if (hour < 12) {
@@ -384,38 +136,37 @@ public class DateUtils extends org.apache.commons.lang3.time.DateUtils {
         if (date == null) {
             return "";
         }
-        Date now = DateUtil.date();
+        Date now = new Date();
 
         // 未来时间或非今年
-        if (date.after(now) || DateUtil.year(date) != DateUtil.year(now)) {
-            return parseDateToStr(FormatsType.YYYY_MM_DD_HH_MM, date);
+        if (date.after(now) || year(date) != year(now)) {
+            return formatDateTime(now);
         }
 
         // 今天
-        if (DateUtil.isSameDay(date, now)) {
-            long minutes = DateUtil.between(date, now, DateUnit.MINUTE);
+        if (isSameDay(date, now)) {
+            long minutes = between(date, now, DateUnit.MINUTE);
             if (minutes < 1) {
                 return "刚刚";
             }
             if (minutes < 60) {
                 return minutes + "分钟前";
             }
-            return getTodayHour(date) + " " + DateUtil.format(date, "HH:mm");
+            return getTodayHour(date) + " " + format(date, "HH:mm");
         }
 
         // 昨天
-        if (DateUtil.isSameDay(date, DateUtil.yesterday())) {
-            return "昨天 " + DateUtil.format(date, "HH:mm");
+        if (isSameDay(date, yesterday())) {
+            return "昨天 " + format(date, "HH:mm");
         }
 
         // 本周
-        if (DateUtil.isSameWeek(date, now, true)) {
-            return DateUtil.dayOfWeekEnum(date).toChinese("周")
-                + " " + DateUtil.format(date, "HH:mm");
+        if (isSameWeek(date, now, true)) {
+            return dayOfWeekEnum(date).toChinese("周") + " " + format(date, "HH:mm");
         }
 
         // 今年内其它时间
-        return DateUtil.format(date, "MM-dd HH:mm");
+        return format(date, "MM-dd HH:mm");
     }
 
 }

ruoyi-common/ruoyi-common-oss/src/main/java/org/dromara/common/oss/client/AbstractOssClientImpl.java

@@ -35,10 +35,7 @@ import java.nio.file.Files;
 import java.nio.file.Path;
 import java.time.Duration;
 import java.time.ZoneOffset;
-import java.util.Collection;
-import java.util.Map;
-import java.util.Objects;
-import java.util.Optional;
+import java.util.*;
 import java.util.concurrent.CompletionException;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
@@ -203,7 +200,7 @@ public abstract class AbstractOssClientImpl implements OssClient {
             .orElse("");
         String mergedPrefix = mergePrefix(defaultPrefix, businessPrefix);
         String suffix = suffix(fileName);
-        String datePath = DateUtils.datePath();
+        String datePath = DateUtils.format(new Date(), "yyyy/MM/dd");
         String uuid = IdUtil.fastSimpleUUID();
         String path = mergedPrefix.isEmpty() ? datePath + StringUtils.SLASH + uuid : mergedPrefix + StringUtils.SLASH + datePath + StringUtils.SLASH + uuid;
         return path + suffix;

ruoyi-common/ruoyi-common-web/src/main/java/org/dromara/common/web/config/ResourcesConfig.java

@@ -1,7 +1,7 @@
 package org.dromara.common.web.config;
 
 import cn.hutool.core.date.DateTime;
-import cn.hutool.core.date.DateUtil;
+import org.dromara.common.core.utils.DateUtils;
 import org.dromara.common.core.utils.ObjectUtils;
 import org.dromara.common.json.enhance.JsonValueEnhancer;
 import org.dromara.common.web.advice.ResponseEnhancementAdvice;
@@ -50,14 +50,14 @@ public class ResourcesConfig implements WebMvcConfigurer {
     public void addFormatters(FormatterRegistry registry) {
         // 全局日期格式转换配置
         registry.addConverter(String.class, Date.class, source -> {
-            DateTime parse = DateUtil.parse(source);
+            DateTime parse = DateUtils.parse(source);
             if (ObjectUtils.isNull(parse)) {
                 return null;
             }
             return parse.toJdkDate();
         });
         registry.addConverter(String.class, LocalDateTime.class, source -> {
-            DateTime parse = DateUtil.parse(source);
+            DateTime parse = DateUtils.parse(source);
             if (ObjectUtils.isNull(parse)) {
                 return null;
             }

ruoyi-modules/ruoyi-gen/src/main/java/org/dromara/gen/util/TemplateEngineUtils.java

@@ -102,7 +102,7 @@ public class TemplateEngineUtils {
         context.put("basePackage", getPackagePrefix(packageName));
         context.put("packageName", packageName);
         context.put("author", genTable.getFunctionAuthor());
-        context.put("datetime", DateUtils.getDate());
+        context.put("datetime", DateUtils.now());
         context.put("pkColumn", genTable.getPkColumn());
         context.put("importList", getImportList(genTable));
         context.put("permissionPrefix", getPermissionPrefix(moduleName, businessName));

ruoyi-modules/ruoyi-job/src/main/java/org/dromara/job/snailjob/AlipayBillTask.java

@@ -33,7 +33,7 @@ public class AlipayBillTask {
         // 设置清算日期
         String settlementDate = (String) jobArgs.getWfContext().get("settlementDate");
         if (StringUtils.equals(settlementDate, "sysdate")) {
-            settlementDate = DateUtils.getDate();
+            settlementDate = DateUtils.now();
         }
         BillDTO billDTO = new BillDTO(23456789L, "alipay", settlementDate, new BigDecimal("2345.67"));
         // 把billDTO对象放入上下文进行传递

ruoyi-modules/ruoyi-job/src/main/java/org/dromara/job/snailjob/WechatBillTask.java

@@ -34,7 +34,7 @@ public class WechatBillTask {
         // 是sysdate设置为当前日期；否则取管理页面设置的值
         String settlementDate = (String) jobArgs.getWfContext().get("settlementDate");
         if (StringUtils.equals(settlementDate, "sysdate")) {
-            settlementDate = DateUtils.getDate();
+            settlementDate = DateUtils.now();
         }
         BillDTO billDTO = new BillDTO(123456789L, "wechat", settlementDate, new BigDecimal("1234.56"));
         // 把billDTO对象放入上下文进行传递

ruoyi-modules/ruoyi-workflow/src/main/java/org/dromara/workflow/domain/vo/FlowHisTaskVo.java

@@ -239,7 +239,7 @@ public class FlowHisTaskVo implements Serializable {
     private void updateRunDuration() {
         // 如果创建时间和更新时间均不为空，计算它们之间的时长
         if (this.updateTime != null && this.createTime != null) {
-            this.runDuration = DateUtils.getTimeDifference(this.updateTime, this.createTime);
+            this.runDuration = DateUtils.formatBetweenBySecond(this.updateTime, this.createTime);
         }
     }
 

ruoyi-modules/ruoyi-workflow/src/main/java/org/dromara/workflow/service/impl/FlwChartExtServiceImpl.java

@@ -164,11 +164,11 @@ public class FlwChartExtServiceImpl implements ChartExtService {
     /**
      * 处理节点的扩展信息，构建用于流程图悬浮提示的内容
      *
-     * @param nodeJson 当前流程节点对象，包含节点基础信息和提示内容容器
-     * @param taskList 当前节点关联的历史审批任务列表，用于生成提示信息
-     * @param userMap  用户信息映射表，key 为用户ID，value 为用户DTO对象，用于获取审批人信息
+     * @param nodeJson    当前流程节点对象，包含节点基础信息和提示内容容器
+     * @param taskList    当前节点关联的历史审批任务列表，用于生成提示信息
+     * @param userMap     用户信息映射表，key 为用户ID，value 为用户DTO对象，用于获取审批人信息
      * @param deptNameMap 部门名称映射表，key 为部门ID，value 为部门名称
-     * @param dictType 数据字典映射表，key 为字典项编码，value 为对应显示值，用于翻译审批状态等
+     * @param dictType    数据字典映射表，key 为字典项编码，value 为对应显示值，用于翻译审批状态等
      */
     private void processNodeExtInfo(NodeJson nodeJson, List<FlowHisTask> taskList, Map<Long, UserDTO> userMap,
                                     Map<Long, String> deptNameMap, Map<String, String> dictType) {
@@ -202,7 +202,7 @@ public class FlwChartExtServiceImpl implements ChartExtService {
             // 添加具体信息项：账号、耗时、时间
             info.add(buildInfoItem("用户账号", userDTO.getUserName()));
             info.add(buildInfoItem("审批状态", dictType.get(task.getFlowStatus())));
-            info.add(buildInfoItem("审批耗时", DateUtils.getTimeDifference(task.getUpdateTime(), task.getCreateTime())));
+            info.add(buildInfoItem("审批耗时", DateUtils.formatBetweenBySecond(task.getUpdateTime(), task.getCreateTime())));
             info.add(buildInfoItem("办理时间", DateUtils.formatDateTime(task.getUpdateTime())));
         }
     }

ruoyi-modules/ruoyi-workflow/src/main/java/org/dromara/workflow/service/impl/FlwTaskAssigneeServiceImpl.java

@@ -189,7 +189,7 @@ public class FlwTaskAssigneeServiceImpl implements IFlwTaskAssigneeService, Hand
             .setHandlerCode(assignee -> StringUtils.blankToDefault(assignee.getHandlerCode(), "无"))
             .setHandlerName(assignee -> StringUtils.blankToDefault(assignee.getHandlerName(), "无"))
             .setGroupName(assignee -> this.getGroupName(type, assignee.getGroupName()))
-            .setCreateTime(assignee -> DateUtils.formatDateTime(assignee.getCreateTime()));
+            .setCreateTime(assignee -> DateUtils.formatLocalDateTime(assignee.getCreateTime()));
     }
 
     /**