KPAuthorizationUtil.getAppId()

KPAuthorizationUtil.getAppSecret(60)

String encoded = KPBase64Utils.encode("Hello World");

String urlSafeEncoded = KPBase64Utils.encodeUrlSafe("https://www.example.com");

String decoded = KPBase64Utils.decode("SGVsbG8gV29ybGQ=");

String urlSafeDecoded = KPBase64Utils.decodeUrlSafe("SGVsbG8gV29ybGQ");

String salted = KPBase64Utils.addSalt("SGVsbG8gV29ybGQ=", 10);

String unsalted = KPBase64Utils.removeSalt(salted, 10);

public KPBarCodeUtil(String vaNumber, String words)

BufferedImage image = new KPBarCodeUtil("A80/90R8A8A", "A80/90R8A8A")
        .width(400)           // 设置宽度为 400
        .height(60)           // 设置条形码高度为 60
        .textColor(Color.GREEN) // 设置文字颜色为绿色
        .font("宋体")          // 设置文字字体为宋体
        .generate()           // 生成条形码
        .getBufferedImage();  // 获取图片流

@RestController
@RequestMapping("/barcode")
public class BarCodeController {

    @GetMapping("/download")
    public void downloadBarCode() {
        // 生成条形码并下载，文件名为"order_barcode"
        new KPBarCodeUtil("ORDER20241104001", "订单编号：ORDER20241104001")
                .wordheight(80)
                .imageType("jpg")
                .generate()
                .downLoad("order_barcode");
    }
}

public KPQRCodeUtil(String body)

BufferedImage image = new KPQRCodeUtil("这是一个自定义样式的二维码")
        .width(400)                     // 二维码宽度
        .height(400)                    // 二维码高度
        .margin(2)                      // 二维码的边距
        .foreColor(Color.BLUE)          // 设置前景色为蓝色
        .backColor(new Color(240, 240, 240)) // 设置背景色为浅灰色
        .generate()                     // 生成二维码
        .getBufferedImage();            // 获取图片流

@RestController
@RequestMapping("/qrcode")
public class QRCodeController {

    @GetMapping("/download")
    public void downloadQRCode() {
        new KPQRCodeUtil("这是一个自定义样式的二维码")
                .width(400)                     // 二维码宽度
                .height(400)                    // 二维码高度
                .margin(2)                      // 二维码的边距
                .foreColor(Color.BLUE)          // 设置前景色为蓝色
                .backColor(new Color(240, 240, 240)) // 设置背景色为浅灰色
                .logoLocalhostPath(localLogoPath) // 添加本地Logo
                // .logoUrl("https://picsum.photos/200") // 或者添加网络Logo
                .generate()                     // 生成二维码
                .downLoad("simple_qrcode");
    }
}

// 通过BigDecimal创建
KPBigDecimalUtils utils1 = new KPBigDecimalUtils(new BigDecimal("10.5"));

// 通过字符串创建
KPBigDecimalUtils utils2 = new KPBigDecimalUtils("20.8");

// 通过整数创建
KPBigDecimalUtils utils3 = new KPBigDecimalUtils(100);

// 通过长整型创建
KPBigDecimalUtils utils4 = new KPBigDecimalUtils(1000L);

// 通过双精度浮点数创建
KPBigDecimalUtils utils5 = new KPBigDecimalUtils(99.9);

// 加法运算
KPBigDecimalUtils result1 = new KPBigDecimalUtils("10.5").add("20.3");

// 减法运算
KPBigDecimalUtils result2 = new KPBigDecimalUtils("50.0").sub("15.5");

// 乘法运算
KPBigDecimalUtils result3 = new KPBigDecimalUtils("6.5").multiply("7.2");

// 除法运算
KPBigDecimalUtils result4 = new KPBigDecimalUtils("100.0").divide("3.0", 2);

// 取余运算
KPBigDecimalUtils result5 = new KPBigDecimalUtils("10.5").balance("3");

// 计算 ((100.5 + 200.8 - 50.3) * 2.5 / 3.0) % 7.5
KPBigDecimalUtils result = new KPBigDecimalUtils("100.5")
        .add("200.8")                    // 加法
        .sub("50.3")                     // 减法
        .multiply("2.5")                 // 乘法
        .divide("3.0", 2)                // 除法，保留2位小数
        .balance("7.5");                 // 取余

