DateDealUtils.java 11.4 KB
package com.qgutech.qgyun.apaas.sync.utils;

import com.qgutech.qgyun.apaas.sync.base.BoErrorCode;
import com.qgutech.qgyun.apaas.sync.base.BoException;
import com.qgutech.qgyun.apaas.sync.cps.enums.QuarterEnum;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

public class DateDealUtils {

    private static final String DATE_TIME_PATTERN = "yyyy-MM-dd HH:mm:ss";

    /**
     * 解析年份开始时间
     */
    public static Date parseYearStartTime(String year) {
        try {
            SimpleDateFormat sdf = new SimpleDateFormat(DATE_TIME_PATTERN);
            return sdf.parse(year + "-01-01 00:00:00");
        } catch (ParseException e) {
            throw new BoException(BoErrorCode.PARAM_ERROR, "年份格式错误");
        }
    }

    /**
     * 解析年份结束时间
     */
    public static Date parseYearEndTime(String year) {
        try {
            SimpleDateFormat sdf = new SimpleDateFormat(DATE_TIME_PATTERN);
            return sdf.parse(year + "-12-31 23:59:59");
        } catch (ParseException e) {
            throw new BoException(BoErrorCode.PARAM_ERROR, "年份格式错误");
        }
    }

    /**
     * 解析季度开始时间
     */
    public static Date parseQuarterStartTime(String year, QuarterEnum quarter) {
        try {
            SimpleDateFormat sdf = new SimpleDateFormat(DATE_TIME_PATTERN);
            return sdf.parse(year + "-" + quarter.getStartDate() + " 00:00:00");
        } catch (ParseException e) {
            throw new BoException(BoErrorCode.PARAM_ERROR, "季度日期格式错误");
        }
    }

    /**
     * 解析季度结束时间
     */
    public static Date parseQuarterEndTime(String year, QuarterEnum quarter) {
        try {
            SimpleDateFormat sdf = new SimpleDateFormat(DATE_TIME_PATTERN);
            return sdf.parse(year + "-" + quarter.getEndDate() + " 23:59:59");
        } catch (ParseException e) {
            throw new BoException(BoErrorCode.PARAM_ERROR, "季度日期格式错误");
        }
    }

    /**
     * 解析日期字符串,支持以下格式:
     * <ul>
     *   <li>yyyy-MM-dd HH:mm:ss</li>
     *   <li>yyyy-MM-dd</li>
     *   <li>yyyy/MM/dd HH:mm:ss</li>
     *   <li>yyyy/MM/dd</li>
     * </ul>
     *
     * @param dateStr 日期字符串
     * @return 解析后的日期,为空时返回 null
     */
    public static Date parseDate(String dateStr) {
        if (dateStr == null || dateStr.trim().isEmpty()) {
            return null;
        }
        String trimmed = dateStr.trim();
        String[] patterns = new String[]{
                "yyyy-MM-dd HH:mm:ss",
                "yyyy-MM-dd",
                "yyyy/MM/dd HH:mm:ss",
                "yyyy/MM/dd"
        };
        for (String pattern : patterns) {
            try {
                SimpleDateFormat sdf = new SimpleDateFormat(pattern);
                sdf.setLenient(false);
                return sdf.parse(trimmed);
            } catch (ParseException ignored) {
                // 尝试下一个格式
            }
        }
        throw new BoException(BoErrorCode.PARAM_ERROR, "日期格式错误,支持 yyyy-MM-dd [HH:mm:ss]");
    }

    /**
     * 将开始时间字符串解析为当天的 00:00:00(若未包含时间部分)
     */
    public static Date parseStartTime(String dateStr) {
        Date date = parseDate(dateStr);
        if (date == null) {
            return null;
        }
        // 如果传入的字符串不包含时间部分,则默认为当天开始
        if (dateStr != null && dateStr.trim().length() <= 10) {
            return date;
        }
        return date;
    }

    /**
     * 将结束时间字符串解析为当天的 23:59:59(若未包含时间部分)
     */
    public static Date parseEndTime(String dateStr) {
        Date date = parseDate(dateStr);
        if (date == null) {
            return null;
        }
        // 如果传入的字符串不包含时间部分,则默认为当天结束
        if (dateStr != null && dateStr.trim().length() <= 10) {
            java.util.Calendar cal = java.util.Calendar.getInstance();
            cal.setTime(date);
            cal.set(java.util.Calendar.HOUR_OF_DAY, 23);
            cal.set(java.util.Calendar.MINUTE, 59);
            cal.set(java.util.Calendar.SECOND, 59);
            cal.set(java.util.Calendar.MILLISECOND, 999);
            return cal.getTime();
        }
        return date;
    }

