Java利用java.time处理时间的方法全解析

// 错误示范：静态SimpleDateFormat引发线程安全问题
public class TimeUtils {
    private static final SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    
    public static String format(Date date) {
        return sdf.format(date); // 多线程调用必出问题
    }
}

// Calendar的设计示例
Calendar cal = Calendar.getInstance();
cal.set(2026, 2, 24); // 本意是2026年3月24日，实际是2026年2月24日！
cal.add(Calendar.HOUR, 24); // 加24小时，却可能因夏令时变成23/25小时

Date date = new Date();
System.out.println(date); // 输出带本地时区的字符串，易误导开发者
// 实际输出：Mon Mar 24 14:30:00 CST 2026（CST是中国标准时间）

// 创建LocalDate
LocalDate today = LocalDate.now(); // 当前本地日期（2026-03-24）
LocalDate specifiedDate = LocalDate.of(2026, 3, 24); // 指定日期
LocalDate fromString = LocalDate.parse("2026-03-24"); // 解析ISO格式字符串

// 日期运算
LocalDate tomorrow = today.plusDays(1); // 加1天
LocalDate lastMonth = today.minusMonths(1); // 减1个月
LocalDate firstDayOfYear = today.with(TemporalAdjusters.firstDayOfYear()); // 本年第一天

// 日期判断
boolean isLeapYear = today.isLeapYear(); // 是否闰年
boolean isBefore = today.isBefore(specifiedDate); // 是否在指定日期之前

// 创建LocalTime
LocalTime now = LocalTime.now(); // 当前本地时间（14:30:45.123）
LocalTime specifiedTime = LocalTime.of(9, 0); // 9:00:00
LocalTime fromString = LocalTime.parse("14:30:00"); // 解析ISO格式

// 时间运算
LocalTime oneHourLater = now.plusHours(1); // 加1小时
LocalTime tenMinutesEarlier = now.minusMinutes(10); // 减10分钟

// 时间判断
boolean isAfter = now.isAfter(LocalTime.of(12, 0)); // 是否在12点之后

// 创建LocalDateTime
LocalDateTime now = LocalDateTime.now(); // 当前本地日期时间
LocalDateTime specified = LocalDateTime.of(2026, 3, 24, 14, 30); // 指定时间
LocalDateTime fromString = LocalDateTime.parse("2026-03-24T14:30:00"); // ISO格式

// 转换
LocalDate date = now.toLocalDate(); // 提取日期
LocalTime time = now.toLocalTime(); // 提取时间

// 运算
LocalDateTime threeDaysLater = now.plusDays(3).plusHours(2); // 加3天2小时

// 创建ZonedDateTime
// 方式1：当前时区时间
ZonedDateTime shanghaiNow = ZonedDateTime.now(ZoneId.of("Asia/Shanghai"));
// 方式2：UTC时间
ZonedDateTime utcNow = ZonedDateTime.now(ZoneOffset.UTC);
// 方式3：LocalDateTime + 时区
LocalDateTime localDateTime = LocalDateTime.of(2026, 3, 24, 14, 30);
ZonedDateTime zoned = ZonedDateTime.of(localDateTime, ZoneId.of("Europe/London"));

// 时区转换
ZonedDateTime newYorkTime = shanghaiNow.withZoneSameInstant(ZoneId.of("America/New_York"));

// 提取信息
ZoneId zoneId = shanghaiNow.getZone(); // 获取时区
OffsetDateTime offset = shanghaiNow.toOffsetDateTime(); // 转换为偏移量时间

// 创建Instant
Instant now = Instant.now(); // 当前UTC时间戳
Instant fromEpochMilli = Instant.ofEpochMilli(System.currentTimeMillis()); // 从毫秒数创建
Instant fromString = Instant.parse("2026-03-24T06:30:00Z"); // ISO格式（Z代表UTC）

// 转换
long epochMilli = now.toEpochMilli(); // 转为毫秒时间戳
ZonedDateTime zoned = now.atZone(ZoneId.of("Asia/Shanghai")); // 转为上海时区时间

