pbn32vpxk
/
tamguo
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/后台运营yy' into 后台运营yy

Browse Source
后台运营yy
yangyang 8 months ago
parent ea8515aebb fbe7ae15a0
commit c1c89ff9d8
2 changed files with 632 additions and 366 deletions
Show Stats Download Patch File Download Diff File

427
tamguo-common/src/main/java/com/tamguo/common/utils/DateUtil.java
Unescape View File

@ -6,45 +6,60 @@ import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
// 将DateUtil类定义为final，意味着该类不能被继承，通常用于封装一些常用的日期处理相关的静态方法，方便在项目中统一进行日期操作，避免被其他类继承后修改其行为逻辑。
public final class DateUtil {
/**
* 正常日期格式化模板.
*/
// 定义一个SimpleDateFormat对象，用于将日期格式化为"yyyy-MM-dd HH:mm:ss"的字符串形式，方便后续对日期时间进行统一的格式化输出，常用于展示包含详细时间信息的日期格式。
private static final SimpleDateFormat NORMAL_DATE_FORMAT = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
// 定义用于将日期格式化为"yyyy-MM-dd"字符串形式的SimpleDateFormat对象，主要用于处理只涉及年月日的日期格式需求，例如在按天统计数据等场景中使用。
private static final SimpleDateFormat NORMAL_DATE_FORMAT_YY_MM_DD = new SimpleDateFormat("yyyy-MM-dd");
// 定义用于将日期格式化为"yyyyMMdd"这种紧凑格式字符串形式的SimpleDateFormat对象，常用于需要简洁表示日期的场景，例如文件名中包含日期、数据库中以紧凑格式存储日期等情况，方便进行日期的比较、排序等操作。
private static final SimpleDateFormat NORMAL_DATE_FORMAT_YY_MM_DD_ = new SimpleDateFormat("yyyyMMdd");
// 定义用于将日期格式化为"yyyyMMddHHmmss"这种包含年月日时分秒的紧凑格式字符串形式的SimpleDateFormat对象，适用于需要精确记录时间戳的场景，比如日志记录、订单生成时间记录等，方便准确追溯具体时间点。
private static final SimpleDateFormat NORMAL_DATE_FORMAT_YYMMDDHHMISS = new SimpleDateFormat("yyyyMMddHHmmss");
/**
* 正常日期格式化.
* 将距离1970年1月1日的秒数转换为"yyyy-MM-dd"格式的日期字符串表示形式。
* 其实现逻辑是先根据传入的秒数创建对应的Date对象（通过乘以1000将秒数转换为毫秒数来构造Date对象，因为Date类的构造函数接收的是毫秒数参数），
* 然后使用预定义的格式化器NORMAL_DATE_FORMAT_YY_MM_DD进行格式化操作，最终返回格式化后的日期字符串，例如传入对应2011-11-24的秒数，会返回"2011-11-24"这样的字符串。
*
* @param date
* 日期距离1970年1月1日秒数
* @return 格式化后的日期(2011-11-24)
* @param date 日期距离1970年1月1日的秒数，例如传入从某个时间点到1970年1月1日0时0分0秒的时间间隔秒数。
* @return 格式化后的日期字符串，格式为"yyyy-MM-dd"，像"2011-11-24"这样的形式。
*/
public static String dateFormatYYMMDD(long date) {
return NORMAL_DATE_FORMAT_YY_MM_DD.format(new Date(date * 1000));
}
/**
* 正常日期格式化.
* 获取当前日期的字符串表示形式，格式为"yyyyMMdd"。
* 该方法通过获取当前系统时间对应的Date对象，然后利用预定义的格式化器NORMAL_DATE_FORMAT_YY_MM_DD_将其格式化为紧凑的年月日数字字符串，例如在2024年12月15日调用该方法，会返回"20241215"这样的字符串，并返回该格式化后的字符串。
*
* @param date
* 日期距离1970年1月1日秒数
* @return 格式化后的日期(20111124)
* @return 格式化后的当前日期字符串，格式为"yyyyMMdd"。
*/
public static String getCurrentDateStr() {
return NORMAL_DATE_FORMAT_YY_MM_DD_.format(new Date());
}
/**
* 获取当前日期的字符串表示形式，格式为"yyyy-MM-dd"。
* 同样是基于当前系统时间创建Date对象，再使用对应的格式化器NORMAL_DATE_FORMAT_YY_MM_DD将其转换为常见的年月日格式的日期字符串，如在2024年12月15日调用，会返回"2024-12-15"这样的字符串，最后返回该字符串。
*
* @return 格式化后的当前日期字符串，格式为"yyyy-MM-dd"。
*/
public static String getCurrentDateYYYYMMDDStr() {
return NORMAL_DATE_FORMAT_YY_MM_DD.format(new Date());
}
/**
* 获取当前日期的下一天的日期字符串表示形式，格式为"yyyy-MM-dd"。
* 首先通过Calendar.getInstance()获取一个Calendar实例，代表当前时间。然后尝试将当前日期（通过调用getCurrentTime方法获取当前日期字符串并解析为Date对象）设置到该Calendar实例中。
* 接着使用Calendar的add方法给日期增加一天（Calendar.DATE表示按天进行日期增减操作），最后再将增加后的日期使用NORMAL_DATE_FORMAT_YY_MM_DD格式化器格式化为指定格式的字符串并返回。
* 如果在解析当前日期字符串为Date对象时出现ParseException异常，会打印异常堆栈信息，并返回null，表示获取下一天日期字符串失败。
*
* @return 格式化后的下一天日期字符串，格式为"yyyy-MM-dd"，若出现异常则返回null。
*/
public static String getNextDayYYYYMMDDStr() {
Calendar cal = Calendar.getInstance();
try {
@ -57,6 +72,13 @@ public final class DateUtil {
return null;
}
/**
* 获取当前日期的下一天对应的时间戳（距离1970年1月1日的毫秒数）。
* 实现逻辑与获取下一天日期字符串类似，先获取当前日期对应的Date对象并解析为"yyyy-MM-dd"格式，将其设置到Calendar实例中，然后通过Calendar的add方法增加一天，最后返回增加后日期对应的时间戳（通过getTimeInMillis方法获取）。
* 若在解析日期字符串为Date对象过程中出现ParseException异常，会打印异常堆栈信息，并返回0l，表示获取时间戳失败。
*
* @return 当前日期下一天对应的时间戳（距离1970年1月1日的毫秒数），若出现异常则返回0l。
*/
public static long getNextDayYYYYMMDDLong() {
Calendar cal = Calendar.getInstance();
try {
@ -69,6 +91,63 @@ public final class DateUtil {
return 0l;
}
/**
* 将距离1970年1月1日的秒数转换为"yyyy-MM-dd HH:mm:ss"格式的日期字符串表示形式。
* 先把传入的秒数乘以1000转换为毫秒数，以此创建对应的Date对象，再使用预定义的格式化器NORMAL_DATE_FORMAT将该Date对象格式化为包含年月日时分秒的完整日期时间字符串，例如传入对应2011-11-24 16:46:38的秒数，会返回"2011-11-24 16:46:38"这样的字符串，最后返回格式化后的字符串。
*
* @param date 日期距离1970年1月1日的秒数，例如从某个时间点到1970年1月1日0时0分0秒的时间间隔秒数。
* @return 格式化后的日期字符串，格式为"yyyy-MM-dd HH:mm:ss"。
*/
public static String dateFormat(long date) {
return NORMAL_DATE_FORMAT.format(new Date(date * 1000));
}
/**
* 将距离1970年1月1日的秒数转换为"yyyy-MM-dd"格式的日期字符串表示形式。
* 与前面类似，先根据传入的秒数创建Date对象（秒数转换为毫秒数），然后使用对应的格式化器NORMAL_DATE_FORMAT_YY_MM_DD进行格式化，得到形如"2011-11-24"的日期字符串并返回。
*
* @param date 日期距离1970年1月1日的秒数，例如某个时间点到1970年1月1日0时0分0秒的时间间隔秒数。
* @return 格式化后的日期字符串，格式为"yyyy-MM-dd"。
*/
public static String dateFormatYYYYMMDD(long date) {
return NORMAL_DATE_FORMAT_YY_MM_DD.format(new Date(date * 1000));
}
/**
* 将Date对象格式化为"yyyy-MM-dd HH:mm:ss"格式的日期字符串表示形式。
* 直接使用预定义的格式化器NORMAL_DATE_FORMAT对传入的Date对象进行格式化操作，将其转换为包含完整日期时间信息的字符串，例如传入一个代表2011-11-24 16:46:38的Date对象，会返回"2011-11-24 16:46:38"这样的字符串，并返回该格式化后的字符串。
*
* @param date 要格式化的Date对象，代表一个具体的日期和时间点。
* @return 格式化后的日期字符串，格式为"yyyy-MM-dd HH:mm:ss"。
*/
public static String dateFormat(Date date) {
return NORMAL_DATE_FORMAT.format(date);
}
/**
* 将Date对象格式化为"yyyyMMddHHmmss"格式的日期字符串表示形式，即紧凑的包含年月日时分秒的数字字符串。
* 通过使用对应的格式化器NORMAL_DATE_FORMAT_YYMMDDHHMISS对传入的Date对象进行格式化转换，生成类似"20241215123000"这样的字符串并返回。
*
* @param date 要格式化的Date对象，包含具体的日期和时间信息。
* @return 格式化后的日期字符串，格式为"yyyyMMddHHmmss"。
*/
public static String dateFormathhmmss(Date date) {
return NORMAL_DATE_FORMAT_YYMMDDHHMISS.format(date);
}
/**
* 将Date对象格式化为"yyyyMMdd"格式的日期字符串表示形式，即紧凑的年月日数字字符串。
* 借助对应的格式化器NORMAL_DATE_FORMAT_YY_MM_DD_把传入的Date对象转换为指定格式的字符串，例如传入一个代表2024年12月15日的Date对象，会返回"20241215"这样的字符串，并返回该格式化后的字符串。
*
* @param date 要格式化的Date对象，代表一个具体的日期。
* @return 格式化后的日期字符串，格式为"yyyyMMdd"。
*/
public static String dateFormatYYYYMMDD(Date date) {
return NORMAL_DATE_FORMAT_YY_MM_DD_.format(date);
}
// 以下代码重复了上述部分注释内容，可能是代码编写过程中的粘贴重复问题，若实际应用中无需重复，可根据实际情况进行适当清理优化。不过按照要求先为你完整添加注释如下：
/**
* 正常日期格式化.
*
@ -127,49 +206,58 @@ public final class DateUtil {
return NORMAL_DATE_FORMAT_YY_MM_DD_.format(date);
}
}
/**
* 正常日期格式化.
* 获取当前日期的字符串表示形式，格式为"yyyy-MM-dd"。
* 该方法通过创建一个代表当前系统时间的`Date`对象，然后利用预定义的`NORMAL_DATE_FORMAT_YY_MM_DD`格式化器将其格式化为常见的年月日格式的日期字符串，例如在2024年12月15日调用该方法，会返回"2024-12-15"这样的字符串，并返回该格式化后的字符串。
*
* @param date
* 日期距离1970年1月1日秒数
* @return 格式化后的日期(2011-11-24 16:46:38)
* @return 格式化后的当前日期字符串，格式为"yyyy-MM-dd"。
*/
public static String getCurrentTime() {
return NORMAL_DATE_FORMAT_YY_MM_DD.format(new Date());
}
/**
* 获取当前距1970年1月1日秒数.
* 获取当前时间距离1970年1月1日的秒数，也就是获取当前时间对应的时间戳并转换为秒数。
* 通过调用`new Date().getTime()`获取当前系统时间对应的`Date`对象距离1970年1月1日的毫秒数，然后将其除以1000，换算为秒数并返回。
*
* @return 当前距1970年1月1日秒数.
* @return 当前距1970年1月1日的秒数。
*/
public static Long getTime() {
return new Date().getTime() / 1000;
}
/**
* 获取当前距1970年1月1日秒数.
* 获取距离当前时间最近一周的时间距离1970年1月1日的秒数。
* 先获取当前系统时间对应的`Date`对象距离1970年1月1日的毫秒数（通过`new Date().getTime()`获取），然后减去一周对应的秒数（一周有7天，每天24小时，每小时60分钟，每分钟60秒，即7 * 24 * 60 * 60秒），得到距离当前一周前的时间对应的秒数并返回。
*
* @return 获取最近一周的秒数.
* @return 获取最近一周的秒数，即距离1970年1月1日的秒数。
*/
public static long getLastWeekTime() {
return new Date().getTime() / 1000 - 7 * 24 * 60 * 60;
}
/**
* 获取当前距1970年1月1日秒数.
* 获取距离当前时间最近一个月的时间距离1970年1月1日的秒数。
* 这里以30天作为一个月的近似天数，先获取当前系统时间对应的`Date`对象距离1970年1月1日的毫秒数（通过`new Date().getTime()`获取），再减去一个月对应的秒数（30 * 24 * 60 * 60秒），从而得到距离当前一个月前的时间对应的秒数并返回。
*
* @return 获取最近一个月的秒数.
* @return 获取最近一个月的秒数，也就是距离1970年1月1日的秒数。
*/
public static long getLastMonthTime() {
return new Date().getTime() / 1000 - 30 * 24 * 60 * 60;
}
/**
* 获取某年某月第一天.
* 获取指定年份和月份的第一天的时间距离1970年1月1日的秒数，日期格式如"2011-12-31 00:00:00"。
* 首先通过`Calendar.getInstance()`获取一个`Calendar`实例，然后使用它的`set`方法分别设置年份（通过将传入的年份字符串转换为整数来设置）和月份（需要注意月份是从0开始计数，所以传入的月份值要减1）。
* 接着将日期设置为该月的第一天（通过调用`cal.getMinimum(Calendar.DATE)`获取该月最小的日期值来设置），再将得到的日期使用`NORMAL_DATE_FORMAT_YY_MM_DD`格式化器格式化为字符串，并在后面拼接上" 00:00:00"表示该天的起始时间。
* 最后通过`parseDate`方法将拼接后的字符串解析为`Date`对象，获取其对应的时间戳（毫秒数）并除以1000转换为秒数后返回。
* 如果在解析日期字符串过程中出现异常，会打印异常堆栈信息，并返回相应的时间戳（可能是错误的）。
*
* @return 日期格式如：2011-12-31 00:00:00 .
* @param year 表示年份的字符串，例如"2011"。
* @param month 表示月份的字符串，例如"12"，取值范围是1 - 12。
* @return 该年该月第一天距离1970年1月1日的秒数，格式如"2011-12-31 00:00:00"对应的秒数。
*/
public static long getFirstDayOfMonth(String year, String month) {
Calendar cal = Calendar.getInstance();
@ -180,9 +268,15 @@ public final class DateUtil {
}
/**
* 获取某年某月最后一天.
* 获取指定年份和月份的最后一天的时间距离1970年1月1日的秒数，日期格式如"2011-12-31 23:59:59"。
* 先获取`Calendar`实例并设置指定的年份和月份（同样月份要减1进行设置），然后将日期先设置为该月的第一天（将日期设置为1），接着通过`cal.getActualMaximum(Calendar.DAY_OF_MONTH)`获取该月实际的最大天数，再将日期设置为该月的最后一天（将获取到的最大天数设置为日期值）。
* 之后把得到的日期使用`NORMAL_DATE_FORMAT_YY_MM_DD`格式化器格式化为字符串，并在后面拼接上" 23:59:59"表示该天的结束时间。
* 最后通过`parseDate`方法将拼接后的字符串解析为`Date`对象，获取其对应的时间戳（毫秒数）并除以1000转换为秒数后返回。
* 若在解析日期时出现异常，会打印异常堆栈信息，并返回相应的时间戳（可能是错误的）。
*
* @return 日期格式如：2011-12-31 23:59:59 .
* @param year 表示年份的字符串，例如"2011"。
* @param month 表示月份的字符串，例如"12"，取值范围是1 - 12。
* @return 该年该月最后一天距离1970年1月1日的秒数，格式如"2011-12-31 23:59:59"对应的秒数。
*/
public static long getLastDayOfMonth(String year, String month) {
Calendar cal = Calendar.getInstance();
@ -195,11 +289,12 @@ public final class DateUtil {
}
/**
* 解析字符串为Date.
* 解析给定的日期字符串为`Date`类型对象。
* 使用定义好的格式为"yyyy-MM-dd HH:mm:ss"的`NORMAL_DATE_FORMAT`对象来尝试解析传入的日期字符串。如果解析成功，则返回对应的`Date`对象；若解析过程中出现异常（例如日期字符串格式不符合要求等情况），
* 会打印异常堆栈信息，并返回`null`，表示解析失败。
*
* @param dateString
* 日期字符串 例如 2011-12-17 17:41:18.843 CST.
* @return 解析后的日期类型.若解析出错则返回null
* @param dateString 日期字符串，例如 "2011-12-17 17:41:18.843 CST"，需要符合"yyyy-MM-dd HH:mm:ss"的格式要求（或者至少能被该格式解析），否则会解析出错。
* @return 解析后的日期类型对象，如果解析出错则返回`null`。
*/
public static Date parseDate(String dateStr) {
try {
@ -211,28 +306,37 @@ public final class DateUtil {
}
/**
* 正常日期格式化.
* 将给定的日期字符串解析为距离1970年1月1日的秒数。
* 首先调用`parseDate`方法将传入的日期字符串解析为`Date`对象，然后获取该`Date`对象对应的时间戳（毫秒数，通过`getTime`方法获取），最后将毫秒数除以1000转换为秒数并返回。
* 如果`parseDate`方法解析日期字符串失败（返回`null`），此处可能会出现空指针异常等问题（取决于后续使用场景）。
*
* @param date
* 日期距离1970年1月1日秒数
* @return 格式化后的日期()
* @param date 表示日期的字符串，例如 "2011-12-17 17:41:18"，需要能被`parseDate`方法成功解析为`Date`对象的格式要求。
* @return 解析后的日期对应的距离1970年1月1日的秒数。
*/
public static long parseLong(String date) {
return parseDate(date).getTime() / 1000;
}
/**
* 日期格式转换为字符串格式
* 将`Date`类型的日期对象转换为"yyyy-MM-dd"格式的字符串表示形式。
* 通过使用预定义的`NORMAL_DATE_FORMAT_YY_MM_DD`格式化器对传入的`Date`对象进行格式化操作，将其转换为常见的年月日格式的日期字符串，例如传入一个代表2024年12月15日的`Date`对象，会返回"2024-12-15"这样的字符串，并返回该格式化后的字符串。
*
* @param date
* @return 格式化后的日期字符串
* @param date 要转换的`Date`对象，代表一个具体的日期。
* @return 格式化后的日期字符串，格式为"yyyy-MM-dd"。
*/
public static String parseString(Date date) {
return NORMAL_DATE_FORMAT_YY_MM_DD.format(date);
}
/**
* 获取给定日期的前一天的起始时间（00:00:00）对应的距离1970年1月1日的秒数。
* 首先通过`Calendar.getInstance()`获取一个`Calendar`实例，然后将传入的日期（以毫秒数表示，先乘以1000转换为毫秒数后设置到`Calendar`实例中）对应的时间设置进去。
* 接着使用`Calendar`的`add`方法将日期往前推一天（通过`add(Calendar.DAY_OF_YEAR, -1)`操作），再将该日期的时间部分设置为00:00:00（分别设置小时、分钟、秒、毫秒都为0），
* 最后获取调整后的日期对应的时间戳（毫秒数）并除以1000转换为秒数后返回，得到的就是前一天起始时间对应的秒数。
*
* @param daytime 表示某个日期的时间，以距离1970年1月1日的秒数传入，例如传入代表2024-12-15这一天的秒数。
* @return 给定日期的前一天的起始时间（00:00:00）对应的距离1970年1月1日的秒数。
*/
public static long getLastDayStartTime(long daytime) {
Calendar todayStart = Calendar.getInstance();
todayStart.setTimeInMillis(daytime * 1000);
@ -244,6 +348,15 @@ public final class DateUtil {
return todayStart.getTimeInMillis() / 1000;
}
/**
* 获取给定日期的前一天的结束时间（23:59:59.999）对应的距离1970年1月1日的秒数。
* 先通过`Calendar.getInstance()`获取一个`Calendar`实例，把传入的日期（先将秒数乘以1000转换为毫秒数后设置到`Calendar`实例中）对应的时间设置进去。
* 接着使用`Calendar`的`add`方法将日期往前推一天（通过`add(Calendar.DAY_OF_YEAR, -1)`操作），然后将该日期的时间部分设置为23:59:59.999（分别设置小时为23、分钟为59、秒为59、毫秒为999），
* 最后获取调整后的日期对应的时间戳（毫秒数）并除以1000转换为秒数后返回，这样就得到了前一天结束时间对应的秒数。
*
* @param daytime 表示某个日期的时间，以距离1970年1月1日的秒数传入，例如传入代表2024-12-15这一天的秒数。
* @return 给定日期的前一天的结束时间（23:59:59.999）对应的距离1970年1月1日的秒数。
*/
public static long getLastDayEndTime(long daytime) {
Calendar todayEnd = Calendar.getInstance();
todayEnd.setTimeInMillis(daytime * 1000);
@ -255,6 +368,15 @@ public final class DateUtil {
return todayEnd.getTimeInMillis() / 1000;
}
/**
* 将给定的时间（以距离1970年1月1日的秒数表示）调整为与当前时间相同的小时、分钟、秒和毫秒部分，并返回调整后的时间对应的距离1970年1月1日的秒数。
* 首先获取两个`Calendar`实例，一个用于设置传入的时间（将秒数乘以1000转换为毫秒数后设置进去），另一个代表当前时间（通过`Calendar.getInstance()`获取）。
* 然后将传入时间对应的`Calendar`实例中的小时、分钟、秒、毫秒部分设置为与当前时间对应的`Calendar`实例相同的值，
* 最后获取调整后的时间对应的时间戳（毫秒数）并除以1000转换为秒数后返回，得到的就是调整后的时间对应的秒数。
*
* @param time 表示要调整的时间，以距离1970年1月1日的秒数传入，例如传入某个历史时间对应的秒数。
* @return 调整后的时间对应的距离1970年1月1日的秒数，其小时、分钟、秒和毫秒部分与当前时间相同。
*/
public static long getTime(long time) {
Calendar timeCalendar = Calendar.getInstance();
Calendar nowCalendar = Calendar.getInstance();
@ -266,10 +388,20 @@ public final class DateUtil {
return timeCalendar.getTimeInMillis() / 1000;
}
/**
* 获取给定日期的起始时间（当天的00:00:00）对应的距离1970年1月1日的秒数。
* 首先通过 `Calendar.getInstance()` 获取一个 `Calendar` 实例，它代表当前的时间状态。
* 接着将传入的以秒数表示的日期（先将秒数乘以1000转换为毫秒数）设置到这个 `Calendar` 实例中，以此确定要操作的具体日期时间。
* 然后将该 `Calendar` 实例中的时间部分设置为当天的起始时间，即分别把小时设置为0（`Calendar.HOUR_OF_DAY`）、分钟设置为0（`Calendar.MINUTE`）、秒设置为0（`Calendar.SECOND`）以及毫秒设置为0（`Calendar.MILLISECOND`）。
* 最后获取调整后的这个代表起始时间的日期对应的时间戳（毫秒数，通过 `getTime().getTime()` 获取），再将其除以1000转换为秒数并返回。
*
* @param daytime 表示某个日期的时间，以距离1970年1月1日的秒数传入，例如传入代表2024-12-15这一天的秒数。
* @return 给定日期的起始时间（00:00:00）对应的距离1970年1月1日的秒数。
*/
public static long getStartTime(long daytime) {
Calendar todayStart = Calendar.getInstance();
todayStart.setTimeInMillis(daytime * 1000);
// todayStart.add(Calendar.DAY_OF_YEAR, -1);
// todayStart.add(Calendar.DAY_OF_YEAR, -1); 此处代码被注释掉，原功能可能是将日期往前推一天，当前逻辑是获取传入日期当天的起始时间
todayStart.set(Calendar.HOUR_OF_DAY, 0);
todayStart.set(Calendar.MINUTE, 0);
todayStart.set(Calendar.SECOND, 0);
@ -277,10 +409,20 @@ public final class DateUtil {
return todayStart.getTime().getTime() / 1000;
}
/**
* 获取给定日期的结束时间（当天的23:59:59.999）对应的距离1970年1月1日的秒数。
* 先通过 `Calendar.getInstance()` 获取一个 `Calendar` 实例，用于表示当前时间状态。
* 把传入的以秒数表示的日期（先乘以1000转换为毫秒数）设置到这个 `Calendar` 实例中，以明确要处理的具体日期时间。
* 接着将该 `Calendar` 实例中的时间部分设置为当天的结束时间，也就是分别把小时设置为23（`Calendar.HOUR_OF_DAY`）、分钟设置为59（`Calendar.MINUTE`）、秒设置为59（`Calendar.SECOND`）以及毫秒设置为999（`Calendar.MILLISECOND`）。
* 最后获取调整后的代表结束时间的日期对应的时间戳（毫秒数，通过 `getTimeInMillis()` 获取），再除以1000转换为秒数后返回。
*
* @param daytime 表示某个日期的时间，以距离1970年1月1日的秒数传入，例如传入代表2024-12-15这一天的秒数。
* @return 给定日期的结束时间（23:59:59.999）对应的距离1970年1月1日的秒数。
*/
public static long getEndTime(long daytime) {
Calendar todayEnd = Calendar.getInstance();
todayEnd.setTimeInMillis(daytime * 1000);
// todayEnd.add(Calendar.DAY_OF_YEAR, -1);
// todayEnd.add(Calendar.DAY_OF_YEAR, -1); 此处代码被注释掉，原功能可能是将日期往前推一天，当前逻辑是获取传入日期当天的结束时间
todayEnd.set(Calendar.HOUR_OF_DAY, 23);
todayEnd.set(Calendar.MINUTE, 59);
todayEnd.set(Calendar.SECOND, 59);
@ -289,11 +431,16 @@ public final class DateUtil {
}
/**
* 比较俩日期是否是同一天
* 比较两个日期是否是同一天。
* 首先分别获取两个日期对应的 `Calendar` 实例，通过 `Calendar.getInstance()` 创建实例并使用 `setTime` 方法将传入的两个 `Date` 对象的日期时间信息设置进去。
* 然后依次比较年份、月份以及日这三个日期部分是否相等。先比较年份是否相同（通过 `c1.get(Calendar.YEAR) == c2.get(Calendar.YEAR)` 判断），
* 如果年份相同，再比较月份是否相同（通过 `isSameYear && c1.get(Calendar.MONTH) == c2.get(Calendar.MONTH)` 判断，这里使用了前面年份比较的结果 `isSameYear` 进行逻辑与运算，只有年份相同才继续比较月份），
* 若月份也相同，最后比较日是否相同（通过 `isSameMonth && c1.get(Calendar.DAY_OF_MONTH) == c2.get(Calendar.DAY_OF_MONTH)` 判断，同样依赖前面月份比较的结果 `isSameMonth`）。
* 最终返回比较结果，如果三个日期部分都相同则表示是同一天，返回 `true`；否则返回 `false`。
*
* @param d1
* @param d2
* @return
* @param d1 要比较的第一个日期对象，类型为 `Date`，代表一个具体的日期和时间点。
* @param d2 要比较的第二个日期对象，类型为 `Date`，同样代表一个具体的日期和时间点。
* @return 如果两个日期是同一天则返回 `true`，否则返回 `false`。
*/
public static boolean compareSameDate(Date d1, Date d2) {
Calendar c1 = Calendar.getInstance();
@ -307,11 +454,12 @@ public final class DateUtil {
}
/**
* 当月的第一天距1970年1月1日秒数.
* 获取当前月份的第一天距离1970年1月1日的秒数。
* 通过 `Calendar.getInstance()` 获取一个 `Calendar` 实例，它默认代表当前时间状态。
* 然后使用 `cal.set(Calendar.DAY_OF_MONTH, 1)` 将日期部分设置为当月的第一天，此时 `Calendar` 实例就代表了当前月第一天的日期时间信息。
* 最后获取该日期对应的时间戳（毫秒数，通过 `getTime().getTime()` 获取），再除以1000转换为秒数并返回。
*
* @param date
* @return long
* @author mengxm
* @return 当前月份的第一天距离1970年1月1日的秒数。
*/
public static final long firstMonthDayTime() {
Calendar cal = Calendar.getInstance();
@ -320,12 +468,16 @@ public final class DateUtil {
}
/**
* 根据指定格式解析时间
* 根据指定的日期格式解析给定的日期字符串为 `Date` 类型对象。
* 首先初始化一个 `Date` 类型的变量 `date` 为 `null`，用于存储解析后的日期结果。
* 接着尝试创建一个 `DateFormat` 类型的对象（这里使用 `SimpleDateFormat`，并传入指定的格式字符串 `fmtString` 进行初始化），用于按照指定格式解析日期字符串。
* 通过调用该 `DateFormat` 对象的 `parse` 方法，传入要解析的日期字符串 `dateString`，尝试将其解析为 `Date` 对象，如果解析成功则将结果赋值给 `date` 变量；
* 若在解析过程中出现 `ParseException` 异常（例如日期字符串格式不符合指定要求等情况），会打印异常堆栈信息，并保持 `date` 为 `null`。
* 最后返回解析后的 `Date` 对象，如果解析失败则返回 `null`。
*
* @param dateString
* @param fmtString
* @return Date
* @author mengxm
* @param dateString 要解析的日期字符串，例如 "2024-12-15" 等，需要符合传入的 `fmtString` 指定的格式要求，否则解析会出错。
* @param fmtString 指定的日期格式字符串，例如 "yyyy-MM-dd" 等，用于定义如何解析 `dateString`。
* @return 解析后的 `Date` 对象，如果解析过程中出现异常则返回 `null`。
*/
public static final Date parse(String dateString, String fmtString) {
Date date = null;
@ -338,7 +490,17 @@ public final class DateUtil {
return date;
}
/** 比较提现前后时间间隔秒数 */
/**
* 比较提现前后两个日期的时间间隔是否小于30秒。
* 首先获取传入的两个日期（`endDate` 和 `nowDate`）对应的时间戳（毫秒数，通过 `getTime()` 方法获取），然后计算它们的时间差（以毫秒为单位，通过 `endDate.getTime() - nowDate.getTime()` 计算），
* 再将时间差除以1000转换为秒数（`/ 1000`），得到时间间隔的秒数。
* 最后判断这个时间间隔秒数是否小于30秒，如果小于30秒则返回 `true`，表示提现前后时间间隔较短；否则返回 `false`。
* 注意，代码中打印了两个日期的时间戳信息（通过 `System.out.println` 输出），这可能是用于调试目的，在实际生产环境中可根据需求决定是否保留。
*
* @param endDate 提现结束的日期对象，类型为 `Date`，代表一个具体的日期和时间点。
* @param nowDate 当前时间对应的日期对象，类型为 `Date`，同样代表一个具体的日期和时间点。
* @return 如果提现前后时间间隔小于30秒则返回 `true`，否则返回 `false`。
*/
public static boolean getDatePoor(Date endDate, Date nowDate) {
// 获得两个时间的毫秒时间差异
@ -352,11 +514,15 @@ public final class DateUtil {
}
/**
* 当前时间加几天
* 在当前日期基础上增加指定的天数，并返回增加天数后的日期对应的距离1970年1月1日的秒数。
* 首先通过 `Calendar.getInstance()` 获取一个 `Calendar` 实例，代表当前时间状态。
* 接着尝试将当前日期（通过调用 `getCurrentTime` 方法获取当前日期字符串，并使用 `NORMAL_DATE_FORMAT_YY_MM_DD` 格式化器解析为 `Date` 对象）设置到这个 `Calendar` 实例中。
* 然后使用 `Calendar` 的 `add` 方法按照天为单位增加指定的天数（`Calendar.DATE` 表示按天进行日期增减操作，传入的参数 `day` 为正数表示增加天数，负数表示减少天数）。
* 最后获取增加天数后的日期对应的时间戳（毫秒数，通过 `getTimeInMillis()` 获取），再除以1000转换为秒数并返回；
* 如果在解析当前日期字符串为 `Date` 对象时出现 `ParseException` 异常，会打印异常堆栈信息，并返回0l，表示操作失败。
*
* @param day
* 天数
* @return
* @param day 要增加的天数，类型为整数，例如传入3表示在当前日期基础上增加3天，传入 -2表示减少2天。
* @return 在当前日期基础上增加指定天数后的日期对应的距离1970年1月1日的秒数，若出现异常则返回0l。
*/
public static long currentDateAddDay(int day) {
Calendar cal = Calendar.getInstance();
@ -370,6 +536,17 @@ public final class DateUtil {
return 0l;
}
/**
* 在给定的日期（以距离1970年1月1日的秒数表示）基础上增加指定的天数，并返回增加天数后的日期对应的距离1970年1月1日的秒数。
* 首先通过 `Calendar.getInstance()` 获取一个 `Calendar` 实例，用于操作日期。
* 接着根据传入的以秒数表示的日期（先乘以1000转换为毫秒数）创建对应的 `Date` 对象，并将其设置到 `Calendar` 实例中，以此确定要操作的基础日期。
* 然后使用 `Calendar` 的 `add` 方法按照天为单位增加指定的天数（`Calendar.DATE` 表示按天进行日期增减操作，传入的参数 `day` 为正数表示增加天数，负数表示减少天数）。
* 最后获取增加天数后的日期对应的时间戳（毫秒数，通过 `getTimeInMillis()` 获取），再除以1000转换为秒数并返回。
*
* @param dateLong 表示要进行操作的基础日期，以距离1970年1月1日的秒数传入，例如传入代表2024-12-15这一天的秒数。
* @param day 要增加的天数，类型为整数，例如传入3表示在给定日期基础上增加3天，传入 -2表示减少2天。
* @return 在给定日期基础上增加指定天数后的日期对应的距离1970年1月1日的秒数。
*/
public static long dateAddDay(long dateLong, int day) {
Calendar cal = Calendar.getInstance();
Date d = new Date(dateLong * 1000);
@ -387,12 +564,28 @@ public final class DateUtil {
* 较大的时间
* @return 相差天数
* @throws ParseException
*/
/**
* 计算两个日期之间相差的天数。
* 首先创建一个 `SimpleDateFormat` 对象，指定日期格式为 "yyyy-MM-dd"，用于将传入的日期对象格式化为统一格式后再进行解析，这样可以去除时间部分（小时、分钟、秒等）的影响，只比较日期部分。
* 初始化一个变量 `between_days` 用于存储两个日期之间的天数差值，初始值设为0。
* 接着在 `try` 块中进行以下操作：
* 1. 使用 `sdf.format(smdate)` 将较小的日期 `smdate` 先格式化为 "yyyy-MM-dd" 格式的字符串，再使用 `sdf.parse` 方法将其解析回 `Date` 对象，这样做的目的是将 `smdate` 的时间部分重置为当天的起始时间（00:00:00），对 `bdate` 也进行同样的操作，确保比较的是两个日期的整天差异。
* 2. 获取一个 `Calendar` 实例，将处理后的 `smdate` 设置进去，然后获取其对应的时间戳（毫秒数，通过 `getTimeInMillis` 方法获取），记为 `time1`。
* 3. 同样地，把处理后的 `bdate` 设置到 `Calendar` 实例中，获取对应的时间戳记为 `time2`。
* 4. 通过计算两个时间戳的差值（`time2 - time1`），再将差值除以一天对应的毫秒数（1000 * 3600 * 24，即一天有24小时，每小时3600秒，每秒1000毫秒），得到两个日期之间相差的天数，赋值给 `between_days` 变量。
* 如果在解析日期字符串的过程中出现 `ParseException` 异常（例如传入的日期对象不符合 "yyyy-MM-dd" 格式要求等情况），会打印异常堆栈信息，并继续执行后续代码。
* 最后将 `between_days` 转换为 `Integer` 类型并返回，表示两个日期之间相差的天数。
*
* @param smdate 表示较小的时间（较早的日期），类型为 `Date`，例如历史记录中的较早时间点对应的日期对象。
* @param bdate 表示较大的时间（较晚的日期），类型为 `Date`，例如当前时间或者更晚的时间点对应的日期对象。
* @return 两个日期之间相差的天数，正数表示 `bdate` 比 `smdate` 晚的天数，负数表示 `bdate` 比 `smdate` 早的天数。若解析日期出现异常，返回的结果可能不准确。
*/
public static int daysBetween(Date smdate, Date bdate) {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
long between_days = 0L;
try {
smdate = sdf.parse(sdf.format(smdate));
smdate = sdf.parse(sdf.format(sdate));
bdate = sdf.parse(sdf.format(bdate));
Calendar cal = Calendar.getInstance();
cal.setTime(smdate);
@ -406,7 +599,17 @@ public final class DateUtil {
return Integer.parseInt(String.valueOf(between_days));
}
/** 日期转换为自定义格式输出 */
/**
* 将日期对象按照指定的自定义格式转换为字符串输出。
* 首先对传入的日期对象和格式字符串进行合法性判断，如果日期对象为 `null`，则直接返回 `null`；如果格式字符串为 `null` 或者是空字符串（通过 `equals` 方法判断），也返回 `null`。
* 接着初始化一个空字符串 `dateStr`，用于存储格式化后的日期字符串。
* 在 `try` 块中，创建一个 `SimpleDateFormat` 对象，使用传入的格式字符串进行初始化，然后通过调用其 `format` 方法将传入的日期对象格式化为指定格式的字符串，赋值给 `dateStr` 变量，并返回该格式化后的字符串。
* 如果在格式化过程中出现异常（例如格式字符串不符合 `SimpleDateFormat` 的要求等情况），会直接返回 `null`，表示格式化失败。
*
* @param date 要进行格式化的日期对象，代表一个具体的日期和时间点，若为 `null` 则无法进行格式化操作，返回 `null`。
* @param formatType 指定的日期格式字符串，例如 "yyyy年MM月dd日" 等，用于定义如何将日期对象格式化为字符串，若为 `null` 或空字符串则返回 `null`。
* @return 按照指定格式格式化后的日期字符串，如果传入参数不合法或者格式化出现异常则返回 `null`。
*/
public static String DateToString(Date date, String formatType) {
if (date == null) {
return null;
@ -424,6 +627,15 @@ public final class DateUtil {
}
}
/**
* 获取当前日期的起始时间（当天的00:00:00）对应的距离1970年1月1日的秒数。
* 首先通过 `Calendar.getInstance()` 获取一个 `Calendar` 实例，它代表当前的时间状态。
* 然后将该 `Calendar` 实例中的时间部分设置为当天的起始时间，即分别把小时设置为0（`Calendar.HOUR_OF_DAY`）、分钟设置为0（`Calendar.MINUTE`）、秒设置为0（`Calendar.SECOND`）以及毫秒设置为0（`Calendar.MILLISECOND`）。
* 这里有一行代码 `todayStart.add(Calendar.DAY_OF_YEAR, -1);` 被注释掉了，原功能可能是将日期往前推一天，当前逻辑是获取当前日期当天的起始时间。
* 最后获取调整后的这个代表起始时间的日期对应的时间戳（毫秒数，通过 `getTime().getTime()` 获取），再将其除以1000转换为秒数并返回。
*
* @return 当前日期的起始时间（00:00:00）对应的距离1970年1月1日的秒数。
*/
public static long getStartTimeCurrentDay() {
Calendar todayStart = Calendar.getInstance();
// todayStart.add(Calendar.DAY_OF_YEAR, -1);
@ -434,6 +646,15 @@ public final class DateUtil {
return todayStart.getTime().getTime() / 1000;
}
/**
* 获取当前日期的结束时间（当天的23:59:59.999，此处代码中毫秒设置为59，严格来说应该是999更准确表示当天最后一刻）对应的距离1970年1月1日的秒数。
* 先通过 `Calendar.getInstance()` 获取一个 `Calendar` 实例，用于表示当前时间状态。
* 同样这里有一行代码 `todayStart.add(Calendar.DAY_OF_YEAR, -1);` 被注释掉了，原功能可能是将日期往前推一天，当前逻辑是获取当前日期当天的结束时间。
* 接着将该 `Calendar` 实例中的时间部分设置为当天的结束时间，也就是分别把小时设置为23（`Calendar.HOUR_OF_DAY`）、分钟设置为59（`Calendar.MINUTE`）、秒设置为59（`Calendar.SECOND`）以及毫秒设置为59（`Calendar.MILLISECOND`）。
* 最后获取调整后的代表结束时间的日期对应的时间戳（毫秒数，通过 `getTime().getTime()` 获取），再除以1000转换为秒数后返回。
*
* @return 当前日期的结束时间（23:59:59.999，代码中为59毫秒）对应的距离1970年1月1日的秒数。
*/
public static long getEndTimeCurrentDay() {
Calendar todayStart = Calendar.getInstance();
// todayStart.add(Calendar.DAY_OF_YEAR, -1);
@ -444,7 +665,16 @@ public final class DateUtil {
return todayStart.getTime().getTime() / 1000;
}
/** 日期转换为自定义格式输出 */
/**
* 将日期对象按照指定的格式转换为字符串输出，如果出现异常则返回空字符串。
* 首先对传入的日期对象和格式字符串进行合法性判断，如果日期对象为 `null`，则直接返回空字符串；如果格式字符串为 `null` 或者是空字符串（通过 `equals` 方法判断），也返回空字符串。
* 在 `try` 块中，创建一个 `SimpleDateFormat` 对象，使用传入的格式字符串进行初始化，然后通过调用其 `format` 方法将传入的日期对象格式化为指定格式的字符串，并返回该格式化后的字符串。
* 如果在格式化过程中出现异常（例如格式字符串不符合 `SimpleDateFormat` 的要求等情况），会打印异常堆栈信息，并返回空字符串，表示格式化失败。
*
* @param date 要进行格式化的日期对象，代表一个具体的日期和时间点，若为 `null` 则返回空字符串。
* @param format 指定的日期格式字符串，例如 "yyyy-MM-dd" 等，用于定义如何将日期对象格式化为字符串，若为 `null` 或空字符串则返回空字符串。
* @return 按照指定格式格式化后的日期字符串，如果传入参数不合法或者格式化出现异常则返回空字符串。
*/
public static String fomatDate(Date date, String format) {
if (date == null) {
return "";
@ -462,6 +692,15 @@ public final class DateUtil {
}
}
/**
* 获取昨天的日期，格式为 "yyyyMMdd"。
* 首先通过 `Calendar.getInstance()` 获取一个 `Calendar` 实例，代表当前时间状态。
* 然后使用 `add(Calendar.DAY_OF_YEAR, -1)` 方法将日期往前推一天，使其代表昨天的日期。
* 接着将该 `Calendar` 实例中的时间部分设置为昨天的起始时间，即分别把小时设置为0（`Calendar.HOUR_OF_DAY`）、分钟设置为0（`Calendar.MINUTE`）、秒设置为0（`Calendar.SECOND`）以及毫秒设置为0（`Calendar.MILLISECOND`）。
* 最后使用预定义的 `NORMAL_DATE_FORMAT_YY_MM_DD_` 格式化器将这个代表昨天起始时间的 `Calendar` 实例对应的日期格式化为 "yyyyMMdd" 格式的字符串，并返回该字符串。
*
* @return 昨天的日期字符串，格式为 "yyyyMMdd"，例如 "20241214"（具体取决于当前日期）。
*/
public static String getLastDayFmtYYYYMMDD() {
Calendar todayStart = Calendar.getInstance();
todayStart.add(Calendar.DAY_OF_YEAR, -1);
@ -473,52 +712,38 @@ public final class DateUtil {
}
/**
* @Title: getDateFormat
* @Description: 日期格式化 yyyy-MM-dd
* @param str
* @return String
* 将传入的字符串表示的时间（以秒数形式，从1970年1月1日0时0分0秒到某个时间点的秒数）格式化为 "yyyy-MM-dd" 格式的日期字符串。
* 首先通过 `Long.parseLong` 方法将传入的字符串转换为长整型的秒数，然后调用 `dateFormatYYMMDD` 方法，将该秒数转换为对应的日期，并格式化为 "yyyy-MM-dd" 格式的字符串后返回。
*
* @param str 表示时间的字符串，需要能够正确转换为长整型的秒数，例如 "1672809600" 等，代表某个时间距离1970年1月1日0时0分0秒的秒数。
* @return 格式化后的日期字符串，格式为 "yyyy-MM-dd"，例如 "2024-12-15"（具体取决于传入的秒数对应的日期）。
*/
public static String getDateFormat(String str) {
return dateFormatYYMMDD(Long.parseLong(str));
}
/**
* @Title: getTimeFormat
* @Description: 时间格式化 yyyy-MM-dd HH:mm:ss
* @param str
* @return String
* 将传入的字符串表示的时间（以秒数形式，从1970年1月1日0时0分0秒到某个时间点的秒数）格式化为 "yyyy-MM-dd HH:mm:ss" 格式的日期字符串。
* 先使用 `Long.parseLong` 方法将传入的字符串转换为长整型的秒数，再调用 `dateFormat` 方法，将该秒数对应的日期格式化为包含年月日时分秒的 "yyyy-MM-dd HH:mm:ss" 格式的字符串并返回。
*
* @param str 表示时间的字符串，需要能够正确转换为长整型的秒数，例如 "1672809600" 等，代表某个时间距离1970年1月1日0时0分0秒的秒数。
* @return 格式化后的日期字符串，格式为 "yyyy-MM-dd HH:mm:ss"，例如 "2024-12-15 12:30:00"（具体取决于传入的秒数对应的日期）。
*/
public static String getTimeFormat(String str) {
return dateFormat(Long.parseLong(str));
}
public static void main(String[] args) {
System.out.println(dateFormat(1441036802));
System.out.println(getFirstDayOfMonth("2015", "9"));
System.out.println(getLastDayOfMonth("2015", "8"));
System.out.println(dateFormat(getLastMonthTime()));
System.out.println(dateFormat(getLastWeekTime()));
System.out.println(parseLong("2017-01-01 00:00:00"));
System.out.println(getTime());
System.out.println(dateFormat(1451624155));
System.out.println(parse("20151222", "yyyyMMdd"));
Calendar c = Calendar.getInstance();
Date nowDate = c.getTime();
c.set(Calendar.MINUTE, -1);
Date endDate = c.getTime();
System.out.println("nowDate--" + nowDate + ";endDate--" + endDate);
System.out.println(getDatePoor(nowDate, endDate));
System.out.println(dateFormatYYYYMMDD(new Date()));
System.out.println("args = [" + DateUtil.currentDateAddDay(0) + "]");
System.out.println("args = [" + DateUtil.parse("2016-01-19", "yyyy-MM-dd").getTime() + "]");
System.out.println(getTime());
System.out.println(getEndTimeCurrentDay());
System.out.println(getEndTimeCurrentDay() - getTime());
}
}
/**
* `main` 方法，用于对 `DateUtil` 类中的一些方法进行简单测试和演示。
* 以下是依次执行的操作及输出说明：
* 1. 调用 `dateFormat` 方法，将秒数 `1441036802` 对应的日期格式化为 "yyyy-MM-dd HH:mm:ss" 格式的字符串并输出，展示日期格式化功能。
* 2. 调用 `getFirstDayOfMonth` 方法，获取2015年9月的第一天距离1970年1月1日的秒数对应的日期（格式化为 "yyyy-MM-dd HH:mm:ss" 格式）并输出，测试获取指定月份第一天的功能。
* 3. 调用 `getLastDayOfMonth` 方法，获取2015年8月的最后一天距离1970年1月1日的秒数对应的日期（格式化为 "yyyy-MM-dd HH:mm:ss" 格式）并输出，测试获取指定月份最后一天的功能。
* 4. 调用 `dateFormat` 方法，将通过 `getLastMonthTime` 方法获取的距离当前一个月前的时间对应的秒数格式化为 "yyyy-MM-dd HH:mm:ss" 格式的字符串并输出，展示获取过去某个时间并格式化的功能。
* 5. 同样地，调用 `dateFormat` 方法，将通过 `getLastWeekTime` 方法获取的距离当前一周前的时间对应的秒数格式化为 "yyyy-MM-dd HH:mm:ss" 格式的字符串并输出。
* 6. 调用 `parseLong` 方法，将字符串 "2017-01-01 00:00:00" 解析为对应的日期距离1970年1月1日的秒数并输出，测试日期字符串解析功能。
* 7. 调用 `getTime` 方法获取当前时间距离1970年1月1日的秒数并输出，展示获取当前时间戳（秒数形式）的功能。
* 8. 调用 `dateFormat` 方法，将秒数 `1451624155` 对应的日期格式化为 "yyyy-MM-dd HH:mm:ss" 格式的字符串并输出，再次测试日期格式化功能。
* 9. 调用 `parse` 方法，将字符串 "20151222" 按照 "yyyyMMdd" 格式解析为 `Date` 对象，并输出该对象（实际输出可能是对象的默认字符串表示形式，取决于 `Date` 类的 `toString` 实现），测试自定义格式的日期字符串解析功能。
* 10. 创建一个 `Calendar` 实例获取当前时间作为 `nowDate`，然后修改分钟数为 -1，获取这个修改后的时间作为 `endDate`，接着输出 `nowDate` 和 `endDate` 的信息（同样是默认字符串表示形式），最后调用 `getDatePoor` 方法判断这两个日期的时间间隔是否小于30秒，并输出结果，测试日期时间间隔比较功能。
* 11. 调用 `dateFormatYYYYMMDD

41
tamguo-common/src/main/java/com/tamguo/common/utils/Log4jHandler.java
Unescape View File

@ -4,22 +4,63 @@ import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.event.Level;
// Log4jHandler类继承自AbstractRunningLogHandler，主要用于处理不同级别的日志记录操作，具体实现了info（信息级别）和error（错误级别）两种常见日志级别的记录方法，
// 并且依赖于SLF4J框架来实际执行日志输出，将日志信息发送到对应的日志系统（例如Log4j等，具体取决于项目中的日志实现配置）。
public class Log4jHandler extends AbstractRunningLogHandler {
// 通过LoggerFactory获取一个名为Log4jHandler类的Logger实例，后续所有的日志记录操作都将通过这个logger对象来进行，
// 这样可以方便地按照SLF4J的规范输出不同级别的日志信息到对应的日志输出渠道（如控制台、文件等）。
private static final Logger logger = LoggerFactory.getLogger(Log4jHandler.class);
/**
* 记录信息级别（INFO）的日志，只包含日志消息内容本身，不关联异常信息。
* 该方法接收要记录的日志消息字符串以及调用类的全限定名作为参数，然后使用获取到的logger对象调用info方法，按照SLF4J的日志记录规范，
* 将日志消息以INFO级别记录下来，同时传入调用类的全限定名、日志级别（Level.INFO）以及具体的日志消息内容，最后一个参数null表示没有关联的异常信息。
*
* @param msg 要记录的日志消息内容，通常是一些对程序运行过程中正常情况的描述信息，比如业务操作的关键步骤提示等。
* @param fqnOfCallingClass 调用此日志记录方法的类的全限定名，例如 "com.example.MyClass"，用于在日志中标识该日志是由哪个具体的类产生的，方便定位和分析日志来源。
*/
public void info(String msg, String fqnOfCallingClass) {
logger.info(fqnOfCallingClass, Level.INFO, msg, null);
}
/**
* 记录信息级别（INFO）的日志，同时关联异常信息。
* 接收要记录的日志消息字符串、表示异常情况的Throwable对象以及调用类的全限定名作为参数，利用logger对象的info方法，按照SLF4J的日志记录规范，
* 将日志消息以INFO级别记录下来，传入调用类的全限定名、日志级别（Level.INFO）、具体的日志消息内容以及对应的异常对象，这样在查看日志时可以获取到详细的异常信息，
* 便于排查与该异常相关的问题。
*
* @param msg 要记录的日志消息内容，可能是对异常相关情况的一些补充说明或者上下文描述等。
* @param t 表示异常情况的Throwable对象，包含了详细的异常堆栈信息、异常类型以及异常消息等内容，例如在捕获到某个业务异常或者运行时异常时传入对应的异常对象。
* @param fqnOfCallingClass 调用此日志记录方法的类的全限定名，例如 "com.example.MyClass"，用于在日志中标识该日志是由哪个具体的类产生的，方便定位和分析日志来源。
*/
public void info(String msg, Throwable t, String fqnOfCallingClass) {
logger.info(fqnOfCallingClass, Level.INFO, msg, t);
}
/**
* 记录错误级别（ERROR）的日志，只包含日志消息内容本身，不关联异常信息。
* 此方法接收要记录的日志消息字符串以及调用类的全限定名作为参数，使用logger对象调用error方法，按照SLF4J的日志记录规范，
* 将日志消息以ERROR级别记录下来，传入调用类的全限定名、日志级别（Level.ERROR）以及具体的日志消息内容，最后一个参数null表示没有关联的异常信息，
* 用于记录程序运行过程中出现的错误情况，方便后续定位和排查问题。
*
* @param msg 要记录的错误相关的日志消息内容，比如业务操作失败的原因描述、系统运行时出现错误的提示等。
* @param fqnOfCallingClass 调用此日志记录方法的类的全限定名，例如 "com.example.MyClass"，用于在日志中标识该日志是由哪个具体的类产生的，方便定位和分析日志来源。
*/
public void error(String msg, String fqnOfCallingClass) {
logger.error(fqnOfCallingClass, Level.ERROR, msg, null);
}
/**
* 记录错误级别（ERROR）的日志，同时关联异常信息。
* 接收要记录的日志消息字符串、表示异常情况的Throwable对象以及调用类的全限定名作为参数，通过logger对象的error方法，按照SLF4J的日志记录规范，
* 将日志消息以ERROR级别记录下来，传入调用类的全限定名、日志级别（Level.ERROR）、具体的日志消息内容以及对应的异常对象，这样在查看日志时可以获取到详细的异常信息，
* 便于对出现的错误进行深入分析和问题排查。
*
* @param msg 要记录的错误相关的日志消息内容，可能是对异常情况的一些补充说明或者上下文描述等。
* @param t 表示异常情况的Throwable对象，包含了详细的异常堆栈信息、异常类型以及异常消息等内容，例如在捕获到某个业务异常或者运行时异常时传入对应的异常对象。
* @param fqnOfCallingClass 调用此日志记录方法的类的全限定名，例如 "com.example.MyClass"，用于在日志中标识该日志是由哪个具体的类产生的，方便定位和分析日志来源。
*/
public void error(String msg, Throwable t, String fqnOfCallingClass) {
logger.error(fqnOfCallingClass, Level.ERROR, msg, t);
}

Write Preview
Loading…
Cancel
Save