    /**
     * 获取当前月的开始时间(当月 1 号 00:00:00.000)
     */
    public static Date getCurrentMonthStartTime() {
        Calendar cal = Calendar.getInstance();
        cal.set(Calendar.DAY_OF_MONTH, cal.getActualMinimum(Calendar.DAY_OF_MONTH));
        cal.set(Calendar.HOUR_OF_DAY, 0);
        cal.set(Calendar.MINUTE, 0);
        cal.set(Calendar.SECOND, 0);
        cal.set(Calendar.MILLISECOND, 0);
        return cal.getTime();
    }

    /**
     * 获取当前月的结束时间(当月最后一天 23:59:59.999)
     */
    public static Date getCurrentMonthEndTime() {
        Calendar cal = Calendar.getInstance();
        cal.set(Calendar.DAY_OF_MONTH, cal.getActualMaximum(Calendar.DAY_OF_MONTH));
        cal.set(Calendar.HOUR_OF_DAY, 23);
        cal.set(Calendar.MINUTE, 59);
        cal.set(Calendar.SECOND, 59);
        cal.set(Calendar.MILLISECOND, 999);
        return cal.getTime();
    }

    /**
     * 解析开始时间字符串,为空时默认返回当前月开始时间
     */
    public static Date parseStartTimeOrCurrentMonthStart(String dateStr) {
        if (dateStr == null || dateStr.trim().isEmpty()) {
            return getCurrentMonthStartTime();
        }
        return parseStartTime(dateStr);
    }

    /**
     * 解析结束时间字符串,为空时默认返回当前月结束时间
     */
    public static Date parseEndTimeOrCurrentMonthEnd(String dateStr) {
        if (dateStr == null || dateStr.trim().isEmpty()) {
            return getCurrentMonthEndTime();
        }
        return parseEndTime(dateStr);
    }

    /**
     * 获取当前日期前一天的结束时间(昨天 23:59:59.999)
     */
    public static Date getYesterdayEndTime() {
        Calendar cal = Calendar.getInstance();
        cal.add(Calendar.DAY_OF_MONTH, -1);
        cal.set(Calendar.HOUR_OF_DAY, 23);
        cal.set(Calendar.MINUTE, 59);
        cal.set(Calendar.SECOND, 59);
        cal.set(Calendar.MILLISECOND, 999);
        return cal.getTime();
    }

    /**
     * 解析结束时间字符串,为空时默认返回当前日期前一天的结束时间
     */
    public static Date parseEndTimeOrYesterdayEnd(String dateStr) {
        if (dateStr == null || dateStr.trim().isEmpty()) {
            return getYesterdayEndTime();
        }
        return parseEndTime(dateStr);
    }

    /**
     * 获取当前天的开始时间(今天 00:00:00.000)
     */
    public static Date getCurrentDayStartTime() {
        Calendar cal = Calendar.getInstance();
        cal.set(Calendar.HOUR_OF_DAY, 0);
        cal.set(Calendar.MINUTE, 0);
        cal.set(Calendar.SECOND, 0);
        cal.set(Calendar.MILLISECOND, 0);
        return cal.getTime();
    }

    /**
     * 获取当前天的结束时间(今天 23:59:59.999)
     */
    public static Date getCurrentDayEndTime() {
        Calendar cal = Calendar.getInstance();
        cal.set(Calendar.HOUR_OF_DAY, 23);
        cal.set(Calendar.MINUTE, 59);
        cal.set(Calendar.SECOND, 59);
        cal.set(Calendar.MILLISECOND, 999);
        return cal.getTime();
    }

    /**
     * 解析开始时间字符串,为空时默认返回当前天开始时间
     */
    public static Date parseStartTimeOrCurrentDayStart(String dateStr) {
        if (dateStr == null || dateStr.trim().isEmpty()) {
            return getCurrentDayStartTime();
        }
        return parseStartTime(dateStr);
    }