// 获取最终结果
BigDecimal finalResult = result.build();
System.out.println("计算结果: " + finalResult); // 输出: 209.17

// 也可以指定精度和取整模式
BigDecimal preciseResult = result.build(4, RoundingMode.HALF_UP);
System.out.println("精确结果: " + preciseResult); // 输出: 209.1667

// 转换为其他数据类型
String resultStr = result.buildString();
Integer resultInt = result.buildInteger(RoundingMode.HALF_UP);
Double resultDouble = result.buildDouble(2, RoundingMode.HALF_UP);

System.out.println("字符串结果: " + resultStr);   // 输出: 209.17
System.out.println("整数结果: " + resultInt);     // 输出: 209
System.out.println("双精度结果: " + resultDouble); // 输出: 209.17

KPBigDecimalUtils calc = new KPBigDecimalUtils("10.5").add("20.3");

// 获取BigDecimal结果
BigDecimal result = calc.build();

// 获取指定精度和取整模式的结果
BigDecimal preciseResult = calc.build(2, RoundingMode.HALF_UP);

// 获取字符串结果
String strResult = calc.buildString();

// 获取整数结果
Integer intResult = calc.buildInteger(RoundingMode.HALF_UP);

// 获取长整型结果
Long longResult = calc.buildLong(RoundingMode.HALF_UP);

// 获取双精度浮点数结果
Double doubleResult = calc.buildDouble(2, RoundingMode.HALF_UP);

// 获取单精度浮点数结果
Float floatResult = calc.buildFloat(2, RoundingMode.HALF_UP);

int comparison = KPBigDecimalUtils.compareTo(new BigDecimal("10.5"), new BigDecimal("20.3"));
// comparison < 0 表示第一个数小于第二个数
// comparison = 0 表示两个数相等
// comparison > 0 表示第一个数大于第二个数

String result = KPCmdUtil.command("ping 192.168.1.1");
System.out.println("命令执行结果：" + result);

    String mac = KPCmdUtil.getMac("192.168.1.1");
    System.out.println("MAC地址：" + mac);

    List<JSONObject> ipMacs = KPCmdUtil.getIPAndMacs();
    for (JSONObject item : ipMacs) {
        System.out.println("IP: " + item.getString("ip") + ", MAC: " + item.getString("mac"));
    }

List<JSONObject> devices = KPCmdUtil.scanAllLanDevices("192.168.0.", 1, 255);
for (JSONObject device : devices) {
    System.out.println("IP: " + device.getString("ip") + ", MAC: " + device.getString("mac") +(device.getBooleanValue("isLocal") ? " (本机)" : ""));
}

List<String> list = Arrays.asList("apple", "banana", "orange");
boolean result = KPCollectionUtil.isEquals("apple", list);

List<String> list = Arrays.asList("apple", "banana", "orange");
boolean result = KPCollectionUtil.isContain("app", list);

List<User> users = getUserList();
Integer index = KPCollectionUtil.index(users, "name", "张三");

List<String> list = Arrays.asList("a", "b", "c", "d", "e", "f");
List<?> pageResult = KPCollectionUtil.paging(list, 2, 3);

String disjunction = KPCollectionUtil.getFileNameDisjunction(ArchiveListCustomerPO.class, ArchivePO.class, "type");

boolean success = KPCollectionUtil.insertBatch(userMapper, userList, 100);

boolean success = KPCollectionUtil.insertBatch(userMapper, dtoList, User.class, 100);