// 运算
Instant oneHourLater = now.plus(1, ChronoUnit.HOURS); // 加1小时

// 创建OffsetDateTime
OffsetDateTime now = OffsetDateTime.now(); // 当前本地偏移量时间
OffsetDateTime utc = OffsetDateTime.now(ZoneOffset.UTC); // UTC偏移量（+00:00）
OffsetDateTime shanghai = OffsetDateTime.of(LocalDateTime.now(), ZoneOffset.ofHours(8)); // 东8区

// Duration示例：计算时间间隔
LocalTime start = LocalTime.of(9, 0);
LocalTime end = LocalTime.of(18, 30);
Duration duration = Duration.between(start, end);
System.out.println(duration.toHours()); // 9
System.out.println(duration.toMinutes()); // 570

// Period示例：计算日期间隔
LocalDate birth = LocalDate.of(2000, 1, 1);
LocalDate now = LocalDate.now();
Period period = Period.between(birth, now);
System.out.println(period.getYears()); // 26（年龄）
System.out.println(period.getMonths()); // 2
System.out.println(period.getDays()); // 23

// 自定义时间段
Duration twoHours = Duration.ofHours(2);
Period threeMonths = Period.ofMonths(3);

LocalDate now = LocalDate.now();

// 当月最后一天
LocalDate lastDayOfMonth = now.with(TemporalAdjusters.lastDayOfMonth());

// 下一个周一（如果今天是周一，返回下周一）
LocalDate nextMonday = now.with(TemporalAdjusters.next(DayOfWeek.MONDAY));

// 当月第一个工作日（假设周末休息）
LocalDate firstWorkDay = now.with(TemporalAdjusters.firstDayOfMonth())
    .with(d -> d.getDayOfWeek() == DayOfWeek.SATURDAY ? d.plusDays(2) :
              d.getDayOfWeek() == DayOfWeek.SUNDAY ? d.plusDays(1) : d);

// 1. 自定义格式
DateTimeFormatter customFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
LocalDateTime now = LocalDateTime.now();
// 格式化
String formatted = now.format(customFormatter); // 2026-03-24 14:30:00
// 解析
LocalDateTime parsed = LocalDateTime.parse("2026-03-24 14:30:00", customFormatter);

// 2. ISO格式（推荐）
DateTimeFormatter isoFormatter = DateTimeFormatter.ISO_ZONED_DATE_TIME;
ZonedDateTime zoned = ZonedDateTime.now();
String isoString = zoned.format(isoFormatter); // 2026-03-24T14:30:00+08:00[Asia/Shanghai]

// 3. 本地化格式
DateTimeFormatter chinaFormatter = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH时mm分ss秒", Locale.CHINA);
String localFormatted = now.format(chinaFormatter); // 2026年03月24日 14时30分00秒

// 4. 严格模式解析（避免非法日期）
DateTimeFormatter strictFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd")
    .withResolverStyle(ResolverStyle.STRICT);
// 下面代码会抛出DateTimeParseException（2月没有30天）
// LocalDate invalid = LocalDate.parse("2026-02-30", strictFormatter);

// 1. 本地日期/时间/日期时间
LocalDate localDateNow = LocalDate.now();
LocalTime localTimeNow = LocalTime.now();
LocalDateTime localDateTimeNow = LocalDateTime.now();

// 2. 指定时区的当前时间
ZonedDateTime shanghaiNow = ZonedDateTime.now(ZoneId.of("Asia/Shanghai"));
ZonedDateTime utcNow = ZonedDateTime.now(ZoneOffset.UTC);

// 3. 机器时间戳
Instant instantNow = Instant.now();

// 1. 手动指定年月日时分秒
LocalDate date = LocalDate.of(2026, 3, 24); // 2026-03-24
LocalTime time = LocalTime.of(14, 30, 45); // 14:30:45
LocalDateTime dateTime = LocalDateTime.of(2026, 3, 24, 14, 30, 45);
ZonedDateTime zoned = ZonedDateTime.of(2026, 3, 24, 14, 30, 45, 0, ZoneId.of("Asia/Shanghai"));

