常用工具类汇总：SM2/SM4/拼音/文件/HTTP 全覆盖

import cn.hutool.extra.pinyin.PinyinUtil;

import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;

/**
 * 中文姓名转拼音邮箱账号工具
 *
 * 支持：
 * - 单姓：张三 → san.zhang
 * - 复姓：诸葛孔明 → kongming.zhuge
 * - 单名：张伟 → wei.zhang
 */
public class PinyinEmailUtil {

    /**
     * 中国常见复姓集合（可根据需要扩充）
     */
    private static final Set<String> COMPOUND_SURNAMES = new HashSet<>(Arrays.asList(
            "欧阳", "太史", "端木", "上官", "司马", "东方", "独孤", "南宫",
            "万俟", "闻人", "夏侯", "诸葛", "尉迟", "公羊", "赫连", "澹台",
            "皇甫", "宗政", "濮阳", "公冶", "太叔", "申屠", "公孙", "慕容",
            "仲孙", "钟离", "长孙", "宇文", "司徒", "鲜于", "司空", "闾丘",
            "子车", "亓官", "司寇", "巫马", "公西", "颛孙", "壤驷", "公良",
            "漆雕", "乐正", "宰父", "谷梁", "拓跋", "夹谷", "轩辕", "令狐",
            "段干", "百里", "呼延", "东郭", "南门", "羊舌", "微生", "公户",
            "公玉", "公仪", "梁丘", "公仲", "公上", "公门", "公山", "公坚",
            "左丘", "公伯", "西门", "公祖", "第五", "公乘", "贯丘", "公皙",
            "南荣", "东里", "东宫", "仲长", "子书", "子桑", "即墨", "达奚",
            "褚师"
    ));

    /**
     * 将中文姓名转换为拼音邮箱账号
     *
     * @param chineseName 中文姓名（如 "诸葛孔明"）
     * @param domain      邮箱域名（如 "company.com"）
     * @return 邮箱账号（如 "kongming.zhuge@company.com"）
     */
    public static String toEmail(String chineseName, String domain) {
        if (chineseName == null || chineseName.length() < 2) {
            throw new IllegalArgumentException("姓名至少需要2个字符");
        }

        String surname;
        String givenName;

        // 判断是否为复姓（取前两个字匹配）
        String firstTwo = chineseName.substring(0, 2);
        if (COMPOUND_SURNAMES.contains(firstTwo)) {
            surname = firstTwo;
            givenName = chineseName.substring(2);
        } else {
            surname = chineseName.substring(0, 1);
            givenName = chineseName.substring(1);
        }

        // 转拼音（去掉声调，转小写）
        String surnamePinyin = PinyinUtil.getPinyin(surname, "");
        String givenNamePinyin = PinyinUtil.getPinyin(givenName, "");

        return givenNamePinyin + "." + surnamePinyin + "@" + domain;
    }

    /**
     * 仅生成邮箱前缀（不含域名）
     */
    public static String toEmailPrefix(String chineseName) {
        String prefix = toEmail(chineseName, "").replace("@", "");
        // 去除末尾可能多余的点号
        if (prefix.endsWith(".")) {
            prefix = prefix.substring(0, prefix.length() - 1);
        }
        return prefix;
    }
}

public class PinyinEmailDemo {
    public static void main(String[] args) {
        // 单姓
        System.out.println(PinyinEmailUtil.toEmail("张三", "company.com"));
        // 输出: san.zhang@company.com

        // 复姓
        System.out.println(PinyinEmailUtil.toEmail("诸葛孔明", "company.com"));
        // 输出: kongming.zhuge@company.com

        // 单名
        System.out.println(PinyinEmailUtil.toEmail("张伟", "company.com"));
        // 输出: wei.zhang@company.com

        // 仅前缀
        System.out.println(PinyinEmailUtil.toEmailPrefix("李小龙"));
        // 输出: xiaolong.li
    }
}

<dependency>
    <groupId>cn.hutool</groupId>
    <artifactId>hutool-extra</artifactId>
    <version>5.8.44</version>
</dependency>
<!-- pinyin4j 底层引擎 -->
<dependency>
    <groupId>com.belerweb</groupId>
    <artifactId>pinyin4j</artifactId>
    <version>2.5.1</version>
</dependency>

import java.math.BigInteger;

/**
 * SM2 密钥处理工具
 *
 * 解决 BigInteger 丢失前导 0 的经典坑
 */
public class SM2KeyUtil {