public List<ArchiveListCustomerPO> queryPageList(ArchiveListParamPO archiveListParamPO) {
    List<String> archiveTypeList = new ArrayList<>();
    if (KPStringUtil.isNotEmpty(archiveListParamPO.getArchiveTypeId()))
        archiveTypeList = archiveTypeMapper.queryArchiveTypeSubsetId(archiveListParamPO.getArchiveTypeId());

    MPJLambdaWrapper<ArchivePO> wrapper = new MPJLambdaWrapper<ArchivePO>()
            .selectAll(ArchivePO.class)
            // 自动生成差集字段，避免手动编写冗长的SELECT语句
            .select(KPCollectionUtil.getFileNameDisjunction(ArchiveListCustomerPO.class, ArchivePO.class, "type"))
            .leftJoin(ArchiveTypePO.class, "type", on -> on
                    .eq(ArchiveTypePO::getArchiveTypeId, ArchivePO::getArchiveTypeId)
                    .eq(ArchiveTypePO::getDeleteFlag, DeleteFalgEnum.NORMAL.code())
            )
            .disableSubLogicDel()
            .in(KPStringUtil.isNotEmpty(archiveListParamPO.getArchiveTypeId()), ArchivePO::getArchiveTypeId, archiveTypeList)
            .like(KPStringUtil.isNotEmpty(archiveListParamPO.getName()), ArchivePO::getName, archiveListParamPO.getName())
            .like(KPStringUtil.isNotEmpty(archiveListParamPO.getCode()), ArchivePO::getCode, archiveListParamPO.getCode())
            .like(KPStringUtil.isNotEmpty(archiveListParamPO.getBusinessNumber()), ArchivePO::getBusinessNumber, archiveListParamPO.getBusinessNumber())
            .eq(KPStringUtil.isNotEmpty(archiveListParamPO.getStatus()), ArchivePO::getStatus, archiveListParamPO.getStatus());
            
    //分页和排序
    PageHelper.startPage(archiveListParamPO.getPageNum(), archiveListParamPO.getPageSize(), archiveListParamPO.getOrderBy(ArchivePO.class));
    return this.baseMapper.selectJoinList(ArchiveListCustomerPO.class, wrapper);
}

// 在查询中使用groupConcat方法
MPJLambdaWrapper<MonthlyReportPO> wrapper = new MPJLambdaWrapper<MonthlyReportPO>()
    .select(KPDatabaseUtil.groupConcat("monthlyReportUser.user_name", true, "userNames"))
    .leftJoin(MonthlyReportUserPO.class, "monthlyReportUser", on -> on
        .eq(MonthlyReportUserPO::getMonthlyId, MonthlyReportPO::getMonthlyId));

String sqlFragment = KPDatabaseUtil.groupDistinctConcat("user_name", "userNames");

MPJLambdaWrapper<MonthlyReportPO> wrapper = new MPJLambdaWrapper<>();
KPDatabaseUtil.groupFieldsBy(wrapper, "monthlyReport", MonthlyReportPO.class);

