package com.ard.sample.utils;
|
|
import org.springframework.stereotype.Component;
|
|
import java.time.*;
|
import java.time.format.DateTimeFormatter;
|
|
/**
|
* 时间戳工具类（支持毫秒级/秒级时间戳，基于Java 8+时间API）
|
* 功能：加/减时间、转换为LocalDateTime、格式化字符串等
|
*/
|
@Component
|
public class TimestampUtils {
|
|
// 默认时区：北京时间（Asia/Shanghai）
|
private static final ZoneId DEFAULT_ZONE = ZoneId.of("Asia/Shanghai");
|
|
// 默认日期时间格式：yyyy-MM-dd HH:mm:ss
|
private static final DateTimeFormatter DEFAULT_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
|
|
// 时间单位常量（毫秒）
|
private static final long ONE_SECOND = 1000L; // 1秒 = 1000毫秒
|
private static final long ONE_MINUTE = 60 * ONE_SECOND; // 1分钟 = 60秒
|
private static final long ONE_HOUR = 60 * ONE_MINUTE; // 1小时 = 60分钟
|
private static final long ONE_DAY = 24 * ONE_HOUR; // 1天 = 24小时
|
|
|
// -------------------------- 毫秒级时间戳操作 --------------------------
|
|
/**
|
* 毫秒级时间戳 + N天
|
* @param millisTimestamp 原毫秒级时间戳（13位）
|
* @param days 天数（正数加，负数减）
|
* @return 计算后的毫秒级时间戳
|
*/
|
public long plusDaysByMillis(long millisTimestamp, int days) {
|
return Instant.ofEpochMilli(millisTimestamp)
|
.plusMillis(days * ONE_DAY)
|
.toEpochMilli();
|
}
|
|
/**
|
* 毫秒级时间戳 + N小时
|
* @param millisTimestamp 原毫秒级时间戳（13位）
|
* @param hours 小时数（正数加，负数减）
|
* @return 计算后的毫秒级时间戳
|
*/
|
public long plusHoursByMillis(long millisTimestamp, int hours) {
|
return Instant.ofEpochMilli(millisTimestamp)
|
.plusMillis(hours * ONE_HOUR)
|
.toEpochMilli();
|
}
|
|
/**
|
* 毫秒级时间戳 + N分钟
|
* @param millisTimestamp 原毫秒级时间戳（13位）
|
* @param minutes 分钟数（正数加，负数减）
|
* @return 计算后的毫秒级时间戳
|
*/
|
public long plusMinutesByMillis(long millisTimestamp, int minutes) {
|
return Instant.ofEpochMilli(millisTimestamp)
|
.plusMillis(minutes * ONE_MINUTE)
|
.toEpochMilli();
|
}
|
|
/**
|
* 毫秒级时间戳 + N秒
|
* @param millisTimestamp 原毫秒级时间戳（13位）
|
* @param seconds 秒数（正数加，负数减）
|
* @return 计算后的毫秒级时间戳
|
*/
|
public long plusSecondsByMillis(long millisTimestamp, int seconds) {
|
return Instant.ofEpochMilli(millisTimestamp)
|
.plusMillis(seconds * ONE_SECOND)
|
.toEpochMilli();
|
}
|
|
/**
|
* 毫秒级时间戳 + 带小数的秒数
|
* @param millisTimestamp 原毫秒级时间戳（13位）
|
* @param seconds 秒数（正数加，负数减，支持小数，如 1.5、-2.3）
|
* @return 计算后的毫秒级时间戳
|
*/
|
public long plusSecondsByMillis(long millisTimestamp, double seconds) {
|
// 将带小数的秒数转换为精确的毫秒数（四舍五入保证整数）
|
long millisToAdd = Math.round(seconds * ONE_SECOND);
|
// 基于原时间戳加减对应的毫秒数
|
return Instant.ofEpochMilli(millisTimestamp)
|
.plusMillis(millisToAdd)
|
.toEpochMilli();
|
}
|
|
|
// -------------------------- 秒级时间戳操作 --------------------------
|
|
/**
|
* 秒级时间戳 + N天（自动转换为毫秒级计算，结果转回秒级）
|
* @param secondTimestamp 原秒级时间戳（10位）
|
* @param days 天数（正数加，负数减）
|
* @return 计算后的秒级时间戳
|
*/
|
public long plusDaysBySecond(long secondTimestamp, int days) {
|
long millis = secondTimestamp * ONE_SECOND;
|
long newMillis = plusDaysByMillis(millis, days);
|
return newMillis / ONE_SECOND;
|
}
|
|
/**
|
* 秒级时间戳 + N小时
|
* @param secondTimestamp 原秒级时间戳（10位）
|
* @param hours 小时数（正数加，负数减）
|
* @return 计算后的秒级时间戳
|
*/
|
public long plusHoursBySecond(long secondTimestamp, int hours) {
|
long millis = secondTimestamp * ONE_SECOND;
|
long newMillis = plusHoursByMillis(millis, hours);
|
return newMillis / ONE_SECOND;
|
}
|
|
/**
|
* 秒级时间戳 + N分钟
|
* @param secondTimestamp 原秒级时间戳（10位）
|
* @param minutes 分钟数（正数加，负数减）
|
* @return 计算后的秒级时间戳
|
*/
|
public long plusMinutesBySecond(long secondTimestamp, int minutes) {
|
long millis = secondTimestamp * ONE_SECOND;
|
long newMillis = plusMinutesByMillis(millis, minutes);
|
return newMillis / ONE_SECOND;
|
}
|
|
/**
|
* 秒级时间戳 + N秒
|
* @param secondTimestamp 原秒级时间戳（10位）
|
* @param seconds 秒数（正数加，负数减）
|
* @return 计算后的秒级时间戳
|
*/
|
public long plusSecondsBySecond(long secondTimestamp, int seconds) {
|
return secondTimestamp + seconds; // 秒级直接加减，无需转毫秒
|
}
|
|
|
// -------------------------- 时间戳转换为LocalDateTime --------------------------
|
|
/**
|
* 毫秒级时间戳转换为LocalDateTime（默认时区：北京时间）
|
* @param millisTimestamp 毫秒级时间戳（13位）
|
* @return LocalDateTime对象
|
*/
|
public LocalDateTime toLocalDateTimeByMillis(long millisTimestamp) {
|
return LocalDateTime.ofInstant(
|
Instant.ofEpochMilli(millisTimestamp),
|
DEFAULT_ZONE
|
);
|
}
|
|
/**
|
* 秒级时间戳转换为LocalDateTime（默认时区：北京时间）
|
* @param secondTimestamp 秒级时间戳（10位）
|
* @return LocalDateTime对象
|
*/
|
public LocalDateTime toLocalDateTimeBySecond(long secondTimestamp) {
|
return LocalDateTime.ofInstant(
|
Instant.ofEpochSecond(secondTimestamp), // 直接用ofEpochSecond处理秒级
|
DEFAULT_ZONE
|
);
|
}
|
|
|
// -------------------------- 时间戳格式化为字符串 --------------------------
|
|
/**
|
* 毫秒级时间戳格式化为字符串（默认格式：yyyy-MM-dd HH:mm:ss）
|
* @param millisTimestamp 毫秒级时间戳（13位）
|
* @return 格式化后的字符串
|
*/
|
public String formatByMillis(long millisTimestamp) {
|
return formatByMillis(millisTimestamp, DEFAULT_FORMATTER);
|
}
|
|
/**
|
* 毫秒级时间戳格式化为自定义格式字符串
|
* @param millisTimestamp 毫秒级时间戳（13位）
|
* @param formatter 自定义格式器（如：DateTimeFormatter.ofPattern("yyyy/MM/dd")）
|
* @return 格式化后的字符串
|
*/
|
public String formatByMillis(long millisTimestamp, DateTimeFormatter formatter) {
|
LocalDateTime dateTime = toLocalDateTimeByMillis(millisTimestamp);
|
return dateTime.format(formatter);
|
}
|
|
/**
|
* 秒级时间戳格式化为字符串（默认格式：yyyy-MM-dd HH:mm:ss）
|
* @param secondTimestamp 秒级时间戳（10位）
|
* @return 格式化后的字符串
|
*/
|
public String formatBySecond(long secondTimestamp) {
|
return formatBySecond(secondTimestamp, DEFAULT_FORMATTER);
|
}
|
|
/**
|
* 秒级时间戳格式化为自定义格式字符串
|
* @param secondTimestamp 秒级时间戳（10位）
|
* @param formatter 自定义格式器
|
* @return 格式化后的字符串
|
*/
|
public String formatBySecond(long secondTimestamp, DateTimeFormatter formatter) {
|
LocalDateTime dateTime = toLocalDateTimeBySecond(secondTimestamp);
|
return dateTime.format(formatter);
|
}
|
|
/**
|
* 取原时间戳的时间部分，与当前日期组合成新时间戳
|
* @param originalTimestamp 原时间戳（毫秒，如System.currentTimeMillis()返回值）
|
* @return 组合后的新时间戳（毫秒）
|
*/
|
public Long combine( Long originalTimestamp) {
|
// 1. 校验原时间戳合法性
|
if (originalTimestamp == null || originalTimestamp < 0) {
|
throw new IllegalArgumentException("原时间戳无效");
|
}
|
|
// 2. 解析原时间戳，提取时间部分（时、分、秒、毫秒）
|
// 原时间戳转换为ZonedDateTime（带时区的日期时间）
|
ZonedDateTime originalZoned = Instant.ofEpochMilli(originalTimestamp)
|
.atZone(DEFAULT_ZONE);
|
// 提取时间部分：时、分、秒、纳秒（纳秒需转换为毫秒级精度）
|
int hour = originalZoned.getHour();
|
int minute = originalZoned.getMinute();
|
int second = originalZoned.getSecond();
|
int nanoOfSecond = originalZoned.getNano(); // 纳秒（1毫秒=1,000,000纳秒）
|
int milliOfSecond = nanoOfSecond / 1_000_000; // 取毫秒部分（0-999）
|
|
|
// 3. 获取当前日期（年月日）
|
LocalDate currentDate = LocalDate.now(DEFAULT_ZONE);
|
|
|
// 4. 组合新的日期时间：当前年月日 + 原时间的时分秒毫秒
|
LocalTime combinedTime = LocalTime.of(hour, minute, second, nanoOfSecond);
|
LocalDateTime combinedDateTime = LocalDateTime.of(currentDate, combinedTime);
|
|
|
// 5. 转换为新时间戳（毫秒）
|
return combinedDateTime.atZone(DEFAULT_ZONE)
|
.toInstant()
|
.toEpochMilli();
|
}
|
|
/**
|
* 获取指定时间戳当天0点0分0秒的时间戳（带时区处理）
|
* @param timestamp 指定时间戳（毫秒，如System.currentTimeMillis()返回值）
|
* @return 当天0点的时间戳（毫秒）
|
*/
|
public Long getDayStartTimestamp(Long timestamp) {
|
// 校验参数合法性
|
if (timestamp == null || timestamp < 0) {
|
throw new IllegalArgumentException("时间戳无效（不能为null或负数）");
|
}
|
// 1. 将时间戳转换为带时区的日期时间
|
ZonedDateTime zonedDateTime = Instant.ofEpochMilli(timestamp)
|
.atZone(DEFAULT_ZONE);
|
|
// 2. 获取当天的起始时刻（00:00:00.000）
|
// atStartOfDay(zoneId) 会自动处理时区特殊情况（如夏令时切换）
|
ZonedDateTime dayStart = zonedDateTime.toLocalDate()
|
.atStartOfDay(DEFAULT_ZONE);
|
|
// 3. 转换为毫秒级时间戳
|
return dayStart.toInstant().toEpochMilli();
|
}
|
}
|