// 2. 从时间戳创建
long epochMilli = 1771852200000L; // 2026-03-24 14:30:00的毫秒数
Instant instantFromMilli = Instant.ofEpochMilli(epochMilli);
LocalDateTime dateTimeFromMilli = LocalDateTime.ofInstant(instantFromMilli, ZoneId.of("Asia/Shanghai"));

// 3. 从字符串创建（ISO格式）
LocalDate dateFromIso = LocalDate.parse("2026-03-24");
LocalTime timeFromIso = LocalTime.parse("14:30:45");
LocalDateTime dateTimeFromIso = LocalDateTime.parse("2026-03-24T14:30:45");
ZonedDateTime zonedFromIso = ZonedDateTime.parse("2026-03-24T14:30:45+08:00[Asia/Shanghai]");

// 4. 从字符串创建（自定义格式）
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyyMMdd HHmmss");
LocalDateTime dateTimeFromCustom = LocalDateTime.parse("20260324 143045", formatter);

// JDBC 4.2+ 原生支持java.time类型
PreparedStatement ps = connection.prepareStatement("SELECT create_time FROM order WHERE id = ?");
ps.setLong(1, orderId);
ResultSet rs = ps.executeQuery();
if (rs.next()) {
    // 1. 读取DATE类型（LocalDate）
    LocalDate createDate = rs.getObject("create_date", LocalDate.class);
    // 2. 读取TIME类型（LocalTime）
    LocalTime createTime = rs.getObject("create_time", LocalTime.class);
    // 3. 读取TIMESTAMP类型（LocalDateTime）
    LocalDateTime createDateTime = rs.getObject("create_datetime", LocalDateTime.class);
    // 4. 读取带时区的时间（推荐用OffsetDateTime）
    OffsetDateTime offsetDateTime = rs.getObject("offset_datetime", OffsetDateTime.class);
}

LocalDateTime now = LocalDateTime.now();

// 1. 加运算
LocalDateTime plusDays = now.plusDays(7); // 加7天
LocalDateTime plusHours = now.plusHours(2); // 加2小时
LocalDateTime plusMonths = now.plusMonths(1); // 加1个月
LocalDateTime plusYears = now.plusYears(1); // 加1年
LocalDateTime plusWeeks = now.plusWeeks(1); // 加1周

// 2. 减运算
LocalDateTime minusMinutes = now.minusMinutes(30); // 减30分钟
LocalDateTime minusSeconds = now.minusSeconds(10); // 减10秒
LocalDateTime minusYears = now.minusYears(5); // 减5年

// 3. 批量运算（TemporalAmount）
Duration duration = Duration.ofHours(3).plusMinutes(30);
LocalDateTime plusDuration = now.plus(duration); // 加3小时30分钟

Period period = Period.ofMonths(2).plusDays(10);
LocalDate plusPeriod = LocalDate.now().plus(period); // 加2个月10天

// 1. 时间差（Duration）
LocalDateTime start = LocalDateTime.of(2026, 3, 24, 9, 0);
LocalDateTime end = LocalDateTime.of(2026, 3, 24, 18, 30);
Duration duration = Duration.between(start, end);
System.out.println("小时差：" + duration.toHours()); // 9
System.out.println("分钟差：" + duration.toMinutes()); // 570
System.out.println("秒差：" + duration.getSeconds()); // 34200

// 2. 日期差（Period）
LocalDate startDate = LocalDate.of(2020, 1, 1);
LocalDate endDate = LocalDate.of(2026, 3, 24);
Period period = Period.between(startDate, endDate);
System.out.println("年差：" + period.getYears()); // 6
System.out.println("月差：" + period.getMonths()); // 2
System.out.println("日差：" + period.getDays()); // 23

// 3. 精确到纳秒的时间差
Instant startInstant = Instant.parse("2026-03-24T06:00:00Z");
Instant endInstant = Instant.parse("2026-03-24T06:00:01.123456789Z");
Duration nanoDiff = Duration.between(startInstant, endInstant);
System.out.println("纳秒差：" + nanoDiff.getNano()); // 123456789