public List<MonthlyReportListCustomerPO> queryPageList(MonthlyReportListParamPO monthlyReportListParamPO) {
    MPJLambdaWrapper<MonthlyReportPO> wrapper = new MPJLambdaWrapper<MonthlyReportPO>("monthlyReport")
            .selectAll(MonthlyReportPO.class, "monthlyReport")
            .select(KPDatabaseUtil.groupDistinctConcat("monthlyReportUser.user_name", "userNamss"))
            .leftJoin(MonthlyReportUserPO.class, "monthlyReportUser", on -> on
                    .eq(MonthlyReportUserPO::getMonthlyId, MonthlyReportPO::getMonthlyId)
                    .eq(MonthlyReportUserPO::getDeleteFlag, DeleteFalgEnum.NORMAL.code())
            )
            .disableSubLogicDel()
            .between(KPStringUtil.isNotEmpty(monthlyReportListParamPO.getPlanTimes()), 
                     MonthlyReportPO::getPlanDate, 
                     monthlyReportListParamPO.getPlanTimes() == null ? LocalDate.now() : KPLocalDateUtil.getEffectiveDate(monthlyReportListParamPO.getPlanTimes().get(0)), 
                     monthlyReportListParamPO.getPlanTimes() == null ? LocalDate.now() : KPLocalDateUtil.getEffectiveDate(monthlyReportListParamPO.getPlanTimes().get(1)))
            .like(KPStringUtil.isNotEmpty(monthlyReportListParamPO.getProjectName()), 
                  MonthlyReportPO::getProjectName, 
                  monthlyReportListParamPO.getProjectName())
            .like(KPStringUtil.isNotEmpty(monthlyReportListParamPO.getTaskName()), 
                  MonthlyReportPO::getTaskName, 
                  monthlyReportListParamPO.getTaskName())
            .eq(KPStringUtil.isNotEmpty(monthlyReportListParamPO.getPriority()), 
                MonthlyReportPO::getPriority, 
                monthlyReportListParamPO.getPriority())
            .eq(KPStringUtil.isNotEmpty(monthlyReportListParamPO.getStatus()), 
                MonthlyReportPO::getStatus, 
                monthlyReportListParamPO.getStatus())
            .eq(KPStringUtil.isNotEmpty(monthlyReportListParamPO.getSource()), 
                MonthlyReportPO::getSource, 
                monthlyReportListParamPO.getSource())
            .eq(KPStringUtil.isNotEmpty(monthlyReportListParamPO.getPostId()), 
                MonthlyReportPO::getPostId, 
                monthlyReportListParamPO.getPostId())
            .eq(KPStringUtil.isNotEmpty(monthlyReportListParamPO.getDeptId()), 
                MonthlyReportPO::getDeptId, 
                monthlyReportListParamPO.getDeptId());

    // 根据不同数据库类型自动生成GROUP BY语句
    KPDatabaseUtil.groupFieldsBy(wrapper, "monthlyReport", MonthlyReportPO.class);
    
    Page page = PageHelper.startPage(monthlyReportListParamPO.getPageNum(), 
                                     monthlyReportListParamPO.getPageSize(), 
                                     monthlyReportListParamPO.getOrderBy(MonthlyReportPO.class));
    page.setCountColumn("distinct monthly_id");
    List<MonthlyReportListCustomerPO> body = this.baseMapper.selectJoinList(MonthlyReportListCustomerPO.class, wrapper);

    body.forEach(po -> po.setPlanTime(KPLocalDateUtil.toString(po.getPlanDate(), KPLocalDateTimeUtil.MONTH_PATTERN)));

    return body;
}

// 增加天数
Date result1 = KPDateUtil.addDays(new Date(), 5);

// 增加小时数
Date result2 = KPDateUtil.addHours(new Date(), 3);

// 增加分钟数
Date result3 = KPDateUtil.addMinutes(new Date(), 30);

// 增加秒数
Date result4 = KPDateUtil.addSeconds(new Date(), 60);

// 增加月数
Date result5 = KPDateUtil.addMonths(new Date(), 2);

// 增加年数
Date result6 = KPDateUtil.addYears(new Date(), 1);

// 日期格式化为字符串
String dateStr1 = KPDateUtil.format(new Date(), "yyyy-MM-dd HH:mm:ss");

// 字符串解析为 Date 对象
Date date1 = KPDateUtil.parse("2024-11-18 10:30:00", "yyyy-MM-dd HH:mm:ss");

// 转换日期格式
String dateStr2 = KPDateUtil.format("2024-11-18", "yyyy-MM-dd", "yyyy/MM/dd");

Date date1 = new Date();
Date date2 = KPDateUtil.addDays(new Date(), 5);

// 比较日期
int comparison = KPDateUtil.compare(date1, date2);

// 获取较小值
Date minDate = KPDateUtil.min(date1, date2);

// 获取较大值
Date maxDate = KPDateUtil.max(date1, date2);

Date startDate = KPDateUtil.parse("2024-11-01", "yyyy-MM-dd");
Date endDate = KPDateUtil.parse("2024-11-18", "yyyy-MM-dd");

// 计算天数差（不含今天）
int days = KPDateUtil.daysBetween(startDate, endDate);

// 计算天数差（包含今天）
int daysIncludeToday = KPDateUtil.daysBetweenIncludeToday(startDate, endDate);

// 计算时间差
String duration = KPDateUtil.getDuration(endDate, startDate);

Date date = new Date();

// 获取年份
int year = KPDateUtil.getYear(date);

// 获取月份（1-12）
int month = KPDateUtil.getMonth(date);

// 获取天数（1-31）
int day = KPDateUtil.getDay(date);

// 获取当月总天数
int daysOfMonth = KPDateUtil.getDaysOfMonth(date);

// 获取当年总天数
int daysOfYear = KPDateUtil.getDaysOfYear(date);

