密码验证加-

whyclxw

2025-05-28 e16302f9d475c7cc4dd18c5abf1a23cb5502e362

 src/main/java/com/whyc/util/DateUtil.java

@@ -3,6 +3,7 @@
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.stream.Collectors;

/**
 * @Description : 时间工具类
@@ -13,6 +14,39 @@
    public static SimpleDateFormat YYYY_MM_DD_HH_MM_SS=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    public static SimpleDateFormat YYYY_MM_DD_HH_MM_SS_UNION=new SimpleDateFormat("yyyyMMddHHmmss");
   public static SimpleDateFormat YYYY_MM_DD=new SimpleDateFormat("yyyy-MM-dd");
   public static SimpleDateFormat YYYY_MM=new SimpleDateFormat("yyyy-MM");
   public static SimpleDateFormat YYYY_MM_TABLE=new SimpleDateFormat("yyyy_MM");

   public static int compare(String date1Str,String date2Str) throws ParseException {
        Date date1 = YYYY_MM_DD_HH_MM_SS.parse(date1Str);
        Date date2 = YYYY_MM_DD_HH_MM_SS.parse(date2Str);
        if(date1.compareTo(date2)>0){
            return 1;
        }else if(date1.compareTo(date2) == 0){
            return 0;
        }else{
            return -1;
        }
    }

    public static Date getMaxTime(String date1Str,String date2Str,String date3Str) {
       try {
            Date date1 = YYYY_MM_DD_HH_MM_SS.parse(date1Str);
            Date date2 = YYYY_MM_DD_HH_MM_SS.parse(date2Str);
            Date date3 = YYYY_MM_DD_HH_MM_SS.parse(date3Str);

            Date maxTime = date1;
            if (maxTime.compareTo(date2) < 0) {
                maxTime = date2;
            }
            if (maxTime.compareTo(date3) < 0) {
                maxTime = date3;
            }
            return maxTime;
        }catch (ParseException e){
           return null;
        }
    }

    public static List<List<Date>> getMonthTime(Date startTimeDate,Date endTimeDate) throws ParseException {
        List<List<Date>> timeList = new LinkedList<>();
@@ -36,7 +70,8 @@
        Calendar dateTemp = Calendar.getInstance();
        for (int i = 0; i < len; i++) {
            List<Date> SEList = new LinkedList<>();
            dateTemp.setTime(YYYY_MM_DD_HH_MM_SS.parse(startY+"-"+startM+"-01 00:00:00"));
            //dateTemp.setTime(YYYY_MM_DD_HH_MM_SS.parse(startY+"-"+startM+"-01 00:00:00"));
            dateTemp.setTime(ThreadLocalUtil.parse(startY+"-"+startM+"-01 00:00:00",1));
            Date recordTime,recordTime1;

            dateTemp.add(Calendar.MONTH,i);
@@ -156,11 +191,13 @@
     */
    public static List<String> getMonthList(String startTimeStr,String endTimeStr) throws ParseException {
        Calendar startTimeCalendar = Calendar.getInstance();
        Date startTime = DateUtil.YYYY_MM_DD_HH_MM_SS.parse(startTimeStr);
        //Date startTime = DateUtil.YYYY_MM_DD_HH_MM_SS.parse(startTimeStr);
        Date startTime = ThreadLocalUtil.parse(startTimeStr,1);
        startTimeCalendar.setTime(startTime);

        Calendar endTimeCalendar = Calendar.getInstance();
        Date endTime = DateUtil.YYYY_MM_DD_HH_MM_SS.parse(endTimeStr);
        //Date endTime = DateUtil.YYYY_MM_DD_HH_MM_SS.parse(endTimeStr);
        Date endTime = ThreadLocalUtil.parse(endTimeStr,1);
        endTimeCalendar.setTime(endTime);

        /*String[] startTimeSplit = startTimeStr.split("-");
@@ -329,6 +366,93 @@
        return result;
    }

    /**
     * 在分表的情况下使用,按月分表,查询需要切割查询使用 时间倒序
     * <p>
     * 根据传入的起止时间,按照年切割成不同时间段
     *
     * @param startTime 2023-01-01 10:00:00
     * @param endTime   2023-05-01 10:10:10
     * @return 示例
     * {
     *  2023_04=[Fri Dec 25 14:12:22 CST 2020, Thu Dec 31 23:59:59 CST 2020]
     *  2023_03=[Fri Jan 01 00:00:00 CST 2021, Fri Dec 31 23:59:59 CST 2021],
     *  2023_02=[Sat Jan 01 00:00:00 CST 2022, Sat Dec 31 23:59:59 CST 2022],
     *  2023_01=[Sun Jan 01 00:00:00 CST 2023, Tue Jan 24 16:45:22 CST 2023],
     *
     * }
     * 使用方法:
     * 根据返回的第一个数据,如果存在表,则查询筛选条件为>=输入的起始时间;不存在则弃用输入的起始时间
     * 根据返回的最后个数据,如果表存在,则查询筛选条件为<=输入的终止时间;不存在则弃用输入的终止时间
     * 返回的非第一最后数据,查询全表
     */
    public static Map<String,List<Date>> getMonthListDesc(Date startTime,Date endTime) throws ParseException {
        Map<String,List<Date>> result = new LinkedHashMap<>();
        Calendar startTimeC = Calendar.getInstance();
        startTimeC.setTime(startTime);
        int startYear = startTimeC.get(Calendar.YEAR);
        int startMonth = startTimeC.get(Calendar.MONTH);

        Calendar endTimeC = Calendar.getInstance();
        endTimeC.setTime(endTime);
        int endYear = endTimeC.get(Calendar.YEAR);
        int endMonth = endTimeC.get(Calendar.MONTH);

        //相差的月份
        int monthCount = endYear*12+endMonth-(startYear*12+startMonth);

        for (int i = monthCount; i >= 0; i--) {
            List<Date> dateList = new LinkedList<>();
            if(monthCount == 0 ){ //起止时间没有跨月
                dateList.add(startTime);
                dateList.add(endTime);
            }
            else if(i==0){ //第一月
                dateList.add(startTime);

                Calendar instance = Calendar.getInstance();
                instance.setTime(startTime);
                instance.set(Calendar.DAY_OF_MONTH,instance.getActualMaximum(Calendar.DAY_OF_MONTH));
                instance.set(Calendar.HOUR_OF_DAY,instance.getActualMaximum(Calendar.HOUR_OF_DAY));
                instance.set(Calendar.MINUTE,instance.getActualMaximum(Calendar.MINUTE));
                instance.set(Calendar.SECOND,instance.getActualMaximum(Calendar.SECOND));
                dateList.add(instance.getTime());
            }
            else if(i== monthCount){ //尾月
                Calendar instance = Calendar.getInstance();
                instance.setTime(endTime);
                instance.set(Calendar.DAY_OF_MONTH,instance.getActualMinimum(Calendar.DAY_OF_MONTH));
                instance.set(Calendar.HOUR_OF_DAY,instance.getActualMinimum(Calendar.HOUR_OF_DAY));
                instance.set(Calendar.MINUTE,instance.getActualMinimum(Calendar.MINUTE));
                instance.set(Calendar.SECOND,instance.getActualMinimum(Calendar.SECOND));
                dateList.add(instance.getTime());

                dateList.add(endTime);
            }else{
                Calendar instance = Calendar.getInstance();
                instance.setTime(startTime);
                instance.add(Calendar.MONTH,i);
                instance.set(Calendar.DAY_OF_MONTH,instance.getActualMinimum(Calendar.DAY_OF_MONTH));
                instance.set(Calendar.HOUR_OF_DAY,instance.getActualMinimum(Calendar.HOUR_OF_DAY));
                instance.set(Calendar.MINUTE,instance.getActualMinimum(Calendar.MINUTE));
                instance.set(Calendar.SECOND,instance.getActualMinimum(Calendar.SECOND));
                dateList.add(instance.getTime());

                Calendar instance2 = Calendar.getInstance();
                instance2.setTime(startTime);
                instance2.add(Calendar.MONTH,i);
                instance2.set(Calendar.DAY_OF_MONTH,instance2.getActualMaximum(Calendar.DAY_OF_MONTH));
                instance2.set(Calendar.HOUR_OF_DAY,instance2.getActualMaximum(Calendar.HOUR_OF_DAY));
                instance2.set(Calendar.MINUTE,instance2.getActualMaximum(Calendar.MINUTE));
                instance2.set(Calendar.SECOND,instance2.getActualMaximum(Calendar.SECOND));
                dateList.add(instance2.getTime());

            }
            //result.put(DateUtil.YYYY_MM_TABLE.format(dateList.get(0)),dateList);
            result.put(ThreadLocalUtil.format(dateList.get(0),2),dateList);
        }
        return result;
    }

    /**
     *  查询使用时,需要处理 默认表查询的问题 倒序
@@ -352,24 +476,17 @@
    public static Map<String,List<Date>> getQueryTimeForSubTablesDesc(Date startTimeDate,Date endTimeDate) throws ParseException {
        //根据筛选的时间段,查询出符合要求的各分表记录数
        //首先,如果当前时间超过7月,默认表中只有本年度的;如果没超过7月,默认表还存在上一年度的记录
        Calendar instance = Calendar.getInstance();
        if(endTimeDate.compareTo(instance.getTime())>0){ //校验优化最大查询时间
            endTimeDate = instance.getTime();
        Calendar now = Calendar.getInstance();
        if(endTimeDate.compareTo(now.getTime())>0){ //校验优化最大查询时间
            endTimeDate = now.getTime();
        }
        int nowYear = instance.get(Calendar.YEAR);
        instance.add(Calendar.MONTH,-6);
        int beforeYear = instance.get(Calendar.YEAR);
        Date beforeYearTime = instance.getTime();
        instance.setTime(endTimeDate);
        int endTimeYear = instance.get(Calendar.YEAR);
        Calendar timeBefore7Month = Calendar.getInstance();
        timeBefore7Month.add(Calendar.MONTH,-7);

        Calendar startTime = Calendar.getInstance();
        startTime.setTime(startTimeDate);

        LinkedHashMap<String,List<Date>> yearTimeMap = (LinkedHashMap<String, List<Date>>) DateUtil.getYearListDesc(startTimeDate, endTimeDate);;
        LinkedHashMap<String,List<Date>> yearTimeMap = (LinkedHashMap<String, List<Date>>) DateUtil.getYearListDesc(startTimeDate, endTimeDate);
        Map<String,List<Date>> yearTimeDescMap = new LinkedHashMap<>();
        boolean existDefaultYear = false;
        if(nowYear == beforeYear){ //默认表只有本年度的(超过了半年,默认表记录全部只有本年度的,同时会生成了当前年度的分表)
        /*if(nowYear == beforeYear){ //默认表只有本年度的(超过了半年,默认表记录全部只有本年度的,同时会生成了当前年度的分表)
            //如果查询时间范围包含当前年度,则需要查询默认表
            if(startTime.get(Calendar.YEAR) >= nowYear && endTimeYear <= nowYear){
                //开始时间设置年度初始时间
@@ -382,7 +499,8 @@
                defaultTableStartTime.set(Calendar.SECOND,defaultTableStartTime.getActualMinimum(Calendar.SECOND));
                //终止时间设置为当前时间
                List<Date> defaultDateList = new LinkedList<>();
                defaultDateList.add(defaultTableStartTime.getTime());
                //defaultDateList.add(defaultTableStartTime.getTime());
                defaultDateList.add(startTimeDate);
                defaultDateList.add(endTimeDate);

                yearTimeMap.put("default",defaultDateList);
@@ -397,12 +515,20 @@
                //起始时间
                //终止时间
                List<Date> defaultDateList = new LinkedList<>();
                defaultDateList.add(beforeYearTime);
                defaultDateList.add(startTimeDate);
                defaultDateList.add(endTimeDate);

                yearTimeMap.put("default",defaultDateList);
                existDefaultYear = true;
            }
        }*/
        if(startTimeDate.before(now.getTime()) || endTimeDate.after(timeBefore7Month.getTime())){
            List<Date> defaultDateList = new LinkedList<>();
            defaultDateList.add(startTimeDate);
            defaultDateList.add(endTimeDate);

            yearTimeMap.put("default",defaultDateList);
            existDefaultYear = true;
        }
        //调整下顺序,将default调整到首位
        if(existDefaultYear){
@@ -419,15 +545,121 @@
        return yearTimeDescMap;
    }

    public static void main(String[] args) throws ParseException {
        Date d1 = YYYY_MM_DD_HH_MM_SS.parse("2020-12-25 14:12:22");
        Date d2 = YYYY_MM_DD_HH_MM_SS.parse("2022-12-29 09:12:22");
        Map<String, List<Date>> yearListForSubTables = getQueryTimeForSubTablesDesc(d1, d2);
        Set<String> strings = yearListForSubTables.keySet();
        Set<Map.Entry<String, List<Date>>> entries = yearListForSubTables.entrySet();
        for (Map.Entry<String, List<Date>> entry : entries) {
            System.out.println(entry);
    /**
     * 按年划分
     * 优化getQueryTimeForSubTablesDesc,待测试
     * 更新default表是否查询的逻辑,改||为&&
     *
     */
    public static Map<String,List<Date>> getQueryTimeForSubTablesDesc2(Date startTimeDate,Date endTimeDate) throws ParseException {
        //根据筛选的时间段,查询出符合要求的各分表记录数
        //首先,如果当前时间超过7月,默认表中只有本年度的;如果没超过7月,默认表还存在上一年度的记录
        Calendar now = Calendar.getInstance();
        if(endTimeDate.compareTo(now.getTime())>0){ //校验优化最大查询时间
            endTimeDate = now.getTime();
        }
        Calendar timeBefore7Month = Calendar.getInstance();
        timeBefore7Month.add(Calendar.MONTH,-7);

        LinkedHashMap<String,List<Date>> yearTimeMap = (LinkedHashMap<String, List<Date>>) DateUtil.getYearListDesc(startTimeDate, endTimeDate);
        Map<String,List<Date>> yearTimeDescMap = new LinkedHashMap<>();
        boolean existDefaultYear = false;
        //查询的开始时间 小于现在
        //查询的结束时间 大于 七个月前
        if(startTimeDate.before(now.getTime()) && endTimeDate.after(timeBefore7Month.getTime())){
            List<Date> defaultDateList = new LinkedList<>();
            defaultDateList.add(startTimeDate);
            defaultDateList.add(endTimeDate);

            yearTimeMap.put("default",defaultDateList);
            existDefaultYear = true;
        }
        //调整下顺序,将default调整到首位
        if(existDefaultYear){
            List<Date> defaultTimeList = yearTimeMap.get("default");
            yearTimeDescMap.put("default",defaultTimeList);
        }
        Set<String> yearSet = yearTimeMap.keySet();
        for (String year : yearSet) {
            if(!year.equals("default")){
                yearTimeDescMap.put(year,yearTimeMap.get(year));
            }
        }

        return yearTimeDescMap;
    }

    /**
     * 按月划分,时间倒序
     * 在原来按起止时间获取月份划分集合的基础上,加入实际子表逻辑,当前月内的,在default表
     * */
    public static Map<String,List<Date>> getQueryTimeForSubTablesByMonthDesc(Date startTimeDate,Date endTimeDate) throws ParseException {
        //根据筛选的时间段,查询出符合要求的各分表记录数
        //首先,如果当前时间超过7月,默认表中只有本年度的;如果没超过7月,默认表还存在上一年度的记录
        Calendar now = Calendar.getInstance();
        if(endTimeDate.compareTo(now.getTime())>0){ //校验优化最大查询时间
            endTimeDate = now.getTime();
        }
        LinkedHashMap<String,List<Date>> yearTimeMap = (LinkedHashMap<String, List<Date>>) DateUtil.getMonthListDesc(startTimeDate, endTimeDate);
        Map<String,List<Date>> yearTimeDescMap = new LinkedHashMap<>();
        boolean existDefaultYear = false;
        //查询的结束时间 在当月,则有default表
        //同时,抹去月份集合里的当月
        //if(DateUtil.YYYY_MM_TABLE.format(endTimeDate).equals(DateUtil.YYYY_MM_TABLE.format(now.getTime()))){
        if(ThreadLocalUtil.format(endTimeDate,2).equals(ThreadLocalUtil.format(now.getTime(),2))){
            List<Date> defaultDateList = new LinkedList<>();
            defaultDateList.add(startTimeDate);
            defaultDateList.add(endTimeDate);

            yearTimeMap.put("default",defaultDateList);
            existDefaultYear = true;

            //yearTimeMap.remove(DateUtil.YYYY_MM_TABLE.format(endTimeDate));
            yearTimeMap.remove(ThreadLocalUtil.format(endTimeDate,2));
        }
        //调整下顺序,将default调整到首位
        if(existDefaultYear){
            List<Date> defaultTimeList = yearTimeMap.get("default");
            yearTimeDescMap.put("default",defaultTimeList);
        }
        Set<String> yearSet = yearTimeMap.keySet();
        for (String year : yearSet) {
            if(!year.equals("default")){
                yearTimeDescMap.put(year,yearTimeMap.get(year));
            }
        }

        return yearTimeDescMap;
    }


    public static void main(String[] args) throws ParseException {
        //Date d1 = YYYY_MM_DD_HH_MM_SS.parse("2023-01-22 14:12:22");
        //Date d2 = YYYY_MM_DD_HH_MM_SS.parse("2023-08-24 16:45:22");
        //Map<String, List<Date>> monthListDesc = getQueryTimeForSubTablesByMonthDesc(d1, d2);
        //
        //Set<Map.Entry<String, List<Date>>> entries = monthListDesc.entrySet();
        //for (Map.Entry<String, List<Date>> entry : entries) {
        //    System.out.println(entry);
        //}
        //Map<String,String> map = new HashMap<>();
        //map.put("2022_01","");
        //map.put("2022_02","");
        //map.put("2022_10","");
        //map.put("2022_12","");
        //map.put("2021_03","");
        //map.put("2023_01","");
        //map.put("2023_05","");
        //map.put("2021_10","");
        //Set<String> keySet = map.keySet();
        //List<String> keySetDesc = keySet.stream().sorted(Comparator.comparing(String::hashCode).reversed()).collect(Collectors.toList());
        String t1 = "2024-01-25 12:22:29";
        String t2 = "2024-01-25 12:32:24";
        String t3 = "2024-01-25 12:42:26";
        Date maxTime = getMaxTime(t1, t2, t3);
        System.out.println(maxTime.toString());


    }

}