    /**
     * SM2 密钥的固定长度（字节数）
     */
    private static final int SM2_KEY_BYTE_LENGTH = 32;

    /**
     * 将十六进制密钥字符串转换为固定长度的字节数组
     *
     * 核心问题：new BigInteger("00abc...") 会丢弃前导 0，
     * 导致 toByteArray() 返回的数组长度 < 32。
     * 而 SM2 算法要求密钥必须是 32 字节。
     *
     * @param hexKey 十六进制密钥字符串（64 个字符）
     * @return 固定 32 字节的密钥字节数组
     */
    public static byte[] hexToFixedBytes(String hexKey) {
        BigInteger bigInt = new BigInteger(hexKey, 16);
        byte[] rawBytes = bigInt.toByteArray();

        // 如果长度刚好 32 字节，直接返回
        if (rawBytes.length == SM2_KEY_BYTE_LENGTH) {
            return rawBytes;
        }

        // 如果长度为 33 字节（BigInteger 对正数补了符号位 0），去掉第一个字节
        if (rawBytes.length == SM2_KEY_BYTE_LENGTH + 1 && rawBytes[0] == 0) {
            byte[] fixed = new byte[SM2_KEY_BYTE_LENGTH];
            System.arraycopy(rawBytes, 1, fixed, 0, SM2_KEY_BYTE_LENGTH);
            return fixed;
        }

        // 如果长度 < 32（丢失了前导 0），左补 0
        if (rawBytes.length < SM2_KEY_BYTE_LENGTH) {
            byte[] fixed = new byte[SM2_KEY_BYTE_LENGTH];
            // 从右往左填充，前面补 0
            System.arraycopy(rawBytes, 0, fixed, SM2_KEY_BYTE_LENGTH - rawBytes.length, rawBytes.length);
            return fixed;
        }

        throw new IllegalArgumentException("无效的 SM2 密钥长度: " + rawBytes.length);
    }

    /**
     * 从 PEM 格式私钥中提取十六进制密钥
     *
     * @param pemContent PEM 内容
     * @return 十六进制密钥字符串
     */
    public static String extractHexFromPem(String pemContent) {
        // 去掉 PEM 头尾和换行
        String base64 = pemContent
                .replace("-----BEGIN EC PRIVATE KEY-----", "")
                .replace("-----END EC PRIVATE KEY-----", "")
                .replace("-----BEGIN PRIVATE KEY-----", "")
                .replace("-----END PRIVATE KEY-----", "")
                .replaceAll("\\s+", "");

        byte[] der = java.util.Base64.getDecoder().decode(base64);
        // DER 编码的 EC 私钥中，最后 32 字节是私钥值
        byte[] privateKey = new byte[SM2_KEY_BYTE_LENGTH];
        System.arraycopy(der, der.length - SM2_KEY_BYTE_LENGTH, privateKey, 0, SM2_KEY_BYTE_LENGTH);

        return bytesToHex(privateKey);
    }

    /**
     * 字节数组转十六进制字符串
     */
    public static String bytesToHex(byte[] bytes) {
        StringBuilder sb = new StringBuilder();
        for (byte b : bytes) {
            sb.append(String.format("%02x", b & 0xff));
        }
        return sb.toString();
    }
}

import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.util.Base64;

/**
 * SM4 对称加密工具类
 *
 * 支持 ECB 和 CBC 模式，默认 PKCS5Padding。
 * 注意：标准 JDK 不内置 SM4，需要先引入并注册 Bouncy Castle 等 JCE Provider。
 */
public class SM4Util {

    private static final String ALGORITHM = "SM4";
    private static final String TRANSFORMATION_ECB = "SM4/ECB/PKCS5Padding";
    private static final String TRANSFORMATION_CBC = "SM4/CBC/PKCS5Padding";

    /**
     * SM4-ECB 加密
     *
     * @param plaintext 明文
     * @param hexKey    十六进制密钥（32 个字符 = 16 字节）
     * @return Base64 编码的密文
     */
    public static String encryptEcb(String plaintext, String hexKey) {
        try {
            byte[] keyBytes = hexStringToBytes(hexKey);
            SecretKeySpec keySpec = new SecretKeySpec(keyBytes, ALGORITHM);
            Cipher cipher = Cipher.getInstance(TRANSFORMATION_ECB);
            cipher.init(Cipher.ENCRYPT_MODE, keySpec);

            byte[] encrypted = cipher.doFinal(plaintext.getBytes(StandardCharsets.UTF_8));
            return Base64.getEncoder().encodeToString(encrypted);
        } catch (Exception e) {
            throw new RuntimeException("SM4 ECB 加密失败", e);
        }
    }