// 获取当月最小日期（1号）
Date minDayOfMonth = KPDateUtil.getMinDayOfMonth(new Date());

// 获取当月最大日期
Date maxDayOfMonth = KPDateUtil.getMaxDayOfMonth(new Date());

// 获取本周周一日期
String monday = KPDateUtil.getMinDayOfWeek();

// 获取本周周日日期
String sunday = KPDateUtil.getMaxDayOfWeek();

// 获取当天凌晨（00:00:00）
Date weeHours = KPDateUtil.getWeeHours();

// 获取指定年份第一天
Date firstDayOfYear = KPDateUtil.getFirstDayOfYear(new Date());

// 获取指定年份最后一天
Date lastDayOfYear = KPDateUtil.getLastDayOfYear(new Date());

// 获取当前秒级时间戳
String timestamp = KPDateUtil.getTimestamp();

// 时间戳转换为日期字符串
String dateStr = KPDateUtil.timestampToDate("1700000000", "yyyy-MM-dd HH:mm:ss");

// 日期字符串转换为时间戳（毫秒）
Long timestampMs = KPDateUtil.dateToTimestamp("2024-11-18 10:30:00", "yyyy-MM-dd HH:mm:ss");

// LocalDateTime 转换为 Date
Date date1 = KPDateUtil.toDate(LocalDateTime.now());

// LocalDate 转换为 Date
Date date2 = KPDateUtil.toDate(LocalDate.now());

// Date 转换为 LocalDateTime
LocalDateTime localDateTime = KPDateUtil.toLocalDateTime(new Date());

// 秒数转换为分秒格式字符串
String minuteSecond = KPDateUtil.toMinuteSecond(150); // 输出: 2分30秒

// 获取服务器启动时间
Date serverStartDate = KPDateUtil.getServerStartDate();

// 增加天数
LocalDateTime result1 = KPLocalDateTimeUtil.addDays(LocalDateTime.now(), 5);

// 增加小时数
LocalDateTime result2 = KPLocalDateTimeUtil.addHours(LocalDateTime.now(), 3);

// 增加分钟数
LocalDateTime result3 = KPLocalDateTimeUtil.addMinutes(LocalDateTime.now(), 30);

// 增加秒数
LocalDateTime result4 = KPLocalDateTimeUtil.addSeconds(LocalDateTime.now(), 60);

// 增加月数
LocalDateTime result5 = KPLocalDateTimeUtil.addMonths(LocalDateTime.now(), 2);

// 增加年数
LocalDateTime result6 = KPLocalDateTimeUtil.addYears(LocalDateTime.now(), 1);

// 日期格式化为字符串
String dateStr1 = KPLocalDateTimeUtil.format(LocalDateTime.now(), "yyyy-MM-dd HH:mm:ss");

// 字符串解析为 LocalDateTime 对象
LocalDateTime date1 = KPLocalDateTimeUtil.parse("2024-11-18 10:30:00", "yyyy-MM-dd HH:mm:ss");

// 转换日期格式
String dateStr2 = KPLocalDateTimeUtil.format("2024-11-18", "yyyy-MM-dd", "yyyy/MM/dd");

LocalDateTime date1 = LocalDateTime.now();
LocalDateTime date2 = KPLocalDateTimeUtil.addDays(LocalDateTime.now(), 5);

// 比较日期
int comparison = KPLocalDateTimeUtil.compare(date1, date2);

// 获取较小值
LocalDateTime minDate = KPLocalDateTimeUtil.min(date1, date2);

// 获取较大值
LocalDateTime maxDate = KPLocalDateTimeUtil.max(date1, date2);

LocalDate startDate = LocalDate.of(2024, 11, 1);
LocalDate endDate = LocalDate.of(2024, 11, 18);

// 计算天数差（不含今天）
long days = KPLocalDateTimeUtil.daysBetween(startDate, endDate);

// 计算天数差（包含今天）
long daysIncludeToday = KPLocalDateTimeUtil.daysBetweenIncludeToday(startDate, endDate);

// 计算时间差
String duration = KPLocalDateTimeUtil.getDuration(endDate.atStartOfDay(), startDate.atStartOfDay());