    /**
     * 解析结束时间字符串,为空时默认返回当前天结束时间
     */
    public static Date parseEndTimeOrCurrentDayEnd(String dateStr) {
        if (dateStr == null || dateStr.trim().isEmpty()) {
            return getCurrentDayEndTime();
        }
        return parseEndTime(dateStr);
    }

    /**
     * 根据年份、月份定位 Calendar;year 为空默认当前年,month(1-12)为空默认当前月
     */
    private static Calendar resolveYearMonth(Integer year, Integer month) {
        if (month != null && (month < 1 || month > 12)) {
            throw new BoException(BoErrorCode.PARAM_ERROR, "月份必须在 1-12 之间");
        }
        Calendar cal = Calendar.getInstance();
        if (year != null) {
            cal.set(Calendar.YEAR, year);
        }
        if (month != null) {
            cal.set(Calendar.MONTH, month - 1);
        }
        return cal;
    }

    /**
     * 获取指定年月的开始时间(当月 1 号 00:00:00.000);year 为空默认当前年,month(1-12)为空默认当前月
     */
    public static Date getMonthStartTime(Integer year, Integer month) {
        Calendar cal = resolveYearMonth(year, month);
        cal.set(Calendar.DAY_OF_MONTH, 1);
        cal.set(Calendar.HOUR_OF_DAY, 0);
        cal.set(Calendar.MINUTE, 0);
        cal.set(Calendar.SECOND, 0);
        cal.set(Calendar.MILLISECOND, 0);
        return cal.getTime();
    }

    /**
     * 获取指定年月的结束时间(当月最后一天 23:59:59.999);year 为空默认当前年,month(1-12)为空默认当前月
     */
    public static Date getMonthEndTime(Integer year, Integer month) {
        Calendar cal = resolveYearMonth(year, month);
        cal.set(Calendar.DAY_OF_MONTH, cal.getActualMaximum(Calendar.DAY_OF_MONTH));
        cal.set(Calendar.HOUR_OF_DAY, 23);
        cal.set(Calendar.MINUTE, 59);
        cal.set(Calendar.SECOND, 59);
        cal.set(Calendar.MILLISECOND, 999);
        return cal.getTime();
    }

    /**
     * 计算指定 Calendar 所处日期距离本周周一的天数(以周一为一周起始)
     * <p>
     * Calendar 中 SUNDAY=1、MONDAY=2 ... SATURDAY=7,周日需向前推 6 天
     */
    private static int diffToMonday(Calendar cal) {
        int dayOfWeek = cal.get(Calendar.DAY_OF_WEEK);
        return (dayOfWeek == Calendar.SUNDAY) ? 6 : dayOfWeek - Calendar.MONDAY;
    }

    /**
     * 获取当前时间所在周的周一开始时间(周一 00:00:00.000)
     */
    public static Date getCurrentWeekMondayStartTime() {
        Calendar cal = Calendar.getInstance();
        // 显式设置周一为一周起始,避免 Locale 差异导致的问题
        cal.setFirstDayOfWeek(Calendar.MONDAY);
        cal.set(Calendar.HOUR_OF_DAY, 0);
        cal.set(Calendar.MINUTE, 0);
        cal.set(Calendar.SECOND, 0);
        cal.set(Calendar.MILLISECOND, 0);
        cal.add(Calendar.DAY_OF_MONTH, -diffToMonday(cal));
        return cal.getTime();
    }

    /**
     * 获取当前时间所在周的周日结束时间(周日 23:59:59.999)
     */
    public static Date getCurrentWeekSundayEndTime() {
        Calendar cal = Calendar.getInstance();
        // 显式设置周一为一周起始,避免 Locale 差异导致的问题
        cal.setFirstDayOfWeek(Calendar.MONDAY);
        cal.set(Calendar.HOUR_OF_DAY, 0);
        cal.set(Calendar.MINUTE, 0);
        cal.set(Calendar.SECOND, 0);
        cal.set(Calendar.MILLISECOND, 0);
        cal.add(Calendar.DAY_OF_MONTH, -diffToMonday(cal) + 6);
        cal.set(Calendar.HOUR_OF_DAY, 23);
        cal.set(Calendar.MINUTE, 59);
        cal.set(Calendar.SECOND, 59);
        cal.set(Calendar.MILLISECOND, 999);
        return cal.getTime();
    }
}