// 錯誤示范：靜態(tài)SimpleDateFormat引發(fā)線程安全問題
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); // 多線程調(diào)用必出問題
    }
}

// Calendar的設(shè)計示例
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); // 輸出帶本地時區(qū)的字符串，易誤導(dǎo)開發(fā)者
// 實際輸出：Mon Mar 24 14:30:00 CST 2026（CST是中國標準時間）

// 創(chuàng)建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); // 是否在指定日期之前

// 創(chuàng)建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點之后

// 創(chuàng)建LocalDateTime
LocalDateTime now = LocalDateTime.now(); // 當前本地日期時間
LocalDateTime specified = LocalDateTime.of(2026, 3, 24, 14, 30); // 指定時間
LocalDateTime fromString = LocalDateTime.parse("2026-03-24T14:30:00"); // ISO格式

// 轉(zhuǎn)換
LocalDate date = now.toLocalDate(); // 提取日期
LocalTime time = now.toLocalTime(); // 提取時間

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

// 創(chuàng)建ZonedDateTime
// 方式1：當前時區(qū)時間
ZonedDateTime shanghaiNow = ZonedDateTime.now(ZoneId.of("Asia/Shanghai"));
// 方式2：UTC時間
ZonedDateTime utcNow = ZonedDateTime.now(ZoneOffset.UTC);
// 方式3：LocalDateTime + 時區(qū)
LocalDateTime localDateTime = LocalDateTime.of(2026, 3, 24, 14, 30);
ZonedDateTime zoned = ZonedDateTime.of(localDateTime, ZoneId.of("Europe/London"));

// 時區(qū)轉(zhuǎn)換
ZonedDateTime newYorkTime = shanghaiNow.withZoneSameInstant(ZoneId.of("America/New_York"));

// 提取信息
ZoneId zoneId = shanghaiNow.getZone(); // 獲取時區(qū)
OffsetDateTime offset = shanghaiNow.toOffsetDateTime(); // 轉(zhuǎn)換為偏移量時間

// 創(chuàng)建Instant
Instant now = Instant.now(); // 當前UTC時間戳
Instant fromEpochMilli = Instant.ofEpochMilli(System.currentTimeMillis()); // 從毫秒數(shù)創(chuàng)建
Instant fromString = Instant.parse("2026-03-24T06:30:00Z"); // ISO格式（Z代表UTC）

// 轉(zhuǎn)換
long epochMilli = now.toEpochMilli(); // 轉(zhuǎn)為毫秒時間戳
ZonedDateTime zoned = now.atZone(ZoneId.of("Asia/Shanghai")); // 轉(zhuǎn)為上海時區(qū)時間

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

// 創(chuàng)建OffsetDateTime
OffsetDateTime now = OffsetDateTime.now(); // 當前本地偏移量時間
OffsetDateTime utc = OffsetDateTime.now(ZoneOffset.UTC); // UTC偏移量（+00:00）
OffsetDateTime shanghai = OffsetDateTime.of(LocalDateTime.now(), ZoneOffset.ofHours(8)); // 東8區(qū)

// 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));

// 當月第一個工作日（假設(shè)周末休息）
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. 指定時區(qū)的當前時間
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. 從時間戳創(chuàng)建
long epochMilli = 1771852200000L; // 2026-03-24 14:30:00的毫秒數(shù)
Instant instantFromMilli = Instant.ofEpochMilli(epochMilli);
LocalDateTime dateTimeFromMilli = LocalDateTime.ofInstant(instantFromMilli, ZoneId.of("Asia/Shanghai"));

// 3. 從字符串創(chuàng)建（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. 從字符串創(chuàng)建（自定義格式）
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. 讀取帶時區(qū)的時間（推薦用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. 自定義調(diào)整器（比如：下一個工作日）
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轉(zhuǎn)換為默認值
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日會自動調(diào)整（ResolverStyle.SMART模式）
DateTimeFormatter fmt = DateTimeFormatter.ofPattern("yyyy-MM-dd")
    .withResolverStyle(ResolverStyle.SMART);
LocalDate adjustedDate = LocalDate.parse("2025-02-29", fmt); // 自動轉(zhuǎn)為2025-03-01