LocalDateTime date = LocalDateTime.now();

// 获取年份
int year = KPLocalDateTimeUtil.getYear(date);

// 获取月份（1-12）
int month = KPLocalDateTimeUtil.getMonth(date);

// 获取天数（1-31）
int day = KPLocalDateTimeUtil.getDay(date);

// 获取当月总天数
int daysOfMonth = KPLocalDateTimeUtil.getDaysOfMonth(date);

// 获取当年总天数
int daysOfYear = KPLocalDateTimeUtil.getDaysOfYear(date);

// 获取当月最小日期（1号）
LocalDateTime minDayOfMonth = KPLocalDateTimeUtil.getMinDayOfMonth(LocalDateTime.now());

// 获取当月最大日期
LocalDateTime maxDayOfMonth = KPLocalDateTimeUtil.getMaxDayOfMonth(LocalDateTime.now());

// 获取本周周一日期
String monday = KPLocalDateTimeUtil.getMinDayOfWeek();

// 获取本周周日日期
String sunday = KPLocalDateTimeUtil.getMaxDayOfWeek();

// 获取当天凌晨（00:00:00）
LocalDateTime weeHours = KPLocalDateTimeUtil.getWeeHours();

// 获取指定年份第一天
LocalDateTime firstDayOfYear = KPLocalDateTimeUtil.getFirstDayOfYear(LocalDateTime.now());

// 获取指定年份最后一天
LocalDateTime lastDayOfYear = KPLocalDateTimeUtil.getLastDayOfYear(LocalDateTime.now());

// 获取当前秒级时间戳
String timestamp = KPLocalDateTimeUtil.getTimestamp();

// 时间戳转换为日期字符串
String dateStr = KPLocalDateTimeUtil.timestampToDate("1700000000", "yyyy-MM-dd HH:mm:ss");

// 日期字符串转换为时间戳（毫秒）
Long timestampMs = KPLocalDateTimeUtil.dateToTimestamp("2024-11-18 10:30:00", "yyyy-MM-dd HH:mm:ss");

// LocalDateTime 转换为 Date
Date date1 = KPLocalDateTimeUtil.toDate(LocalDateTime.now());

// LocalDate 转换为 Date
Date date2 = KPLocalDateTimeUtil.toDate(LocalDate.now());

// Date 转换为 LocalDateTime
LocalDateTime localDateTime = KPLocalDateTimeUtil.toLocalDateTime(new Date());

// 秒数转换为分秒格式字符串
String minuteSecond = KPLocalDateTimeUtil.toMinuteSecond(150); // 输出: 2分30秒

// 获取服务器启动时间
LocalDateTime serverStartDate = KPLocalDateTimeUtil.getServerStartDate();

// 将毫秒数转换为天、小时、分钟、秒和毫秒的字符串形式
String duration = KPLocalDateTimeUtil.formatDuration(3661000L); // 输出: 1时1分1秒

// 计算两个日期时间相差的秒数
long seconds = KPLocalDateTimeUtil.getSecondsBetween(LocalDateTime.now(), KPLocalDateTimeUtil.addMinutes(LocalDateTime.now(), 5));

// 获取从当前时间到当日24:00（次日0点）剩余的秒数
long secondsUntilEnd = KPLocalDateTimeUtil.secondsUntilEndOfDay();

// 日期格式化为字符串
String dateStr1 = KPLocalDateUtil.format(LocalDate.now(), "yyyy-MM-dd");

// 字符串解析为 LocalDate 对象
LocalDate date1 = KPLocalDateUtil.parse("2024-11-18", "yyyy-MM-dd");

// 转换日期格式
String dateStr2 = KPLocalDateUtil.format("2024-11-18", "yyyy-MM-dd", "yyyy/MM/dd");

// 增加天数
LocalDate result1 = KPLocalDateUtil.addDays(LocalDate.now(), 5);

// 增加月数
LocalDate result2 = KPLocalDateUtil.addMonths(LocalDate.now(), 2);

// 增加年数
LocalDate result3 = KPLocalDateUtil.addYears(LocalDate.now(), 1);

LocalDate date1 = LocalDate.now();
LocalDate date2 = KPLocalDateUtil.addDays(LocalDate.now(), 5);