LocalDate now = LocalDate.now();

// 1. 本月第一天/最后一天
LocalDate firstDayOfMonth = now.with(TemporalAdjusters.firstDayOfMonth());
LocalDate lastDayOfMonth = now.with(TemporalAdjusters.lastDayOfMonth());

// 2. 本年第一天/最后一天
LocalDate firstDayOfYear = now.with(TemporalAdjusters.firstDayOfYear());
LocalDate lastDayOfYear = now.with(TemporalAdjusters.lastDayOfYear());

// 3. 下一个/上一个指定星期
LocalDate nextFriday = now.with(TemporalAdjusters.next(DayOfWeek.FRIDAY));
LocalDate previousMonday = now.with(TemporalAdjusters.previous(DayOfWeek.MONDAY));
// 下一个周五（如果今天是周五，返回今天）
LocalDate nextOrSameFriday = now.with(TemporalAdjusters.nextOrSame(DayOfWeek.FRIDAY));

// 4. 当月第N个指定星期
// 当月第二个周三
LocalDate secondWednesday = now.with(TemporalAdjusters.dayOfWeekInMonth(2, DayOfWeek.WEDNESDAY));

// 5. 自定义调整器（比如：下一个工作日）
TemporalAdjuster nextWorkDay = temporal -> {
    LocalDate date = LocalDate.from(temporal);
    switch (date.getDayOfWeek()) {
        case FRIDAY: return date.plusDays(3);
        case SATURDAY: return date.plusDays(2);
        default: return date.plusDays(1);
    }
};
LocalDate nextWorkDayDate = now.with(nextWorkDay);

// 1. 常用格式：yyyy-MM-dd HH:mm:ss
DateTimeFormatter fmt1 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
LocalDateTime now = LocalDateTime.now();
String fmt1Str = now.format(fmt1); // 2026-03-24 14:30:00
LocalDateTime fmt1Parse = LocalDateTime.parse(fmt1Str, fmt1);

// 2. 紧凑格式：yyyyMMddHHmmss
DateTimeFormatter fmt2 = DateTimeFormatter.ofPattern("yyyyMMddHHmmss");
String fmt2Str = now.format(fmt2); // 20260324143000

// 3. 带毫秒的格式：yyyy-MM-dd HH:mm:ss.SSS
DateTimeFormatter fmt3 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS");
String fmt3Str = now.format(fmt3); // 2026-03-24 14:30:00.123

// 4. 仅日期：yyyy年MM月dd日（中文）
DateTimeFormatter fmt4 = DateTimeFormatter.ofPattern("yyyy年MM月dd日", Locale.CHINA);
String fmt4Str = LocalDate.now().format(fmt4); // 2026年03月24日

// 1. ISO_LOCAL_DATE：2026-03-24
LocalDate date = LocalDate.now();
String isoDate = date.format(DateTimeFormatter.ISO_LOCAL_DATE);

// 2. ISO_LOCAL_TIME：14:30:00.123
LocalTime time = LocalTime.now();
String isoTime = time.format(DateTimeFormatter.ISO_LOCAL_TIME);

// 3. ISO_LOCAL_DATE_TIME：2026-03-24T14:30:00.123
LocalDateTime dateTime = LocalDateTime.now();
String isoDateTime = dateTime.format(DateTimeFormatter.ISO_LOCAL_DATE_TIME);

// 4. ISO_ZONED_DATE_TIME：2026-03-24T14:30:00.123+08:00[Asia/Shanghai]
ZonedDateTime zoned = ZonedDateTime.now(ZoneId.of("Asia/Shanghai"));
String isoZoned = zoned.format(DateTimeFormatter.ISO_ZONED_DATE_TIME);

// 5. ISO_INSTANT：2026-03-24T06:30:00.123Z（UTC时间）
Instant instant = Instant.now();
String isoInstant = instant.format(DateTimeFormatter.ISO_INSTANT);

// 1. 中文格式
DateTimeFormatter chinaFmt = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.FULL)
    .withLocale(Locale.CHINA);