    /**
     * SM4-ECB 解密
     *
     * @param ciphertext Base64 编码的密文
     * @param hexKey     十六进制密钥
     * @return 明文
     */
    public static String decryptEcb(String ciphertext, String hexKey) {
        try {
            byte[] keyBytes = hexStringToBytes(hexKey);
            SecretKeySpec keySpec = new SecretKeySpec(keyBytes, ALGORITHM);
            Cipher cipher = Cipher.getInstance(TRANSFORMATION_ECB);
            cipher.init(Cipher.DECRYPT_MODE, keySpec);

            byte[] decrypted = cipher.doFinal(Base64.getDecoder().decode(ciphertext));
            return new String(decrypted, StandardCharsets.UTF_8);
        } catch (Exception e) {
            throw new RuntimeException("SM4 ECB 解密失败", e);
        }
    }

    /**
     * SM4-CBC 加密
     *
     * @param plaintext 明文
     * @param hexKey    十六进制密钥（32 字符）
     * @param hexIv     十六进制 IV 向量（32 字符）
     * @return Base64 编码的密文
     */
    public static String encryptCbc(String plaintext, String hexKey, String hexIv) {
        try {
            byte[] keyBytes = hexStringToBytes(hexKey);
            byte[] ivBytes = hexStringToBytes(hexIv);
            SecretKeySpec keySpec = new SecretKeySpec(keyBytes, ALGORITHM);
            IvParameterSpec ivSpec = new IvParameterSpec(ivBytes);

            Cipher cipher = Cipher.getInstance(TRANSFORMATION_CBC);
            cipher.init(Cipher.ENCRYPT_MODE, keySpec, ivSpec);

            byte[] encrypted = cipher.doFinal(plaintext.getBytes(StandardCharsets.UTF_8));
            return Base64.getEncoder().encodeToString(encrypted);
        } catch (Exception e) {
            throw new RuntimeException("SM4 CBC 加密失败", e);
        }
    }

    /**
     * SM4-CBC 解密
     */
    public static String decryptCbc(String ciphertext, String hexKey, String hexIv) {
        try {
            byte[] keyBytes = hexStringToBytes(hexKey);
            byte[] ivBytes = hexStringToBytes(hexIv);
            SecretKeySpec keySpec = new SecretKeySpec(keyBytes, ALGORITHM);
            IvParameterSpec ivSpec = new IvParameterSpec(ivBytes);

            Cipher cipher = Cipher.getInstance(TRANSFORMATION_CBC);
            cipher.init(Cipher.DECRYPT_MODE, keySpec, ivSpec);

            byte[] decrypted = cipher.doFinal(Base64.getDecoder().decode(ciphertext));
            return new String(decrypted, StandardCharsets.UTF_8);
        } catch (Exception e) {
            throw new RuntimeException("SM4 CBC 解密失败", e);
        }
    }

    private static byte[] hexStringToBytes(String hex) {
        if (hex == null || (hex.length() & 1) == 1) {
            throw new IllegalArgumentException("十六进制字符串长度必须为偶数");
        }
        int len = hex.length();
        byte[] bytes = new byte[len / 2];
        for (int i = 0; i < len; i += 2) {
            int high = Character.digit(hex.charAt(i), 16);
            int low = Character.digit(hex.charAt(i + 1), 16);
            if (high < 0 || low < 0) {
                throw new IllegalArgumentException("包含非法十六进制字符: " + hex);
            }
            bytes[i / 2] = (byte) ((high << 4) + low);
        }
        return bytes;
    }
}

public class SM4Demo {
    public static void main(String[] args) {
        String key = "0123456789abcdef0123456789abcdef";  // 16 字节 = 32 hex
        String plaintext = "这是一段需要加密的敏感数据";

        // ECB 模式
        String encrypted = SM4Util.encryptEcb(plaintext, key);
        System.out.println("密文: " + encrypted);
        String decrypted = SM4Util.decryptEcb(encrypted, key);
        System.out.println("明文: " + decrypted);

        // CBC 模式（更安全，推荐）
        String iv = "abcdef0123456789abcdef0123456789";
        String encryptedCbc = SM4Util.encryptCbc(plaintext, key, iv);
        System.out.println("CBC密文: " + encryptedCbc);
        String decryptedCbc = SM4Util.decryptCbc(encryptedCbc, key, iv);
        System.out.println("CBC明文: " + decryptedCbc);
    }
}