// 比较日期
int comparison = KPLocalDateUtil.compare(date1, date2);

// 获取较小值
LocalDate minDate = KPLocalDateUtil.min(date1, date2);

// 获取较大值
LocalDate maxDate = KPLocalDateUtil.max(date1, date2);

LocalDate startDate = LocalDate.of(2024, 11, 1);
LocalDate endDate = LocalDate.of(2024, 11, 18);

// 计算天数差（不含结束日）
long days = KPLocalDateUtil.daysBetween(startDate, endDate);

// 计算天数差（包含结束日）
long daysIncludeToday = KPLocalDateUtil.daysBetweenIncludeToday(startDate, endDate);

// 计算月数差
long months = KPLocalDateUtil.getMonthsBetween(startDate, endDate);

// 计算年数差
long years = KPLocalDateUtil.getYearsBetween(startDate, endDate);

LocalDate date = LocalDate.now();

// 获取年份
int year = KPLocalDateUtil.getYear(date);

// 获取月份（1-12）
int month = KPLocalDateUtil.getMonth(date);

// 获取天数（1-31）
int day = KPLocalDateUtil.getDay(date);

// 获取当月总天数
int daysOfMonth = KPLocalDateUtil.getDaysOfMonth(date);

// 获取当年总天数
int daysOfYear = KPLocalDateUtil.getDaysOfYear(date);

// 获取当月最小日期（1号）
LocalDate minDayOfMonth = KPLocalDateUtil.getMinDayOfMonth(LocalDate.now());

// 获取当月最大日期
LocalDate maxDayOfMonth = KPLocalDateUtil.getMaxDayOfMonth(LocalDate.now());

// 获取本周周一日期
String monday = KPLocalDateUtil.getMinDayOfWeek();

// 获取本周周日日期
String sunday = KPLocalDateUtil.getMaxDayOfWeek();

// 获取指定年份第一天
LocalDate firstDayOfYear = KPLocalDateUtil.getFirstDayOfYear(LocalDate.now());

// 获取指定年份最后一天
LocalDate lastDayOfYear = KPLocalDateUtil.getLastDayOfYear(LocalDate.now());

// 判断日期是否在指定范围内（包含边界）
boolean isBetween = KPLocalDateUtil.isBetween(LocalDate.now(), 
    LocalDate.now().minusDays(1), LocalDate.now().plusDays(1));

// 获取有效日期（若输入日期为null则返回当前日期，否则返回原日期）
LocalDate effectiveDate = KPLocalDateUtil.getEffectiveDate((LocalDate) null);
LocalDate effectiveDateFromString = KPLocalDateUtil.getEffectiveDate("2024-11-18");

List<User> userList = getUserList();
KPEasyExcelUtil.exportByTemplate("用户列表.xlsx", "/template/user.xlsx", userList);

List<User> userList = getUserList();
InputStream templateStream = getClass().getResourceAsStream("/template/user.xlsx");
KPEasyExcelUtil.exportByTemplate("用户列表.xlsx", templateStream, userList);

List<User> userList = getUserList();
List<Department> deptList = getDepartmentList();
InputStream templateStream = getClass().getResourceAsStream("/template/user_dept.xlsx");
KPEasyExcelUtil.exportByTemplate("用户部门列表.xlsx", templateStream, userList, deptList);

List<User> userList = getUserList();
KPEasyExcelUtil.minioExprotByTemplate("template-bucket", "user_template.xlsx", userList);

boolean success = KPFileUtil.createFolder("D:/test/folder");

boolean isFile = KPFileUtil.isFile("D:/test/file.txt");

boolean deleted = KPFileUtil.deleteFile("D:/test/file.txt");

KPFileUtil.deleteFolder("D:/test/folder");

String filePath = KPFileUtil.saveFileFromBase64("D:/test", "output.txt", "SGVsbG8gV29ybGQ=");

byte[] bytes = KPFileUtil.base64String2ByteFun("SGVsbG8gV29ybGQ=");

String base64 = KPFileUtil.byte2Base64StringFun(bytes);

byte[] bytes = KPFileUtil.getBytesByFile("D:/test/file.txt");