String chinaStr = ZonedDateTime.now().format(chinaFmt);
// 输出：2026年3月24日 星期一 中国标准时间 14时30分00秒

// 2. 英文格式
DateTimeFormatter usFmt = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.LONG)
    .withLocale(Locale.US);
String usStr = ZonedDateTime.now().format(usFmt);
// 输出：March 24, 2026 2:30:00 PM CST

// 工具方法：null转换为默认值
public static LocalDateTime nullToDefault(LocalDateTime dateTime, LocalDateTime defaultValue) {
    return dateTime == null ? defaultValue : dateTime;
}

// 使用示例
LocalDateTime nullableDateTime = null;
LocalDateTime safeDateTime = nullToDefault(nullableDateTime, LocalDateTime.of(1970, 1, 1, 0, 0));

// 1. 最小/最大时间
LocalDate minDate = LocalDate.MIN; // -999999999-01-01
LocalDate maxDate = LocalDate.MAX; // +999999999-12-31
LocalDateTime minDateTime = LocalDateTime.MIN; // -999999999-01-01T00:00:00
LocalDateTime maxDateTime = LocalDateTime.MAX; // +999999999-12-31T23:59:59.999999999

// 2. 1970-01-01（Unix纪元）
LocalDate epochDate = LocalDate.of(1970, 1, 1);
Instant epochInstant = Instant.EPOCH; // 1970-01-01T00:00:00Z

// 3. 闰年处理
LocalDate leapYearDate = LocalDate.of(2024, 2, 29); // 2024是闰年
// 非闰年的2月29日会自动调整（ResolverStyle.SMART模式）
DateTimeFormatter fmt = DateTimeFormatter.ofPattern("yyyy-MM-dd")
    .withResolverStyle(ResolverStyle.SMART);
LocalDate adjustedDate = LocalDate.parse("2025-02-29", fmt); // 自动转为2025-03-01

// 1. UTC时间转北京时间
// 方式1：Instant + 时区
Instant utcInstant = Instant.now(); // 当前UTC时间
ZonedDateTime shanghaiTime1 = utcInstant.atZone(ZoneId.of("Asia/Shanghai"));

// 方式2：ZonedDateTime转换
ZonedDateTime utcZoned = ZonedDateTime.now(ZoneOffset.UTC);
ZonedDateTime shanghaiTime2 = utcZoned.withZoneSameInstant(ZoneId.of("Asia/Shanghai"));

// 2. 北京时间转UTC时间
ZonedDateTime shanghaiZoned = ZonedDateTime.now(ZoneId.of("Asia/Shanghai"));
ZonedDateTime utcTime1 = shanghaiZoned.withZoneSameInstant(ZoneOffset.UTC);
Instant utcInstant2 = shanghaiZoned.toInstant(); // 直接转为Instant（UTC）

// 3. 工具方法：UTC时间戳转北京时间字符串
public static String utcMilliToShanghaiStr(long utcMilli) {
    return Instant.ofEpochMilli(utcMilli)
        .atZone(ZoneId.of("Asia/Shanghai"))
        .format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
}

// 使用示例
long utcMilli = System.currentTimeMillis();
String shanghaiStr = utcMilliToShanghaiStr(utcMilli); // 2026-03-24 14:30:00

// 基础时间：上海2026-03-24 14:30:00
ZonedDateTime shanghaiTime = ZonedDateTime.of(
    2026, 3, 24, 14, 30, 0, 0,
    ZoneId.of("Asia/Shanghai")
);