import java.io.*;
import java.nio.charset.StandardCharsets;
import java.nio.file.*;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 文件读写工具类
 */
public class FileUtil {

    /**
     * 读取文本文件内容为字符串
     *
     * @param filePath 文件路径
     * @return 文件内容
     */
    public static String readFile(String filePath) {
        try {
            byte[] bytes = Files.readAllBytes(Paths.get(filePath));
            return new String(bytes, StandardCharsets.UTF_8);
        } catch (IOException e) {
            throw new RuntimeException("读取文件失败: " + filePath, e);
        }
    }

    /**
     * 读取文件为行列表
     *
     * @param filePath 文件路径
     * @return 行列表
     */
    public static List<String> readLines(String filePath) {
        try {
            return Files.readAllLines(Paths.get(filePath), StandardCharsets.UTF_8);
        } catch (IOException e) {
            throw new RuntimeException("读取文件失败: " + filePath, e);
        }
    }

    /**
     * 写入字符串到文件（覆盖模式）
     *
     * @param filePath 文件路径
     * @param content  内容
     */
    public static void writeFile(String filePath, String content) {
        try {
            // 自动创建父目录
            Path path = Paths.get(filePath);
            if (path.getParent() != null) {
                Files.createDirectories(path.getParent());
            }
            Files.write(path, content.getBytes(StandardCharsets.UTF_8));
        } catch (IOException e) {
            throw new RuntimeException("写入文件失败: " + filePath, e);
        }
    }

    /**
     * 追加内容到文件
     *
     * @param filePath 文件路径
     * @param content  内容
     */
    public static void appendFile(String filePath, String content) {
        try {
            Path path = Paths.get(filePath);
            if (path.getParent() != null) {
                Files.createDirectories(path.getParent());
            }
            Files.write(path, content.getBytes(StandardCharsets.UTF_8),
                    StandardOpenOption.CREATE, StandardOpenOption.APPEND);
        } catch (IOException e) {
            throw new RuntimeException("追加文件失败: " + filePath, e);
        }
    }

    /**
     * 读取 classpath 资源文件
     *
     * @param resourcePath 资源路径（相对于 classpath）
     * @return 文件内容
     */
    public static String readClasspathResource(String resourcePath) {
        try (InputStream is = FileUtil.class.getClassLoader().getResourceAsStream(resourcePath)) {
            if (is == null) {
                throw new FileNotFoundException("资源文件不存在: " + resourcePath);
            }
            BufferedReader reader = new BufferedReader(new InputStreamReader(is, StandardCharsets.UTF_8));
            return reader.lines().collect(Collectors.joining("\n"));
        } catch (IOException e) {
            throw new RuntimeException("读取资源文件失败: " + resourcePath, e);
        }
    }
}

// 读取文件
String content = FileUtil.readFile("/data/config/app.properties");

// 读取 classpath 资源
String template = FileUtil.readClasspathResource("templates/email.html");

// 写入文件
FileUtil.writeFile("/data/output/result.txt", "处理完成");

// 追加日志
FileUtil.appendFile("/data/logs/audit.log", "2024-01-01 操作记录...");

import java.beans.BeanInfo;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;

/**
 * Bean 转 Map 工具
 */
public class BeanUtil {

    /**
     * 将 Java Bean 转为 Map<String, String>
     *
     * @param bean  Java Bean 对象
     * @return 属性名 → 属性值的 Map（值调用 toString()）
     */
    public static Map<String, String> beanToStringMap(Object bean) {
        if (bean == null) {
            return new HashMap<>();
        }

        Map<String, String> map = new HashMap<>();
        try {
            BeanInfo beanInfo = Introspector.getBeanInfo(bean.getClass(), Object.class);
            PropertyDescriptor[] pds = beanInfo.getPropertyDescriptors();

            for (PropertyDescriptor pd : pds) {
                Method getter = pd.getReadMethod();
                if (getter != null) {
                    Object value = getter.invoke(bean);
                    map.put(pd.getName(), value != null ? value.toString() : "");
                }
            }
        } catch (Exception e) {
            throw new RuntimeException("Bean 转 Map 失败", e);
        }
        return map;
    }

