package com.whyc.util;
|
|
import java.text.ParseException;
|
import java.text.SimpleDateFormat;
|
import java.time.LocalDate;
|
import java.time.LocalDateTime;
|
import java.time.ZoneId;
|
import java.time.temporal.TemporalAdjusters;
|
import java.util.*;
|
|
/**
|
* @Description : 时间工具类
|
* @date 2020/10/15
|
**/
|
public class DateUtil {
|
|
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<>();
|
|
Calendar startTimeCalendar = Calendar.getInstance();
|
startTimeCalendar.setTime(startTimeDate);
|
|
Calendar endTimeCalendar = Calendar.getInstance();
|
endTimeCalendar.setTime(endTimeDate);
|
|
//按月份切分时段
|
int startY = startTimeCalendar.get(Calendar.YEAR);
|
int startM = startTimeCalendar.get(Calendar.MONTH)+1;
|
|
int endY = endTimeCalendar.get(Calendar.YEAR);
|
int endM = endTimeCalendar.get(Calendar.MONTH)+1;
|
|
int Y = endY - startY;
|
int len = Y*12+(endM-startM)+1;
|
|
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(ThreadLocalUtil.parse(startY+"-"+startM+"-01 00:00:00",1));
|
Date recordTime,recordTime1;
|
|
dateTemp.add(Calendar.MONTH,i);
|
recordTime = dateTemp.getTime();
|
|
int lastDay = dateTemp.getActualMaximum(Calendar.DAY_OF_MONTH);
|
dateTemp.set(Calendar.DAY_OF_MONTH,lastDay);
|
dateTemp.set(Calendar.HOUR_OF_DAY,23);
|
dateTemp.set(Calendar.MINUTE,59);
|
dateTemp.set(Calendar.SECOND,59);
|
recordTime1 = dateTemp.getTime();
|
|
if(i==0){
|
recordTime = startTimeDate;
|
}
|
if(i==len-1){
|
recordTime1 = endTimeDate;
|
}
|
SEList.add(recordTime);
|
SEList.add(recordTime1);
|
|
timeList.add(SEList);
|
}
|
return timeList;
|
}
|
|
/**
|
* 在分表的情况下使用,按年分表,查询需要切割查询使用
|
* <p>
|
* 根据传入的起止时间,按照年切割成不同时间段
|
*
|
* @param startTime 2021-01-01 10:00:00
|
* @param endTime 2023-05-01 10:10:10
|
* @return 示例[2021, 2022, 2023]
|
* 使用方法:
|
* 根据返回的第一个数据,如果存在表,则查询筛选条件为>=输入的起始时间;不存在则弃用输入的起始时间
|
* 根据返回的最后个数据,如果表存在,则查询筛选条件为<=输入的终止时间;不存在则弃用输入的终止时间
|
* 返回的非第一最后数据,查询全表
|
*/
|
public static Map<String,List<Date>> getYearList(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);
|
|
Calendar endTimeC = Calendar.getInstance();
|
endTimeC.setTime(endTime);
|
int endYear = endTimeC.get(Calendar.YEAR);
|
int yearSize = endYear - startYear + 1;
|
for (int i = startYear; i <= endYear; i++) {
|
List<Date> dateList = new LinkedList<>();
|
if(yearSize == 1){ //起止时间没有跨年
|
dateList.add(startTime);
|
dateList.add(endTime);
|
}
|
else if(i==startYear){ //第一年
|
dateList.add(startTime);
|
|
Calendar instance = Calendar.getInstance();
|
instance.set(Calendar.YEAR,i);
|
instance.set(Calendar.MONTH,instance.getActualMaximum(Calendar.MONTH));
|
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== endYear){ //尾年
|
Calendar instance = Calendar.getInstance();
|
instance.set(Calendar.YEAR,i);
|
instance.set(Calendar.MONTH,instance.getActualMinimum(Calendar.MONTH));
|
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.set(Calendar.YEAR,i);
|
instance.set(Calendar.MONTH,instance.getActualMinimum(Calendar.MONTH));
|
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.set(Calendar.YEAR,i);
|
instance2.set(Calendar.MONTH,instance2.getActualMaximum(Calendar.MONTH));
|
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(String.valueOf(i),dateList);
|
}
|
return result;
|
}
|
|
/**
|
*
|
* 在分表的情况下使用,按月分表,查询需要切割查询使用
|
*
|
* 根据传入的起止时间,按照月切割成不同时间段
|
* @param startTimeStr 2022-11-01 10:00:00
|
* @param endTimeStr 2023-05-01 10:10:10
|
* @return 示例[2022_12,2023_1,2023_2,2023_3,2023_4,2023_5] 这个返回对象格式 需要根据业务需要进行调整
|
* 使用方法:
|
* 根据返回的第一个数据,如果存在表,则查询筛选条件为>=输入的起始时间;不存在则弃用输入的起始时间
|
* 根据返回的最后个数据,如果表存在,则查询筛选条件为<=输入的终止时间;不存在则弃用输入的终止时间
|
* 返回的非第一最后数据,查询全表
|
*
|
*/
|
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 = ThreadLocalUtil.parse(startTimeStr,1);
|
startTimeCalendar.setTime(startTime);
|
|
Calendar endTimeCalendar = Calendar.getInstance();
|
//Date endTime = DateUtil.YYYY_MM_DD_HH_MM_SS.parse(endTimeStr);
|
Date endTime = ThreadLocalUtil.parse(endTimeStr,1);
|
endTimeCalendar.setTime(endTime);
|
|
/*String[] startTimeSplit = startTimeStr.split("-");
|
int startYear = Integer.parseInt(startTimeSplit[0]);
|
int startMonth = Integer.parseInt(startTimeSplit[1]);
|
|
String[] endTimeSplit = endTimeStr.split("-");
|
int endYear = Integer.parseInt(endTimeSplit[0]);
|
int endMonth = Integer.parseInt(endTimeSplit[1]);*/
|
|
List<String> yearMonthList = new LinkedList<>();
|
while (!startTimeCalendar.after(endTimeCalendar)){ //起始时间大于终止时间则停止
|
yearMonthList.add(startTimeCalendar.get(Calendar.YEAR)+"_"+(startTimeCalendar.get(Calendar.MONTH)+1));
|
startTimeCalendar.add(Calendar.MONTH,1);
|
}
|
return yearMonthList;
|
}
|
|
/**
|
* 查询使用时,需要处理 默认表查询的问题
|
* 示例:
|
* <p>
|
* {2020=[Fri Dec 25 14:12:22 CST 2020, Thu Dec 31 23:59:59 CST 2020]}
|
* {2021=[Fri Jan 01 00:00:00 CST 2021, Fri Dec 31 23:59:59 CST 2021]}
|
* {2022=[Sat Jan 01 00:00:00 CST 2022, Tue Nov 29 09:12:22 CST 2022]}
|
* 或
|
* {2020=[Fri Dec 25 14:12:22 CST 2020, Thu Dec 31 23:59:59 CST 2020]}
|
* {2021=[Fri Jan 01 00:00:00 CST 2021, Fri Dec 31 23:59:59 CST 2021]}
|
* {2022=[Sat Jan 01 00:00:00 CST 2022, Thu Dec 29 09:12:22 CST 2022]}
|
* {default=[Wed Dec 14 15:27:13 CST 2022, Thu Dec 29 09:12:22 CST 2022]}
|
* </p>
|
* key为数字,表示年度分表;default为默认表
|
* @param startTimeDate 起始时间
|
* @param endTimeDate 终止时间
|
* @return 需要查询的表及查询时间
|
* @throws ParseException
|
*/
|
public static Map<String,List<Date>> getQueryTimeForSubTables(Date startTimeDate,Date endTimeDate) throws ParseException {
|
//根据筛选的时间段,查询出符合要求的各分表记录数
|
//首先,如果当前时间超过7月,默认表中只有本年度的;如果没超过7月,默认表还存在上一年度的记录
|
Calendar instance = Calendar.getInstance();
|
if(endTimeDate.compareTo(instance.getTime())>0){ //校验优化最大查询时间
|
endTimeDate = instance.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 startTime = Calendar.getInstance();
|
startTime.setTime(startTimeDate);
|
|
Map<String,List<Date>> yearTimeMap = DateUtil.getYearList(startTimeDate, endTimeDate);;
|
if(nowYear == beforeYear){ //默认表只有本年度的(超过了半年,默认表记录全部只有本年度的,同时会生成了当前年度的分表)
|
//如果查询时间范围包含当前年度,则需要查询默认表
|
if(startTime.get(Calendar.YEAR) >= nowYear && endTimeYear <= nowYear){
|
//开始时间设置年度初始时间
|
Calendar defaultTableStartTime = Calendar.getInstance();
|
defaultTableStartTime.set(Calendar.YEAR,nowYear);
|
defaultTableStartTime.set(Calendar.MONTH,defaultTableStartTime.getActualMinimum(Calendar.MONTH));
|
defaultTableStartTime.set(Calendar.DAY_OF_MONTH,defaultTableStartTime.getActualMinimum(Calendar.DAY_OF_MONTH));
|
defaultTableStartTime.set(Calendar.HOUR_OF_DAY,defaultTableStartTime.getActualMinimum(Calendar.HOUR_OF_DAY));
|
defaultTableStartTime.set(Calendar.MINUTE,defaultTableStartTime.getActualMinimum(Calendar.MINUTE));
|
defaultTableStartTime.set(Calendar.SECOND,defaultTableStartTime.getActualMinimum(Calendar.SECOND));
|
//终止时间设置为当前时间
|
List<Date> defaultDateList = new LinkedList<>();
|
defaultDateList.add(defaultTableStartTime.getTime());
|
defaultDateList.add(endTimeDate);
|
|
yearTimeMap.put("default",defaultDateList);
|
|
}
|
|
}else{ //查询时间范围不在当前年度
|
//默认表中存在上一年度的记录.上一年的最早时间为beforeYearTime-上一年的年末
|
//判断查询时间范围是否包含默认表中上一年度的时间
|
if(instance.getTime().compareTo(beforeYearTime)>0){ //查询时间大于默认表中上一年度时间,说明查询记录也包含在默认表中
|
//起始时间
|
//终止时间
|
List<Date> defaultDateList = new LinkedList<>();
|
defaultDateList.add(beforeYearTime);
|
defaultDateList.add(endTimeDate);
|
|
yearTimeMap.put("default",defaultDateList);
|
}
|
}
|
return yearTimeMap;
|
}
|
|
/**
|
* 在分表的情况下使用,按年分表,查询需要切割查询使用 时间倒序
|
* <p>
|
* 根据传入的起止时间,按照年切割成不同时间段
|
*
|
* @param startTime 2021-01-01 10:00:00
|
* @param endTime 2023-05-01 10:10:10
|
* @return 示例
|
* 使用方法:
|
* 根据返回的第一个数据,如果存在表,则查询筛选条件为>=输入的起始时间;不存在则弃用输入的起始时间
|
* 根据返回的最后个数据,如果表存在,则查询筛选条件为<=输入的终止时间;不存在则弃用输入的终止时间
|
* 返回的非第一最后数据,查询全表
|
*/
|
public static Map<String,List<Date>> getYearListDesc(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);
|
|
Calendar endTimeC = Calendar.getInstance();
|
endTimeC.setTime(endTime);
|
int endYear = endTimeC.get(Calendar.YEAR);
|
int yearSize = endYear - startYear + 1;
|
for (int i = endYear; i >= startYear; i--) {
|
List<Date> dateList = new LinkedList<>();
|
if(yearSize == 1){ //起止时间没有跨年
|
dateList.add(startTime);
|
dateList.add(endTime);
|
}
|
else if(i==startYear){ //第一年
|
dateList.add(startTime);
|
|
Calendar instance = Calendar.getInstance();
|
instance.set(Calendar.YEAR,i);
|
instance.set(Calendar.MONTH,instance.getActualMaximum(Calendar.MONTH));
|
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== endYear){ //尾年
|
Calendar instance = Calendar.getInstance();
|
instance.set(Calendar.YEAR,i);
|
instance.set(Calendar.MONTH,instance.getActualMinimum(Calendar.MONTH));
|
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.set(Calendar.YEAR,i);
|
instance.set(Calendar.MONTH,instance.getActualMinimum(Calendar.MONTH));
|
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.set(Calendar.YEAR,i);
|
instance2.set(Calendar.MONTH,instance2.getActualMaximum(Calendar.MONTH));
|
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(String.valueOf(i),dateList);
|
}
|
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;
|
}
|
|
/**
|
* 查询使用时,需要处理 默认表查询的问题 倒序
|
* 示例:
|
* <p>
|
* {2020=[Fri Dec 25 14:12:22 CST 2020, Thu Dec 31 23:59:59 CST 2020]}
|
* {2021=[Fri Jan 01 00:00:00 CST 2021, Fri Dec 31 23:59:59 CST 2021]}
|
* {2022=[Sat Jan 01 00:00:00 CST 2022, Tue Nov 29 09:12:22 CST 2022]}
|
* 或
|
* {2020=[Fri Dec 25 14:12:22 CST 2020, Thu Dec 31 23:59:59 CST 2020]}
|
* {2021=[Fri Jan 01 00:00:00 CST 2021, Fri Dec 31 23:59:59 CST 2021]}
|
* {2022=[Sat Jan 01 00:00:00 CST 2022, Thu Dec 29 09:12:22 CST 2022]}
|
* {default=[Wed Dec 14 15:27:13 CST 2022, Thu Dec 29 09:12:22 CST 2022]}
|
* </p>
|
* key为数字,表示年度分表;default为默认表
|
* @param startTimeDate 起始时间
|
* @param endTimeDate 终止时间
|
* @return 需要查询的表及查询时间
|
* @throws ParseException
|
*/
|
public static Map<String,List<Date>> getQueryTimeForSubTablesDesc(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(nowYear == beforeYear){ //默认表只有本年度的(超过了半年,默认表记录全部只有本年度的,同时会生成了当前年度的分表)
|
//如果查询时间范围包含当前年度,则需要查询默认表
|
if(startTime.get(Calendar.YEAR) >= nowYear && endTimeYear <= nowYear){
|
//开始时间设置年度初始时间
|
Calendar defaultTableStartTime = Calendar.getInstance();
|
defaultTableStartTime.set(Calendar.YEAR,nowYear);
|
defaultTableStartTime.set(Calendar.MONTH,defaultTableStartTime.getActualMinimum(Calendar.MONTH));
|
defaultTableStartTime.set(Calendar.DAY_OF_MONTH,defaultTableStartTime.getActualMinimum(Calendar.DAY_OF_MONTH));
|
defaultTableStartTime.set(Calendar.HOUR_OF_DAY,defaultTableStartTime.getActualMinimum(Calendar.HOUR_OF_DAY));
|
defaultTableStartTime.set(Calendar.MINUTE,defaultTableStartTime.getActualMinimum(Calendar.MINUTE));
|
defaultTableStartTime.set(Calendar.SECOND,defaultTableStartTime.getActualMinimum(Calendar.SECOND));
|
//终止时间设置为当前时间
|
List<Date> defaultDateList = new LinkedList<>();
|
//defaultDateList.add(defaultTableStartTime.getTime());
|
defaultDateList.add(startTimeDate);
|
defaultDateList.add(endTimeDate);
|
|
yearTimeMap.put("default",defaultDateList);
|
existDefaultYear = true;
|
|
}
|
|
}else{ //查询时间范围不在当前年度
|
//默认表中存在上一年度的记录.上一年的最早时间为beforeYearTime-上一年的年末
|
//判断查询时间范围是否包含默认表中上一年度的时间
|
if(instance.getTime().compareTo(beforeYearTime)>0){ //查询时间大于默认表中上一年度时间,说明查询记录也包含在默认表中
|
//起始时间
|
//终止时间
|
List<Date> defaultDateList = new LinkedList<>();
|
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){
|
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;
|
}
|
|
/**
|
* 查询使用时,需要处理 默认表查询的问题 倒序
|
* 示例:
|
* <p>
|
* {2020=[Fri Dec 25 14:12:22 CST 2020, Thu Dec 31 23:59:59 CST 2020]}
|
* {2021=[Fri Jan 01 00:00:00 CST 2021, Fri Dec 31 23:59:59 CST 2021]}
|
* {2022=[Sat Jan 01 00:00:00 CST 2022, Tue Nov 29 09:12:22 CST 2022]}
|
* 或
|
* {2020=[Fri Dec 25 14:12:22 CST 2020, Thu Dec 31 23:59:59 CST 2020]}
|
* {2021=[Fri Jan 01 00:00:00 CST 2021, Fri Dec 31 23:59:59 CST 2021]}
|
* {2022=[Sat Jan 01 00:00:00 CST 2022, Thu Dec 29 09:12:22 CST 2022]}
|
* {default=[Wed Dec 14 15:27:13 CST 2022, Thu Dec 29 09:12:22 CST 2022]}
|
* </p>
|
* key为数字,表示年度分表;default为默认表
|
* @param startTimeDate 起始时间
|
* @param endTimeDate 终止时间
|
* @return 需要查询的表及查询时间
|
* @throws ParseException
|
*/
|
public static Map<String,List<Date>> getQueryTimeForSubTablesDescWithOutDefault(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);
|
return yearTimeMap;
|
}
|
|
/**
|
* 按年划分
|
* 优化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;
|
}
|
|
/**
|
* 按月划分且,不存在默认表,都是分表
|
* @param startTimeDate
|
* @param endTimeDate
|
* @return
|
* @throws ParseException
|
*/
|
public static Map<String,List<Date>> getQueryTimeForSubTablesByMonthDesc2(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;
|
//查询的结束时间
|
//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);
|
}
|
//调整下顺序,将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 LocalDateTime getStartOfYear() {
|
LocalDateTime now = LocalDateTime.now();
|
return now.with(TemporalAdjusters.firstDayOfYear()).with(LocalDateTime.MIN.toLocalTime());
|
}
|
|
/**
|
* 获取本季度的开始时间
|
*/
|
public static LocalDateTime getStartOfQuarter() {
|
LocalDateTime now = LocalDateTime.now();
|
int currentMonthValue = now.getMonthValue();
|
// 计算当前季度的第一个月
|
int quarterStartMonth = 3 * ((currentMonthValue - 1) / 3) + 1;
|
return LocalDate.of(now.getYear(), quarterStartMonth, 1).atStartOfDay();
|
}
|
|
/**
|
* 获取本月的开始时间
|
*/
|
public static LocalDateTime getStartOfMonth() {
|
LocalDateTime now = LocalDateTime.now();
|
return now.with(TemporalAdjusters.firstDayOfMonth()).with(LocalDateTime.MIN.toLocalTime());
|
}
|
|
/**
|
* Date 转 LocalDateTime 工具方法
|
*/
|
public static LocalDateTime convertToLocalDateTime(java.util.Date date) {
|
return date.toInstant()
|
.atZone(ZoneId.systemDefault())
|
.toLocalDateTime();
|
}
|
|
/**
|
* LocalDateTime转 Date
|
*/
|
public static Date convertToDate(LocalDateTime localDateTime) {
|
return Date.from(localDateTime.atZone(ZoneId.systemDefault()).toInstant());
|
}
|
}
|