// 1. UTC時間轉(zhuǎn)北京時間
// 方式1：Instant + 時區(qū)
Instant utcInstant = Instant.now(); // 當前UTC時間
ZonedDateTime shanghaiTime1 = utcInstant.atZone(ZoneId.of("Asia/Shanghai"));

// 方式2：ZonedDateTime轉(zhuǎn)換
ZonedDateTime utcZoned = ZonedDateTime.now(ZoneOffset.UTC);
ZonedDateTime shanghaiTime2 = utcZoned.withZoneSameInstant(ZoneId.of("Asia/Shanghai"));

// 2. 北京時間轉(zhuǎn)UTC時間
ZonedDateTime shanghaiZoned = ZonedDateTime.now(ZoneId.of("Asia/Shanghai"));
ZonedDateTime utcTime1 = shanghaiZoned.withZoneSameInstant(ZoneOffset.UTC);
Instant utcInstant2 = shanghaiZoned.toInstant(); // 直接轉(zhuǎn)為Instant（UTC）

// 3. 工具方法：UTC時間戳轉(zhuǎn)北京時間字符串
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

// 基礎(chǔ)時間：上海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. 多時區(qū)對比工具方法
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結(jié)果：
// 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. 夏令時結(jié)束（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]（重復(fù)的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;
    // 本地日期（無時區(qū)）
    private LocalDate orderDate;
    // 帶時區(qū)的下單時間（推薦）
    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) {
        // 填充創(chuàng)建時間（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參數(shù)（格式：yyyy-MM-dd）
    @GetMapping("/by-date")
    public List<Order> getByDate(@RequestParam @DateTimeFormat(pattern = "yyyy-MM-dd") LocalDate orderDate) {
        return orderService.getByDate(orderDate);
    }
    
    // 接收LocalDateTime參數(shù)（格式：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（轉(zhuǎn)為東8區(qū)）
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "Asia/Shanghai")
    private OffsetDateTime createTime;
    
    // getter/setter
}

@Configuration
public class WebConfig implements WebMvcConfigurer {
    // 全局請求參數(shù)時間格式化
    @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格式（轉(zhuǎn)為東8區(qū)）
            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+時區(qū)標注，格式：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("{} - 訂單{}創(chuàng)建成功", LogUtils.getUtcLogTime(), orderNo);
// 日志輸出：2026-03-24 06:30:00.123 UTC - 訂單123456創(chuàng)建成功

// 測試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時間轉(zhuǎn)北京時間字符串
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. 日期判斷（是否周末/節(jié)假日）
boolean isWeekend = DateUtil.isWeekend(LocalDate.now());

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

// 1. 舊API轉(zhuǎn)新API
Date oldDate = new Date();
LocalDateTime newDateTime = DateUtils.toLocalDateTime(oldDate);

// 2. 新API轉(zhuǎn)舊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");
    
    // 上海時區(qū)
    private static final ZoneId SHANGHAI_ZONE = ZoneId.of("Asia/Shanghai");
    // UTC時區(qū)
    private static final ZoneId UTC_ZONE = ZoneOffset.UTC;

    /**
     * UTC毫秒數(shù)轉(zhuǎn)上海時間字符串
     */
    public static String utcMilliToShanghaiStr(long utcMilli) {
        return Instant.ofEpochMilli(utcMilli)
            .atZone(SHANGHAI_ZONE)
            .format(DEFAULT_FORMATTER);
    }

    /**
     * 上海時間字符串轉(zhuǎn)UTC毫秒數(shù)
     */
    public static long shanghaiStrToUtcMilli(String shanghaiStr) {
        return LocalDateTime.parse(shanghaiStr, DEFAULT_FORMATTER)
            .atZone(SHANGHAI_ZONE)
            .toInstant()
            .toEpochMilli();
    }

    /**
     * 獲取本月第一天0點（上海時區(qū)）
     */
    public static LocalDateTime getFirstDayOfMonth() {
        return LocalDate.now(SHANGHAI_ZONE)
            .with(TemporalAdjusters.firstDayOfMonth())
            .atStartOfDay();
    }

    /**
     * 獲取本月最后一天23:59:59（上海時區(qū)）
     */
    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;
    }
}