    /**
     * 将 Java Bean 转为 Map<String, Object>（保留原始类型）
     */
    public static Map<String, Object> beanToMap(Object bean) {
        if (bean == null) {
            return new HashMap<>();
        }

        Map<String, Object> map = new HashMap<>();
        try {
            BeanInfo beanInfo = Introspector.getBeanInfo(bean.getClass(), Object.class);
            PropertyDescriptor[] pds = beanInfo.getPropertyDescriptors();

            for (PropertyDescriptor pd : pds) {
                Method getter = pd.getReadMethod();
                if (getter != null) {
                    map.put(pd.getName(), getter.invoke(bean));
                }
            }
        } catch (Exception e) {
            throw new RuntimeException("Bean 转 Map 失败", e);
        }
        return map;
    }

    /**
     * Map 转 Bean
     *
     * @param map   数据 Map
     * @param clazz 目标类型
     * @return Bean 对象
     */
    public static <T> T mapToBean(Map<String, Object> map, Class<T> clazz) {
        try {
            T bean = clazz.getDeclaredConstructor().newInstance();
            BeanInfo beanInfo = Introspector.getBeanInfo(clazz, Object.class);
            PropertyDescriptor[] pds = beanInfo.getPropertyDescriptors();

            for (PropertyDescriptor pd : pds) {
                Object value = map.get(pd.getName());
                if (value != null && pd.getWriteMethod() != null) {
                    // 简单类型转换
                    Class<?> propType = pd.getPropertyType();
                    if (propType == String.class) {
                        pd.getWriteMethod().invoke(bean, value.toString());
                    } else if (propType == Integer.class || propType == int.class) {
                        pd.getWriteMethod().invoke(bean, Integer.parseInt(value.toString()));
                    } else if (propType == Long.class || propType == long.class) {
                        pd.getWriteMethod().invoke(bean, Long.parseLong(value.toString()));
                    } else {
                        pd.getWriteMethod().invoke(bean, value);
                    }
                }
            }
            return bean;
        } catch (Exception e) {
            throw new RuntimeException("Map 转 Bean 失败", e);
        }
    }
}

import java.util.Collection;
import java.util.Map;

/**
 * 集合判空工具
 */
public class CollUtil {

    /**
     * Collection 是否为空（null 或 size==0）
     */
    public static boolean isEmpty(Collection<?> collection) {
        return collection == null || collection.isEmpty();
    }

    /**
     * Collection 是否非空
     */
    public static boolean isNotEmpty(Collection<?> collection) {
        return !isEmpty(collection);
    }

    /**
     * Map 是否为空
     */
    public static boolean isEmpty(Map<?, ?> map) {
        return map == null || map.isEmpty();
    }

    /**
     * Map 是否非空
     */
    public static boolean isNotEmpty(Map<?, ?> map) {
        return !isEmpty(map);
    }

    /**
     * 数组是否为空
     */
    public static boolean isEmpty(Object[] array) {
        return array == null || array.length == 0;
    }
}

List<String> list = queryUsers();

// ❌ 不安全
if (list != null && list.size() > 0) { ... }

// ✅ 推荐
if (CollUtil.isNotEmpty(list)) {
    list.forEach(System.out::println);
}

// 也可以用 hutool（如果项目已引入）
// cn.hutool.core.collection.CollUtil.isEmpty(list)

import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.Date;

/**
 * 日期格式化工具
 *
 * 基于 Java 8+ 的 java.time API（推荐，线程安全）
 */
public class DateUtil {

    // ========== 常用格式 ==========
    public static final String DATE_PATTERN = "yyyy-MM-dd";
    public static final String DATETIME_PATTERN = "yyyy-MM-dd HH:mm:ss";
    public static final String COMPACT_DATE = "yyyyMMdd";
    public static final String COMPACT_DATETIME = "yyyyMMddHHmmss";
    public static final String CHINESE_DATE = "yyyy年MM月dd日";

    // ========== 预定义 Formatter（线程安全，可复用） ==========
    public static final DateTimeFormatter DATE_FMT = DateTimeFormatter.ofPattern(DATE_PATTERN);
    public static final DateTimeFormatter DATETIME_FMT = DateTimeFormatter.ofPattern(DATETIME_PATTERN);
    public static final DateTimeFormatter COMPACT_DATE_FMT = DateTimeFormatter.ofPattern(COMPACT_DATE);
    public static final DateTimeFormatter COMPACT_DATETIME_FMT = DateTimeFormatter.ofPattern(COMPACT_DATETIME);
    public static final DateTimeFormatter CHINESE_DATE_FMT = DateTimeFormatter.ofPattern(CHINESE_DATE);