KPFileUtil.writeBytesToFile(bytes, "D:/test", "output.txt");

byte[] bytes = KPFileUtil.readBytesFromUrl("https://example.com/image.jpg");

File file = KPFileUtil.downloadFile("https://example.com/image.jpg", "D:/downloads");

byte[] qrWithLogo = KPFileUtil.encodeWithLogo("https://example.com/qrcode.png", "iVBORw0KGgoAAAANSUhEUgAAAAUA");

Map<String, Integer> existingNames = new HashMap<>();
String uniqueName = KPFileUtil.getUniqueName(existingNames, "file.txt");

List<String> filePaths = new ArrayList<>();
KPFileUtil.findAllFiles(new File("D:/test"), filePaths);

List<String> messages = Arrays.asList("欢迎使用系统", "版本: 1.0.0");
KPIconUtil.println(KPIconUtil.GREEN, messages);

KPIconUtil.ok(KPIconUtil.GREEN);

Integer age = KPIDCardUtil.getUserAge("身份证号码");

// 不带姓名的版本
String gender = KPIDCardUtil.getUserSex("身份证号码");

// 带姓名的版本
String genderWithPrefix = KPIDCardUtil.getUserSex("张三", "身份证号码");

@RestController
@RequestMapping("/file")
public class FileController {
    
    @GetMapping("/download")
    public void downloadFile() throws IOException {
        InputStream inputStream = getFileInputStream(); // 获取文件输入流
        KPIOUtil.downloadFile(inputStream, "示例文件.pdf");
    }
}

@RestController
@RequestMapping("/file")
public class FileController {
    
    @GetMapping("/downloadWithResponse")
    public void downloadFile(HttpServletResponse response) throws IOException {
        InputStream inputStream = getFileInputStream();
        KPIOUtil.downloadFile(inputStream, "示例文件.pdf", response);
    }
}

@RestController
@RequestMapping("/file")
public class FileController {
    
    @GetMapping("/downloadLocal")
    public void downloadLocalFile(HttpServletResponse response) throws IOException {
        KPIOUtil.downloadLocalFile("/path/to/local/file.xlsx", response);
    }
}

@RestController
@RequestMapping("/file")
public class FileController {
    
    @GetMapping("/downloadWithHeader")
    public void downloadWithHeader(HttpServletResponse response) throws IOException {
        KPIOUtil.setDownloadResponseHeader("示例文件.pdf", response);
        // 后续手动处理文件内容传输
    }
    
    @GetMapping("/downloadWithHeaderAndSize")
    public void downloadWithHeaderAndSize(HttpServletResponse response) throws IOException {
        File file = new File("/path/to/file.pdf");
        KPIOUtil.setDownloadResponseHeader("示例文件.pdf", file.length(), response);
        // 后续手动处理文件内容传输
    }
}

@RestController
@RequestMapping("/api")
public class ApiController {
    
    @GetMapping("/client-info")
    public Map<String, Object> getClientInfo(HttpServletRequest request) {
        Map<String, Object> result = new HashMap<>();
        String clientIP = KPIPUtil.getClientIP(request);
        result.put("clientIP", clientIP);
        result.put("isInternal", KPIPUtil.isInternalIp(clientIP));
        return result;
    }
}

String clientIP = KPIPUtil.getClientIP();
System.out.println("当前客户端IP: " + clientIP);

boolean isInternal = KPIPUtil.isInternalIp("192.168.1.100");
if (isInternal) {
    System.out.println("这是内网IP地址");
} else {
    System.out.println("这是外网IP地址");
}

String hostName = KPIPUtil.getHostName();
System.out.println("服务器主机名: " + hostName);

String hostIp = KPIPUtil.getHostIp();
System.out.println("服务器IP地址: " + hostIp);

boolean isOccupied = KPIPUtil.isPortOccupied("localhost", 8080);
if (isOccupied) {
    System.out.println("端口8080已被占用");
} else {
    System.out.println("端口8080未被占用");
}

int availablePort = KPIPUtil.findAvailablePort("localhost", 8080);
if (availablePort != -1) {
    System.out.println("找到可用端口: " + availablePort);
} else {
    System.out.println("未找到可用端口");
}