// 1. 上海→纽约（考虑夏令时）
ZonedDateTime newYorkTime = shanghaiTime.withZoneSameInstant(ZoneId.of("America/New_York"));
System.out.println("纽约时间：" + newYorkTime.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
// 输出：2026-03-24 02:30:00（纽约冬令时，UTC-5）

// 2. 上海→伦敦（考虑夏令时）
ZonedDateTime londonTime = shanghaiTime.withZoneSameInstant(ZoneId.of("Europe/London"));
System.out.println("伦敦时间：" + londonTime.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
// 输出：2026-03-24 07:30:00（伦敦冬令时，UTC+0）

// 3. 多时区对比工具方法
public static Map<String, String> convertToMultipleTimeZones(ZonedDateTime sourceTime, List<String> zoneIds) {
    Map<String, String> result = new HashMap<>();
    DateTimeFormatter fmt = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
    for (String zoneId : zoneIds) {
        ZonedDateTime targetTime = sourceTime.withZoneSameInstant(ZoneId.of(zoneId));
        result.put(zoneId, targetTime.format(fmt));
    }
    return result;
}

// 使用示例
List<String> zones = Arrays.asList("Asia/Shanghai", "America/New_York", "Europe/London", "Asia/Tokyo");
Map<String, String> timeMap = convertToMultipleTimeZones(shanghaiTime, zones);
// timeMap结果：
// Asia/Shanghai → 2026-03-24 14:30:00
// America/New_York → 2026-03-24 02:30:00
// Europe/London → 2026-03-24 07:30:00
// Asia/Tokyo → 2026-03-24 15:30:00

// 测试美国东部夏令时切换（2026年3月9日2:00，时钟拨快1小时到3:00）
// 1. 夏令时切换前的时间
ZonedDateTime beforeDST = ZonedDateTime.of(
    2026, 3, 9, 1, 30, 0, 0,
    ZoneId.of("America/New_York")
);
// 加1小时，自动适配夏令时
ZonedDateTime afterDST = beforeDST.plusHours(1);
System.out.println(afterDST); // 2026-03-09T03:30-04:00[America/New_York]

// 2. 夏令时结束（2026年11月2日2:00，时钟拨慢1小时到1:00）
ZonedDateTime beforeEndDST = ZonedDateTime.of(
    2026, 11, 2, 1, 30, 0, 0,
    ZoneId.of("America/New_York")
);
ZonedDateTime afterEndDST = beforeEndDST.plusHours(1);
System.out.println(afterEndDST); // 2026-11-02T01:30-05:00[America/New_York]（重复的1点）

// 3. 检测夏令时
ZoneId nyZone = ZoneId.of("America/New_York");
ZonedDateTime nyTime = ZonedDateTime.now(nyZone);
boolean isDST = nyZone.getRules().isDaylightSavings(nyTime.toInstant());
System.out.println("纽约是否夏令时：" + isDST);

public class Order {
    private Long id;
    private String orderNo;
    // 本地日期（无时区）
    private LocalDate orderDate;
    // 带时区的下单时间（推荐）
    private OffsetDateTime createTime;
    // 本地时间（支付时间点）
    private LocalTime payTime;
    
    // getter/setter
}

<mapper namespace="com.example.mapper.OrderMapper">
    <resultMap id="OrderResultMap" type="com.example.entity.Order">
        <id property="id" column="id"/>
        <result property="orderNo" column="order_no"/>
        <result property="orderDate" column="order_date"/>
        <result property="createTime" column="create_time"/>
        <result property="payTime" column="pay_time"/>
    </resultMap>
    <select id="selectById" resultMap="OrderResultMap">
        SELECT id, order_no, order_date, create_time, pay_time
        FROM `order`
        WHERE id = #{id}
    </select>
    <insert id="insert">
        INSERT INTO `order` (order_no, order_date, create_time, pay_time)
        VALUES (#{orderNo}, #{orderDate}, #{createTime}, #{payTime})
    </insert>
</mapper>

@Component
public class MyMetaObjectHandler implements MetaObjectHandler {
    @Override
    public void insertFill(MetaObject metaObject) {
        // 填充创建时间（UTC偏移量）
        strictInsertFill(metaObject, "createTime", OffsetDateTime.class, OffsetDateTime.now(ZoneOffset.UTC));
    }

    @Override
    public void updateFill(MetaObject metaObject) {
        // 填充更新时间
        strictUpdateFill(metaObject, "updateTime", OffsetDateTime.class, OffsetDateTime.now(ZoneOffset.UTC));
    }
}

@RestController
@RequestMapping("/order")
public class OrderController {
    // 接收LocalDate参数（格式：yyyy-MM-dd）
    @GetMapping("/by-date")
    public List<Order> getByDate(@RequestParam @DateTimeFormat(pattern = "yyyy-MM-dd") LocalDate orderDate) {
        return orderService.getByDate(orderDate);
    }
    
    // 接收LocalDateTime参数（格式：yyyy-MM-dd HH:mm:ss）
    @GetMapping("/by-time")
    public List<Order> getByTime(@RequestParam @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") LocalDateTime createTime) {
        return orderService.getByTime(createTime);
    }
}

public class OrderVO {
    private Long id;
    private String orderNo;
    
    // 格式化LocalDate为yyyy-MM-dd
    @JsonFormat(pattern = "yyyy-MM-dd")
    private LocalDate orderDate;
    
    // 格式化OffsetDateTime为yyyy-MM-dd HH:mm:ss（转为东8区）
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "Asia/Shanghai")
    private OffsetDateTime createTime;
    
    // getter/setter
}

@Configuration
public class WebConfig implements WebMvcConfigurer {
    // 全局请求参数时间格式化
    @Bean
    public Formatter<LocalDateTime> localDateTimeFormatter() {
        return new Formatter<LocalDateTime>() {
            @Override
            public LocalDateTime parse(String text, Locale locale) {
                return LocalDateTime.parse(text, DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
            }

            @Override
            public String print(LocalDateTime object, Locale locale) {
                return object.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
            }
        };
    }
    
    // 全局JSON时间格式化（Jackson）
    @Bean
    public Jackson2ObjectMapperBuilderCustomizer jackson2ObjectMapperBuilderCustomizer() {
        return builder -> {
            // LocalDate格式
            builder.simpleDateFormat("yyyy-MM-dd");
            builder.serializers(new LocalDateSerializer(DateTimeFormatter.ofPattern("yyyy-MM-dd")));
            builder.deserializers(new LocalDateDeserializer(DateTimeFormatter.ofPattern("yyyy-MM-dd")));
            // LocalDateTime格式
            builder.serializers(new LocalDateTimeSerializer(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
            builder.deserializers(new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
            // OffsetDateTime格式（转为东8区）
            DateTimeFormatter offsetFmt = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")
                .withZone(ZoneId.of("Asia/Shanghai"));
            builder.serializers(new OffsetDateTimeSerializer(offsetFmt));
        };
    }
}

// 日志格式配置（logback.xml）
<appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
    <file>logs/app.log</file>
    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
        <fileNamePattern>logs/app.%d{yyyy-MM-dd}.log</fileNamePattern>
    </rollingPolicy>
    <encoder>
        <!-- 日志时间用UTC+时区标注，格式：yyyy-MM-dd HH:mm:ss.SSS UTC -->
        <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS UTC} [%thread] %-5level %logger{36} - %msg%n</pattern>
    </encoder>
</appender>
// 代码中输出UTC时间
public class LogUtils {
    public static String getUtcLogTime() {
        return Instant.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS")) + " UTC";
    }
}
// 使用示例
logger.info("{} - 订单{}创建成功", LogUtils.getUtcLogTime(), orderNo);
// 日志输出：2026-03-24 06:30:00.123 UTC - 订单123456创建成功

// 测试DateTimeFormatter线程安全
public class DateTimeFormatterThreadSafeTest {
    private static final DateTimeFormatter FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
    private static final int THREAD_COUNT = 100;
    private static final int LOOP_COUNT = 1000;

    public static void main(String[] args) throws InterruptedException {
        ExecutorService executor = Executors.newFixedThreadPool(THREAD_COUNT);
        CountDownLatch latch = new CountDownLatch(THREAD_COUNT);
        
        for (int i = 0; i < THREAD_COUNT; i++) {
            executor.submit(() -> {
                try {
                    for (int j = 0; j < LOOP_COUNT; j++) {
                        LocalDateTime now = LocalDateTime.now();
                        String formatted = now.format(FORMATTER);
                        LocalDateTime parsed = LocalDateTime.parse(formatted, FORMATTER);
                        if (!now.truncatedTo(ChronoUnit.SECONDS).equals(parsed)) {
                            System.out.println("线程安全验证失败：" + formatted);
                        }
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    latch.countDown();
                }
            });
        }
        
        latch.await();
        executor.shutdown();
        System.out.println("线程安全验证通过！");
    }
}

<dependency>
    <groupId>cn.hutool</groupId>
    <artifactId>hutool-all</artifactId>
    <version>5.8.22</version>
</dependency>

// 1. UTC时间转北京时间字符串
String shanghaiStr = DateUtil.format(
    DateUtil.utcToLocal(Instant.now()), 
    "yyyy-MM-dd HH:mm:ss"
);

// 2. 获取本月第一天0点
LocalDateTime firstDayOfMonth = DateUtil.beginOfMonth(LocalDateTime.now());

// 3. 计算两个日期的间隔（人性化）
String between = DateUtil.formatBetween(
    LocalDateTime.of(2026, 1, 1, 0, 0),
    LocalDateTime.now(),
    BetweenFormatter.Level.DAY
);
System.out.println(between); // 83天14小时30分钟

// 4. 日期判断（是否周末/节假日）
boolean isWeekend = DateUtil.isWeekend(LocalDate.now());

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.14.0</version>
</dependency>

// 1. 旧API转新API
Date oldDate = new Date();
LocalDateTime newDateTime = DateUtils.toLocalDateTime(oldDate);

// 2. 新API转旧API（兼容存量代码）
LocalDateTime newDateTime = LocalDateTime.now();
Date oldDate = DateUtils.toDate(newDateTime);

// 3. 日期加减（兼容旧API）
Date newDate = DateUtils.addDays(oldDate, 7);

/**
 * java.time工具类（封装高频操作）
 */
public class LocalDateTimeUtils {
    // 常用格式化器（线程安全）
    public static final DateTimeFormatter DEFAULT_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
    public static final DateTimeFormatter DATE_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd");
    public static final DateTimeFormatter TIME_FORMATTER = DateTimeFormatter.ofPattern("HH:mm:ss");
    
    // 上海时区
    private static final ZoneId SHANGHAI_ZONE = ZoneId.of("Asia/Shanghai");
    // UTC时区
    private static final ZoneId UTC_ZONE = ZoneOffset.UTC;

    /**
     * UTC毫秒数转上海时间字符串
     */
    public static String utcMilliToShanghaiStr(long utcMilli) {
        return Instant.ofEpochMilli(utcMilli)
            .atZone(SHANGHAI_ZONE)
            .format(DEFAULT_FORMATTER);
    }

    /**
     * 上海时间字符串转UTC毫秒数
     */
    public static long shanghaiStrToUtcMilli(String shanghaiStr) {
        return LocalDateTime.parse(shanghaiStr, DEFAULT_FORMATTER)
            .atZone(SHANGHAI_ZONE)
            .toInstant()
            .toEpochMilli();
    }

    /**
     * 获取本月第一天0点（上海时区）
     */
    public static LocalDateTime getFirstDayOfMonth() {
        return LocalDate.now(SHANGHAI_ZONE)
            .with(TemporalAdjusters.firstDayOfMonth())
            .atStartOfDay();
    }

    /**
     * 获取本月最后一天23:59:59（上海时区）
     */
    public static LocalDateTime getLastDayOfMonth() {
        return LocalDate.now(SHANGHAI_ZONE)
            .with(TemporalAdjusters.lastDayOfMonth())
            .atTime(23, 59, 59);
    }

    /**
     * 计算两个时间的间隔（天/小时/分钟/秒）
     */
    public static Map<String, Long> getDuration(LocalDateTime start, LocalDateTime end) {
        Duration duration = Duration.between(start, end);
        Map<String, Long> result = new HashMap<>();
        result.put("days", duration.toDays());
        result.put("hours", duration.toHours() % 24);
        result.put("minutes", duration.toMinutes() % 60);
        result.put("seconds", duration.getSeconds() % 60);
        return result;
    }
}