    /**
     * 当前日期时间字符串
     */
    public static String now() {
        return LocalDateTime.now().format(DATETIME_FMT);
    }

    /**
     * 当前日期字符串
     */
    public static String today() {
        return LocalDate.now().format(DATE_FMT);
    }

    /**
     * 指定格式的当前时间
     */
    public static String now(String pattern) {
        return LocalDateTime.now().format(DateTimeFormatter.ofPattern(pattern));
    }

    /**
     * 格式化 LocalDateTime
     */
    public static String format(LocalDateTime dateTime, String pattern) {
        if (dateTime == null) return "";
        return dateTime.format(DateTimeFormatter.ofPattern(pattern));
    }

    /**
     * 格式化 LocalDate
     */
    public static String format(LocalDate date, String pattern) {
        if (date == null) return "";
        return date.format(DateTimeFormatter.ofPattern(pattern));
    }

    /**
     * 解析字符串为 LocalDateTime
     */
    public static LocalDateTime parseDateTime(String dateTimeStr, String pattern) {
        return LocalDateTime.parse(dateTimeStr, DateTimeFormatter.ofPattern(pattern));
    }

    /**
     * Date 转 LocalDateTime
     */
    public static LocalDateTime toLocalDateTime(Date date) {
        if (date == null) return null;
        return date.toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime();
    }

    /**
     * LocalDateTime 转 Date
     */
    public static Date toDate(LocalDateTime localDateTime) {
        if (localDateTime == null) return null;
        return Date.from(localDateTime.atZone(ZoneId.systemDefault()).toInstant());
    }
}

import java.time.*;
import java.time.temporal.ChronoUnit;

/**
 * 时间区间计算工具
 */
public class DateRangeUtil {

    /**
     * 计算两个日期之间的天数
     *
     * @param start 开始日期
     * @param end   结束日期
     * @return 天数（可为负数）
     */
    public static long daysBetween(LocalDate start, LocalDate end) {
        return ChronoUnit.DAYS.between(start, end);
    }

    /**
     * 计算两个时间点之间的小时数
     */
    public static long hoursBetween(LocalDateTime start, LocalDateTime end) {
        return ChronoUnit.HOURS.between(start, end);
    }

    /**
     * 计算两个时间点之间的分钟数
     */
    public static long minutesBetween(LocalDateTime start, LocalDateTime end) {
        return ChronoUnit.MINUTES.between(start, end);
    }

    /**
     * 判断当前时间是否在指定范围内
     *
     * @param start 开始时间
     * @param end   结束时间
     * @return 是否在范围内
     */
    public static boolean isNowBetween(LocalDateTime start, LocalDateTime end) {
        LocalDateTime now = LocalDateTime.now();
        return !now.isBefore(start) && !now.isAfter(end);
    }

    /**
     * 获取今天的开始时间（00:00:00）
     */
    public static LocalDateTime startOfToday() {
        return LocalDate.now().atStartOfDay();
    }

    /**
     * 获取今天的结束时间（23:59:59）
     */
    public static LocalDateTime endOfToday() {
        return LocalDate.now().atTime(LocalTime.MAX);
    }

    /**
     * 获取本周的开始时间（周一 00:00:00）
     */
    public static LocalDateTime startOfWeek() {
        return LocalDate.now().with(DayOfWeek.MONDAY).atStartOfDay();
    }

    /**
     * 获取本月的开始时间
     */
    public static LocalDateTime startOfMonth() {
        return LocalDate.now().withDayOfMonth(1).atStartOfDay();
    }
}

// 计算两个日期之间的天数
LocalDate start = LocalDate.of(2024, 1, 1);
LocalDate end = LocalDate.of(2024, 12, 31);
long days = DateRangeUtil.daysBetween(start, end);
System.out.println("相差 " + days + " 天");  // 相差 365 天

// 判断是否在活动期间
LocalDateTime activityStart = LocalDateTime.of(2024, 11, 11, 0, 0);
LocalDateTime activityEnd = LocalDateTime.of(2024, 11, 11, 23, 59);
if (DateRangeUtil.isNowBetween(activityStart, activityEnd)) {
    System.out.println("双十一大促进行中！");
}

// 格式化
System.out.println(DateUtil.now());          // 2024-01-15 14:30:00
System.out.println(DateUtil.today());        // 2024-01-15
System.out.println(DateUtil.now("yyyyMMdd")); // 20240115