Compare commits

..
Author SHA1 Message Date
minglipro f2ee83ca64 feat(utils): 添加ByteBuffer变长数字编解码和防抖器功能
- 在ByteBufferUtils中添加getVarLong、getVarInt、getVarShort读取变长数字功能
- 在ByteBufferUtils中添加putVarLong、putVarInt、putVarShort写入变长数字功能
- 新增Debouncer防抖器类用于防止短时间内重复执行任务
- 更新build.gradle.kts中mybatis-plus-core依赖版本至3.5.15
- 优化FileUtils中文件操作方法,增加Path和File类型的扩展函数
- 添加字节转义字符常量定义和hex字符串转换工具方法
2026-01-14 13:01:50 +08:00
minglipro 66ec71cbc7 Merge pull request 'chore(build): 更新项目版本号并修改最后更新时间' (#13) from dev into master
Reviewed-on: #13
2026-01-10 08:56:05 +08:00
minglipro f773b1975e chore(build): 更新项目版本号并修改最后更新时间
- 将 VERSIONS 从 4.3.2 更新为 4.3.3
2026-01-10 08:55:22 +08:00
minglipro 3f666d652d feat(utils): 添加函数式接口和条件验证工具类
- 添加 RFunction 函数式接口用于无参数函数调用
- 更新文件头版权年份从 2025 到 2026
- 更新文件最后修改时间戳
- 新增 Require 类提供条件验证功能
- 支持多种构造方式包括布尔值、函数式参数等
- 提供多种异常抛出机制包括自定义异常类型
- 添加扩展函数和静态工厂方法简化使用
- 支持 Java 互操作性的 JvmStatic 注解
2026-01-10 08:54:17 +08:00
minglipro 00c1be6387 Merge branch 'master' of git.mingliqiye.com:minglipro/mingli-utils 2026-01-08 13:21:38 +08:00
minglipro 2063d86097 feat(core): 将项目从Java迁移到Kotlin并升级依赖
- 将多个Java文件转换为Kotlin文件,包括CallType、QuickBaseTypeHandler等
- 升级Netty版本从4.2.9.Final到4.130.Final
- 添加新的Netty重连调度器ClientScheduleReconnect功能
- 新增DateTime和MySQL UUID类型处理器支持
- 创建命名线程工厂NamedThreadFactory用于线程池管理
- 修复UUID转换方法名称错误
- 更新项目版本号从4.2.7到4.3.2
- 移除Java版本的ValueGetter类,使用Kotlin数据类替代
2026-01-08 13:21:02 +08:00
minglipro 2db24530d6 feat(bytes): 添加ByteBuffer工具类和ByteFlags数据结构
- 新增ByteBufferUtils.kt文件,提供字符串、布尔值、位标志等类型的读写扩展函数
- 新增ByteFlags.kt文件,实现8位布尔标志集合的数据结构和位操作功能
- 添加putString/getString方法支持C风格字符串的null终止符处理
- 实现ByteFlags的位操作功能,包括AND、OR、XOR、NOT等运算
- 添加二进制字符串、十六进制字符串的转换和格式化输出功能
- 移除NettyUtils中重复的toByteBuffer扩展函数
- 更新项目版本号从4.2.6到4.2.7
2026-01-07 10:07:48 +08:00
minglipro 2bcd4b329c feat(network): 增强网络地址端口处理功能
- 添加IPv4地址与字节数组相互转换功能
- 实现ByteBuffer与网络地址端口的读写操作
- 增加网络端点字节数组序列化支持
- 添加Netty框架ByteBuf转换工具类
- 更新项目版本号至4.2.6
- 修改依赖引入方式为compileOnly
- 移除未使用的SuperStream导入
- 添加UUID类ByteBuffer读写功能
- 创建新的测试主函数验证功能
2026-01-06 14:36:13 +08:00
minglipro a081744f14 refactor(mybatis):重构类型处理器实现以提升可维护性
移除 Kotlin 编写的 DateTimeTypeHandler 和 UUID 相关类型处理器,
新增 Java 编写的通用 QuickBaseTypeHandler 抽象类及辅助类,统一处理 MyBatis 类型转换逻辑。同时更新 UUID 类的 toString 方法,
增强不同版本 UUID 的信息展示。升级项目版本至 4.2.4。
2025-09-21 21:55:43 +08:00
minglipro 1509597032 Merge pull request 'dev' (#12) from dev into master
Reviewed-on: #12
2025-09-21 15:41:49 +08:00
minglipro ac92f62967 build(jdk8): 更新构建脚本中的 Kotlin 和 Dokka 插件版本- 在 jdk8/build.gradle.kts 中添加了 Kotlin JVM 插件和 Dokka 插件
- 更新 `build.gradle.kts` 中的 Dokka 版本从2.1.0-Beta 到2.0.0- 调整了 Gradle 任务依赖方式,使用字符串名称替代任务引用
- 升级项目版本号从 4.1.8 到 4.1.9
2025-09-21 15:39:14 +08:00
minglipro 683aeb2c7f ```
feat(stream): 优化 SuperStream 的 toArray 方法实现- 调整 toArray 方法,支持传入 Class 参数以正确创建泛型数组
- 原无参 toArray 方法改为返回 Object[],避免类型转换异常
- 移除对 ForEach 工具类的依赖
- 提升流处理中数组转换的灵活性与安全性

```

```
feat(collection): 改进 toArray 工具方法支持泛型数组创建

- 新增基于 reified 泛型的 toArray 扩展方法,自动推断数组类型
- 添加带 Class 参数的 toArray 重载方法,用于明确指定元素类型
- 处理空列表时直接返回空数组,避免后续操作异常

```

```
build(gradle): 升级 dokka 插件版本并更新项目依赖- 将 org.jetbrains.dokka 插件升级至 2.1.0-Beta 版本
- 添加 jna5.17.0 依赖用于本地库调用支持
- 引入 mybatis-plus-core 3.0.1 编译依赖
- 更新项目版本号从 4.1.7 至 4.1.8

```
2025-09-21 14:37:22 +08:00
minglipro 5eed682aa1 feat(utils): 添加 MyBatis-Plus 查询包装器支持
在 build.gradle.kts 中替换 JNA依赖为 mybatis-plus-core,并新增BaseMapperQuery 接口,提供通用的 QueryWrapper 实例创建方法,便于MyBatis-Plus 相关操作的统一封装与复用
2025-09-20 14:22:14 +08:00
minglipro 578f0a3e89 fix(collection): 抑制类型转换警告并更新文件时间戳修复了 Collection.kt 文件中的类型转换警告问题,通过添加 @Suppress("UNCHECKED_CAST")
注解来抑制编译器警告。同时更新了文件的最后修改时
2025-09-20 14:05:41 +08:00
minglipro 075dc2346a feat(utils): 更新工具类并优化集合扩展函数
- 更新多个工具类的最后修改时间和用户信息
- 移除冗余的 main 函数测试代码
- 优化 ByteUtils 中流处理方法的引用- 为 Collection 扩展大量实用函数,包括转换、获取元素和创建集合实例等
- 引入 SuperStream 替代部分自定义流处理逻辑
- 调整 Spring Boot 自动配置包扫描路径- 修复资源读取时的空指针风险,使用 Kotlin 的 elvis 操作符简化代码
2025-09-20 14:01:36 +08:00
minglipro 23548c0c3d refactor(Base91): 更新Base91解码表并添加示例
更新了Base91解码表的初始化方式,并添加了一个示例方法来演示编码和解码功能。

feat(Base256): 添加Base256编解码器

新增了Base256类,实现了Base256编解码功能,并在BaseUtils中添加了相应的实例。

refactor(BaseCodec): 增加字符串编解码方法

在BaseCodec接口中增加了对字符串进行Base64编码和解码的方法。refactor(OsPath): 简化路径处理逻辑

移除了OsPath类中不必要的方法实现,简化了路径处理逻辑。

feat(UUID): 支持Base256短字符串

在UUID类中添加了对Base256短字符串的支持,包括编码和解码方法。
2025-09-18 14:43:01 +08:00
minglipro 4b187f3774 添加 String.join 的文档
添加 List.join 的文档
添加 split 的文档
2025-09-18 09:28:06 +08:00
minglipro c90c1d590b 修改 List.join 为<T> 2025-09-18 09:24:43 +08:00
minglipro 42a3302495 添加 String.join 方法 2025-09-18 09:23:19 +08:00
minglipro 496c3e6248 更新List.join方法 2025-09-18 09:22:55 +08:00
minglipro 9002f41c63 Merge pull request 'dev' (#11) from dev into master
Reviewed-on: #11
2025-09-17 21:20:20 +08:00
minglipro 58806e85f1 refactor(bcrypt): 重构 BCrypt.kt 文件
- 将 BCrypt 对象中的函数转换为顶级函数
- 添加 @JvmName 注解以自定义 JVM 方法名
- 更新相关文件中的导入和引用
- 调整 DateTime 类的 parse 和 format 方法
- 优化 StringUtils 中的 isEmpty 方法
2025-09-17 21:15:39 +08:00
minglipro 0f5748d55d feat(utils): 添加 BCrypt 加密工具类
- 新增 BCrypt.kt 文件,提供 BCrypt 加密相关方法
- 更新 build.gradle.kts,调整依赖项和版本
- 更新 gradle.properties,升级版本号至 4.1.1
- 更新 HashUtils.kt,使用新的 BCrypt 工具类
- 添加 NOTICE 文件,记录第三方软件的版权声明
2025-09-17 12:10:53 +08:00
minglipro 8f8ffc72db Merge pull request 'feat(build): 重构项目并添加 Maven 发布支持' (#10) from dev into master
Reviewed-on: #10
2025-09-17 11:12:41 +08:00
minglipro fcd528a821 feat(build): 重构项目并添加 Maven 发布支持
- 更新 .gitignore 文件,添加 secret.gpg
- 移除 .prettierrc 文件
- 重构 AES 加密工具类,使用新的 Base64 实现
- 新增 Base16、Base64 和 Base91 编解码工具类
- 新增 BaseCodec接口和 BaseUtils 工具类
- 更新 build.gradle.kts 配置,添加 Maven 发布和签名
- 修复 ByteUtils 和 DateTime 工具类中的问题
- 重构 UUID 使用自己的实现 不依赖标准库以及其他的 UUID库
2025-09-17 11:12:10 +08:00
66 changed files with 7146 additions and 1656 deletions
+1
View File
@@ -45,3 +45,4 @@ log
node_modules node_modules
*lock* *lock*
.kotlin .kotlin
secret.gpg
-8
View File
@@ -1,8 +0,0 @@
{
"$schema": "https://json.schemastore.org/prettierrc",
"plugins": [
"prettier-plugin-java"
],
"tabWidth": 4,
"useTabs": true
}
+25
View File
@@ -0,0 +1,25 @@
mingli-utils
Copyright 2025 mingliqiye
This product includes software developed by third parties.
The original copyright notices and licenses are reproduced below.
------------------------------------------------------------
https://github.com/jeremyh/jBCrypt (org.mindrot:jbcrypt@0.4)
Copyright (c) 2006 Damien Miller <djm@mindrot.org>
Permission to use, copy, modify, and distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
------------------------------------------------------------
View File
+49 -18
View File
@@ -1,5 +1,5 @@
/* /*
* Copyright 2025 mingliqiye * Copyright 2026 mingliqiye
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@@ -16,7 +16,7 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils * ModuleName mingli-utils
* CurrentFile build.gradle.kts * CurrentFile build.gradle.kts
* LastUpdate 2025-09-15 22:22:00 * LastUpdate 2026-01-14 13:01:44
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@@ -26,8 +26,9 @@ import java.time.format.DateTimeFormatter
plugins { plugins {
idea idea
java java
id("java-library") signing
id("maven-publish") `java-library`
`maven-publish`
kotlin("jvm") version "2.2.20" kotlin("jvm") version "2.2.20"
id("org.jetbrains.dokka") version "2.0.0" id("org.jetbrains.dokka") version "2.0.0"
} }
@@ -64,22 +65,21 @@ java {
} }
dependencies { dependencies {
annotationProcessor("org.jetbrains:annotations:24.0.0")
annotationProcessor("org.projectlombok:lombok:1.18.38") implementation("org.slf4j:slf4j-api:2.0.17")
implementation("com.mingliqiye.utils.jna:WinKernel32Api:1.0.1")
compileOnly("org.mindrot:jbcrypt:0.4")
compileOnly("org.springframework.boot:spring-boot-starter:2.7.14") compileOnly("org.springframework.boot:spring-boot-starter:2.7.14")
compileOnly("com.fasterxml.jackson.core:jackson-databind:2.19.2") compileOnly("com.fasterxml.jackson.core:jackson-databind:2.19.2")
compileOnly("com.google.code.gson:gson:2.13.1") compileOnly("com.google.code.gson:gson:2.13.1")
compileOnly("org.mybatis:mybatis:3.5.19") compileOnly("org.mybatis:mybatis:3.5.19")
compileOnly("com.alibaba.fastjson2:fastjson2:2.0.58") compileOnly("com.alibaba.fastjson2:fastjson2:2.0.58")
compileOnly("org.projectlombok:lombok:1.18.38") compileOnly("io.netty:netty-all:4.1.130.Final")
implementation("org.bouncycastle:bcprov-jdk18on:1.81")
implementation("com.github.f4b6a3:uuid-creator:6.1.0")
implementation("org.mindrot:jbcrypt:0.4")
implementation("org.jetbrains:annotations:24.0.0")
compileOnly("net.java.dev.jna:jna:5.17.0")
implementation("org.slf4j:slf4j-api:2.0.17")
implementation("com.mingliqiye.utils.jna:WinKernel32Api:1.0.1")
compileOnly("com.baomidou:mybatis-plus-core:3.5.15")
compileOnly("net.java.dev.jna:jna:5.17.0")
} }
@@ -96,10 +96,12 @@ tasks.withType<JavaExec>().configureEach {
tasks.withType<org.gradle.jvm.tasks.Jar> { tasks.withType<org.gradle.jvm.tasks.Jar> {
duplicatesStrategy = DuplicatesStrategy.EXCLUDE duplicatesStrategy = DuplicatesStrategy.EXCLUDE
from("LICENSE") { into("META-INF") }
from("NOTICE") { into("META-INF") }
manifest { manifest {
attributes( attributes(
mapOf( mapOf(
"Main-Class" to "com.mingliqiye.utils.Main", "Main-Class" to "com.mingliqiye.utils.main.Main",
"Specification-Title" to ARTIFACTID, "Specification-Title" to ARTIFACTID,
"Specification-Version" to VERSIONS, "Specification-Version" to VERSIONS,
"Specification-Vendor" to "minglipro", "Specification-Vendor" to "minglipro",
@@ -130,17 +132,16 @@ repositories {
} }
mavenCentral() mavenCentral()
} }
tasks.register<Jar>("javaDocJar") { tasks.register<Jar>("javaDocJar") {
group = "build" group = "build"
archiveClassifier.set("javadoc") archiveClassifier.set("javadoc")
dependsOn(tasks.dokkaJavadoc) dependsOn("dokkaJavadoc")
from(buildDir.resolve("dokka/javadoc")) from(buildDir.resolve("dokka/javadoc"))
} }
tasks.register<Jar>("kotlinDocJar") { tasks.register<Jar>("kotlinDocJar") {
group = "build" group = "build"
archiveClassifier.set("kotlindoc") archiveClassifier.set("kotlindoc")
dependsOn(tasks.dokkaHtml) dependsOn("dokkaHtml")
from(buildDir.resolve("dokka/html")) from(buildDir.resolve("dokka/html"))
} }
publishing { publishing {
@@ -149,6 +150,10 @@ publishing {
name = "MavenRepositoryRaw" name = "MavenRepositoryRaw"
url = uri("C:/data/git/maven-repository-raw") url = uri("C:/data/git/maven-repository-raw")
} }
maven {
name = "OSSRepository"
url = uri("C:/data/git/maven-repository-raw-utils")
}
} }
publications { publications {
create<MavenPublication>("mavenJava") { create<MavenPublication>("mavenJava") {
@@ -157,8 +162,34 @@ publishing {
artifact(tasks.named("kotlinDocJar")) artifact(tasks.named("kotlinDocJar"))
artifactId = ARTIFACTID artifactId = ARTIFACTID
java.toolchain.languageVersion.set(JavaLanguageVersion.of(8)) java.toolchain.languageVersion.set(JavaLanguageVersion.of(8))
pom {
name = "mingli-utils"
url = "https://mingli-utils.mingliqiye.com"
description = "A Java/kotlin Utils"
licenses {
license {
name = "The Apache License, Version 2.0"
url = "http://www.apache.org/licenses/LICENSE-2.0.txt"
} }
} }
developers {
developer {
id = "minglipro"
name = "mingli"
email = "minglipro@163.com"
}
}
scm {
connection = "scm:git:https://git.mingliqiye.com/minglipro/mingli-utils.git"
developerConnection = "scm:git:https://git.mingliqiye.com:minglipro/mingli-utils.git"
url = "https://git.mingliqiye.com/minglipro/mingli-utils"
}
}
}
}
signing {
sign(publishing.publications)
}
} }
tasks.build { tasks.build {
+6 -3
View File
@@ -1,5 +1,5 @@
# #
# Copyright 2025 mingliqiye # Copyright 2026 mingliqiye
# #
# Licensed under the Apache License, Version 2.0 (the "License"); # Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License. # you may not use this file except in compliance with the License.
@@ -16,10 +16,13 @@
# ProjectName mingli-utils # ProjectName mingli-utils
# ModuleName mingli-utils # ModuleName mingli-utils
# CurrentFile gradle.properties # CurrentFile gradle.properties
# LastUpdate 2025-09-15 22:32:50 # LastUpdate 2026-01-14 13:01:41
# UpdateUser MingLiPro # UpdateUser MingLiPro
# #
JDKVERSIONS=1.8 JDKVERSIONS=1.8
GROUPSID=com.mingliqiye.utils GROUPSID=com.mingliqiye.utils
ARTIFACTID=mingli-utils ARTIFACTID=mingli-utils
VERSIONS=4.0.7 VERSIONS=4.3.5
signing.keyId=B22AA93B
signing.password=
signing.secretKeyRingFile=secret.gpg
+36 -3
View File
@@ -16,12 +16,16 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.jdk8 * ModuleName mingli-utils.jdk8
* CurrentFile build.gradle.kts * CurrentFile build.gradle.kts
* LastUpdate 2025-09-15 22:32:50 * LastUpdate 2025-09-21 15:39:12
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
plugins { plugins {
id("java-library") id("java-library")
id("maven-publish") id("maven-publish")
signing
kotlin("jvm") version "2.2.20"
id("org.jetbrains.dokka") version "2.0.0"
} }
val GROUPSID = project.properties["GROUPSID"] as String val GROUPSID = project.properties["GROUPSID"] as String
val VERSIONS = project.properties["VERSIONS"] as String val VERSIONS = project.properties["VERSIONS"] as String
@@ -39,15 +43,44 @@ publishing {
name = "MavenRepositoryRaw" name = "MavenRepositoryRaw"
url = uri("C:/data/git/maven-repository-raw") url = uri("C:/data/git/maven-repository-raw")
} }
maven {
name = "OSSRepository"
url = uri("C:/data/git/maven-repository-raw-utils")
}
} }
publications { publications {
create<MavenPublication>("mavenJava") { create<MavenPublication>("mavenJava") {
from(components["java"]) from(components["java"])
artifactId = "$ARTIFACTID-win-jdk8" artifactId = "$ARTIFACTID-win-jdk8"
groupId = GROUPSID java.toolchain.languageVersion.set(JavaLanguageVersion.of(8))
version = VERSIONS pom {
name = "mingli-utils-win-jdk8"
url = "https://mingli-utils.mingliqiye.com"
description = "A Java/kotlin Utils"
licenses {
license {
name = "The Apache License, Version 2.0"
url = "http://www.apache.org/licenses/LICENSE-2.0.txt"
} }
} }
developers {
developer {
id = "minglipro"
name = "mingli"
email = "minglipro@163.com"
}
}
scm {
connection = "scm:git:https://git.mingliqiye.com/minglipro/mingli-utils.git"
developerConnection = "scm:git:https://git.mingliqiye.com:minglipro/mingli-utils.git"
url = "https://git.mingliqiye.com/minglipro/mingli-utils"
}
}
}
}
signing {
sign(publishing.publications)
}
} }
java.toolchain.languageVersion.set(JavaLanguageVersion.of(8)) java.toolchain.languageVersion.set(JavaLanguageVersion.of(8))
+23
View File
@@ -0,0 +1,23 @@
#
# Copyright 2025 mingliqiye
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# ProjectName mingli-utils
# ModuleName mingli-utils.jdk8
# CurrentFile gradle.properties
# LastUpdate 2025-09-16 12:14:37
# UpdateUser MingLiPro
#
signing.secretKeyRingFile=../secret.gpg
-14
View File
@@ -1,14 +0,0 @@
{
"name": "maven-repository",
"version": "1.0.0",
"scripts": {
"build": "gradle build-jar",
"buildw": "gradlew build-jar",
"format": "prettier --write \"**/*.{js,ts,jsx,tsx,cjs,cts,mjs,mts,vue,astro,json,java}\"",
"f": "prettier --write \"**/*.{js,ts,jsx,tsx,cjs,cts,mjs,mts,vue,astro,json,java}\""
},
"devDependencies": {
"prettier-plugin-java": "^2.7.1",
"prettier": "^3.6.2"
}
}
+1 -1
View File
@@ -16,7 +16,7 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils * ModuleName mingli-utils
* CurrentFile settings.gradle.kts * CurrentFile settings.gradle.kts
* LastUpdate 2025-09-15 22:32:50 * LastUpdate 2025-09-16 12:32:52
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
File diff suppressed because it is too large Load Diff
@@ -16,7 +16,7 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile AesUtils.kt * CurrentFile AesUtils.kt
* LastUpdate 2025-09-15 22:32:50 * LastUpdate 2025-09-19 21:35:53
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@@ -25,8 +25,7 @@
package com.mingliqiye.utils.aes package com.mingliqiye.utils.aes
import com.mingliqiye.utils.base64.decode import com.mingliqiye.utils.base.BASE64
import com.mingliqiye.utils.base64.encode
import java.nio.charset.StandardCharsets import java.nio.charset.StandardCharsets
import java.security.GeneralSecurityException import java.security.GeneralSecurityException
import java.security.MessageDigest import java.security.MessageDigest
@@ -72,8 +71,8 @@ fun encrypt(sSrc: String, sKey: String?): String? {
val encrypted = cipher.doFinal( val encrypted = cipher.doFinal(
sSrc.toByteArray(StandardCharsets.UTF_8) sSrc.toByteArray(StandardCharsets.UTF_8)
) )
return encode( return BASE64.encode(
"${encode(iv)}:${encode(encrypted)}".toByteArray() "${BASE64.encode(iv)}:${BASE64.encode(encrypted)}".toByteArray()
) )
} }
@@ -86,13 +85,13 @@ fun encrypt(sSrc: String, sKey: String?): String? {
fun decrypt(sSrc: String, sKey: String): String? { fun decrypt(sSrc: String, sKey: String): String? {
try { try {
// 分割IV和加密数据 // 分割IV和加密数据
val sSrcs = String(decode(sSrc)) val sSrcs = String(BASE64.decode(sSrc))
val parts: Array<String?> = sSrcs.split(":".toRegex(), limit = 2).toTypedArray() val parts: Array<String?> = sSrcs.split(":".toRegex(), limit = 2).toTypedArray()
if (parts.size != 2) { if (parts.size != 2) {
return null return null
} }
val iv = decode(parts[0]!!) val iv = BASE64.decode(parts[0]!!)
val encryptedData = decode(parts[1]!!) val encryptedData = BASE64.decode(parts[1]!!)
if (iv.size != GCM_IV_LENGTH) { if (iv.size != GCM_IV_LENGTH) {
return null return null
} }
@@ -122,3 +121,4 @@ private fun createSecretKey(sKey: String): SecretKeySpec {
val digest = md.digest(key) val digest = md.digest(key)
return SecretKeySpec(digest, ALGORITHM) return SecretKeySpec(digest, ALGORITHM)
} }
@@ -0,0 +1,54 @@
/*
* Copyright 2025 mingliqiye
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* ProjectName mingli-utils
* ModuleName mingli-utils.main
* CurrentFile Base16.kt
* LastUpdate 2025-09-17 10:56:07
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.base
/**
* Base16编解码器实现类
* 提供字节数组与十六进制字符串之间的相互转换功能
*/
class Base16 : BaseCodec {
/**
* 将字节数组编码为十六进制字符串
* @param bytes 待编码的字节数组
* @return 编码后的十六进制字符串,每个字节对应两位十六进制字符
*/
override fun encode(bytes: ByteArray): String {
// 将每个字节转换为两位十六进制字符串并拼接
return bytes.joinToString("") {
it.toInt().and(0xff).toString(16).padStart(2, '0')
}
}
/**
* 将十六进制字符串解码为字节数组
* @param string 待解码的十六进制字符串
* @return 解码后的字节数组
*/
override fun decode(string: String): ByteArray {
// 按每两个字符分组,转换为字节
return string.chunked(2).map {
it.toInt(16).toByte()
}.toByteArray()
}
}
@@ -0,0 +1,313 @@
/*
* Copyright 2025 mingliqiye
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* ProjectName mingli-utils
* ModuleName mingli-utils.main
* CurrentFile Base256.kt
* LastUpdate 2025-09-20 14:01:29
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.base
/**
* Base256 字符集 256个
*
* 256个字符 要字符集的下面复制
*
* !#$%&()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~§±×÷←↑→↓⇒⇔∀∃∅∆∇∈∉∋∌∏∑−∓∕∗∘∙√∛∜∞∟∠∣∥∧∨∩∪∫∬∭∮∯∰∱∲∳∴∵∶∷≈≠≡≤≥≦≧≪≫≺≻⊂⊃⊆⊇⊈⊉⊊⊋⊕⊖⊗⊘⊙⊚⊛⊜⊝⊞⊟⊠⊡⊢⊣⊤⊥⊦⊧⊨⊩⊪⊫⊬⊭⊮⊯⋀⋁⋂⋃⋄⋅⋆⋇⋈⋉⋊⋋⋌⋍⋎⋏⋐⋑⋒⋓⋔⋕⋖⋗⋘⋙⋚⋛⋜⋝⋞⋟⋠⋡⋢⋣⋤⋥⋦⋧⋨⋩▁▂▃▄▅▆▇█▉▊▋▌▍▎▏▐░▒▓▔▕▖▗▘▙
*
*/
class Base256 : BaseCodec {
companion object {
val code = arrayOf(
'!',
'#',
'$',
'%',
'&',
'(',
')',
'*',
'+',
',',
'-',
'.',
'/',
'0',
'1',
'2',
'3',
'4',
'5',
'6',
'7',
'8',
'9',
':',
';',
'<',
'=',
'>',
'?',
'@',
'A',
'B',
'C',
'D',
'E',
'F',
'G',
'H',
'I',
'J',
'K',
'L',
'M',
'N',
'O',
'P',
'Q',
'R',
'S',
'T',
'U',
'V',
'W',
'X',
'Y',
'Z',
'[',
']',
'^',
'_',
'`',
'a',
'b',
'c',
'd',
'e',
'f',
'g',
'h',
'i',
'j',
'k',
'l',
'm',
'n',
'o',
'p',
'q',
'r',
's',
't',
'u',
'v',
'w',
'x',
'y',
'z',
'{',
'|',
'}',
'~',
'§',
'±',
'×',
'÷',
'←',
'↑',
'→',
'↓',
'⇒',
'⇔',
'∀',
'∃',
'∅',
'∆',
'∇',
'∈',
'∉',
'∋',
'∌',
'∏',
'∑',
'−',
'∓',
'∕',
'∗',
'∘',
'∙',
'√',
'∛',
'∜',
'∞',
'∟',
'∠',
'∣',
'∥',
'∧',
'∨',
'∩',
'∪',
'∫',
'∬',
'∭',
'∮',
'∯',
'∰',
'∱',
'∲',
'∳',
'∴',
'∵',
'∶',
'∷',
'≈',
'≠',
'≡',
'≤',
'≥',
'≦',
'≧',
'≪',
'≫',
'≺',
'≻',
'⊂',
'⊃',
'⊆',
'⊇',
'⊈',
'⊉',
'⊊',
'⊋',
'⊕',
'⊖',
'⊗',
'⊘',
'⊙',
'⊚',
'⊛',
'⊜',
'⊝',
'⊞',
'⊟',
'⊠',
'⊡',
'⊢',
'⊣',
'⊤',
'⊥',
'⊦',
'⊧',
'⊨',
'⊩',
'⊪',
'⊫',
'⊬',
'⊭',
'⊮',
'⊯',
'⋀',
'⋁',
'⋂',
'⋃',
'⋄',
'⋅',
'⋆',
'⋇',
'⋈',
'⋉',
'⋊',
'⋋',
'⋌',
'⋍',
'⋎',
'⋏',
'⋐',
'⋑',
'⋒',
'⋓',
'⋔',
'⋕',
'⋖',
'⋗',
'⋘',
'⋙',
'⋚',
'⋛',
'⋜',
'⋝',
'⋞',
'⋟',
'⋠',
'⋡',
'⋢',
'⋣',
'⋤',
'⋥',
'⋦',
'⋧',
'⋨',
'⋩',
'▁',
'▂',
'▃',
'▄',
'▅',
'▆',
'▇',
'█',
'▉',
'▊',
'▋',
'▌',
'▍',
'▎',
'▏',
'▐',
'░',
'▒',
'▓',
'▔',
'▕',
'▖',
'▗',
'▘',
'▙'
)
val codeMap = code.mapIndexed { index, c -> c to index }.toMap()
}
override fun encode(bytes: ByteArray): String {
val result = CharArray(bytes.size)
for (i in bytes.indices) {
val unsignedByte = bytes[i].toInt() and 0xFF
result[i] = code[unsignedByte]
}
return String(result)
}
override fun decode(string: String): ByteArray {
val result = ByteArray(string.length)
for (i in string.indices) {
result[i] = codeMap[string[i]]!!.toByte()
}
return result
}
}
@@ -0,0 +1,62 @@
/*
* Copyright 2025 mingliqiye
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* ProjectName mingli-utils
* ModuleName mingli-utils.main
* CurrentFile Base64.kt
* LastUpdate 2025-09-17 10:56:32
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.base
/*
* Base64编解码工具类
* 提供Base64编码和解码功能的实现
*/
class Base64 : BaseCodec {
/*
* Base64编码器实例
* 用于执行字节数组到Base64字符串的编码操作
*/
val BASE_64_ENCODER: java.util.Base64.Encoder = java.util.Base64.getEncoder()
/*
* Base64解码器实例
* 用于执行Base64字符串到字节数组的解码操作
*/
val BASE_64_DECODER: java.util.Base64.Decoder = java.util.Base64.getDecoder()
/*
* 将字节数组编码为Base64字符串
*
* @param bytes 待编码的字节数组
* @return 编码后的Base64字符串
*/
override fun encode(bytes: ByteArray): String {
return BASE_64_ENCODER.encodeToString(bytes)
}
/*
* 将Base64字符串解码为字节数组
*
* @param string 待解码的Base64字符串
* @return 解码后的字节数组
*/
override fun decode(string: String): ByteArray {
return BASE_64_DECODER.decode(string)
}
}
@@ -0,0 +1,404 @@
/*
* Copyright 2025 mingliqiye
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* ProjectName mingli-utils
* ModuleName mingli-utils.main
* CurrentFile Base91.kt
* LastUpdate 2025-09-19 20:08:46
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.base
/**
* Base91 编解码工具类,用于将字节数组编码为 Base91 字符串,或将 Base91 字符串解码为原始字节数组。
*
* Base91 是一种高效的二进制到文本的编码方式,相较于 Base64,它使用更少的字符来表示相同的数据。
*/
class Base91 : BaseCodec {
companion object {
/**
* Base91 编码表,共 91 个可打印 ASCII 字符。
*/
val ENCODING_TABLE: CharArray = charArrayOf(
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '!', '#', '$',
'%', '&', '(', ')', '*', '+', ',', '.', '/', ':', ';', '<', '=',
'>', '?', '@', '[', ']', '^', '_', '`', '{', '|', '}', '~', '"'
)
/**
* Base91 解码表,大小为 256,用于快速查找字符对应的数值。
* 初始化时将所有元素设为 -1,表示无效字符;然后根据 ENCODING_TABLE 填充有效字符的索引。
*/
val DECODING_TABLE: Array<Int> = arrayOf(
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
62,
90,
63,
64,
65,
66,
-1,
67,
68,
69,
70,
71,
-1,
72,
73,
52,
53,
54,
55,
56,
57,
58,
59,
60,
61,
74,
75,
76,
77,
78,
79,
80,
0,
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
13,
14,
15,
16,
17,
18,
19,
20,
21,
22,
23,
24,
25,
81,
-1,
82,
83,
84,
85,
26,
27,
28,
29,
30,
31,
32,
33,
34,
35,
36,
37,
38,
39,
40,
41,
42,
43,
44,
45,
46,
47,
48,
49,
50,
51,
86,
87,
88,
89,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1
)
}
/**
* 将字节数组编码为 Base91 字符串。
*
* @param bytes 待编码的字节数组
* @return 编码后的 Base91 字符串
*/
override fun encode(bytes: ByteArray): String {
if (bytes.isEmpty()) return ""
val sb = StringBuilder()
var ebq = 0 // 编码缓冲区,用于暂存待处理的位数据
var en = 0 // 当前缓冲区中的有效位数
for (b in bytes) {
// 将当前字节加入缓冲区
ebq = ebq or ((b.toInt() and 0xFF) shl en)
en += 8
// 每当缓冲区中有超过 13 位的数据时,尝试进行编码
if (en > 13) {
var ev = ebq and 0x1FFF // 取出低 13 位作为候选值
if (ev > 88) {
// 如果候选值大于 88,则使用 13 位编码
ebq = ebq shr 13
en -= 13
} else {
// 否则使用 14 位编码
ev = ebq and 0x3FFF
ebq = ebq shr 14
en -= 14
}
// 将两个字符追加到结果中
sb.append(ENCODING_TABLE[ev % 91])
sb.append(ENCODING_TABLE[ev / 91])
}
}
// 处理剩余未编码的数据
if (en > 0) {
sb.append(ENCODING_TABLE[ebq % 91])
if (en > 7 || ebq > 90) {
sb.append(ENCODING_TABLE[ebq / 91])
}
}
return sb.toString()
}
/**
* 将 Base91 字符串解码为原始字节数组。
*
* @param string 待解码的 Base91 字符串
* @return 解码后的字节数组
*/
override fun decode(string: String): ByteArray {
if (string.isEmpty()) return ByteArray(0)
var dbq = 0 // 解码缓冲区,用于暂存待处理的位数据
var dn = 0 // 当前缓冲区中的有效位数
var dv = -1 // 当前读取到的 Base91 值
val buffer = ByteArray(string.length * 13 / 8) // 预分配输出缓冲区
var index = 0 // 输出缓冲区写入位置
for (c in string.toCharArray()) {
// 忽略不在编码表中的字符
if (DECODING_TABLE[c.code] == -1) continue
if (dv == -1) {
// 第一次读取字符,保存为 dv
dv = DECODING_TABLE[c.code]
} else {
// 第二次读取字符,组合成完整的 Base91 值
dv += DECODING_TABLE[c.code] * 91
dbq = dbq or (dv shl dn)
// 根据值大小判断是 13 位还是 14 位编码
dn += if ((dv and 0x1FFF) > 88) 13 else 14
// 将缓冲区中完整的字节写入输出数组
do {
buffer[index++] = (dbq and 0xFF).toByte()
dbq = dbq shr 8
dn -= 8
} while (dn > 7)
dv = -1 // 重置 dv,准备下一轮读取
}
}
// 处理最后剩余的一个字符(如果存在)
if (dv != -1) {
buffer[index++] = ((dbq or (dv shl dn)) and 0xFF).toByte()
}
// 返回实际使用的部分
return buffer.copyOf(index)
}
}
@@ -0,0 +1,173 @@
/*
* Copyright 2025 mingliqiye
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* ProjectName mingli-utils
* ModuleName mingli-utils.main
* CurrentFile BaseCodec.kt
* LastUpdate 2025-09-18 14:07:35
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.base
import java.io.File
import java.io.IOException
import java.nio.file.Path
interface BaseCodec {
/**
* 将字节数组编码为Base64字符串
*
* @param bytes 需要编码的字节数组
* @return 编码后的Base64字符串
*/
fun encode(bytes: ByteArray): String
/**
* 将Base64字符串解码为字节数组
*
* @param string 需要解码的Base64字符串
* @return 解码后的字节数组
*/
fun decode(string: String): ByteArray
/**
* 将文件内容编码为Base64字符串
*
* @param file 需要编码的文件
* @return 文件内容的Base64编码字符串
* @throws IOException 当文件读取失败时抛出
*/
@Throws(IOException::class)
fun encode(file: File): String {
return encode(file.readBytes())
}
/**
* 将Base64字符串解码并写入文件
*
* @param file 目标文件
* @param string 需要解码的Base64字符串
* @throws IOException 当文件写入失败时抛出
*/
@Throws(IOException::class)
fun decode(file: File, string: String) {
file.writeBytes(decode(string))
}
/**
* 安全地将文件内容编码为Base64字符串,出现异常时返回null
*
* @param file 需要编码的文件
* @return 文件内容的Base64编码字符串,失败时返回null
*/
fun encodeSafe(file: File): String? {
return try {
encode(file)
} catch (_: Exception) {
null
}
}
/**
* 安全地将Base64字符串解码并写入文件,返回操作是否成功
*
* @param file 目标文件
* @param string 需要解码的Base64字符串
* @return 操作成功返回true,失败返回false
*/
fun decodeSafe(file: File, string: String): Boolean {
return try {
decode(file, string)
true
} catch (_: Exception) {
false
}
}
/**
* 将路径对应的文件内容编码为Base64字符串
*
* @param path 需要编码的文件路径
* @return 文件内容的Base64编码字符串
* @throws IOException 当文件读取失败时抛出
*/
@Throws(IOException::class)
fun encode(path: Path): String {
return encode(path.toFile().readBytes())
}
/**
* 将Base64字符串解码并写入路径指定的文件
*
* @param path 目标文件路径
* @param string 需要解码的Base64字符串
* @throws IOException 当文件写入失败时抛出
*/
@Throws(IOException::class)
fun decode(path: Path, string: String) {
path.toFile().writeBytes(decode(string))
}
/**
* 安全地将路径对应的文件内容编码为Base64字符串,出现异常时返回null
*
* @param path 需要编码的文件路径
* @return 文件内容的Base64编码字符串,失败时返回null
*/
fun encodeSafe(path: Path): String? {
return try {
encode(path)
} catch (_: Exception) {
null
}
}
/**
* 安全地将Base64字符串解码并写入路径指定的文件,返回操作是否成功
*
* @param path 目标文件路径
* @param string 需要解码的Base64字符串
* @return 操作成功返回true,失败返回false
*/
fun decodeSafe(path: Path, string: String): Boolean {
return try {
decode(path, string)
true
} catch (_: Exception) {
false
}
}
/**
* 将字符串编码为Base64字符串
*
* @param string 需要编码的字符串
* @return 编码后的Base64字符串
*/
fun encode(string: String): String {
return encode(string.toByteArray())
}
/**
* 将Base64字符串解码为字符串
*
* @param string 需要解码的Base64字符串
* @return 解码后的字符串
*/
fun decodetoString(string: String): String {
return decode(string).toString(Charsets.UTF_8)
}
}
@@ -0,0 +1,63 @@
/*
* Copyright 2025 mingliqiye
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* ProjectName mingli-utils
* ModuleName mingli-utils.main
* CurrentFile BaseUtils.kt
* LastUpdate 2025-09-19 20:18:09
* UpdateUser MingLiPro
*/
@file:JvmName("BaseUtils")
package com.mingliqiye.utils.base
/**
* Base64编解码器实例
* 使用懒加载方式初始化Base64编解码器对象
* 保证线程安全且只在首次访问时创建实例
*/
val BASE64: BaseCodec by lazy {
Base64()
}
/**
* Base91编解码器实例
* 使用懒加载方式初始化Base91编解码器对象
* 保证线程安全且只在首次访问时创建实例
*/
val BASE91: BaseCodec by lazy {
Base91()
}
/**
* Base91编解码器实例
* 使用懒加载方式初始化Base91编解码器对象
* 保证线程安全且只在首次访问时创建实例
*/
val BASE16: BaseCodec by lazy {
Base16()
}
/**
* Base256编解码器实例
* 使用懒加载方式初始化Base256编解码器对象
* 保证线程安全且只在首次访问时创建实例
*/
val BASE256: BaseCodec by lazy {
Base256()
}
@@ -1,160 +0,0 @@
/*
* Copyright 2025 mingliqiye
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* ProjectName mingli-utils
* ModuleName mingli-utils.main
* CurrentFile Base64Utils.kt
* LastUpdate 2025-09-15 22:32:50
* UpdateUser MingLiPro
*/
@file:JvmName("Base64Utils")
package com.mingliqiye.utils.base64
import java.io.File
import java.io.IOException
import java.nio.file.Path
import java.util.*
val BASE_64_ENCODER: Base64.Encoder = Base64.getEncoder()
val BASE_64_DECODER: Base64.Decoder = Base64.getDecoder()
/**
* 将字节数组编码为Base64字符串
*
* @param bytes 需要编码的字节数组
* @return 编码后的Base64字符串
*/
fun encode(bytes: ByteArray): String {
return BASE_64_ENCODER.encodeToString(bytes)
}
/**
* 将Base64字符串解码为字节数组
*
* @param string 需要解码的Base64字符串
* @return 解码后的字节数组
*/
fun decode(string: String): ByteArray {
return BASE_64_DECODER.decode(string)
}
/**
* 将文件内容编码为Base64字符串
*
* @param file 需要编码的文件
* @return 文件内容的Base64编码字符串
* @throws IOException 当文件读取失败时抛出
*/
@Throws(IOException::class)
fun encode(file: File): String {
return encode(file.readBytes())
}
/**
* 将Base64字符串解码并写入文件
*
* @param file 目标文件
* @param string 需要解码的Base64字符串
* @throws IOException 当文件写入失败时抛出
*/
@Throws(IOException::class)
fun decode(file: File, string: String) {
file.writeBytes(decode(string))
}
/**
* 安全地将文件内容编码为Base64字符串,出现异常时返回null
*
* @param file 需要编码的文件
* @return 文件内容的Base64编码字符串,失败时返回null
*/
fun encodeSafe(file: File): String? {
return try {
encode(file)
} catch (_: Exception) {
null
}
}
/**
* 安全地将Base64字符串解码并写入文件,返回操作是否成功
*
* @param file 目标文件
* @param string 需要解码的Base64字符串
* @return 操作成功返回true,失败返回false
*/
fun decodeSafe(file: File, string: String): Boolean {
return try {
decode(file, string)
true
} catch (_: Exception) {
false
}
}
/**
* 将路径对应的文件内容编码为Base64字符串
*
* @param path 需要编码的文件路径
* @return 文件内容的Base64编码字符串
* @throws IOException 当文件读取失败时抛出
*/
@Throws(IOException::class)
fun encode(path: Path): String {
return encode(path.toFile().readBytes())
}
/**
* 将Base64字符串解码并写入路径指定的文件
*
* @param path 目标文件路径
* @param string 需要解码的Base64字符串
* @throws IOException 当文件写入失败时抛出
*/
@Throws(IOException::class)
fun decode(path: Path, string: String) {
path.toFile().writeBytes(decode(string))
}
/**
* 安全地将路径对应的文件内容编码为Base64字符串,出现异常时返回null
*
* @param path 需要编码的文件路径
* @return 文件内容的Base64编码字符串,失败时返回null
*/
fun encodeSafe(path: Path): String? {
return try {
encode(path)
} catch (_: Exception) {
null
}
}
/**
* 安全地将Base64字符串解码并写入路径指定的文件,返回操作是否成功
*
* @param path 目标文件路径
* @param string 需要解码的Base64字符串
* @return 操作成功返回true,失败返回false
*/
fun decodeSafe(path: Path, string: String): Boolean {
return try {
decode(path, string)
true
} catch (_: Exception) {
false
}
}
@@ -0,0 +1,59 @@
/*
* Copyright 2025 mingliqiye
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* ProjectName mingli-utils
* ModuleName mingli-utils.main
* CurrentFile BCrypt.kt
* LastUpdate 2025-09-19 20:17:41
* UpdateUser MingLiPro
*/
@file:JvmName("BCrypt")
package com.mingliqiye.utils.bcrypt
import java.security.SecureRandom
import org.mindrot.jbcrypt.BCrypt as JBCrypt
fun hashpw(string: String): String {
return hashpw(string, gensalt())
}
fun hashpw(string: String, salt: String = gensalt()): String {
return JBCrypt.hashpw(string, salt)
}
fun checkpw(string: String, bcrypted: String): Boolean {
return JBCrypt.checkpw(string, bcrypted)
}
fun gensalt(): String {
return JBCrypt.gensalt()
}
fun gensalt(long: Int): String {
return JBCrypt.gensalt(long)
}
fun gensalt(long: Int, secureRandom: SecureRandom): String {
return JBCrypt.gensalt(long, secureRandom)
}
@@ -1,241 +0,0 @@
/*
* Copyright 2025 mingliqiye
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* ProjectName mingli-utils
* ModuleName mingli-utils.main
* CurrentFile Factory.kt
* LastUpdate 2025-09-15 22:32:50
* UpdateUser MingLiPro
*/
@file:JvmName("Factory")
package com.mingliqiye.utils.bean
import com.mingliqiye.utils.bean.annotation.ComponentBean
import com.mingliqiye.utils.bean.annotation.InjectBean
import java.io.File
import java.net.URL
import java.util.*
import java.util.concurrent.ConcurrentHashMap
import kotlin.reflect.KClass
/**
* 存储所有已注册的Bean实例,键为Bean名称,值为Bean实例
*/
private val BEANS: ConcurrentHashMap<String, Any> = ConcurrentHashMap()
/**
* 存储按类型查找的Bean实例,键为Bean的Class对象,值为Bean实例
*/
private val TYPE_BEANS: ConcurrentHashMap<KClass<*>, Any> = ConcurrentHashMap()
/**
* 自动扫描指定类所在包下的所有类并注册为Bean
*
* @param c 指定的类,用于获取其所在的包
* @throws IllegalArgumentException 如果传入的类为null或位于默认包中
*/
fun autoScan(c: Class<*>?) {
if (c == null) {
throw IllegalArgumentException("Class cannot be null")
}
val pkg = c.`package`
if (pkg == null) {
throw IllegalArgumentException("Class is in the default package")
}
scan(pkg.name)
}
/**
* 扫描指定包路径下的所有类文件,并注册其中带有@ComponentBean注解的类为Bean
*
* @param basePackage 要扫描的基础包名
* @throws RuntimeException 如果在扫描过程中发生异常
*/
fun scan(basePackage: String) {
try {
val path = basePackage.replace('.', '/')
val classLoader = Thread.currentThread().contextClassLoader
val resources: Enumeration<URL> = classLoader.getResources(path)
while (resources.hasMoreElements()) {
val resource = resources.nextElement()
val file = File(resource.toURI())
scanDirectory(file, basePackage)
}
injectDependencies()
} catch (e: Exception) {
throw RuntimeException(e)
}
}
/**
* 递归扫描目录中的所有类文件,并注册符合条件的类为Bean
*
* @param directory 当前要扫描的目录
* @param packageName 当前目录对应的包名
* @throws Exception 如果在扫描或类加载过程中发生异常
*/
private fun scanDirectory(directory: File, packageName: String) {
val files = directory.listFiles() ?: return
for (file in files) {
if (file.isDirectory) {
scanDirectory(file, "$packageName.${file.name}")
} else if (file.name.endsWith(".class")) {
val className = packageName + '.' + file.name.replace(".class", "")
registerComponent(Class.forName(className))
}
}
}
/**
* 注册一个带有@ComponentBean注解的类为Bean实例
*
* @param clazz 要注册的类
* @throws Exception 如果在实例化类或处理注解时发生异常
*/
private fun registerComponent(clazz: Class<*>) {
if (clazz.isAnnotationPresent(ComponentBean::class.java)) {
val component = clazz.getAnnotation(ComponentBean::class.java)
val name = component.value.ifEmpty { clazz.name }
val instance = clazz.getDeclaredConstructor().newInstance()
BEANS[name] = instance
val kClass = clazz.kotlin
TYPE_BEANS[kClass] = instance
for (interfaceClass in clazz.interfaces) {
TYPE_BEANS.putIfAbsent(interfaceClass.kotlin, instance)
}
}
}
/**
* 对所有已注册的Bean进行依赖注入处理
*
* @throws Exception 如果在注入过程中发生异常
*/
private fun injectDependencies() {
for (bean in BEANS.values) {
for (field in bean.javaClass.declaredFields) {
if (field.isAnnotationPresent(InjectBean::class.java)) {
val inject = field.getAnnotation(InjectBean::class.java)
val dependency = findDependency(field.type, inject.value)
if (dependency == null) {
throw IllegalStateException(
"No suitable dependency found for field " + field.name + " in class " + bean.javaClass.name
)
}
field.isAccessible = true
field.set(bean, dependency)
}
}
}
}
/**
* 根据类型和名称查找对应的依赖实例
*
* @param type 依赖的类型
* @param name 依赖的名称(可为空)
* @return 找到的依赖实例,未找到则返回null
*/
private fun findDependency(type: Class<*>, name: String): Any? {
if (name.isNotEmpty()) {
return BEANS[name]
}
val dependency = TYPE_BEANS[type.kotlin]
if (dependency != null) {
return dependency
}
for (interfaceType in TYPE_BEANS.keys) {
if (type.isAssignableFrom(interfaceType.java)) {
return TYPE_BEANS[interfaceType]
}
}
return null
}
/**
* 将一个对象添加到Bean容器中,使用其类名作为键
*
* @param obj 要添加的对象
* @throws RuntimeException 如果在注入依赖时发生异常
*/
fun add(obj: Any) {
val clazz = obj.javaClass
val name = clazz.name
BEANS[name] = obj
TYPE_BEANS[clazz.kotlin] = obj
try {
injectDependencies()
} catch (e: Exception) {
throw RuntimeException(e)
}
}
/**
* 将一个对象以指定名称添加到Bean容器中
*
* @param name Bean的名称
* @param obj 要添加的对象
* @throws RuntimeException 如果在注入依赖时发生异常
*/
fun add(name: String, obj: Any) {
BEANS[name] = obj
TYPE_BEANS[obj.javaClass.kotlin] = obj
try {
injectDependencies()
} catch (e: Exception) {
throw RuntimeException(e)
}
}
/**
* 根据类型获取对应的Bean实例
*
* @param objclass Bean的类型
* @param T Bean的泛型类型
* @return 对应类型的Bean实例,未找到则返回null
*/
@Suppress("UNCHECKED_CAST")
fun <T : Any> get(objclass: KClass<T>): T? {
return TYPE_BEANS[objclass] as? T
}
/**
* 根据名称和类型获取对应的Bean实例
*
* @param name Bean的名称
* @param objclass Bean的类型
* @param T Bean的泛型类型
* @return 对应名称和类型的Bean实例,未找到则返回null
*/
@Suppress("UNCHECKED_CAST")
fun <T : Any> get(name: String, objclass: KClass<T>): T? {
return BEANS[name] as? T
}
/**
* 根据名称获取对应的Bean实例
*
* @param name Bean的名称
* @return 对应名称的Bean实例,未找到则返回null
*/
fun get(name: String): Any? {
return BEANS[name]
}
@@ -0,0 +1,297 @@
/*
* Copyright 2026 mingliqiye
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* ProjectName mingli-utils
* ModuleName mingli-utils.main
* CurrentFile ByteBufferUtils.kt
* LastUpdate 2026-01-11 09:44:19
* UpdateUser MingLiPro
*/
@file:JvmName("ByteBufferUtils")
package com.mingliqiye.utils.bytes
import java.io.IOException
import java.io.OutputStream
import java.nio.ByteBuffer
import java.nio.charset.Charset
/**
* 将字符串以指定字符集编码后写入 [ByteBuffer],并在末尾追加一个空字节(`0x00`)作为字符串终止符。
*
* 此方法适用于需要 C 风格字符串(null-terminated string)的协议或场景。
*
* @param string 要写入的字符串,不可为 null
* @param charset 字符编码,默认为 [Charsets.UTF_8]
* @return 当前 [ByteBuffer] 实例(支持链式调用)
*/
fun ByteBuffer.putString(string: String, charset: Charset = Charsets.UTF_8): ByteBuffer =
this.put(string.toByteArray(charset)).put(0x00)
/**
* 从 [ByteBuffer] 中读取一个以空字节(`0x00`)结尾的字符串。
*
* 该方法会持续读取字节,直到遇到第一个 `0x00`(null terminator)为止,并将之前读取的字节按指定字符集解码为字符串。
* **注意**:此操作会修改缓冲区的位置(position),且不处理缓冲区越界情况(若无终止符会抛出异常)。
*
* @param charset 字符编码,默认为 [Charsets.UTF_8]
* @return 解码后的字符串(不含终止符)
* @throws BufferUnderflowException 如果缓冲区中没有足够的字节(即未找到终止符)
*/
fun ByteBuffer.getString(charset: Charset = Charsets.UTF_8): String {
val data = ArrayList<Byte>()
while (true) {
val byte = this.get()
if (byte == 0x00.toByte()) {
break
}
data.add(byte)
}
return String(data.toByteArray(), charset)
}
/**
* 将 [ByteBuffer] 中剩余的全部字节读取为一个 [ByteArray]。
*
* 此方法会读取从当前位置到 limit 之间的所有字节,并推进 position。
*
* @return 包含剩余字节的新字节数组
*/
fun ByteBuffer.toByteArray(): ByteArray {
val ba = ByteArray(this.remaining())
this.get(ba)
return ba
}
/**
* 将一个布尔列表(长度必须为 8)转换为 [ByteFlags] 并写入 [ByteBuffer]。
*
* 列表索引 0~7 分别对应位 b0~b7(b0 为最低有效位)。
*
* @param bit 长度为 8 的布尔列表,表示 8 个位的状态
* @return 当前 [ByteBuffer] 实例(支持链式调用)
* @throws IndexOutOfBoundsException 如果列表长度不足 8
*/
fun ByteBuffer.putByteFlags(
bit: List<Boolean> = List(8) { false },
): ByteBuffer = this.putByteFlags(
ByteFlags(
bit[0],
bit[1],
bit[2],
bit[3],
bit[4],
bit[5],
bit[6],
bit[7],
)
)
/**
* 将一个布尔数组(长度必须为 8)转换为 [ByteFlags] 并写入 [ByteBuffer]。
*
* 数组索引 0~7 分别对应位 b0~b7(b0 为最低有效位)。
*
* @param bit 长度为 8 的布尔数组
* @return 当前 [ByteBuffer] 实例(支持链式调用)
* @throws IndexOutOfBoundsException 如果数组长度不足 8
*/
fun ByteBuffer.putByteFlags(
bit: BooleanArray = BooleanArray(8),
): ByteBuffer = this.putByteFlags(
ByteFlags(
bit[0],
bit[1],
bit[2],
bit[3],
bit[4],
bit[5],
bit[6],
bit[7],
)
)
/**
* 将 [ByteFlags] 对象转换为字节并写入 [ByteBuffer]。
*
* @param byteFlags 要写入的位标志对象
* @return 当前 [ByteBuffer] 实例(支持链式调用)
*/
fun ByteBuffer.putByteFlags(byteFlags: ByteFlags): ByteBuffer = this.put(byteFlags.toByte())
/**
* 通过 8 个独立的布尔参数构造 [ByteFlags] 并写入 [ByteBuffer]。
*
* 参数顺序:`bit0`(LSB)到 `bit7`(MSB)。
*
* @param bit0 第 0 位(最低位)
* @param bit1 第 1 位
* @param bit2 第 2 位
* @param bit3 第 3 位
* @param bit4 第 4 位
* @param bit5 第 5 位
* @param bit6 第 6 位
* @param bit7 第 7 位(最高位)
* @return 当前 [ByteBuffer] 实例(支持链式调用)
*/
fun ByteBuffer.putByteFlags(
bit0: Boolean = false,
bit1: Boolean = false,
bit2: Boolean = false,
bit3: Boolean = false,
bit4: Boolean = false,
bit5: Boolean = false,
bit6: Boolean = false,
bit7: Boolean = false,
): ByteBuffer = this.putByteFlags(
ByteFlags(
bit0,
bit1,
bit2,
bit3,
bit4,
bit5,
bit6,
bit7,
)
)
/**
* 从 [ByteBuffer] 中读取一个字节,并将其解析为 [ByteFlags] 对象。
*
* @return 表示该字节各位状态的 [ByteFlags] 实例
*/
fun ByteBuffer.getByteFlags(): ByteFlags = ByteFlags(this.get())
/**
* 从 [ByteBuffer] 中读取一个字节,并将其解释为布尔值。
*
* 约定:`0x01` 表示 `true`,其他值(包括 `0x00`)均视为 `false`。
*
* @return 布尔值
*/
fun ByteBuffer.getBoolean(): Boolean = this.get() == 0x01.toByte()
/**
* 将布尔值写入 [ByteBuffer]。
*
* 约定:`true` 写为 `0x01`,`false` 写为 `0x00`。
*
* @param boolean 要写入的布尔值
* @return 当前 [ByteBuffer] 实例(支持链式调用)
*/
fun ByteBuffer.putBoolean(boolean: Boolean): ByteBuffer = this.put(if (boolean) 0x01 else 0x00)
/**
* 将当前字节数组包装为一个只读的 [ByteBuffer]。
*
* 使用 [ByteBuffer.wrap] 创建,position 初始为 0,limit 为数组长度。
*
* @return 包装后的 [ByteBuffer] 实例
*/
fun ByteArray.toByteBuffer(): ByteBuffer {
return ByteBuffer.wrap(this)
}
/**
* 从ByteBuffer中读取一个变长整数(VarNumber)。
*
* 变长整数使用可变长度编码方式,每个字节的最高位表示是否还有后续字节:
* - 如果最高位为1,则表示还有下一个字节;
* - 如果最高位为0,则表示当前字节是最后一个字节。
*
* @param size 最大允许读取的字节数,默认为8(即Long类型的最大长度)。
* @return 解码后的长整型数值。
* @throws IOException 当读取过程中发生IO异常时抛出。
*/
fun ByteBuffer.getVarLong(size: Int = 8): Long {
var numRead = 0
var result: Long = 0
var read: Byte
do {
read = this.get()
// 将当前字节的有效7位数据左移相应位置后与结果进行按位或运算
result = result or ((read.toLong() and 127) shl (7 * numRead))
numRead++
if (numRead > size) {
throw IOException("VarNumber is too big")
}
} while ((read.toLong() and 128) != 0L)
return result
}
/**
* 从ByteBuffer中读取一个变长整数(VarNumber),返回Int类型。
*
* @return 解码后的整型数值。
*/
fun ByteBuffer.getVarInt(): Int = this.getVarLong(4).toInt()
/**
* 从ByteBuffer中读取一个变长整数(VarNumber),返回Short类型。
*
* @return 解码后的短整型数值。
*/
fun ByteBuffer.getVarShort(): Short = this.getVarLong(2).toShort()
/**
* 从输入流中读取一个变长长整数(VarLong),最大长度默认为8个字节。
*
* @return 解码后的长整型数值。
* @throws IOException 当读取过程中发生IO异常时抛出。
*/
@Throws(IOException::class)
fun ByteBuffer.getVarLong(): Long = this.getVarLong(8)
/**
* 将长整型数值编码为变长格式并写入ByteBuffer
*
* 变长整数使用可变长度编码方式,每个字节的最高位表示是否还有后续字节:
* - 如果数值还有更多字节,则最高位设为1;
* - 最后一个字节最高位设为0。
*
* @param value 要写入的长整型数值
* @return 当前ByteBuffer实例(支持链式调用)
*/
fun ByteBuffer.putVarLong(value: Long): ByteBuffer {
var v = value
while (v >= 0x80) {
this.put((v and 0x7F or 0x80).toByte())
v = v shr 7
}
this.put(v.toByte())
return this
}
/**
* 将整型数值编码为变长格式并写入ByteBuffer
*
* @param value 要写入的整型数值
* @return 当前ByteBuffer实例(支持链式调用)
*/
fun ByteBuffer.putVarInt(value: Int): ByteBuffer = this.putVarLong(value.toLong())
/**
* 将短整型数值编码为变长格式并写入ByteBuffer
*
* @param value 要写入的短整型数值
* @return 当前ByteBuffer实例(支持链式调用)
*/
fun ByteBuffer.putVarShort(value: Short): ByteBuffer = this.putVarLong(value.toLong())
fun ByteBuffer.writeStream(outputStream: OutputStream) = outputStream.write(this.toByteArray())
@@ -0,0 +1,460 @@
/*
* Copyright 2026 mingliqiye
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* ProjectName mingli-utils
* ModuleName mingli-utils.main
* CurrentFile ByteFlags.kt
* LastUpdate 2026-01-07 09:37:09
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.bytes
/**
* 表示一个字节(8 位)的布尔标志集合。
*
* 每一位对应一个布尔值,其中:
* - `b0` 表示最低有效位(LSB,bit 0,值为 0x01)
* - `b7` 表示最高有效位(MSB,bit 7,值为 0x80)
*
* 该类支持从字节、布尔数组、二进制字符串等构造,并提供位操作、状态查询和格式化输出等功能。
*/
data class ByteFlags(
/** 第 0 位(最低位,0x01) */
var b0: Boolean = false,
/** 第 1 位(0x02) */
var b1: Boolean = false,
/** 第 2 位(0x04) */
var b2: Boolean = false,
/** 第 3 位(0x08) */
var b3: Boolean = false,
/** 第 4 位(0x10) */
var b4: Boolean = false,
/** 第 5 位(0x20) */
var b5: Boolean = false,
/** 第 6 位(0x40) */
var b6: Boolean = false,
/** 第 7 位(最高位,0x80) */
var b7: Boolean = false
) {
/**
* 通过一个 [Byte] 值构造 [ByteFlags] 实例。
*
* @param byte 用于初始化的字节值(仅使用低 8 位)
*/
constructor(byte: Byte) : this() {
fromByte(byte)
}
/**
* 从给定的 [Byte] 值解析并设置各个位标志。
*
* @param byte 要解析的字节
*/
fun fromByte(byte: Byte) {
val value = byte.toInt() and 0xFF
b0 = (value and 0x01) != 0
b1 = (value and 0x02) != 0
b2 = (value and 0x04) != 0
b3 = (value and 0x08) != 0
b4 = (value and 0x10) != 0
b5 = (value and 0x20) != 0
b6 = (value and 0x40) != 0
b7 = (value and 0x80) != 0
}
/**
* 将当前标志状态转换为一个 [Byte] 值。
*
* @return 对应的字节值(范围 0x00 ~ 0xFF,以有符号字节形式返回)
*/
fun toByte(): Byte {
var result = 0
if (b0) result = result or 0x01
if (b1) result = result or 0x02
if (b2) result = result or 0x04
if (b3) result = result or 0x08
if (b4) result = result or 0x10
if (b5) result = result or 0x20
if (b6) result = result or 0x40
if (b7) result = result or 0x80
return result.toByte()
}
/**
* 通过索引(0~7)获取对应位的布尔值。
*
* @param index 位索引(0 = LSB, 7 = MSB)
* @return 该位是否为 true
* @throws IndexOutOfBoundsException 如果索引不在 0~7 范围内
*/
operator fun get(index: Int): Boolean {
return when (index) {
0 -> b0
1 -> b1
2 -> b2
3 -> b3
4 -> b4
5 -> b5
6 -> b6
7 -> b7
else -> throw IndexOutOfBoundsException("索引必须在0-7之间")
}
}
/**
* 通过索引(0~7)设置对应位的布尔值。
*
* @param index 位索引(0 = LSB, 7 = MSB)
* @param value 要设置的布尔值
* @throws IndexOutOfBoundsException 如果索引不在 0~7 范围内
*/
operator fun set(index: Int, value: Boolean) {
when (index) {
0 -> b0 = value
1 -> b1 = value
2 -> b2 = value
3 -> b3 = value
4 -> b4 = value
5 -> b5 = value
6 -> b6 = value
7 -> b7 = value
else -> throw IndexOutOfBoundsException("索引必须在0-7之间")
}
}
/**
* 将所有 8 个位设置为 `true`。
*/
fun setAll() {
b0 = true
b1 = true
b2 = true
b3 = true
b4 = true
b5 = true
b6 = true
b7 = true
}
/**
* 将所有 8 个位设置为 `false`。
*/
fun clearAll() {
b0 = false
b1 = false
b2 = false
b3 = false
b4 = false
b5 = false
b6 = false
b7 = false
}
/**
* 对所有位执行逻辑取反(true ↔ false)。
*/
fun toggleAll() {
b0 = !b0
b1 = !b1
b2 = !b2
b3 = !b3
b4 = !b4
b5 = !b5
b6 = !b6
b7 = !b7
}
/**
* 切换指定索引位的状态(true 变 false,反之亦然)。
*
* @param index 要切换的位索引(0~7)
* @throws IndexOutOfBoundsException 如果索引无效
*/
fun toggle(index: Int) {
this[index] = !this[index]
}
/**
* 检查是否所有位都为 `true`。
*
* @return 若全部为 true 则返回 true,否则 false
*/
fun allTrue(): Boolean {
return b0 && b1 && b2 && b3 && b4 && b5 && b6 && b7
}
/**
* 检查是否所有位都为 `false`。
*
* @return 若全部为 false 则返回 true,否则 false
*/
fun allFalse(): Boolean {
return !b0 && !b1 && !b2 && !b3 && !b4 && !b5 && !b6 && !b7
}
/**
* 统计值为 `true` 的位数量。
*
* @return true 位的个数(0~8)
*/
fun countTrue(): Int {
var count = 0
if (b0) count++
if (b1) count++
if (b2) count++
if (b3) count++
if (b4) count++
if (b5) count++
if (b6) count++
if (b7) count++
return count
}
/**
* 统计值为 `false` 的位数量。
*
* @return false 位的个数(0~8)
*/
fun countFalse(): Int = 8 - countTrue()
/**
* 通过位名称(如 "b0"、"bit3" 等)获取对应位的值。
*
* 支持别名:`bN` 或 `bitN`(不区分大小写)。
*
* @param name 位的名称(例如 "b0", "BIT5")
* @return 对应位的布尔值
* @throws IllegalArgumentException 如果名称无效
*/
fun getByName(name: String): Boolean {
return when (name.lowercase()) {
"b0", "bit0" -> b0
"b1", "bit1" -> b1
"b2", "bit2" -> b2
"b3", "bit3" -> b3
"b4", "bit4" -> b4
"b5", "bit5" -> b5
"b6", "bit6" -> b6
"b7", "bit7" -> b7
else -> throw IllegalArgumentException("未知的位名称: $name")
}
}
/**
* 将当前状态转换为标准二进制字符串(MSB 在前)。
*
* 例如:若 b7=true, b6=false, ..., b0=true,则返回 "10000001"
*
* @return 8 位二进制字符串(高位在左)
*/
fun toBinaryString(): String {
return buildString {
if (b7) append('1') else append('0')
if (b6) append('1') else append('0')
if (b5) append('1') else append('0')
if (b4) append('1') else append('0')
if (b3) append('1') else append('0')
if (b2) append('1') else append('0')
if (b1) append('1') else append('0')
if (b0) append('1') else append('0')
}
}
/**
* 将当前状态转换为十六进制字符串(带 0x 前缀,大写,两位)。
*
* 例如:若值为 10,则返回 "0x0A"
*
* @return 格式如 "0xXX" 的十六进制字符串
*/
fun toHexString(): String {
return "0x" + (toByte().toInt() and 0xFF).toString(16).padStart(2, '0').uppercase()
}
/**
* 将当前位状态转换为布尔数组。
*
* 数组顺序为 [b0, b1, b2, ..., b7](LSB 在前)。
*
* @return 长度为 8 的布尔数组
*/
fun toBooleanArray(): BooleanArray {
return booleanArrayOf(b0, b1, b2, b3, b4, b5, b6, b7)
}
/**
* 从布尔数组初始化位状态。
*
* 使用数组的前 8 个元素(索引 0~7),分别对应 b0~b7。
*
* @param array 布尔数组(长度至少为 8)
* @throws IllegalArgumentException 如果数组长度不足 8
*/
fun fromBooleanArray(array: BooleanArray) {
require(array.size >= 8) { "数组长度至少为8" }
b0 = array[0]
b1 = array[1]
b2 = array[2]
b3 = array[3]
b4 = array[4]
b5 = array[5]
b6 = array[6]
b7 = array[7]
}
/**
* 对两个 [ByteFlags] 执行按位“与”操作(AND)。
*
* 结果的每一位 = this位 && other位
*
* @param other 另一个 ByteFlags 实例
* @return 新的 ByteFlags 实例,表示 AND 结果
*/
infix fun and(other: ByteFlags): ByteFlags {
return ByteFlags(
this.b0 && other.b0,
this.b1 && other.b1,
this.b2 && other.b2,
this.b3 && other.b3,
this.b4 && other.b4,
this.b5 && other.b5,
this.b6 && other.b6,
this.b7 && other.b7
)
}
/**
* 对两个 [ByteFlags] 执行按位“或”操作(OR)。
*
* 结果的每一位 = this位 || other位
*
* @param other 另一个 ByteFlags 实例
* @return 新的 ByteFlags 实例,表示 OR 结果
*/
infix fun or(other: ByteFlags): ByteFlags {
return ByteFlags(
this.b0 || other.b0,
this.b1 || other.b1,
this.b2 || other.b2,
this.b3 || other.b3,
this.b4 || other.b4,
this.b5 || other.b5,
this.b6 || other.b6,
this.b7 || other.b7
)
}
/**
* 对两个 [ByteFlags] 执行按位“异或”操作(XOR)。
*
* 结果的每一位 = this位 != other位
*
* @param other 另一个 ByteFlags 实例
* @return 新的 ByteFlags 实例,表示 XOR 结果
*/
infix fun xor(other: ByteFlags): ByteFlags {
return ByteFlags(
this.b0 != other.b0,
this.b1 != other.b1,
this.b2 != other.b2,
this.b3 != other.b3,
this.b4 != other.b4,
this.b5 != other.b5,
this.b6 != other.b6,
this.b7 != other.b7
)
}
/**
* 对当前 [ByteFlags] 执行按位“非”操作(NOT)。
*
* 每一位取反。
*
* @return 新的 ByteFlags 实例,所有位取反
*/
operator fun not(): ByteFlags {
return ByteFlags(
!b0, !b1, !b2, !b3, !b4, !b5, !b6, !b7
)
}
/**
* 返回可读的字符串表示,包含二进制和十六进制形式。
*
* 示例:`ByteFlags(10100001 = 0xA1)`
*
* @return 字符串描述
*/
override fun toString(): String {
return "ByteFlags(${toBinaryString()} = ${toHexString()})"
}
companion object {
/**
* 创建一个所有位均为 `true` 的 [ByteFlags] 实例。
*
* @return 全 1 的 ByteFlags(值为 0xFF)
*/
fun allTrue(): ByteFlags {
return ByteFlags(true, true, true, true, true, true, true, true)
}
/**
* 创建一个所有位均为 `false` 的 [ByteFlags] 实例。
*
* @return 全 0 的 ByteFlags(值为 0x00)
*/
fun allFalse(): ByteFlags {
return ByteFlags()
}
/**
* 从 8 位二进制字符串创建 [ByteFlags] 实例。
*
* 字符串格式:高位在前(MSB first),如 "10000001" 表示 b7=1, b0=1。
*
* @param binary 8 位二进制字符串(仅含 '0' 和 '1')
* @return 对应的 ByteFlags 实例
* @throws IllegalArgumentException 如果字符串长度不是 8 或包含非法字符
*/
fun fromBinaryString(binary: String): ByteFlags {
require(binary.length == 8) { "二进制字符串长度必须为8" }
require(binary.all { it == '0' || it == '1' }) { "二进制字符串只能包含0和1" }
return ByteFlags(
binary[7] == '1', // b0 是最低位(对应字符串最后一位)
binary[6] == '1',
binary[5] == '1',
binary[4] == '1',
binary[3] == '1',
binary[2] == '1',
binary[1] == '1',
binary[0] == '1' // b7 是最高位(对应字符串第一位)
)
}
/**
* 从整数创建 [ByteFlags] 实例(仅使用低 8 位)。
*
* @param value 输入整数
* @return 对应的 ByteFlags 实例
*/
fun fromInt(value: Int): ByteFlags {
return ByteFlags((value and 0xFF).toByte())
}
}
}
@@ -1,5 +1,5 @@
/* /*
* Copyright 2025 mingliqiye * Copyright 2026 mingliqiye
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@@ -16,31 +16,114 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile ByteUtils.kt * CurrentFile ByteUtils.kt
* LastUpdate 2025-09-15 17:26:34 * LastUpdate 2026-01-14 13:01:44
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@file:JvmName("ByteUtils") @file:JvmName("ByteUtils")
package com.mingliqiye.utils.bytes package com.mingliqiye.utils.bytes
import com.mingliqiye.utils.base.BASE16
import com.mingliqiye.utils.stream.SuperStream
/**
* 转义字符常量定义
* 定义了用于数据传输或协议通信中的特殊控制字节值
*/
const val ESC_ASC: Byte = 0x10 const val ESC_ASC: Byte = 0x10
/**
* 转义字符常量定义
* 定义了用于数据传输或协议通信中的特殊控制字节值
*/
const val ESC_DESC: Byte = 0x1B const val ESC_DESC: Byte = 0x1B
/**
* 转义字符常量定义
* 定义了用于数据传输或协议通信中的特殊控制字节值
*/
const val ESC_NONE: Byte = 0x00 const val ESC_NONE: Byte = 0x00
/**
* 转义字符常量定义
* 定义了用于数据传输或协议通信中的特殊控制字节值
*/
const val ESC_START: Byte = 0x01 const val ESC_START: Byte = 0x01
/**
* 转义字符常量定义
* 定义了用于数据传输或协议通信中的特殊控制字节值
*/
const val ESC_END: Byte = 0x02 const val ESC_END: Byte = 0x02
/**
* 转义字符常量定义
* 定义了用于数据传输或协议通信中的特殊控制字节值
*/
const val ESC_ESC: Byte = 0x03 const val ESC_ESC: Byte = 0x03
/**
* 转义字符常量定义
* 定义了用于数据传输或协议通信中的特殊控制字节值
*/
const val ESC_CONTROL: Byte = 0x04 const val ESC_CONTROL: Byte = 0x04
/**
* 转义字符常量定义
* 定义了用于数据传输或协议通信中的特殊控制字节值
*/
const val ESC_DATA: Byte = 0x05 const val ESC_DATA: Byte = 0x05
/**
* 转义字符常量定义
* 定义了用于数据传输或协议通信中的特殊控制字节值
*/
const val ESC_RESERVED: Byte = 0x06 const val ESC_RESERVED: Byte = 0x06
/** /**
* 将字节数组转换为十六进制字符串列表 * 将字节数组转换为十六进制字符串列表
* @receiver 字节数组
* @return 包含每个字节对应十六进制字符串的列表 * @return 包含每个字节对应十六进制字符串的列表
*/ */
fun ByteArray.getByteArrayString(): MutableList<String> { fun ByteArray.getByteArrayString(): MutableList<String> {
return this.toList().stream() return this.toList().stream().map { a -> String.format("0X%02X", a!!.toInt() and 0xFF) }
.map { a -> String.format("0X%02X", a!!.toInt() and 0xFF) } .collect(SuperStream.toList()) as MutableList<String>
.collect(com.mingliqiye.utils.stream.toList()) as MutableList<String>
} }
/**
* 将十六进制字符转换为对应的数值
* @receiver 十六进制字符
* @return 对应的数值(0-15)
* @throws NumberFormatException 当字符不是有效的十六进制字符时抛出
*/
fun Char.hexDigitToValue(): Int {
return when (this) {
in '0'..'9' -> this - '0'
in 'A'..'F' -> this - 'A' + 10
in 'a'..'f' -> this - 'a' + 10
else -> throw NumberFormatException("Invalid hex character: $this")
}
}
/**
* 将十六进制字符串转换为字节数组
*
* @param string 输入的十六进制字符串
* @return 转换后的字节数组
*/
fun hexStringToByteArray(string: String): ByteArray {
return string.hexToByteArray()
}
/**
* 将字节数组转换为十六进制字符串表示。
*
* @param bytes 输入的字节数组
* @return 对应的十六进制字符串
*/
fun bytesToHex(bytes: ByteArray): String {
return BASE16.encode(bytes)
}
@@ -0,0 +1,146 @@
/*
* Copyright 2026 mingliqiye
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* ProjectName mingli-utils
* ModuleName mingli-utils.main
* CurrentFile StreamUtils.kt
* LastUpdate 2026-01-11 09:41:14
* UpdateUser MingLiPro
*/
@file:JvmName("StreamUtils")
package com.mingliqiye.utils.bytes
import java.io.IOException
import java.io.InputStream
import java.io.OutputStream
/**
* 从输入流中读取一个变长整数(VarNumber)。
*
* 变长整数使用可变长度编码方式,每个字节的最高位表示是否还有后续字节:
* - 如果最高位为1,则表示还有下一个字节;
* - 如果最高位为0,则表示当前字节是最后一个字节。
*
* @param size 最大允许读取的字节数,默认为8(即Long类型的最大长度)。
* @return 解码后的长整型数值。
* @throws IOException 当读取过程中发生IO异常或到达流末尾时抛出。
*/
@Throws(IOException::class)
fun InputStream.readVarNumber(size: Int = 8): Long {
var numRead = 0
var result: Long = 0
var read: Byte
do {
read = this.read().let {
if (it == -1) {
throw IOException("Reached end of stream")
}
it.toByte()
}
result = result or ((read.toLong() and 127) shl (7 * numRead))
numRead++
if (numRead > size) {
throw IOException("VarNumber is too big")
}
} while ((read.toLong() and 128) != 0L)
return result
}
/**
* 从输入流中读取一个变长整数(VarInt),最大长度限制为4个字节。
*
* @return 解码后的整型数值。
* @throws IOException 当读取过程中发生IO异常时抛出。
*/
@Throws(IOException::class)
fun InputStream.readVarInt(): Int = this.readVarNumber(4).toInt()
/**
* 从输入流中读取一个变长短整数(VarShort),最大长度限制为2个字节。
*
* @return 解码后的短整型数值。
* @throws IOException 当读取过程中发生IO异常时抛出。
*/
@Throws(IOException::class)
fun InputStream.readVarShort(): Short = this.readVarNumber(2).toShort()
/**
* 从输入流中读取一个变长长整数(VarLong),最大长度默认为8个字节。
*
* @return 解码后的长整型数值。
* @throws IOException 当读取过程中发生IO异常时抛出。
*/
@Throws(IOException::class)
fun InputStream.readVarLong(): Long = this.readVarNumber()
/**
* 将长整型数值编码为变长格式并写入输出流
*
* 变长整数使用可变长度编码方式,每个字节的最高位表示是否还有后续字节:
* - 如果数值还有更多字节,则最高位设为1;
* - 最后一个字节最高位设为0。
*
* @param value 要写入的长整型数值
* @param size 最大允许写入的字节数,默认为8
* @throws IOException 当写入过程中发生IO异常时抛出
*/
@Throws(IOException::class)
fun OutputStream.writeVarNumber(value: Long, size: Int = 8) {
var v = value
var numWritten = 0
while (v >= 0x80 && numWritten < size - 1) {
this.write((v and 0x7F or 0x80).toInt())
v = v ushr 7
numWritten++
}
if (numWritten >= size) {
throw IOException("VarNumber is too big")
}
this.write(v.toInt())
}
/**
* 将整型数值编码为变长格式并写入输出流
*
* @param value 要写入的整型数值
* @throws IOException 当写入过程中发生IO异常时抛出
*/
@Throws(IOException::class)
fun OutputStream.writeVarInt(value: Int): Unit = this.writeVarNumber(value.toLong(), 4)
/**
* 将短整型数值编码为变长格式并写入输出流
*
* @param value 要写入的短整型数值
* @throws IOException 当写入过程中发生IO异常时抛出
*/
@Throws(IOException::class)
fun OutputStream.writeVarShort(value: Short): Unit = this.writeVarNumber(value.toLong(), 2)
/**
* 将长整型数值编码为变长格式并写入输出流
*
* @param value 要写入的长整型数值
* @throws IOException 当写入过程中发生IO异常时抛出
*/
@Throws(IOException::class)
fun OutputStream.writeVarLong(value: Long): Unit = this.writeVarNumber(value, 8)
@@ -16,7 +16,7 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile CloneUtils.kt * CurrentFile CloneUtils.kt
* LastUpdate 2025-09-15 09:30:37 * LastUpdate 2025-09-20 14:01:29
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@file:JvmName("CloneUtils") @file:JvmName("CloneUtils")
@@ -38,8 +38,7 @@ inline fun <reified T> T.deepJsonClone(jsonApi: JsonApi): T {
} catch (e: Exception) { } catch (e: Exception) {
throw JsonException( throw JsonException(
"Failed to deep clone object using JSON", "Failed to deep clone object using JSON", e
e
) )
} }
} }
@@ -16,7 +16,7 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile Collection.kt * CurrentFile Collection.kt
* LastUpdate 2025-09-15 17:26:00 * LastUpdate 2025-09-21 14:36:57
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@@ -24,22 +24,48 @@
package com.mingliqiye.utils.collection package com.mingliqiye.utils.collection
import com.mingliqiye.utils.stream.SuperStream
import java.util.* import java.util.*
import java.util.stream.Collectors import java.util.stream.Collectors
/**
* 将当前集合转换为数组。
*
* @param T 集合元素类型
* @return 转换后的数组
*/
inline fun <reified T> Collection<T>.toArray(): Array<T> { inline fun <reified T> Collection<T>.toArray(): Array<T> {
return arrayOf(*this.toTypedArray()) return arrayOf(*this.toTypedArray())
} }
/**
* 将当前集合转换为 Map,其中键为集合元素本身,值由给定函数生成。
*
* @param T 集合元素类型
* @param V 映射值的类型
* @param v 用于生成映射值的函数
* @return 转换后的 Map
*/
@Suppress("UNCHECKED_CAST")
inline fun <reified T, V> Collection<T>.toMap(noinline v: (T) -> V): Map<T, V> { inline fun <reified T, V> Collection<T>.toMap(noinline v: (T) -> V): Map<T, V> {
return this.stream().collect( return this.stream().collect(
com.mingliqiye.utils.stream.toMapValueThis( SuperStream.toMap(
v v
) )
) ) as Map<T, V>
} }
/**
* 将当前集合转换为 Map,其中键和值分别由给定函数生成。
*
* @param T 集合元素类型
* @param V 映射值的类型
* @param K 映射键的类型
* @param k 用于生成映射键的函数
* @param v 用于生成映射值的函数
* @return 转换后的 Map
*/
inline fun <reified T, V, K> Collection<T>.toMap(noinline k: (T) -> K, noinline v: (T) -> V): Map<K, V> { inline fun <reified T, V, K> Collection<T>.toMap(noinline k: (T) -> K, noinline v: (T) -> V): Map<K, V> {
return this.stream().collect( return this.stream().collect(
Collectors.toMap( Collectors.toMap(
@@ -48,11 +74,24 @@ inline fun <reified T, V, K> Collection<T>.toMap(noinline k: (T) -> K, noinline
) )
} }
/**
* 将数组转换为 Set。
*
* @param T 数组元素类型
* @param array 输入数组
* @return 转换后的 Set
*/
fun <T> toSet(array: Array<T>): Set<T> { fun <T> toSet(array: Array<T>): Set<T> {
return array.toSet() return array.toSet()
} }
/**
* 获取集合中的第一个元素,如果集合为空则返回 null。
*
* @param T 集合元素类型
* @return 第一个元素或 null
*/
inline fun <reified T> Collection<T>.getFirst(): T? { inline fun <reified T> Collection<T>.getFirst(): T? {
if (this.isEmpty()) { if (this.isEmpty()) {
return null return null
@@ -63,6 +102,12 @@ inline fun <reified T> Collection<T>.getFirst(): T? {
return this.iterator().next() return this.iterator().next()
} }
/**
* 获取数组中的第一个元素,如果数组为空则返回 null。
*
* @param T 数组元素类型
* @return 第一个元素或 null
*/
inline fun <reified T> Array<T>.getFirst(): T? { inline fun <reified T> Array<T>.getFirst(): T? {
if (this.isEmpty()) { if (this.isEmpty()) {
return null return null
@@ -70,6 +115,12 @@ inline fun <reified T> Array<T>.getFirst(): T? {
return this.first() return this.first()
} }
/**
* 获取集合中的最后一个元素,如果集合为空则返回 null。
*
* @param T 集合元素类型
* @return 最后一个元素或 null
*/
inline fun <reified T> Collection<T>.getLast(): T? { inline fun <reified T> Collection<T>.getLast(): T? {
if (this.isEmpty()) { if (this.isEmpty()) {
return null return null
@@ -84,6 +135,12 @@ inline fun <reified T> Collection<T>.getLast(): T? {
return lastElement return lastElement
} }
/**
* 获取数组中的最后一个元素,如果数组为空则返回 null。
*
* @param T 数组元素类型
* @return 最后一个元素或 null
*/
inline fun <reified T> Array<T>.getLast(): T? { inline fun <reified T> Array<T>.getLast(): T? {
if (this.isEmpty()) { if (this.isEmpty()) {
return null return null
@@ -92,6 +149,14 @@ inline fun <reified T> Array<T>.getLast(): T? {
} }
/**
* 根据索引获取集合中的元素,若索引越界则返回默认值。
*
* @param T 集合元素类型
* @param index 索引位置
* @param defaultValue 默认返回值
* @return 指定索引处的元素或默认值
*/
inline fun <reified T> Collection<T>.getOrDefault( inline fun <reified T> Collection<T>.getOrDefault(
index: Int, defaultValue: T index: Int, defaultValue: T
): T { ): T {
@@ -111,54 +176,135 @@ inline fun <reified T> Collection<T>.getOrDefault(
return defaultValue return defaultValue
} }
/**
* 创建一个新的 ArrayList 实例。
*
* @param T 元素类型
* @return 新创建的 ArrayList
*/
fun <T> newArrayList(): ArrayList<T> { fun <T> newArrayList(): ArrayList<T> {
return ArrayList() return ArrayList()
} }
/**
* 创建一个指定初始容量的新 ArrayList 实例。
*
* @param T 元素类型
* @param size 初始容量大小
* @return 新创建的 ArrayList
*/
fun <T> newArrayList(size: Int): ArrayList<T> { fun <T> newArrayList(size: Int): ArrayList<T> {
return ArrayList() return ArrayList()
} }
/**
* 使用可变参数创建一个新的 ArrayList 实例。
*
* @param T 元素类型
* @param elements 可变参数列表
* @return 新创建的 ArrayList
*/
fun <T> newArrayList(vararg elements: T): ArrayList<T> { fun <T> newArrayList(vararg elements: T): ArrayList<T> {
return newArrayList(elements.asList()) return newArrayList(elements.asList())
} }
/**
* 将当前集合转换为新的 ArrayList 实例。
*
* @param T 元素类型
* @return 新创建的 ArrayList
*/
fun <T> Collection<T>.newArrayLists(): ArrayList<T> { fun <T> Collection<T>.newArrayLists(): ArrayList<T> {
return newArrayList(this) return newArrayList(this)
} }
/**
* 将数组转换为新的 ArrayList 实例。
*
* @param T 元素类型
* @param elements 输入数组
* @return 新创建的 ArrayList
*/
fun <T> newArrayLists(elements: Array<T>): ArrayList<T> { fun <T> newArrayLists(elements: Array<T>): ArrayList<T> {
return newArrayList(elements.asList()) return newArrayList(elements.asList())
} }
/**
* 将集合转换为新的 ArrayList 实例。
*
* @param T 元素类型
* @param elements 输入集合
* @return 新创建的 ArrayList
*/
fun <T> newArrayList(elements: Collection<T>): ArrayList<T> { fun <T> newArrayList(elements: Collection<T>): ArrayList<T> {
return ArrayList(elements.toList()) return ArrayList(elements.toList())
} }
/**
* 将 Iterable 转换为新的 ArrayList 实例。
*
* @param T 元素类型
* @param elements 输入 Iterable
* @return 新创建的 ArrayList
*/
fun <T> newArrayList(elements: Iterable<T>): ArrayList<T> { fun <T> newArrayList(elements: Iterable<T>): ArrayList<T> {
return newArrayList(elements.toList()) return newArrayList(elements.toList())
} }
/**
* 将 Sequence 转换为新的 ArrayList 实例。
*
* @param T 元素类型
* @param elements 输入 Sequence
* @return 新创建的 ArrayList
*/
fun <T> newArrayList(elements: Sequence<T>): ArrayList<T> { fun <T> newArrayList(elements: Sequence<T>): ArrayList<T> {
return newArrayList(elements.toList()) return newArrayList(elements.toList())
} }
/**
* 创建一个新的 LinkedList 实例。
*
* @param T 元素类型
* @return 新创建的 LinkedList
*/
fun <T> newLinkedList(): LinkedList<T> { fun <T> newLinkedList(): LinkedList<T> {
return LinkedList() return LinkedList()
} }
/**
* 使用可变参数创建一个新的 LinkedList 实例。
*
* @param T 元素类型
* @param elements 可变参数列表
* @return 新创建的 LinkedList
*/
fun <T> newLinkedList(vararg elements: T): LinkedList<T> { fun <T> newLinkedList(vararg elements: T): LinkedList<T> {
val list = newLinkedList<T>() val list = newLinkedList<T>()
list.addAll(elements.asList()) list.addAll(elements.asList())
return list return list
} }
/**
* 将集合转换为新的 LinkedList 实例。
*
* @param T 元素类型
* @param elements 输入集合
* @return 新创建的 LinkedList
*/
fun <T> newLinkedList(elements: Collection<T>): LinkedList<T> { fun <T> newLinkedList(elements: Collection<T>): LinkedList<T> {
val list = newLinkedList<T>() val list = newLinkedList<T>()
list.addAll(elements) list.addAll(elements)
return list return list
} }
/**
* 将 Iterable 转换为新的 LinkedList 实例。
*
* @param T 元素类型
* @param elements 输入 Iterable
* @return 新创建的 LinkedList
*/
fun <T> newLinkedList(elements: Iterable<T>): LinkedList<T> { fun <T> newLinkedList(elements: Iterable<T>): LinkedList<T> {
val list = newLinkedList<T>() val list = newLinkedList<T>()
for (element in elements) { for (element in elements) {
@@ -167,26 +313,60 @@ fun <T> newLinkedList(elements: Iterable<T>): LinkedList<T> {
return list return list
} }
/**
* 将 Sequence 转换为新的 LinkedList 实例。
*
* @param T 元素类型
* @param elements 输入 Sequence
* @return 新创建的 LinkedList
*/
fun <T> newLinkedList(elements: Sequence<T>): LinkedList<T> { fun <T> newLinkedList(elements: Sequence<T>): LinkedList<T> {
return newLinkedList(elements.toList()) return newLinkedList(elements.toList())
} }
/**
* 创建一个新的 Vector 实例。
*
* @param T 元素类型
* @return 新创建的 Vector
*/
fun <T> newVector(): Vector<T> { fun <T> newVector(): Vector<T> {
return Vector() return Vector()
} }
/**
* 使用可变参数创建一个新的 Vector 实例。
*
* @param T 元素类型
* @param elements 可变参数列表
* @return 新创建的 Vector
*/
fun <T> newVector(vararg elements: T): Vector<T> { fun <T> newVector(vararg elements: T): Vector<T> {
val vector = newVector<T>() val vector = newVector<T>()
vector.addAll(elements.asList()) vector.addAll(elements.asList())
return vector return vector
} }
/**
* 将集合转换为新的 Vector 实例。
*
* @param T 元素类型
* @param elements 输入集合
* @return 新创建的 Vector
*/
fun <T> newVector(elements: Collection<T>): Vector<T> { fun <T> newVector(elements: Collection<T>): Vector<T> {
val vector = newVector<T>() val vector = newVector<T>()
vector.addAll(elements) vector.addAll(elements)
return vector return vector
} }
/**
* 将 Iterable 转换为新的 Vector 实例。
*
* @param T 元素类型
* @param elements 输入 Iterable
* @return 新创建的 Vector
*/
fun <T> newVector(elements: Iterable<T>): Vector<T> { fun <T> newVector(elements: Iterable<T>): Vector<T> {
val vector = newVector<T>() val vector = newVector<T>()
for (element in elements) { for (element in elements) {
@@ -195,31 +375,72 @@ fun <T> newVector(elements: Iterable<T>): Vector<T> {
return vector return vector
} }
/**
* 将 Sequence 转换为新的 Vector 实例。
*
* @param T 元素类型
* @param elements 输入 Sequence
* @return 新创建的 Vector
*/
fun <T> newVector(elements: Sequence<T>): Vector<T> { fun <T> newVector(elements: Sequence<T>): Vector<T> {
return newVector(elements.toList()) return newVector(elements.toList())
} }
/**
* 创建一个新的 HashSet 实例。
*
* @param T 元素类型
* @return 新创建的 HashSet
*/
fun <T> newHashSet(): HashSet<T> { fun <T> newHashSet(): HashSet<T> {
return HashSet() return HashSet()
} }
/**
* 创建一个指定初始容量的新 HashSet 实例。
*
* @param T 元素类型
* @param size 初始容量大小
* @return 新创建的 HashSet
*/
fun <T> newHashSet(size: Int): HashSet<T> { fun <T> newHashSet(size: Int): HashSet<T> {
return HashSet(size) return HashSet(size)
} }
/**
* 使用可变参数创建一个新的 HashSet 实例。
*
* @param T 元素类型
* @param elements 可变参数列表
* @return 新创建的 HashSet
*/
fun <T> newHashSet(vararg elements: T): HashSet<T> { fun <T> newHashSet(vararg elements: T): HashSet<T> {
val set = newHashSet<T>() val set = newHashSet<T>()
set.addAll(elements.asList()) set.addAll(elements.asList())
return set return set
} }
/**
* 将集合转换为新的 HashSet 实例。
*
* @param T 元素类型
* @param elements 输入集合
* @return 新创建的 HashSet
*/
fun <T> newHashSet(elements: Collection<T>): HashSet<T> { fun <T> newHashSet(elements: Collection<T>): HashSet<T> {
val set = newHashSet<T>() val set = newHashSet<T>()
set.addAll(elements) set.addAll(elements)
return set return set
} }
/**
* 将 Iterable 转换为新的 HashSet 实例。
*
* @param T 元素类型
* @param elements 输入 Iterable
* @return 新创建的 HashSet
*/
fun <T> newHashSet(elements: Iterable<T>): HashSet<T> { fun <T> newHashSet(elements: Iterable<T>): HashSet<T> {
val set = newHashSet<T>() val set = newHashSet<T>()
for (element in elements) { for (element in elements) {
@@ -228,30 +449,71 @@ fun <T> newHashSet(elements: Iterable<T>): HashSet<T> {
return set return set
} }
/**
* 将 Sequence 转换为新的 HashSet 实例。
*
* @param T 元素类型
* @param elements 输入 Sequence
* @return 新创建的 HashSet
*/
fun <T> newHashSet(elements: Sequence<T>): HashSet<T> { fun <T> newHashSet(elements: Sequence<T>): HashSet<T> {
return newHashSet(elements.toSet()) return newHashSet(elements.toSet())
} }
/**
* 创建一个新的 LinkedHashSet 实例。
*
* @param T 元素类型
* @return 新创建的 LinkedHashSet
*/
fun <T> newLinkedHashSet(): LinkedHashSet<T> { fun <T> newLinkedHashSet(): LinkedHashSet<T> {
return LinkedHashSet() return LinkedHashSet()
} }
/**
* 创建一个指定初始容量的新 LinkedHashSet 实例。
*
* @param T 元素类型
* @param size 初始容量大小
* @return 新创建的 LinkedHashSet
*/
fun <T> newLinkedHashSet(size: Int): LinkedHashSet<T> { fun <T> newLinkedHashSet(size: Int): LinkedHashSet<T> {
return LinkedHashSet(size) return LinkedHashSet(size)
} }
/**
* 使用可变参数创建一个新的 LinkedHashSet 实例。
*
* @param T 元素类型
* @param elements 可变参数列表
* @return 新创建的 LinkedHashSet
*/
fun <T> newLinkedHashSet(vararg elements: T): LinkedHashSet<T> { fun <T> newLinkedHashSet(vararg elements: T): LinkedHashSet<T> {
val set = newLinkedHashSet<T>() val set = newLinkedHashSet<T>()
set.addAll(elements.asList()) set.addAll(elements.asList())
return set return set
} }
/**
* 将集合转换为新的 LinkedHashSet 实例。
*
* @param T 元素类型
* @param elements 输入集合
* @return 新创建的 LinkedHashSet
*/
fun <T> newLinkedHashSet(elements: Collection<T>): LinkedHashSet<T> { fun <T> newLinkedHashSet(elements: Collection<T>): LinkedHashSet<T> {
val set = newLinkedHashSet<T>() val set = newLinkedHashSet<T>()
set.addAll(elements) set.addAll(elements)
return set return set
} }
/**
* 将 Iterable 转换为新的 LinkedHashSet 实例。
*
* @param T 元素类型
* @param elements 输入 Iterable
* @return 新创建的 LinkedHashSet
*/
fun <T> newLinkedHashSet(elements: Iterable<T>): LinkedHashSet<T> { fun <T> newLinkedHashSet(elements: Iterable<T>): LinkedHashSet<T> {
val set = newLinkedHashSet<T>() val set = newLinkedHashSet<T>()
for (element in elements) { for (element in elements) {
@@ -260,26 +522,60 @@ fun <T> newLinkedHashSet(elements: Iterable<T>): LinkedHashSet<T> {
return set return set
} }
/**
* 将 Sequence 转换为新的 LinkedHashSet 实例。
*
* @param T 元素类型
* @param elements 输入 Sequence
* @return 新创建的 LinkedHashSet
*/
fun <T> newLinkedHashSet(elements: Sequence<T>): LinkedHashSet<T> { fun <T> newLinkedHashSet(elements: Sequence<T>): LinkedHashSet<T> {
return newLinkedHashSet(elements.toSet()) return newLinkedHashSet(elements.toSet())
} }
/**
* 创建一个新的 TreeSet 实例。
*
* @param T 元素类型,必须实现 Comparable 接口
* @return 新创建的 TreeSet
*/
fun <T : Comparable<T>> newTreeSet(): TreeSet<T> { fun <T : Comparable<T>> newTreeSet(): TreeSet<T> {
return TreeSet() return TreeSet()
} }
/**
* 使用可变参数创建一个新的 TreeSet 实例。
*
* @param T 元素类型,必须实现 Comparable 接口
* @param elements 可变参数列表
* @return 新创建的 TreeSet
*/
fun <T : Comparable<T>> newTreeSet(vararg elements: T): TreeSet<T> { fun <T : Comparable<T>> newTreeSet(vararg elements: T): TreeSet<T> {
val set = newTreeSet<T>() val set = newTreeSet<T>()
set.addAll(elements.asList()) set.addAll(elements.asList())
return set return set
} }
/**
* 将集合转换为新的 TreeSet 实例。
*
* @param T 元素类型,必须实现 Comparable 接口
* @param elements 输入集合
* @return 新创建的 TreeSet
*/
fun <T : Comparable<T>> newTreeSet(elements: Collection<T>): TreeSet<T> { fun <T : Comparable<T>> newTreeSet(elements: Collection<T>): TreeSet<T> {
val set = newTreeSet<T>() val set = newTreeSet<T>()
set.addAll(elements) set.addAll(elements)
return set return set
} }
/**
* 将 Iterable 转换为新的 TreeSet 实例。
*
* @param T 元素类型,必须实现 Comparable 接口
* @param elements 输入 Iterable
* @return 新创建的 TreeSet
*/
fun <T : Comparable<T>> newTreeSet(elements: Iterable<T>): TreeSet<T> { fun <T : Comparable<T>> newTreeSet(elements: Iterable<T>): TreeSet<T> {
val set = newTreeSet<T>() val set = newTreeSet<T>()
for (element in elements) { for (element in elements) {
@@ -288,65 +584,160 @@ fun <T : Comparable<T>> newTreeSet(elements: Iterable<T>): TreeSet<T> {
return set return set
} }
/**
* 将 Sequence 转换为新的 TreeSet 实例。
*
* @param T 元素类型,必须实现 Comparable 接口
* @param elements 输入 Sequence
* @return 新创建的 TreeSet
*/
fun <T : Comparable<T>> newTreeSet(elements: Sequence<T>): TreeSet<T> { fun <T : Comparable<T>> newTreeSet(elements: Sequence<T>): TreeSet<T> {
return newTreeSet(elements.toSet()) return newTreeSet(elements.toSet())
} }
/**
* 将字节数组转换为 ArrayList。
*
* @param elements 输入字节数组
* @return 转换后的 ArrayList
*/
fun newArrayLists(elements: ByteArray): ArrayList<Byte> { fun newArrayLists(elements: ByteArray): ArrayList<Byte> {
return ArrayList(elements.toList()) return ArrayList(elements.toList())
} }
/**
* 将短整型数组转换为 ArrayList。
*
* @param elements 输入短整型数组
* @return 转换后的 ArrayList
*/
fun newArrayLists(elements: ShortArray): ArrayList<Short> { fun newArrayLists(elements: ShortArray): ArrayList<Short> {
return ArrayList(elements.toList()) return ArrayList(elements.toList())
} }
/**
* 将整型数组转换为 ArrayList。
*
* @param elements 输入整型数组
* @return 转换后的 ArrayList
*/
fun newArrayLists(elements: IntArray): ArrayList<Int> { fun newArrayLists(elements: IntArray): ArrayList<Int> {
return ArrayList(elements.toList()) return ArrayList(elements.toList())
} }
/**
* 将长整型数组转换为 ArrayList。
*
* @param elements 输入长整型数组
* @return 转换后的 ArrayList
*/
fun newArrayLists(elements: LongArray): ArrayList<Long> { fun newArrayLists(elements: LongArray): ArrayList<Long> {
return ArrayList(elements.toList()) return ArrayList(elements.toList())
} }
/**
* 将浮点数组转换为 ArrayList。
*
* @param elements 输入浮点数组
* @return 转换后的 ArrayList
*/
fun newArrayLists(elements: FloatArray): ArrayList<Float> { fun newArrayLists(elements: FloatArray): ArrayList<Float> {
return ArrayList(elements.toList()) return ArrayList(elements.toList())
} }
/**
* 将双精度浮点数组转换为 ArrayList。
*
* @param elements 输入双精度浮点数组
* @return 转换后的 ArrayList
*/
fun newArrayLists(elements: DoubleArray): ArrayList<Double> { fun newArrayLists(elements: DoubleArray): ArrayList<Double> {
return ArrayList(elements.toList()) return ArrayList(elements.toList())
} }
/**
* 将布尔数组转换为 ArrayList。
*
* @param elements 输入布尔数组
* @return 转换后的 ArrayList
*/
fun newArrayLists(elements: BooleanArray): ArrayList<Boolean> { fun newArrayLists(elements: BooleanArray): ArrayList<Boolean> {
return ArrayList(elements.toList()) return ArrayList(elements.toList())
} }
/**
* 将字符数组转换为 ArrayList。
*
* @param elements 输入字符数组
* @return 转换后的 ArrayList
*/
fun newArrayLists(elements: CharArray): ArrayList<Char> { fun newArrayLists(elements: CharArray): ArrayList<Char> {
return ArrayList(elements.toList()) return ArrayList(elements.toList())
} }
/**
* 创建一个新的 CopyOnWriteArrayList 实例。
*
* @param T 元素类型
* @return 新创建的 CopyOnWriteArrayList
*/
fun <T> newCopyOnWriteArrayList(): java.util.concurrent.CopyOnWriteArrayList<T> { fun <T> newCopyOnWriteArrayList(): java.util.concurrent.CopyOnWriteArrayList<T> {
return java.util.concurrent.CopyOnWriteArrayList() return java.util.concurrent.CopyOnWriteArrayList()
} }
/**
* 使用可变参数创建一个新的 CopyOnWriteArrayList 实例。
*
* @param T 元素类型
* @param elements 可变参数列表
* @return 新创建的 CopyOnWriteArrayList
*/
fun <T> newCopyOnWriteArrayList(vararg elements: T): java.util.concurrent.CopyOnWriteArrayList<T> { fun <T> newCopyOnWriteArrayList(vararg elements: T): java.util.concurrent.CopyOnWriteArrayList<T> {
return java.util.concurrent.CopyOnWriteArrayList(elements.asList()) return java.util.concurrent.CopyOnWriteArrayList(elements.asList())
} }
/**
* 将集合转换为新的 CopyOnWriteArrayList 实例。
*
* @param T 元素类型
* @param elements 输入集合
* @return 新创建的 CopyOnWriteArrayList
*/
fun <T> newCopyOnWriteArrayList(elements: Collection<T>): java.util.concurrent.CopyOnWriteArrayList<T> { fun <T> newCopyOnWriteArrayList(elements: Collection<T>): java.util.concurrent.CopyOnWriteArrayList<T> {
return java.util.concurrent.CopyOnWriteArrayList(elements) return java.util.concurrent.CopyOnWriteArrayList(elements)
} }
/**
* 创建一个新的 Stack 实例。
*
* @param T 元素类型
* @return 新创建的 Stack
*/
fun <T> newStack(): Stack<T> { fun <T> newStack(): Stack<T> {
return Stack() return Stack()
} }
/**
* 使用可变参数创建一个新的 Stack 实例。
*
* @param T 元素类型
* @param elements 可变参数列表
* @return 新创建的 Stack
*/
fun <T> newStack(vararg elements: T): Stack<T> { fun <T> newStack(vararg elements: T): Stack<T> {
val stack = newStack<T>() val stack = newStack<T>()
stack.addAll(elements.asList()) stack.addAll(elements.asList())
return stack return stack
} }
/**
* 将集合转换为新的 Stack 实例。
*
* @param T 元素类型
* @param elements 输入集合
* @return 新创建的 Stack
*/
fun <T> newStack(elements: Collection<T>): Stack<T> { fun <T> newStack(elements: Collection<T>): Stack<T> {
val stack = newStack<T>() val stack = newStack<T>()
stack.addAll(elements) stack.addAll(elements)
@@ -354,22 +745,53 @@ fun <T> newStack(elements: Collection<T>): Stack<T> {
} }
/**
* 创建一个新的 TreeSet 实例,并指定比较器。
*
* @param T 元素类型
* @param comparator 用于排序的比较器
* @return 新创建的 TreeSet
*/
fun <T> newTreeSet(comparator: Comparator<T>): TreeSet<T> { fun <T> newTreeSet(comparator: Comparator<T>): TreeSet<T> {
return TreeSet(comparator) return TreeSet(comparator)
} }
/**
* 使用可变参数创建一个新的 TreeSet 实例,并指定比较器。
*
* @param T 元素类型
* @param comparator 用于排序的比较器
* @param elements 可变参数列表
* @return 新创建的 TreeSet
*/
fun <T> newTreeSet(comparator: Comparator<T>, vararg elements: T): TreeSet<T> { fun <T> newTreeSet(comparator: Comparator<T>, vararg elements: T): TreeSet<T> {
val set = newTreeSet(comparator) val set = newTreeSet(comparator)
set.addAll(elements.asList()) set.addAll(elements.asList())
return set return set
} }
/**
* 将集合转换为新的 TreeSet 实例,并指定比较器。
*
* @param T 元素类型
* @param comparator 用于排序的比较器
* @param elements 输入集合
* @return 新创建的 TreeSet
*/
fun <T> newTreeSet(comparator: Comparator<T>, elements: Collection<T>): TreeSet<T> { fun <T> newTreeSet(comparator: Comparator<T>, elements: Collection<T>): TreeSet<T> {
val set = newTreeSet(comparator) val set = newTreeSet(comparator)
set.addAll(elements) set.addAll(elements)
return set return set
} }
/**
* 将 Iterable 转换为新的 TreeSet 实例,并指定比较器。
*
* @param T 元素类型
* @param comparator 用于排序的比较器
* @param elements 输入 Iterable
* @return 新创建的 TreeSet
*/
fun <T> newTreeSet(comparator: Comparator<T>, elements: Iterable<T>): TreeSet<T> { fun <T> newTreeSet(comparator: Comparator<T>, elements: Iterable<T>): TreeSet<T> {
val set = newTreeSet(comparator) val set = newTreeSet(comparator)
for (element in elements) { for (element in elements) {
@@ -378,32 +800,71 @@ fun <T> newTreeSet(comparator: Comparator<T>, elements: Iterable<T>): TreeSet<T>
return set return set
} }
/**
* 将 Sequence 转换为新的 TreeSet 实例,并指定比较器。
*
* @param T 元素类型
* @param comparator 用于排序的比较器
* @param elements 输入 Sequence
* @return 新创建的 TreeSet
*/
fun <T> newTreeSet(comparator: Comparator<T>, elements: Sequence<T>): TreeSet<T> { fun <T> newTreeSet(comparator: Comparator<T>, elements: Sequence<T>): TreeSet<T> {
return newTreeSet(comparator, elements.toSet()) return newTreeSet(comparator, elements.toSet())
} }
/**
* 将当前集合转换为新的 CopyOnWriteArrayList 实例。
*
* @param T 元素类型
* @return 新创建的 CopyOnWriteArrayList
*/
fun <T> Collection<T>.newCopyOnWriteArrayLists(): java.util.concurrent.CopyOnWriteArrayList<T> { fun <T> Collection<T>.newCopyOnWriteArrayLists(): java.util.concurrent.CopyOnWriteArrayList<T> {
return java.util.concurrent.CopyOnWriteArrayList(this) return java.util.concurrent.CopyOnWriteArrayList(this)
} }
/**
* 将当前集合转换为新的 Stack 实例。
*
* @param T 元素类型
* @return 新创建的 Stack
*/
fun <T> Collection<T>.newStacks(): Stack<T> { fun <T> Collection<T>.newStacks(): Stack<T> {
val stack = Stack<T>() val stack = Stack<T>()
stack.addAll(this) stack.addAll(this)
return stack return stack
} }
/**
* 将当前集合转换为新的 TreeSet 实例。
*
* @param T 元素类型,必须实现 Comparable 接口
* @return 新创建的 TreeSet
*/
fun <T> Collection<T>.newTreeSets(): TreeSet<T> where T : Comparable<T> { fun <T> Collection<T>.newTreeSets(): TreeSet<T> where T : Comparable<T> {
val set = TreeSet<T>() val set = TreeSet<T>()
set.addAll(this) set.addAll(this)
return set return set
} }
/**
* 将当前集合转换为新的 TreeSet 实例,并指定比较器。
*
* @param T 元素类型
* @param comparator 用于排序的比较器
* @return 新创建的 TreeSet
*/
fun <T> Collection<T>.newTreeSets(comparator: Comparator<T>): TreeSet<T> { fun <T> Collection<T>.newTreeSets(comparator: Comparator<T>): TreeSet<T> {
val set = TreeSet(comparator) val set = TreeSet(comparator)
set.addAll(this) set.addAll(this)
return set return set
} }
/**
* 将 Byte 类型的 List 转换为字节数组。
*
* @param list 输入的 Byte 列表
* @return 转换后的字节数组
*/
fun toArray(list: List<Byte>): ByteArray { fun toArray(list: List<Byte>): ByteArray {
val arr = ByteArray(list.size) val arr = ByteArray(list.size)
for (i in list.indices) { for (i in list.indices) {
@@ -413,6 +874,12 @@ fun toArray(list: List<Byte>): ByteArray {
} }
/**
* 将 Short 类型的 List 转换为短整型数组。
*
* @param list 输入的 Short 列表
* @return 转换后的短整型数组
*/
fun toArray(list: List<Short>): ShortArray { fun toArray(list: List<Short>): ShortArray {
val arr = ShortArray(list.size) val arr = ShortArray(list.size)
for (i in list.indices) { for (i in list.indices) {
@@ -421,6 +888,12 @@ fun toArray(list: List<Short>): ShortArray {
return arr return arr
} }
/**
* 将 Int 类型的 List 转换为整型数组。
*
* @param list 输入的 Int 列表
* @return 转换后的整型数组
*/
fun toArray(list: List<Int>): IntArray { fun toArray(list: List<Int>): IntArray {
val arr = IntArray(list.size) val arr = IntArray(list.size)
for (i in list.indices) { for (i in list.indices) {
@@ -429,6 +902,12 @@ fun toArray(list: List<Int>): IntArray {
return arr return arr
} }
/**
* 将 Long 类型的 List 转换为长整型数组。
*
* @param list 输入的 Long 列表
* @return 转换后的长整型数组
*/
fun toArray(list: List<Long>): LongArray { fun toArray(list: List<Long>): LongArray {
val arr = LongArray(list.size) val arr = LongArray(list.size)
for (i in list.indices) { for (i in list.indices) {
@@ -437,6 +916,12 @@ fun toArray(list: List<Long>): LongArray {
return arr return arr
} }
/**
* 将 Float 类型的 List 转换为浮点数组。
*
* @param list 输入的 Float 列表
* @return 转换后的浮点数组
*/
fun toArray(list: List<Float>): FloatArray { fun toArray(list: List<Float>): FloatArray {
val arr = FloatArray(list.size) val arr = FloatArray(list.size)
for (i in list.indices) { for (i in list.indices) {
@@ -445,6 +930,12 @@ fun toArray(list: List<Float>): FloatArray {
return arr return arr
} }
/**
* 将 Double 类型的 List 转换为双精度浮点数组。
*
* @param list 输入的 Double 列表
* @return 转换后的双精度浮点数组
*/
fun toArray(list: List<Double>): DoubleArray { fun toArray(list: List<Double>): DoubleArray {
val arr = DoubleArray(list.size) val arr = DoubleArray(list.size)
for (i in list.indices) { for (i in list.indices) {
@@ -453,6 +944,12 @@ fun toArray(list: List<Double>): DoubleArray {
return arr return arr
} }
/**
* 将 Boolean 类型的 List 转换为布尔数组。
*
* @param list 输入的 Boolean 列表
* @return 转换后的布尔数组
*/
fun toArray(list: List<Boolean>): BooleanArray { fun toArray(list: List<Boolean>): BooleanArray {
val arr = BooleanArray(list.size) val arr = BooleanArray(list.size)
for (i in list.indices) { for (i in list.indices) {
@@ -461,6 +958,12 @@ fun toArray(list: List<Boolean>): BooleanArray {
return arr return arr
} }
/**
* 将 Char 类型的 List 转换为字符数组。
*
* @param list 输入的 Char 列表
* @return 转换后的字符数组
*/
fun toArray(list: List<Char>): CharArray { fun toArray(list: List<Char>): CharArray {
val arr = CharArray(list.size) val arr = CharArray(list.size)
for (i in list.indices) { for (i in list.indices) {
@@ -468,3 +971,23 @@ fun toArray(list: List<Char>): CharArray {
} }
return arr return arr
} }
/**
* 将任意类型的 List 转换为数组。
*
* @param T 元素类型
* @param list 输入的 List
* @return 转换后的数组
*/
inline fun <reified T> toArray(list: List<T>): Array<T> {
if (list.isEmpty())
return arrayOf<T>()
return SuperStream.of<T>(list)
.toArray(T::class.java)
}
fun <T> toArray(list: List<T>, clazz: Class<T>): Array<T> {
return SuperStream.of<T>(list)
.toArray(clazz)
}
@@ -16,7 +16,7 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile IsChanged.kt * CurrentFile IsChanged.kt
* LastUpdate 2025-09-15 09:30:37 * LastUpdate 2025-09-19 20:17:07
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@@ -0,0 +1,273 @@
/*
* Copyright 2025 mingliqiye
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* ProjectName mingli-utils
* ModuleName mingli-utils.main
* CurrentFile ConfigurationProp.kt
* LastUpdate 2025-09-19 11:30:04
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.configuration
/**
* 配置属性注解,用于标记配置类中的字段,支持通过命令行参数进行初始化。
*
* @param name 配置项的名称,默认为空字符串,表示使用字段名作为配置项名称。
* @param description 配置项的描述信息,默认为空字符串。
* @param showHelper 是否显示帮助信息,默认为 true。
*/
@Retention(AnnotationRetention.RUNTIME)
@Target(
AnnotationTarget.TYPE_PARAMETER,
AnnotationTarget.VALUE_PARAMETER,
AnnotationTarget.FIELD, // 添加字段支持
AnnotationTarget.PROPERTY // 添加属性支持
)
annotation class ConfigurationProp(val name: String = "", val description: String = "", val showHelper: Boolean = true)
/**
* 根据字段名生成对应的 setter 方法名。
*
* @param fieldName 字段名。
* @return 对应的 setter 方法名。
*/
private fun getSetterName(fieldName: String): String {
return "set" + fieldName.take(1).uppercase() + fieldName.substring(1)
}
/**
* 根据字段名生成对应的 getter 方法名。
*
* @param fieldName 字段名。
* @return 对应的 getter 方法名。
*/
private fun getGetterName(fieldName: String): String {
return "get" + fieldName.take(1).uppercase() + fieldName.substring(1)
}
/**
* 配置初始化器,用于解析命令行参数并填充配置对象。
*/
open class ConfigurationProps {
companion object {
/**
* 初始化配置类实例,并根据命令行参数填充其字段。
*
* @param clazz 配置类的 Class 对象。
* @param args 命令行参数数组。
* @return 初始化后的配置类实例。
*/
@JvmStatic
fun <T : ConfigurationProps> init(clazz: Class<T>, args: Array<String>): T {
val mapsArgs = parseArguments(args)
val instance = clazz.getDeclaredConstructor().newInstance()
processFields(clazz, instance, mapsArgs)
return instance
}
/**
* 解析命令行参数,将其转换为键值对映射。
*
* 支持以下格式:
* - `--key=value` 或 `-k=value`:键值对形式。
* - `--key value` 或 `-k value`:键和值分开的形式。
* - `--flag` 或 `-f`:布尔标志形式,默认值为 "true"。
*
* @param args 命令行参数数组。
* @return 解析后的键值对映射。
*/
private fun parseArguments(args: Array<String>): Map<String, List<String>> {
val mapsArgs = mutableMapOf<String, MutableList<String>>()
var i = 0
while (i < args.size) {
val arg = args[i]
when {
arg.startsWith("--") -> {
// 处理 --key=value 格式
if (arg.contains("=")) {
val (key, value) = arg.substring(2).split("=", limit = 2)
mapsArgs.getOrPut(key) { mutableListOf() }.add(value)
}
// 处理 --key value 格式
else if (i + 1 < args.size && !args[i + 1].startsWith("-")) {
val key = arg.substring(2)
val value = args[i + 1]
mapsArgs.getOrPut(key) { mutableListOf() }.add(value)
i++ // 跳过下一个参数
}
// 处理 --flag 格式的布尔标志
else {
val key = arg.substring(2)
mapsArgs.getOrPut(key) { mutableListOf() }.add("true")
}
}
arg.startsWith("-") -> {
// 处理 -k=value 格式
if (arg.contains("=")) {
val (key, value) = arg.substring(1).split("=", limit = 2)
mapsArgs.getOrPut(key) { mutableListOf() }.add(value)
}
// 处理 -k value 格式
else if (i + 1 < args.size && !args[i + 1].startsWith("-")) {
val key = arg.substring(1)
val value = args[i + 1]
mapsArgs.getOrPut(key) { mutableListOf() }.add(value)
i++
}
// 处理 -f 格式的布尔标志
else {
val key = arg.substring(1)
mapsArgs.getOrPut(key) { mutableListOf() }.add("true")
}
}
}
i++
}
return mapsArgs
}
/**
* 处理配置类中的字段,根据解析出的参数设置字段值。
*
* @param clazz 配置类的 Class 对象。
* @param instance 配置类的实例。
* @param mapsArgs 解析后的命令行参数映射。
*/
private fun <T : ConfigurationProps> processFields(
clazz: Class<T>,
instance: T,
mapsArgs: Map<String, List<String>>
) {
val fields = clazz.declaredFields
for (field in fields) {
val configurationProp = field.getAnnotation(ConfigurationProp::class.java)
if (configurationProp != null) {
val fieldName = configurationProp.name.ifEmpty { field.name }
val values = mapsArgs[fieldName]
if (values != null) {
try {
val setter = clazz.getDeclaredMethod(
getSetterName(field.name),
field.type
)
val value = convertValue(field.type, values, configurationProp)
setter.invoke(instance, value)
} catch (e: Exception) {
println("Warning: Failed to set field ${field.name}: ${e.message}")
}
}
}
}
}
/**
* 将字符串值转换为目标类型。
*
* @param type 目标类型。
* @param values 字符串值列表。
* @param annotation 配置属性注解。
* @return 转换后的值。
*/
private fun convertValue(
type: Class<*>,
values: List<String>,
annotation: ConfigurationProp
): Any? {
val lastValue = values.lastOrNull() ?: return null
return when (type) {
String::class.java -> lastValue
Integer::class.java, Int::class.java -> try {
lastValue.toInt()
} catch (e: NumberFormatException) {
println("Warning: Invalid integer value '$lastValue'")
null
}
Long::class.java, java.lang.Long::class.java -> try {
lastValue.toLong()
} catch (e: NumberFormatException) {
println("Warning: Invalid long value '$lastValue'")
null
}
Double::class.java, java.lang.Double::class.java -> try {
lastValue.toDouble()
} catch (e: NumberFormatException) {
println("Warning: Invalid double value '$lastValue'")
null
}
Boolean::class.java, java.lang.Boolean::class.java -> when (lastValue.lowercase()) {
"true", "1", "yes", "on" -> true
"false", "0", "no", "off" -> false
else -> {
println("Warning: Invalid boolean value '$lastValue'")
null
}
}
List::class.java -> values
else -> {
println("Warning: Unsupported type ${type.simpleName}")
null
}
}
}
}
fun printHelp() {
val fields = this::class.java.declaredFields
val help = StringBuilder()
for (field in fields) {
val configurationProp = field.getAnnotation(ConfigurationProp::class.java)
if (configurationProp != null && configurationProp.showHelper) {
val fieldName = configurationProp.name.ifEmpty { field.name }
help.append("$fieldName -> 类型: ${field.type.simpleName}")
if (configurationProp.description.isNotEmpty()) {
help.append(" 描述: ${configurationProp.description}")
}
help.append("\n")
}
}
println(help)
}
val fields: Map<String, Any?>
get() {
val fields = this::class.java.declaredFields
val fieldValues = mutableMapOf<String, Any?>()
for (field in fields) {
field.isAccessible = true
val fieldName = field.name
val fieldValue = field.get(this)
fieldValues[fieldName] = fieldValue
}
return fieldValues
}
}
@@ -0,0 +1,146 @@
/*
* Copyright 2025 mingliqiye
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* ProjectName mingli-utils
* ModuleName mingli-utils.main
* CurrentFile DtoUtils.kt
* LastUpdate 2025-09-19 13:38:56
* UpdateUser MingLiPro
*/
@file:JvmName("DtoUtils")
package com.mingliqiye.utils.dto
import java.lang.reflect.Field
/**
* 克隆一个对象,通过反射创建新实例并复制所有非静态字段值。
*
* @param obj 要克隆的对象,必须是非空的任意类型实例。
* @return 返回一个新的对象实例,其字段值与原对象一致。
*/
fun <T : Any> clone(obj: T): T {
val clazz = obj.javaClass
val constructor = clazz.getDeclaredConstructor().apply {
isAccessible = true
}
val instance = constructor.newInstance()
// 遍历类及其父类的所有字段进行赋值
var currentClass: Class<*>? = clazz
while (currentClass != null) {
currentClass.declaredFields.forEach { field ->
if (!java.lang.reflect.Modifier.isStatic(field.modifiers)) {
field.isAccessible = true
field.set(instance, field.get(obj))
}
}
currentClass = currentClass.superclass
}
return instance
}
/**
* 定义 DTO 拷贝行为的枚举类型。
*/
enum class DotCopyType {
/**
* 表示使用点拷贝(.copy)方式处理字段。
*/
DOT_COPY,
/**
* 表示普通拷贝方式处理字段。
*/
COPY
}
/**
* 标注用于控制 DTO 字段拷贝行为的注解。
*
* @param type 指定拷贝类型,默认为 COPY。
*/
@Retention(AnnotationRetention.RUNTIME)
@Target(
AnnotationTarget.TYPE_PARAMETER,
AnnotationTarget.VALUE_PARAMETER,
AnnotationTarget.FIELD,
AnnotationTarget.PROPERTY
)
annotation class DtoCopy(val type: DotCopyType = DotCopyType.COPY)
/**
* 将源对象转换为目标 DTO 类型的实例,并根据字段名匹配拷贝字段值。
*
* @param obj 源对象,包含需要被拷贝的数据。
* @param dtoClass 目标 DTO 的 Class 对象。
* @return 返回一个新的目标 DTO 实例,字段值已从源对象拷贝。
*/
fun <R : Any> toDto(obj: Any, dtoClass: Class<R>): R {
val instance = dtoClass.getDeclaredConstructor().apply {
isAccessible = true
}.newInstance()
val sourceFields = getAllFields(obj.javaClass)
for (sourceField in sourceFields) {
sourceField.isAccessible = true
val fieldName = sourceField.name
val fieldValue = sourceField.get(obj)
try {
val targetField = dtoClass.getDeclaredField(fieldName).apply {
isAccessible = true
}
if (java.lang.reflect.Modifier.isStatic(targetField.modifiers)) {
continue
}
val ta = targetField.getAnnotation(DtoCopy::class.java)
if (ta != null) {
if (ta.type == DotCopyType.DOT_COPY) {
continue
}
}
targetField.set(instance, fieldValue)
} catch (e: NoSuchFieldException) {
continue
} catch (e: IllegalArgumentException) {
continue
}
}
return instance
}
/**
* 获取指定类及其所有父类中声明的所有字段。
*
* @param clazz 起始类对象。
* @return 包含所有字段的列表。
*/
private fun getAllFields(clazz: Class<*>): List<Field> {
val fields = mutableListOf<Field>()
var currentClass: Class<*>? = clazz
while (currentClass != null && currentClass != Any::class.java) {
fields.addAll(currentClass.declaredFields)
currentClass = currentClass.superclass
}
return fields
}
@@ -1,5 +1,5 @@
/* /*
* Copyright 2025 mingliqiye * Copyright 2026 mingliqiye
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@@ -16,7 +16,7 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile FileUtils.kt * CurrentFile FileUtils.kt
* LastUpdate 2025-09-15 09:12:47 * LastUpdate 2026-01-11 09:20:20
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@file:JvmName("FileUtils") @file:JvmName("FileUtils")
@@ -24,195 +24,188 @@
package com.mingliqiye.utils.file package com.mingliqiye.utils.file
import com.mingliqiye.utils.path.OsPath import com.mingliqiye.utils.path.OsPath
import java.io.File
import java.io.IOException import java.io.IOException
import java.nio.charset.Charset import java.nio.charset.Charset
import java.nio.charset.StandardCharsets import java.nio.charset.StandardCharsets
import java.nio.file.Files import java.nio.file.Files
import java.nio.file.Path
import java.nio.file.Paths import java.nio.file.Paths
import java.nio.file.StandardOpenOption import java.nio.file.StandardOpenOption
/** /**
* 默认字符集 * 默认字符集
*/ */
var DEFAULT_CHARSET: Charset = StandardCharsets.UTF_8 var DEFAULT_CHARSET: Charset = StandardCharsets.UTF_8
/** // 读取文件内容为字符串
* 读取文件内容为字符串 @Throws(IOException::class)
/**
* 读取文件内容为字符串,使用默认字符集
* *
* @param filePath 文件路径 * @return 文件内容的字符串表示
* @return 文件内容字符串
* @throws IOException 读取文件时发生错误 * @throws IOException 读取文件时发生错误
*/ */
fun String.readFileToString(): String {
@Throws(IOException::class) return this.readFileToString(DEFAULT_CHARSET)
fun readFileToString(filePath: String): String {
return readFileToString(filePath, DEFAULT_CHARSET)
} }
/** @Throws(IOException::class)
/**
* 读取文件内容为字符串 * 读取文件内容为字符串
* *
* @param filePath 文件路径 * @param charset 字符编码格式
* @param charset 字符集 * @return 文件内容的字符串表示
* @return 文件内容字符串
* @throws IOException 读取文件时发生错误 * @throws IOException 读取文件时发生错误
*/ */
fun String.readFileToString(charset: Charset): String {
@Throws(IOException::class) val path = OsPath.of(this)
fun readFileToString(filePath: String, charset: Charset): String {
val path = OsPath.of(filePath)
val bytes = Files.readAllBytes(path) val bytes = Files.readAllBytes(path)
return String(bytes, charset) return String(bytes, charset)
} }
/** // 将字符串写入文件
* 将字符串写入文件 @Throws(IOException::class)
/**
* 将字符串写入文件,使用默认字符集
* *
* @param filePath 文件路径 * @param content 要写入的字符串内容
* @param content 要写入的内容
* @throws IOException 写入文件时发生错误 * @throws IOException 写入文件时发生错误
*/ */
@Throws(IOException::class) fun String.writeStringToFile(content: String) {
fun writeStringToFile(filePath: String, content: String) { this.writeStringToFile(content, DEFAULT_CHARSET)
writeStringToFile(filePath, content, DEFAULT_CHARSET)
} }
/** @Throws(IOException::class)
/**
* 将字符串写入文件 * 将字符串写入文件
* *
* @param filePath 文件路径 * @param content 要写入的字符串内容
* @param content 要写入的内容 * @param charset 字符编码格式
* @param charset 字符集
* @throws IOException 写入文件时发生错误 * @throws IOException 写入文件时发生错误
*/ */
@Throws(IOException::class) fun String.writeStringToFile(content: String, charset: Charset) {
fun writeStringToFile(filePath: String, content: String, charset: Charset) { val path = Paths.get(this)
val path = Paths.get(filePath)
path.parent?.let { Files.createDirectories(it) } path.parent?.let { Files.createDirectories(it) }
Files.write(path, content.toByteArray(charset)) Files.write(path, content.toByteArray(charset))
} }
/** // 读取文件内容为字符串列表(按行分割)
* 读取文件内容为字符串列表(按行分割) @Throws(IOException::class)
/**
* 读取文件内容为字符串列表(按行分割),使用默认字符集
* *
* @param filePath 文件路径 * @return 按行分割的字符串列表
* @return 文件内容按行分割的字符串列表
* @throws IOException 读取文件时发生错误 * @throws IOException 读取文件时发生错误
*/ */
@Throws(IOException::class) fun String.readLines(): List<String> {
fun readLines(filePath: String): List<String> { return this.readLines(DEFAULT_CHARSET)
return readLines(filePath, DEFAULT_CHARSET)
} }
/** @Throws(IOException::class)
/**
* 读取文件内容为字符串列表(按行分割) * 读取文件内容为字符串列表(按行分割)
* *
* @param filePath 文件路径 * @param charset 字符编码格式
* @param charset 字符集 * @return 按行分割的字符串列表
* @return 文件内容按行分割的字符串列表
* @throws IOException 读取文件时发生错误 * @throws IOException 读取文件时发生错误
*/ */
@Throws(IOException::class) fun String.readLines(charset: Charset): List<String> {
fun readLines(filePath: String, charset: Charset): List<String> { val path = Paths.get(this)
val path = Paths.get(filePath)
return Files.readAllLines(path, charset) return Files.readAllLines(path, charset)
} }
/** // 将字符串列表写入文件(每行一个元素)
* 将字符串列表写入文件(每行一个元素) @Throws(IOException::class)
/**
* 将字符串列表写入文件(每行一个元素),使用默认字符集
* *
* @param filePath 文件路径 * @param lines 要写入的字符串列表
* @param lines 要写入的行内容列表
* @throws IOException 写入文件时发生错误 * @throws IOException 写入文件时发生错误
*/ */
@Throws(IOException::class) fun String.writeLines(lines: List<String>) {
fun writeLines(filePath: String, lines: List<String>) { this.writeLines(lines, DEFAULT_CHARSET)
writeLines(filePath, lines, DEFAULT_CHARSET)
} }
/** @Throws(IOException::class)
/**
* 将字符串列表写入文件(每行一个元素) * 将字符串列表写入文件(每行一个元素)
* *
* @param filePath 文件路径 * @param lines 要写入的字符串列表
* @param lines 要写入的行内容列表 * @param charset 字符编码格式
* @param charset 字符集
* @throws IOException 写入文件时发生错误 * @throws IOException 写入文件时发生错误
*/ */
@Throws(IOException::class) fun String.writeLines(lines: List<String>, charset: Charset) {
fun writeLines(filePath: String, lines: List<String>, charset: Charset) { val path = Paths.get(this)
val path = Paths.get(filePath)
Files.createDirectories(path.parent) Files.createDirectories(path.parent)
Files.write(path, lines, charset) Files.write(path, lines, charset)
} }
/** // 复制文件
* 复制文件 @Throws(IOException::class)
/**
* 复制文件到目标路径
* *
* @param sourcePath 源文件路径
* @param targetPath 目标文件路径 * @param targetPath 目标文件路径
* @throws IOException 复制文件时发生错误 * @throws IOException 复制文件时发生错误
*/ */
@Throws(IOException::class) fun String.copyFile(targetPath: String) {
fun copyFile(sourcePath: String, targetPath: String) { val source = Paths.get(this)
val source = Paths.get(sourcePath)
val target = Paths.get(targetPath) val target = Paths.get(targetPath)
Files.createDirectories(target.parent) Files.createDirectories(target.parent)
Files.copy(source, target) Files.copy(source, target)
} }
// 删除文件
/** /**
* 删除文件 * 删除文件
* *
* @param filePath 文件路径 * @return 删除操作是否成功
* @return 如果文件删除成功返回true,否则返回false
*/ */
fun deleteFile(filePath: String): Boolean { fun String.deleteFile(): Boolean {
return try { return try {
val path = Paths.get(filePath) val path = Paths.get(this)
Files.deleteIfExists(path) Files.deleteIfExists(path)
} catch (e: IOException) { } catch (e: IOException) {
false false
} }
} }
// 检查文件是否存在
/** /**
* 检查文件是否存在 * 检查文件是否存在
* *
* @param filePath 文件路径 * @return 文件是否存在
* @return 如果文件存在返回true,否则返回false
*/ */
fun exists(filePath: String): Boolean { fun String.exists(): Boolean {
val path = Paths.get(filePath) val path = Paths.get(this)
return Files.exists(path) return Files.exists(path)
} }
// 获取文件大小
/** /**
* 获取文件大小 * 获取文件大小
* *
* @param filePath 文件路径 * @return 文件大小(字节),如果获取失败则返回-1
* @return 文件大小(字节),如果文件不存在返回-1
*/ */
fun String.getFileSize(): Long {
fun getFileSize(filePath: String): Long {
return try { return try {
val path = Paths.get(filePath) val path = Paths.get(this)
Files.size(path) Files.size(path)
} catch (e: IOException) { } catch (e: IOException) {
-1 -1
} }
} }
// 创建目录
/** /**
* 创建目录 * 创建目录
* *
* @param dirPath 目录路径 * @return 创建操作是否成功
* @return 如果目录创建成功返回true,否则返回false
*/ */
fun String.createDirectory(): Boolean {
fun createDirectory(dirPath: String): Boolean {
return try { return try {
val path = Paths.get(dirPath) val path = Paths.get(this)
Files.createDirectories(path) Files.createDirectories(path)
true true
} catch (e: IOException) { } catch (e: IOException) {
@@ -220,97 +213,61 @@ fun createDirectory(dirPath: String): Boolean {
} }
} }
/** // 读取文件内容为字节数组
* 获取文件扩展名 @Throws(IOException::class)
* /**
* @param fileName 文件名
* @return 文件扩展名(不包含点号),如果无扩展名返回空字符串
*/
fun getFileExtension(fileName: String): String {
if (fileName.isEmpty()) {
return ""
}
val lastDotIndex = fileName!!.lastIndexOf('.')
return if (lastDotIndex == -1 || lastDotIndex == fileName.length - 1) {
""
} else fileName.substring(lastDotIndex + 1)
}
/**
* 获取不带扩展名的文件名
*
* @param fileName 文件名
* @return 不带扩展名的文件名
*/
fun getFileNameWithoutExtension(fileName: String): String {
if (fileName.isEmpty()) {
return ""
}
val lastDotIndex = fileName!!.lastIndexOf('.')
return if (lastDotIndex == -1) {
fileName
} else fileName.substring(0, lastDotIndex)
}
/**
* 读取文件内容为字节数组 * 读取文件内容为字节数组
* *
* @param filePath 文件路径 * @return 文件内容的字节数组表示
* @return 文件内容的字节数组
* @throws IOException 读取文件时发生错误 * @throws IOException 读取文件时发生错误
*/ */
@Throws(IOException::class) fun String.readByteArray(): ByteArray {
fun readFileToByteArray(filePath: String): ByteArray { val path = Paths.get(this)
val path = Paths.get(filePath)
return Files.readAllBytes(path) return Files.readAllBytes(path)
} }
/** // 将字节数组写入文件
@Throws(IOException::class)
/**
* 将字节数组写入文件 * 将字节数组写入文件
* *
* @param filePath 文件路径 * @param data 要写入的字节数组
* @param data 要写入的字节数据
* @throws IOException 写入文件时发生错误 * @throws IOException 写入文件时发生错误
*/ */
fun String.writeByteArray(data: ByteArray) {
@Throws(IOException::class) val path = Paths.get(this)
fun writeByteArrayToFile(filePath: String, data: ByteArray) {
val path = Paths.get(filePath)
Files.createDirectories(path.parent) Files.createDirectories(path.parent)
Files.write(path, data) Files.write(path, data)
} }
/** // 将字节数组追加到文件末尾
@Throws(IOException::class)
/**
* 将字节数组追加到文件末尾 * 将字节数组追加到文件末尾
* *
* @param filePath 文件路径 * @param data 要追加的字节数组
* @param data 要追加的字节数据 * @throws IOException 追加文件时发生错误
* @throws IOException 追加数据时发生错误
*/ */
fun String.appendByteArray(data: ByteArray) {
@Throws(IOException::class) val path = Paths.get(this)
fun appendByteArrayToFile(filePath: String, data: ByteArray) {
val path = Paths.get(filePath)
Files.createDirectories(path.parent) Files.createDirectories(path.parent)
Files.write( Files.write(
path, data, StandardOpenOption.CREATE, StandardOpenOption.APPEND path, data, StandardOpenOption.CREATE, StandardOpenOption.APPEND
) )
} }
/** // 分块读取大文件为字节数组列表
@Throws(IOException::class)
/**
* 分块读取大文件为字节数组列表 * 分块读取大文件为字节数组列表
* *
* @param filePath 文件路径 * @param chunkSize 每个块的大小
* @param chunkSize 每块大小(字节) * @return 字节数组列表
* @return 文件内容按指定大小分割的字节数组列表
* @throws IOException 读取文件时发生错误 * @throws IOException 读取文件时发生错误
*/ */
fun String.readByteArrayChunks(chunkSize: Int): List<ByteArray> {
@Throws(IOException::class)
fun readFileToByteArrayChunks(filePath: String, chunkSize: Int): List<ByteArray> {
val chunks = mutableListOf<ByteArray>() val chunks = mutableListOf<ByteArray>()
val path = Paths.get(filePath) val path = Paths.get(this)
Files.newInputStream(path).use { inputStream -> Files.newInputStream(path).use { inputStream ->
val buffer = ByteArray(chunkSize) val buffer = ByteArray(chunkSize)
@@ -325,17 +282,16 @@ fun readFileToByteArrayChunks(filePath: String, chunkSize: Int): List<ByteArray>
return chunks return chunks
} }
/** // 将字节数组列表写入文件
@Throws(IOException::class)
/**
* 将字节数组列表写入文件 * 将字节数组列表写入文件
* *
* @param filePath 文件路径
* @param chunks 字节数组列表 * @param chunks 字节数组列表
* @throws IOException 写入文件时发生错误 * @throws IOException 写入文件时发生错误
*/ */
fun String.writeByteArrayChunks(chunks: List<ByteArray>) {
@Throws(IOException::class) val path = Paths.get(this)
fun writeByteArrayChunksToFile(filePath: String, chunks: List<ByteArray>) {
val path = Paths.get(filePath)
Files.createDirectories(path.parent) Files.createDirectories(path.parent)
Files.newOutputStream(path).use { outputStream -> Files.newOutputStream(path).use { outputStream ->
@@ -344,3 +300,466 @@ fun writeByteArrayChunksToFile(filePath: String, chunks: List<ByteArray>) {
} }
} }
} }
// 读取文件内容为字符串
@Throws(IOException::class)
/**
* 读取文件内容为字符串,使用默认字符集
*
* @return 文件内容的字符串表示
* @throws IOException 读取文件时发生错误
*/
fun Path.readFileToString(): String {
return this.readFileToString(DEFAULT_CHARSET)
}
@Throws(IOException::class)
/**
* 读取文件内容为字符串
*
* @param charset 字符编码格式
* @return 文件内容的字符串表示
* @throws IOException 读取文件时发生错误
*/
fun Path.readFileToString(charset: Charset): String {
val bytes = Files.readAllBytes(this)
return String(bytes, charset)
}
// 将字符串写入文件
@Throws(IOException::class)
/**
* 将字符串写入文件,使用默认字符集
*
* @param content 要写入的字符串内容
* @throws IOException 写入文件时发生错误
*/
fun Path.writeStringToFile(content: String) {
this.writeStringToFile(content, DEFAULT_CHARSET)
}
@Throws(IOException::class)
/**
* 将字符串写入文件
*
* @param content 要写入的字符串内容
* @param charset 字符编码格式
* @throws IOException 写入文件时发生错误
*/
fun Path.writeStringToFile(content: String, charset: Charset) {
this.parent?.let { Files.createDirectories(it) }
Files.write(this, content.toByteArray(charset))
}
// 读取文件内容为字符串列表
@Throws(IOException::class)
/**
* 读取文件内容为字符串列表,使用默认字符集
*
* @return 按行分割的字符串列表
* @throws IOException 读取文件时发生错误
*/
fun Path.readLines(): List<String> {
return this.readLines(DEFAULT_CHARSET)
}
@Throws(IOException::class)
/**
* 读取文件内容为字符串列表
*
* @param charset 字符编码格式
* @return 按行分割的字符串列表
* @throws IOException 读取文件时发生错误
*/
fun Path.readLines(charset: Charset): List<String> {
return Files.readAllLines(this, charset)
}
// 将字符串列表写入文件
@Throws(IOException::class)
/**
* 将字符串列表写入文件,使用默认字符集
*
* @param lines 要写入的字符串列表
* @throws IOException 写入文件时发生错误
*/
fun Path.writeLines(lines: List<String>) {
this.writeLines(lines, DEFAULT_CHARSET)
}
@Throws(IOException::class)
/**
* 将字符串列表写入文件
*
* @param lines 要写入的字符串列表
* @param charset 字符编码格式
* @throws IOException 写入文件时发生错误
*/
fun Path.writeLines(lines: List<String>, charset: Charset) {
Files.createDirectories(this.parent)
Files.write(this, lines, charset)
}
// 复制文件
@Throws(IOException::class)
/**
* 复制文件到目标路径
*
* @param target 目标文件路径
* @throws IOException 复制文件时发生错误
*/
fun Path.copyTo(target: Path) {
Files.createDirectories(target.parent)
Files.copy(this, target)
}
// 删除文件
/**
* 删除文件
*
* @return 删除操作是否成功
*/
fun Path.delete(): Boolean {
return try {
Files.deleteIfExists(this)
} catch (e: IOException) {
false
}
}
// 检查文件是否存在
/**
* 检查文件是否存在
*
* @return 文件是否存在
*/
fun Path.exists(): Boolean {
return Files.exists(this)
}
// 获取文件大小
/**
* 获取文件大小
*
* @return 文件大小(字节),如果获取失败则返回-1
*/
fun Path.getFileSize(): Long {
return try {
Files.size(this)
} catch (e: IOException) {
-1
}
}
// 读取文件内容为字节数组
@Throws(IOException::class)
/**
* 读取文件内容为字节数组
*
* @return 文件内容的字节数组表示
* @throws IOException 读取文件时发生错误
*/
fun Path.readByteArray(): ByteArray {
return Files.readAllBytes(this)
}
// 将字节数组写入文件
@Throws(IOException::class)
/**
* 将字节数组写入文件
*
* @param data 要写入的字节数组
* @throws IOException 写入文件时发生错误
*/
fun Path.writeByteArray(data: ByteArray) {
Files.createDirectories(this.parent)
Files.write(this, data)
}
// 将字节数组追加到文件末尾
@Throws(IOException::class)
/**
* 将字节数组追加到文件末尾
*
* @param data 要追加的字节数组
* @throws IOException 追加文件时发生错误
*/
fun Path.appendByteArray(data: ByteArray) {
Files.createDirectories(this.parent)
Files.write(this, data, StandardOpenOption.CREATE, StandardOpenOption.APPEND)
}
// 分块读取大文件为字节数组列表
@Throws(IOException::class)
/**
* 分块读取大文件为字节数组列表
*
* @param chunkSize 每个块的大小
* @return 字节数组列表
* @throws IOException 读取文件时发生错误
*/
fun Path.readByteArrayChunks(chunkSize: Int): List<ByteArray> {
val chunks = mutableListOf<ByteArray>()
Files.newInputStream(this).use { inputStream ->
val buffer = ByteArray(chunkSize)
var bytesRead: Int
while (inputStream.read(buffer).also { bytesRead = it } != -1) {
val chunk = ByteArray(bytesRead)
System.arraycopy(buffer, 0, chunk, 0, bytesRead)
chunks.add(chunk)
}
}
return chunks
}
// 将字节数组列表写入文件
@Throws(IOException::class)
/**
* 将字节数组列表写入文件
*
* @param chunks 字节数组列表
* @throws IOException 写入文件时发生错误
*/
fun Path.writeByteArrayChunks(chunks: List<ByteArray>) {
Files.createDirectories(this.parent)
Files.newOutputStream(this).use { outputStream ->
for (chunk in chunks) {
outputStream.write(chunk)
}
}
}
// 读取文件内容为字符串
@Throws(IOException::class)
/**
* 读取文件内容为字符串,使用默认字符集
*
* @return 文件内容的字符串表示
* @throws IOException 读取文件时发生错误
*/
fun File.readFileToString(): String {
return this.readFileToString(DEFAULT_CHARSET)
}
@Throws(IOException::class)
/**
* 读取文件内容为字符串
*
* @param charset 字符编码格式
* @return 文件内容的字符串表示
* @throws IOException 读取文件时发生错误
*/
fun File.readFileToString(charset: Charset): String {
return String(this.readBytes(), charset)
}
// 将字符串写入文件
@Throws(IOException::class)
/**
* 将字符串写入文件,使用默认字符集
*
* @param content 要写入的字符串内容
* @throws IOException 写入文件时发生错误
*/
fun File.writeStringToFile(content: String) {
this.writeStringToFile(content, DEFAULT_CHARSET)
}
@Throws(IOException::class)
/**
* 将字符串写入文件
*
* @param content 要写入的字符串内容
* @param charset 字符编码格式
* @throws IOException 写入文件时发生错误
*/
fun File.writeStringToFile(content: String, charset: Charset) {
this.parentFile?.mkdirs()
this.writeText(content, charset)
}
// 读取文件内容为字符串列表
@Throws(IOException::class)
/**
* 读取文件内容为字符串列表,使用默认字符集
*
* @return 按行分割的字符串列表
* @throws IOException 读取文件时发生错误
*/
fun File.readLines(): List<String> {
return this.readLines(DEFAULT_CHARSET)
}
@Throws(IOException::class)
/**
* 读取文件内容为字符串列表
*
* @param charset 字符编码格式
* @return 按行分割的字符串列表
* @throws IOException 读取文件时发生错误
*/
fun File.readLines(charset: Charset): List<String> {
return this.readLines(charset)
}
// 将字符串列表写入文件
@Throws(IOException::class)
/**
* 将字符串列表写入文件,使用默认字符集
*
* @param lines 要写入的字符串列表
* @throws IOException 写入文件时发生错误
*/
fun File.writeLines(lines: List<String>) {
this.writeLines(lines, DEFAULT_CHARSET)
}
@Throws(IOException::class)
/**
* 将字符串列表写入文件
*
* @param lines 要写入的字符串列表
* @param charset 字符编码格式
* @throws IOException 写入文件时发生错误
*/
fun File.writeLines(lines: List<String>, charset: Charset) {
this.parentFile?.mkdirs()
this.writeLines(lines, charset)
}
// 复制文件
@Throws(IOException::class)
/**
* 复制文件到目标文件
*
* @param target 目标文件
* @throws IOException 复制文件时发生错误
*/
fun File.copyTo(target: File) {
target.parentFile?.mkdirs()
this.copyTo(target, overwrite = true)
}
// 删除文件
/**
* 删除文件
*
* @return 删除操作是否成功
*/
fun File.delete(): Boolean {
return this.delete()
}
// 检查文件是否存在
/**
* 检查文件是否存在
*
* @return 文件是否存在
*/
fun File.exists(): Boolean {
return this.exists()
}
// 获取文件大小
/**
* 获取文件大小
*
* @return 文件大小(字节),如果文件不存在则返回-1L
*/
fun File.getFileSize(): Long {
return if (this.exists()) this.length() else -1L
}
// 创建目录
/**
* 创建目录
*
* @return 创建操作是否成功
*/
fun File.createDirectory(): Boolean {
return this.mkdirs()
}
// 读取文件内容为字节数组
@Throws(IOException::class)
/**
* 读取文件内容为字节数组
*
* @return 文件内容的字节数组表示
* @throws IOException 读取文件时发生错误
*/
fun File.readByteArray(): ByteArray {
return this.readBytes()
}
// 将字节数组写入文件
@Throws(IOException::class)
/**
* 将字节数组写入文件
*
* @param data 要写入的字节数组
* @throws IOException 写入文件时发生错误
*/
fun File.writeByteArray(data: ByteArray) {
this.parentFile?.mkdirs()
this.writeBytes(data)
}
// 将字节数组追加到文件末尾
@Throws(IOException::class)
/**
* 将字节数组追加到文件末尾
*
* @param data 要追加的字节数组
* @throws IOException 追加文件时发生错误
*/
fun File.appendByteArray(data: ByteArray) {
this.parentFile?.mkdirs()
this.appendBytes(data)
}
// 分块读取大文件为字节数组列表
@Throws(IOException::class)
/**
* 分块读取大文件为字节数组列表
*
* @param chunkSize 每个块的大小
* @return 字节数组列表
* @throws IOException 读取文件时发生错误
*/
fun File.readByteArrayChunks(chunkSize: Int): List<ByteArray> {
val chunks = mutableListOf<ByteArray>()
this.inputStream().use { inputStream ->
val buffer = ByteArray(chunkSize)
var bytesRead: Int
while (inputStream.read(buffer).also { bytesRead = it } != -1) {
val chunk = ByteArray(bytesRead)
System.arraycopy(buffer, 0, chunk, 0, bytesRead)
chunks.add(chunk)
}
}
return chunks
}
// 将字节数组列表写入文件
@Throws(IOException::class)
/**
* 将字节数组列表写入文件
*
* @param chunks 字节数组列表
* @throws IOException 写入文件时发生错误
*/
fun File.writeByteArrayChunks(chunks: List<ByteArray>) {
this.parentFile?.mkdirs()
this.outputStream().use { outputStream ->
for (chunk in chunks) {
outputStream.write(chunk)
}
}
}
@@ -0,0 +1,81 @@
/*
* Copyright 2026 mingliqiye
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* ProjectName mingli-utils
* ModuleName mingli-utils.main
* CurrentFile Debouncer.kt
* LastUpdate 2026-01-11 09:10:30
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.functions
import java.util.concurrent.*
/**
* 防抖器类,用于实现防抖功能,防止在短时间内重复执行相同任务
*
* @author MingLiPro
*/
class Debouncer(private val delay: Long, unit: TimeUnit) {
private val scheduler: ScheduledExecutorService = Executors.newSingleThreadScheduledExecutor()
private val delayedMap: ConcurrentHashMap<Any, Future<*>> = ConcurrentHashMap()
private val delayMillis: Long = unit.toMillis(delay)
/**
* 执行防抖操作,如果在指定延迟时间内再次调用相同key的任务,则取消之前的任务并重新计时
*
* @param key 任务的唯一标识符,用于区分不同任务
* @param task 要执行的任务
*/
fun debounce(key: Any, task: Runnable) {
// 提交新任务并获取之前可能存在的任务
val prev = delayedMap.put(
key,
scheduler.schedule(
{
try {
task.run()
} finally {
// 任务执行完成后从映射中移除
delayedMap.remove(key)
}
},
delayMillis,
TimeUnit.MILLISECONDS
)
)
// 如果之前存在任务,则取消它
if (prev != null) {
prev.cancel(true)
}
}
/**
* 关闭防抖器,取消所有待执行的任务并关闭调度器
*/
fun shutdown() {
// 先取消所有延迟任务
for (future in delayedMap.values) {
future.cancel(true)
}
delayedMap.clear()
// 再关闭调度器
scheduler.shutdownNow()
}
}
@@ -1,5 +1,5 @@
/* /*
* Copyright 2025 mingliqiye * Copyright 2026 mingliqiye
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@@ -16,75 +16,24 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile Functions.kt * CurrentFile Functions.kt
* LastUpdate 2025-09-15 09:56:54 * LastUpdate 2026-01-11 09:10:48
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@file:JvmName("Functions")
package com.mingliqiye.utils.functions package com.mingliqiye.utils.functions
import java.util.concurrent.*
/**
* 防抖器类,用于实现防抖功能,防止在短时间内重复执行相同任务
*
* @author MingLiPro
*/
class Debouncer(private val delay: Long, unit: TimeUnit) {
private val scheduler: ScheduledExecutorService = Executors.newSingleThreadScheduledExecutor()
private val delayedMap: ConcurrentHashMap<Any, Future<*>> = ConcurrentHashMap()
private val delayMillis: Long = unit.toMillis(delay)
/**
* 执行防抖操作,如果在指定延迟时间内再次调用相同key的任务,则取消之前的任务并重新计时
*
* @param key 任务的唯一标识符,用于区分不同任务
* @param task 要执行的任务
*/
fun debounce(key: Any, task: Runnable) {
// 提交新任务并获取之前可能存在的任务
val prev = delayedMap.put(
key,
scheduler.schedule(
{
try {
task.run()
} finally {
// 任务执行完成后从映射中移除
delayedMap.remove(key)
}
},
delayMillis,
TimeUnit.MILLISECONDS
)
)
// 如果之前存在任务,则取消它
if (prev != null) {
prev.cancel(true)
}
}
/**
* 关闭防抖器,取消所有待执行的任务并关闭调度器
*/
fun shutdown() {
// 先取消所有延迟任务
for (future in delayedMap.values) {
future.cancel(true)
}
delayedMap.clear()
// 再关闭调度器
scheduler.shutdownNow()
}
}
@FunctionalInterface @FunctionalInterface
fun interface P1Function<P> { fun interface P1Function<P> {
fun call(p: P) fun call(p: P)
} }
@FunctionalInterface
fun interface RFunction<R> {
fun call(): R
}
@FunctionalInterface @FunctionalInterface
fun interface P1RFunction<P, R> { fun interface P1RFunction<P, R> {
fun call(p: P): R fun call(p: P): R
@@ -1,5 +1,5 @@
/* /*
* Copyright 2025 mingliqiye * Copyright 2026 mingliqiye
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@@ -16,25 +16,22 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile HashUtils.kt * CurrentFile HashUtils.kt
* LastUpdate 2025-09-15 09:38:04 * LastUpdate 2026-01-11 09:09:52
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@file:JvmName("HashUtils") @file:JvmName("HashUtils")
package com.mingliqiye.utils.hash package com.mingliqiye.utils.hash
import org.bouncycastle.jce.provider.BouncyCastleProvider
import org.mindrot.jbcrypt.BCrypt import com.mingliqiye.utils.bcrypt.checkpw
import com.mingliqiye.utils.bcrypt.hashpw
import com.mingliqiye.utils.bytes.bytesToHex
import java.io.File import java.io.File
import java.io.FileInputStream import java.io.FileInputStream
import java.io.IOException import java.io.IOException
import java.security.MessageDigest import java.security.MessageDigest
import java.security.NoSuchAlgorithmException import java.security.NoSuchAlgorithmException
import java.security.Security
private val _addProvider = run {
Security.addProvider(BouncyCastleProvider())
}
/** /**
* 计算指定文件的哈希值。 * 计算指定文件的哈希值。
@@ -67,24 +64,6 @@ fun calculateFileHash(file: File, algorithm: String): String {
return bytesToHex(digest.digest()) return bytesToHex(digest.digest())
} }
/**
* 将字节数组转换为十六进制字符串表示。
*
* @param bytes 输入的字节数组
* @return 对应的十六进制字符串
*/
private fun bytesToHex(bytes: ByteArray): String {
val hexString = StringBuilder(2 * bytes.size)
for (b in bytes) {
val hex = Integer.toHexString(0xff and b.toInt())
if (hex.length == 1) {
hexString.append('0')
}
hexString.append(hex)
}
return hexString.toString()
}
/** /**
* 使用 BCrypt 算法对字符串进行加密。 * 使用 BCrypt 算法对字符串进行加密。
* *
@@ -92,7 +71,7 @@ private fun bytesToHex(bytes: ByteArray): String {
* @return 加密后的 BCrypt 哈希字符串 * @return 加密后的 BCrypt 哈希字符串
*/ */
fun bcrypt(string: String): String { fun bcrypt(string: String): String {
return BCrypt.hashpw(string, BCrypt.gensalt()) return hashpw(string)
} }
/** /**
@@ -103,5 +82,5 @@ fun bcrypt(string: String): String {
* @return 如果匹配返回 true,否则返回 false * @return 如果匹配返回 true,否则返回 false
*/ */
fun checkBcrypt(string: String, bcrypted: String): Boolean { fun checkBcrypt(string: String, bcrypted: String): Boolean {
return BCrypt.checkpw(string, bcrypted) return checkpw(string, bcrypted)
} }
@@ -0,0 +1,63 @@
/*
* Copyright 2025 mingliqiye
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* ProjectName mingli-utils
* ModuleName mingli-utils.main
* CurrentFile IO.kt
* LastUpdate 2025-09-20 16:03:14
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.io
fun Any?.println() {
IO.println(this)
}
class IO {
companion object {
@JvmStatic
fun print(vararg args: Any?) {
printA(" ", *args)
}
@JvmStatic
fun println(vararg args: Any?) {
printlnA(" ", *args)
}
@JvmStatic
fun printlnA(sp: String, vararg args: Any?) {
printA(" ", *args)
kotlin.io.println()
}
@JvmStatic
fun printA(sp: String = "", vararg args: Any?) {
if (args.isEmpty()) {
kotlin.io.println()
}
val sb = StringBuilder()
for (i in args.indices) {
sb.append(args[i])
if (i < args.size - 1) sb.append(sp)
}
kotlin.io.print(sb)
}
}
}
@@ -16,7 +16,7 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile JsonTypeUtils.kt * CurrentFile JsonTypeUtils.kt
* LastUpdate 2025-09-15 22:04:54 * LastUpdate 2025-09-17 11:12:06
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@file:JvmName("JsonTypeUtils") @file:JvmName("JsonTypeUtils")
@@ -177,11 +177,11 @@ fun <K, V> MapType(keyType: Class<K>, valueType: Class<V>): JsonTypeReference<Ma
return null return null
} }
override fun equals(obj: Any?): Boolean { override fun equals(other: Any?): Boolean {
if (this === obj) return true if (this === other) return true
if (obj !is ParameterizedType) return false if (other !is ParameterizedType) return false
val that = obj val that = other
return (Objects.equals( return (Objects.equals(
rawType, rawType,
that.rawType that.rawType
@@ -16,7 +16,7 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile JsonStringConverter.kt * CurrentFile JsonStringConverter.kt
* LastUpdate 2025-09-15 11:03:53 * LastUpdate 2025-09-17 19:09:17
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@@ -35,7 +35,6 @@ import com.google.gson.stream.JsonReader
import com.google.gson.stream.JsonWriter import com.google.gson.stream.JsonWriter
import com.mingliqiye.utils.time.DateTime import com.mingliqiye.utils.time.DateTime
import com.mingliqiye.utils.time.DateTime.Companion.parse import com.mingliqiye.utils.time.DateTime.Companion.parse
import com.mingliqiye.utils.time.Formatter
import com.mingliqiye.utils.uuid.UUID import com.mingliqiye.utils.uuid.UUID
import com.mingliqiye.utils.uuid.UUID.Companion.of import com.mingliqiye.utils.uuid.UUID.Companion.of
import java.io.IOException import java.io.IOException
@@ -219,7 +218,7 @@ class DateTimeJsonConverter : JsonStringConverter<DateTime>() {
if (obj == null) { if (obj == null) {
return null return null
} }
return obj.format(Formatter.STANDARD_DATETIME) return obj.format()
} }
override fun deConvert(obj: String?): DateTime? { override fun deConvert(obj: String?): DateTime? {
@@ -227,9 +226,7 @@ class DateTimeJsonConverter : JsonStringConverter<DateTime>() {
return null return null
} }
return parse( return parse(
obj, obj
Formatter.STANDARD_DATETIME_MILLISECOUND7,
true
) )
} }
} }
@@ -16,7 +16,7 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile Loggers.kt * CurrentFile Loggers.kt
* LastUpdate 2025-09-15 22:32:50 * LastUpdate 2025-09-18 09:30:48
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@@ -416,6 +416,6 @@ class MingLiLoggerFactory {
} }
} }
val mingLiLoggerFactory = MingLiLoggerFactory() val mingLiLoggerFactory: MingLiLoggerFactory by lazy { MingLiLoggerFactory() }
@@ -1,5 +1,5 @@
/* /*
* Copyright 2025 mingliqiye * Copyright 2026 mingliqiye
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@@ -16,16 +16,15 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile Main.kt * CurrentFile Main.kt
* LastUpdate 2025-09-15 22:31:33 * LastUpdate 2026-01-06 14:36:10
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@file:JvmName("Main") @file:JvmName("Main")
package com.mingliqiye.utils package com.mingliqiye.utils.main
import com.mingliqiye.utils.springboot.autoconfigure.AutoConfiguration import com.mingliqiye.utils.springboot.autoconfigure.AutoConfiguration
fun main() { fun main() {
AutoConfiguration.printBanner() AutoConfiguration.printBanner()
} }
@@ -0,0 +1,64 @@
/*
* Copyright 2025 mingliqiye
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* ProjectName mingli-utils
* ModuleName mingli-utils.main
* CurrentFile MetaData.kt
* LastUpdate 2025-09-20 10:45:43
* UpdateUser MingLiPro
*/
@file:JvmName("MetaData")
package com.mingliqiye.utils.metadata
import com.mingliqiye.utils.resource.ResourceUtils
import java.util.stream.Collectors.toMap
fun getMetaData(): Map<String, String> {
return ResourceUtils.getStringResource("/META-INF/meta-data").split("\n").stream().map {
if (it.isBlank()) {
return@map null
}
val split = it.split("=")
if (split.size == 2) {
split[0] to split[1]
} else {
return@map null
}
}.filter { it != null }.collect(toMap({ it!!.first }, { it!!.second }))
}
class MingliUtilsMetaData {
var buildTime: String = ""
var groupId: String = ""
var artifactId: String = ""
var version: String = ""
var buildJdkVersion: String = ""
var author: String = ""
var website: String = ""
}
val mingliUtilsMetaData: MingliUtilsMetaData by lazy {
val metaData = getMetaData()
MingliUtilsMetaData().apply {
buildTime = metaData["buildTime"] ?: ""
groupId = metaData["groupId"] ?: ""
artifactId = metaData["artifactId"] ?: ""
version = metaData["version"] ?: ""
buildJdkVersion = metaData["buildJdkVersion"] ?: ""
author = metaData["author"] ?: ""
website = metaData["website"] ?: ""
}
}
@@ -1,5 +1,5 @@
/* /*
* Copyright 2025 mingliqiye * Copyright 2026 mingliqiye
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@@ -15,29 +15,29 @@
* *
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile ComponentBean.kt * CurrentFile CallType.kt
* LastUpdate 2025-09-15 22:32:50 * LastUpdate 2026-01-07 19:06:59
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
package com.mingliqiye.utils.bean.annotation package com.mingliqiye.utils.mybatis
import kotlin.annotation.AnnotationRetention.RUNTIME enum class CallType {
import kotlin.annotation.AnnotationTarget.CLASS /**
import kotlin.annotation.AnnotationTarget.FIELD * 通过索引访问结果集
* 使用数字索引位置来获取结果集中的数据
/**
* 组件bean注解
* @author MingLiPro
*/ */
@Retention(RUNTIME) RESULTSET_INDEX,
@Target(CLASS)
annotation class ComponentBean(val value: String = "")
/** /**
* 注入bean注解 * 通过名称访问结果集
* @author MingLiPro * 使用列名来获取结果集中的数据
*/ */
@Retention(RUNTIME) RESULTSET_NAME,
@Target(FIELD)
annotation class InjectBean(val value: String = "") /**
* 通过索引访问可调用语句
* 使用数字索引位置来获取可调用语句中的数据
*/
CALLABLE_STATEMENT_INDEX
}
@@ -0,0 +1,126 @@
/*
* Copyright 2026 mingliqiye
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* ProjectName mingli-utils
* ModuleName mingli-utils.main
* CurrentFile QuickBaseTypeHandler.kt
* LastUpdate 2026-01-08 07:59:47
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.mybatis
import org.apache.ibatis.type.BaseTypeHandler
import org.apache.ibatis.type.JdbcType
import java.sql.CallableStatement
import java.sql.PreparedStatement
import java.sql.ResultSet
import java.sql.SQLException
/**
* 抽象类 QuickBaseTypeHandler 是 MyBatis 的 BaseTypeHandler 的扩展,
* 提供了统一处理数据库字段与 Java 类型之间转换的抽象方法。
* 子类需要实现 getValue 和 setValue 方法来完成具体的类型转换逻辑。
*
* @param T 要处理的 Java 类型
*/
abstract class QuickBaseTypeHandler<T> : BaseTypeHandler<T>() {
/**
* 抽象方法,用于从数据库结果中获取并转换为 Java 类型 T。
*
* @param vg 值获取器,封装了 ResultSet 或 CallableStatement
* @param ct 调用类型,标识当前是从 ResultSet 还是 CallableStatement 获取数据
* @param ci 列索引(可为 null)
* @param cn 列名(可为 null)
* @return 转换后的 Java 类型 T 实例
* @throws SQLException SQL 执行异常时抛出
*/
@Throws(SQLException::class)
abstract fun getValue(
vg: QuickBaseTypeHandlerValueGetter,
ct: CallType,
ci: Int?,
cn: String?
): T
/**
* 抽象方法,用于将 Java 类型 T 设置到 PreparedStatement 中。
*
* @param ps PreparedStatement 对象
* @param index 参数索引位置
* @param parameter Java 类型 T 的实例
* @param jdbcType JDBC 类型
* @throws SQLException SQL 执行异常时抛出
*/
@Throws(SQLException::class)
abstract fun setValue(ps: PreparedStatement, index: Int, parameter: T, jdbcType: JdbcType?)
/**
* 实现 BaseTypeHandler 的 setNonNullParameter 方法,
* 将非空参数设置到 PreparedStatement 中。
*
* @param ps PreparedStatement 对象
* @param i 参数索引位置
* @param parameter Java 类型 T 的实例(非空)
* @param jdbcType JDBC 类型
* @throws SQLException SQL 执行异常时抛出
*/
@Throws(SQLException::class)
override fun setNonNullParameter(ps: PreparedStatement, i: Int, parameter: T, jdbcType: JdbcType?) {
setValue(ps, i, parameter, jdbcType)
}
/**
* 实现 BaseTypeHandler 的 getNullableResult 方法,
* 通过列名从 ResultSet 中获取可能为 null 的结果。
*
* @param rs ResultSet 对象
* @param columnName 数据库列名
* @return 转换后的 Java 类型 T 实例(可能为 null)
* @throws SQLException SQL 执行异常时抛出
*/
@Throws(SQLException::class)
override fun getNullableResult(rs: ResultSet, columnName: String): T {
return getValue(QuickBaseTypeHandlerValueGetter(null, rs), CallType.RESULTSET_NAME, null, columnName)
}
/**
* 实现 BaseTypeHandler 的 getNullableResult 方法,
* 通过列索引从 ResultSet 中获取可能为 null 的结果。
*
* @param rs ResultSet 对象
* @param columnIndex 数据库列索引
* @return 转换后的 Java 类型 T 实例(可能为 null)
* @throws SQLException SQL 执行异常时抛出
*/
@Throws(SQLException::class)
override fun getNullableResult(rs: ResultSet, columnIndex: Int): T {
return getValue(QuickBaseTypeHandlerValueGetter(null, rs), CallType.RESULTSET_INDEX, columnIndex, null)
}
/**
* 实现 BaseTypeHandler 的 getNullableResult 方法,
* 通过列索引从 CallableStatement 中获取可能为 null 的结果。
*
* @param cs CallableStatement 对象
* @param columnIndex 数据库列索引
* @return 转换后的 Java 类型 T 实例(可能为 null)
* @throws SQLException SQL 执行异常时抛出
*/
@Throws(SQLException::class)
override fun getNullableResult(cs: CallableStatement, columnIndex: Int): T {
return getValue(QuickBaseTypeHandlerValueGetter(cs, null), CallType.CALLABLE_STATEMENT_INDEX, columnIndex, null)
}
}
@@ -0,0 +1,28 @@
/*
* Copyright 2026 mingliqiye
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* ProjectName mingli-utils
* ModuleName mingli-utils.main
* CurrentFile QuickBaseTypeHandlerValueGetter.kt
* LastUpdate 2026-01-07 19:10:44
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.mybatis
import java.sql.CallableStatement
import java.sql.ResultSet
data class QuickBaseTypeHandlerValueGetter(var callableStatement: CallableStatement?, var resultSet: ResultSet?)
@@ -1,5 +1,5 @@
/* /*
* Copyright 2025 mingliqiye * Copyright 2026 mingliqiye
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@@ -16,87 +16,48 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile DateTimeTypeHandler.kt * CurrentFile DateTimeTypeHandler.kt
* LastUpdate 2025-09-15 13:53:53 * LastUpdate 2026-01-07 19:23:12
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@file:JvmName("DateTimeConvertor")
package com.mingliqiye.utils.mybatis.typehandler.datetime package com.mingliqiye.utils.mybatis.typehandler.datetime
import com.mingliqiye.utils.mybatis.CallType
import com.mingliqiye.utils.mybatis.QuickBaseTypeHandler
import com.mingliqiye.utils.mybatis.QuickBaseTypeHandlerValueGetter
import com.mingliqiye.utils.time.DateTime import com.mingliqiye.utils.time.DateTime
import org.apache.ibatis.type.BaseTypeHandler
import org.apache.ibatis.type.JdbcType import org.apache.ibatis.type.JdbcType
import org.apache.ibatis.type.MappedTypes import org.apache.ibatis.type.MappedTypes
import java.sql.CallableStatement
import java.sql.PreparedStatement import java.sql.PreparedStatement
import java.sql.ResultSet import java.sql.Timestamp
import java.sql.SQLException
import java.time.LocalDateTime
/**
* 将LocalDateTime对象转换为DateTime对象
*
* @param localDateTime LocalDateTime对象
* @return DateTime对象,如果localDateTime为null则返回null
*/
fun toDateTime(localDateTime: LocalDateTime?): DateTime? {
return localDateTime?.let { DateTime.of(it) }
}
/**
* 将DateTime对象转换为LocalDateTime对象
*
* @param dateTime DateTime对象
* @return LocalDateTime对象,如果dateTime为null则返回null
*/
fun toLocalDateTime(dateTime: DateTime?): LocalDateTime? {
return dateTime?.toLocalDateTime()
}
/** /**
* DateTime类型处理器,用于在数据库和Java对象之间转换DateTime类型 * DateTime类型处理器,用于在数据库和Java对象之间转换DateTime类型
* @author MingLiQiye
* @date 2025/9/12
*/ */
@MappedTypes(DateTime::class) @MappedTypes(DateTime::class)
class DateTimeTypeHandler : BaseTypeHandler<DateTime>() { class DateTimeTypeHandler : QuickBaseTypeHandler<DateTime>() {
@Throws(SQLException::class) override fun getValue(
override fun setNonNullParameter( vg: QuickBaseTypeHandlerValueGetter,
ct: CallType,
ci: Int?,
cn: String?
): DateTime {
return DateTime.of(
(when (ct) {
CallType.RESULTSET_INDEX -> vg.resultSet!!.getTimestamp(ci!!)
CallType.RESULTSET_NAME -> vg.resultSet!!.getTimestamp(cn!!)
CallType.CALLABLE_STATEMENT_INDEX -> vg.callableStatement!!.getTimestamp(ci!!)
})
)
}
override fun setValue(
ps: PreparedStatement, ps: PreparedStatement,
i: Int, index: Int,
parameter: DateTime, parameter: DateTime,
jdbcType: JdbcType? jdbcType: JdbcType?
) { ) {
// 使用 setObject 允许传入 null,由数据库处理 ps.setTimestamp(index, Timestamp.valueOf(parameter.toLocalDateTime()))
ps.setObject(i, toLocalDateTime(parameter))
}
@Throws(SQLException::class)
override fun getNullableResult(rs: ResultSet, columnName: String): DateTime? {
// 安全类型转换和空检查
return when (val value = rs.getObject(columnName)) {
is LocalDateTime -> toDateTime(value)
null -> null
else -> throw SQLException("Expected LocalDateTime for column '$columnName', but got ${value.javaClass.name}")
}
}
@Throws(SQLException::class)
override fun getNullableResult(rs: ResultSet, columnIndex: Int): DateTime? {
return when (val value = rs.getObject(columnIndex)) {
is LocalDateTime -> toDateTime(value)
null -> null
else -> throw SQLException("Expected LocalDateTime at column index $columnIndex, but got ${value.javaClass.name}")
}
}
@Throws(SQLException::class)
override fun getNullableResult(cs: CallableStatement, columnIndex: Int): DateTime? {
return when (val value = cs.getObject(columnIndex)) {
is LocalDateTime -> toDateTime(value)
null -> null
else -> throw SQLException("Expected LocalDateTime at column index $columnIndex, but got ${value.javaClass.name}")
}
} }
} }
@@ -0,0 +1,78 @@
/*
* Copyright 2026 mingliqiye
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* ProjectName mingli-utils
* ModuleName mingli-utils.main
* CurrentFile MysqlUUIDBinaryTypeHandler.kt
* LastUpdate 2026-01-07 19:30:31
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.mybatis.typehandler.mysql.uuid
import com.mingliqiye.utils.mybatis.CallType
import com.mingliqiye.utils.mybatis.QuickBaseTypeHandler
import com.mingliqiye.utils.mybatis.QuickBaseTypeHandlerValueGetter
import com.mingliqiye.utils.uuid.UUID
import com.mingliqiye.utils.uuid.mysqlToUuid
import com.mingliqiye.utils.uuid.uuidToMysql
import org.apache.ibatis.type.JdbcType
import org.apache.ibatis.type.MappedTypes
import java.sql.PreparedStatement
@MappedTypes(UUID::class)
class MysqlUUIDBinaryTypeHandler : QuickBaseTypeHandler<UUID>() {
companion object {
/**
* 将字节数组转换为UUID对象
*
* @param byteArray 字节数组
* @return UUID对象,如果字节数组为null则返回null
*/
private fun toUUID(byteArray: ByteArray?): UUID? {
return byteArray?.let { UUID.of(mysqlToUuid(it)) }
}
/**
* 将UUID对象转换为字节数组
*
* @param uuid UUID对象
* @return 字节数组,如果UUID为null则返回null
*/
fun toByteArray(uuid: UUID?): ByteArray? {
return uuid?.let { uuidToMysql(it.toBytes()) }
}
}
override fun getValue(
vg: QuickBaseTypeHandlerValueGetter, ct: CallType, ci: Int?, cn: String?
): UUID {
return toUUID(
when (ct) {
CallType.RESULTSET_NAME -> vg.resultSet!!.getBytes(cn!!)
CallType.RESULTSET_INDEX -> vg.resultSet!!.getBytes(ci!!)
CallType.CALLABLE_STATEMENT_INDEX -> vg.resultSet!!.getBytes(ci!!)
}
)!!
}
override fun setValue(
ps: PreparedStatement, index: Int, parameter: UUID, jdbcType: JdbcType?
) {
ps.setBytes(index, toByteArray(parameter))
}
}
@@ -1,279 +0,0 @@
/*
* Copyright 2025 mingliqiye
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* ProjectName mingli-utils
* ModuleName mingli-utils.main
* CurrentFile UUIDTypeHandler.kt
* LastUpdate 2025-09-15 13:54:18
* UpdateUser MingLiPro
*/
@file:JvmName("UUIDConvertor")
package com.mingliqiye.utils.mybatis.typehandler.uuid
import com.mingliqiye.utils.uuid.UUID
import org.apache.ibatis.type.BaseTypeHandler
import org.apache.ibatis.type.JdbcType
import org.apache.ibatis.type.MappedJdbcTypes
import org.apache.ibatis.type.MappedTypes
import java.sql.CallableStatement
import java.sql.PreparedStatement
import java.sql.ResultSet
import java.util.UUID as JUUID
/**
* 将字节数组转换为UUID对象
*
* @param byteArray 字节数组
* @return UUID对象,如果字节数组为null则返回null
*/
fun byteArraytoUUID(byteArray: ByteArray?): UUID? {
return byteArray?.let { UUID.of(it) }
}
/**
* 将UUID对象转换为字节数组
*
* @param uuid UUID对象
* @return 字节数组,如果UUID为null则返回null
*/
fun uuidToByteArray(uuid: UUID?): ByteArray? {
return uuid?.toBytes()
}
/**
* 将字符串转换为UUID对象
*
* @param str 字符串
* @return UUID对象,如果字符串为null则返回null
*/
fun stringToUUID(str: String?): UUID? {
return str?.let { UUID.of(it) }
}
/**
* 将UUID对象转换为字符串
*
* @param uuid UUID对象
* @return 字符串,如果UUID为null则返回null
*/
fun uuidToString(uuid: UUID?): String? {
return uuid?.getString()
}
/**
* 将java UUID转换为UUID对象
*
* @param uuid JUUID java UUID
* @return UUID对象,如果字符串为null则返回null
*/
fun juuidToUUID(uuid: JUUID?): UUID? {
return uuid?.let { UUID(it) }
}
/**
* 将UUID对象转换为java UUID
*
* @param uuid UUID对象
* @return java UUID,如果UUID为null则返回null
*/
fun uuidToJuuid(uuid: UUID?): JUUID? {
return uuid?.getUuid()
}
/**
* JDBC类型转换 UUID BINARY
* @author MingLiQiye
* @date 2025/9/12
*/
@MappedTypes(UUID::class)
@MappedJdbcTypes(JdbcType.BINARY)
class UUIDBinaryTypeHandler : BaseTypeHandler<UUID>() {
/**
* 设置非空参数到PreparedStatement中
*
* @param ps PreparedStatement对象
* @param i 参数索引
* @param parameter UUID参数值
* @param jdbcType JDBC类型
*/
override fun setNonNullParameter(
ps: PreparedStatement, i: Int, parameter: UUID, jdbcType: JdbcType?
) {
ps.setBytes(i, uuidToByteArray(parameter))
}
/**
* 从ResultSet中根据列名获取可空的UUID结果
*
* @param rs ResultSet对象
* @param columnName 列名
* @return UUID对象或null
*/
override fun getNullableResult(
rs: ResultSet, columnName: String
): UUID? {
return byteArraytoUUID(rs.getBytes(columnName))
}
/**
* 从ResultSet中根据列索引获取可空的UUID结果
*
* @param rs ResultSet对象
* @param columnIndex 列索引
* @return UUID对象或null
*/
override fun getNullableResult(rs: ResultSet, columnIndex: Int): UUID? {
return byteArraytoUUID(rs.getBytes(columnIndex))
}
/**
* 从CallableStatement中根据列索引获取可空的UUID结果
*
* @param cs CallableStatement对象
* @param columnIndex 列索引
* @return UUID对象或null
*/
override fun getNullableResult(
cs: CallableStatement, columnIndex: Int
): UUID? {
return byteArraytoUUID(cs.getBytes(columnIndex))
}
}
/**
* JDBC类型转换 UUID String
* @author MingLiQiye
* @date 2025/9/12
*/
@MappedTypes(UUID::class)
@MappedJdbcTypes(JdbcType.VARCHAR)
class UUIDStringTypeHandler : BaseTypeHandler<UUID>() {
/**
* 设置非空参数到PreparedStatement中
*
* @param ps PreparedStatement对象
* @param i 参数索引
* @param parameter UUID参数值
* @param jdbcType JDBC类型
*/
override fun setNonNullParameter(
ps: PreparedStatement, i: Int, parameter: UUID, jdbcType: JdbcType?
) {
ps.setString(i, uuidToString(parameter))
}
/**
* 从ResultSet中根据列名获取可空的UUID结果
*
* @param rs ResultSet对象
* @param columnName 列名
* @return UUID对象或null
*/
override fun getNullableResult(
rs: ResultSet, columnName: String
): UUID? {
return stringToUUID(rs.getString(columnName))
}
/**
* 从ResultSet中根据列索引获取可空的UUID结果
*
* @param rs ResultSet对象
* @param columnIndex 列索引
* @return UUID对象或null
*/
override fun getNullableResult(rs: ResultSet, columnIndex: Int): UUID? {
return stringToUUID(rs.getString(columnIndex))
}
/**
* 从CallableStatement中根据列索引获取可空的UUID结果
*
* @param cs CallableStatement对象
* @param columnIndex 列索引
* @return UUID对象或null
*/
override fun getNullableResult(
cs: CallableStatement, columnIndex: Int
): UUID? {
return stringToUUID(cs.getString(columnIndex))
}
}
/**
* JDBC类型转换 UUID java UUID
* @author MingLiQiye
* @date 2025/9/12
*/
@MappedTypes(UUID::class)
@MappedJdbcTypes(JdbcType.OTHER)
class UUIDTypeHandler : BaseTypeHandler<UUID>() {
/**
* 设置非空参数到PreparedStatement中
*
* @param ps PreparedStatement对象
* @param i 参数索引
* @param parameter UUID参数值
* @param jdbcType JDBC类型
*/
override fun setNonNullParameter(
ps: PreparedStatement, i: Int, parameter: UUID, jdbcType: JdbcType?
) {
ps.setObject(i, parameter.getUuid())
}
/**
* 从ResultSet中根据列名获取可空的UUID结果
*
* @param rs ResultSet对象
* @param columnName 列名
* @return UUID对象或null
*/
override fun getNullableResult(
rs: ResultSet,
columnName: String
): UUID? {
return juuidToUUID(rs.getObject(columnName, JUUID::class.java) as JUUID)
}
/**
* 从ResultSet中根据列索引获取可空的UUID结果
*
* @param rs ResultSet对象
* @param columnIndex 列索引
* @return UUID对象或null
*/
override fun getNullableResult(rs: ResultSet, columnIndex: Int): UUID? {
return juuidToUUID(rs.getObject(columnIndex, JUUID::class.java) as JUUID)
}
/**
* 从CallableStatement中根据列索引获取可空的UUID结果
*
* @param cs CallableStatement对象
* @param columnIndex 列索引
* @return UUID对象或null
*/
override fun getNullableResult(
cs: CallableStatement, columnIndex: Int
): UUID? {
return juuidToUUID(cs.getObject(columnIndex, JUUID::class.java) as JUUID)
}
}
@@ -1,119 +0,0 @@
/*
* Copyright 2025 mingliqiye
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* ProjectName mingli-utils
* ModuleName mingli-utils.main
* CurrentFile MysqlUUIDBinaryTypeHandler.kt
* LastUpdate 2025-09-15 13:54:29
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.mybatis.typehandler.uuid.mysql
import com.mingliqiye.utils.uuid.UUID
import com.mingliqiye.utils.uuid.mysqlToUuid
import com.mingliqiye.utils.uuid.uuidToMysql
import org.apache.ibatis.type.BaseTypeHandler
import org.apache.ibatis.type.JdbcType
import org.apache.ibatis.type.MappedTypes
import java.sql.CallableStatement
import java.sql.PreparedStatement
import java.sql.ResultSet
/**
* JDBC类型转换 UUID
* @author MingLiQiye
* @date 2025/9/12
*/
@MappedTypes(UUID::class)
class MysqlUUIDBinaryTypeHandler : BaseTypeHandler<UUID>() {
/**
* 将字节数组转换为UUID对象
*
* @param byteArray 字节数组
* @return UUID对象,如果字节数组为null则返回null
*/
private fun toUUID(byteArray: ByteArray?): UUID? {
return byteArray?.let { UUID.of(mysqlToUuid(it)) }
}
/**
* 将UUID对象转换为字节数组
*
* @param uuid UUID对象
* @return 字节数组,如果UUID为null则返回null
*/
fun toByteArray(uuid: UUID?): ByteArray? {
return uuid?.let { uuidToMysql(it.toBytes()) }
}
/**
* 设置非空参数到PreparedStatement中
*
* @param ps PreparedStatement对象
* @param i 参数索引
* @param parameter UUID参数值
* @param jdbcType JDBC类型
*/
override fun setNonNullParameter(
ps: PreparedStatement,
i: Int,
parameter: UUID,
jdbcType: JdbcType?
) {
ps.setBytes(i, toByteArray(parameter))
}
/**
* 从ResultSet中根据列名获取可空的UUID结果
*
* @param rs ResultSet对象
* @param columnName 列名
* @return UUID对象或null
*/
override fun getNullableResult(
rs: ResultSet,
columnName: String
): UUID? {
return toUUID(rs.getBytes(columnName))
}
/**
* 从ResultSet中根据列索引获取可空的UUID结果
*
* @param rs ResultSet对象
* @param columnIndex 列索引
* @return UUID对象或null
*/
override fun getNullableResult(rs: ResultSet, columnIndex: Int): UUID? {
return toUUID(rs.getBytes(columnIndex))
}
/**
* 从CallableStatement中根据列索引获取可空的UUID结果
*
* @param cs CallableStatement对象
* @param columnIndex 列索引
* @return UUID对象或null
*/
override fun getNullableResult(
cs: CallableStatement,
columnIndex: Int
): UUID? {
return toUUID(cs.getBytes(columnIndex))
}
}
@@ -0,0 +1,72 @@
/*
* Copyright 2026 mingliqiye
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* ProjectName mingli-utils
* ModuleName mingli-utils.main
* CurrentFile QueryWrapper.kt
* LastUpdate 2026-01-14 13:00:31
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.mybatisplus
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper
import com.baomidou.mybatisplus.core.mapper.BaseMapper
/**
* BaseMapperQuery接口扩展了BaseMapper,提供了通用的查询包装器功能
*
* @param T 实体类类型
*/
interface BaseMapperQuery<T> : BaseMapper<T> {
/**
* 创建并返回一个新的QueryWrapper实例
*
* @return QueryWrapper<T> 返回类型化的查询包装器实例
*/
fun queryWrapper(): QueryWrapper<T> {
return QueryWrapper<T>()
}
/**
* 创建并返回一个新的UpdateWrapper实例
*
* @return UpdateWrapper<T> 返回类型化的更新包装器实例
*/
fun updateWrapper(): UpdateWrapper<T> {
return UpdateWrapper<T>()
}
/**
* 创建并返回一个新的LambdaQueryWrapper实例
*
* @return LambdaQueryWrapper<T> 返回类型化的Lambda查询包装器实例
*/
fun lambdaQueryWrapper(): LambdaQueryWrapper<T> {
return LambdaQueryWrapper<T>()
}
/**
* 创建并返回一个新的LambdaUpdateWrapper实例
*
* @return LambdaUpdateWrapper<T> 返回类型化的Lambda更新包装器实例
*/
fun lambdaUpdateWrapper(): LambdaUpdateWrapper<T> {
return LambdaUpdateWrapper<T>()
}
}
@@ -0,0 +1,105 @@
/*
* Copyright 2026 mingliqiye
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* ProjectName mingli-utils
* ModuleName mingli-utils.main
* CurrentFile ClientScheduleReconnect.kt
* LastUpdate 2026-01-08 10:45:37
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.netty
import io.netty.bootstrap.Bootstrap
import io.netty.channel.Channel
import io.netty.channel.ChannelFuture
import io.netty.channel.ChannelFutureListener
import java.util.concurrent.TimeUnit
abstract class ClientScheduleReconnect(
protected val bootstrap: Bootstrap,
protected var delay: Long = 10L,
protected var timeUnit: TimeUnit = TimeUnit.SECONDS
) {
protected var isStop = false
protected var channel: Channel? = null
abstract fun onConnectedLog(channel: Channel)
abstract fun onConnectFailedLog(cause: Throwable?)
abstract fun onStoppedLog()
abstract fun doConnect(): ChannelFuture
open fun updateReconnectDelay(newDelay: Long, newTimeUnit: TimeUnit) {
require(newDelay > 0) { "Delay must be positive" }
this.delay = newDelay
this.timeUnit = newTimeUnit
}
open fun connect() {
doConnect().addListener(object : ChannelFutureListener {
override fun operationComplete(future: ChannelFuture) {
if (future.isSuccess) {
onConnected(future.channel())
} else {
onConnectFailed(future.cause())
}
}
})
}
open fun stop() {
isStop = true
disConnect()
}
open fun disConnect() {
channel?.close()
channel = null
}
open fun scheduleReconnect() {
if (isStop) {
onStoppedLog()
return
}
bootstrap.config().group().schedule({
if (isStop) {
onStoppedLog()
return@schedule
}
connect()
}, delay, timeUnit)
}
open fun onConnected(channel: Channel) {
this.channel = channel
onConnectedLog(channel)
channel.closeFuture().addListener { _ ->
scheduleReconnect()
}
}
open fun onConnectFailed(cause: Throwable?) {
onConnectFailedLog(cause)
scheduleReconnect()
}
open fun isConnected(): Boolean {
return channel?.isActive ?: false
}
}
@@ -0,0 +1,73 @@
/*
* Copyright 2026 mingliqiye
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* ProjectName mingli-utils
* ModuleName mingli-utils.main
* CurrentFile NamedThreadFactory.kt
* LastUpdate 2026-01-08 13:21:00
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.netty
import io.netty.util.concurrent.FastThreadLocalThread
import java.util.concurrent.ThreadFactory
import java.util.concurrent.atomic.AtomicInteger
open class NamedThreadFactory(private val getName: NamedThreadFactoryNameGetter) : ThreadFactory {
companion object {
@JvmStatic
private val allThreadPoolNumber = AtomicInteger(0)
@FunctionalInterface
fun interface NamedThreadFactoryNameGetter {
fun getName(clazz: Class<out NamedThreadFactory>, poolNumber: Int, threadNumber: Int): String
}
@JvmStatic
val defaultGetName =
NamedThreadFactoryNameGetter { clazz, poolNumber, threadNumber -> "${clazz.simpleName}-$poolNumber-$threadNumber" }
@JvmStatic
fun of(name: String): NamedThreadFactory {
return NamedThreadFactory { a, b, c ->
"$name-$c"
}
}
@JvmStatic
fun of(getter: NamedThreadFactoryNameGetter = defaultGetName): NamedThreadFactory {
return NamedThreadFactory(getter)
}
}
private val threadNumber = AtomicInteger(0)
private val threadPoolNumber = allThreadPoolNumber.addAndGet(1)
open fun getThreadName(clazz: Class<out NamedThreadFactory>, poolNumber: Int, threadNumber: Int) =
getName.getName(clazz, poolNumber, threadNumber)
override fun newThread(r: Runnable): Thread {
return FastThreadLocalThread(
null,
r,
getThreadName(this.javaClass, threadPoolNumber, threadNumber.addAndGet(1))
)
}
}
@@ -0,0 +1,81 @@
/*
* Copyright 2026 mingliqiye
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* ProjectName mingli-utils
* ModuleName mingli-utils.main
* CurrentFile NettyUtils.kt
* LastUpdate 2026-01-07 10:00:31
* UpdateUser MingLiPro
*/
@file:JvmName("NettyUtils")
package com.mingliqiye.utils.netty
import io.netty.buffer.ByteBuf
import io.netty.buffer.Unpooled
import java.nio.ByteBuffer
/**
* 将ByteBuffer转换为Netty的ByteBuf对象
*
* 该函数使用Netty库的Unpooled工具类将标准的java.nio.ByteBuffer包装成Netty的ByteBuf
* 以便在Netty框架中使用
*
* @receiver ByteBuffer 需要转换的原始ByteBuffer对象
* @return ByteBuf 转换后的Netty ByteBuf对象,该对象包装了原始的ByteBuffer
*/
fun ByteBuffer.toByteBuf(): ByteBuf {
return Unpooled.wrappedBuffer(this)
}
/**
* 将Netty的ByteBuf对象转换为ByteBuffer
*
* 该函数通过ByteBuf的nioBuffer()方法将Netty的ByteBuf转换为标准的java.nio.ByteBuffer
*
* @receiver ByteBuf 需要转换的原始ByteBuf对象
* @return ByteBuffer 转换后的java.nio.ByteBuffer对象
*/
fun ByteBuf.toByteBuffer(): ByteBuffer {
return this.nioBuffer()
}
/**
* 将Netty的ByteBuf对象转换为字节数组
*
* 该函数将ByteBuf中的可读字节读取到一个新的字节数组中
*
* @receiver ByteBuf 需要转换的原始ByteBuf对象
* @return ByteArray 转换后的字节数组,包含ByteBuf中所有可读的字节数据
*/
fun ByteBuf.toByteArray(): ByteArray {
val array = ByteArray(this.readableBytes())
this.readBytes(array)
return array
}
/**
* 将字节数组转换为Netty的ByteBuf对象
*
* 该函数使用Netty库的Unpooled工具类将字节数组包装成Netty的ByteBuf
* 以便在Netty框架中使用
*
* @receiver ByteArray 需要转换的原始字节数组
* @return ByteBuf 转换后的Netty ByteBuf对象,该对象包装了原始的字节数组
*/
fun ByteArray.toByteBuf(): ByteBuf {
return Unpooled.wrappedBuffer(this)
}
@@ -1,5 +1,5 @@
/* /*
* Copyright 2025 mingliqiye * Copyright 2026 mingliqiye
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@@ -16,16 +16,18 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile AddressPort.kt * CurrentFile AddressPort.kt
* LastUpdate 2025-09-15 22:01:27 * LastUpdate 2026-01-06 14:03:47
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
package com.mingliqiye.utils.network package com.mingliqiye.utils.network
import com.mingliqiye.utils.string.join
import java.io.Serializable import java.io.Serializable
import java.net.InetAddress import java.net.InetAddress
import java.net.InetSocketAddress import java.net.InetSocketAddress
import java.net.UnknownHostException import java.net.UnknownHostException
import java.nio.ByteBuffer
import java.util.regex.Pattern import java.util.regex.Pattern
/** /**
@@ -80,6 +82,20 @@ class NetworkAddress private constructor(domip: String) : Serializable {
return NetworkAddress(domip) return NetworkAddress(domip)
} }
@JvmStatic
fun ofIpv4(byteBuffer: ByteBuffer): NetworkAddress {
val byteArray = ByteArray(4)
byteBuffer.get(byteArray)
return ofIpv4(byteArray)
}
@JvmStatic
fun ofIpv4(byteArray: ByteArray): NetworkAddress {
return of(".".join(byteArray.map {
(it.toInt() and 0xFF).toString()
}))
}
/** /**
* 静态工厂方法,通过 InetAddress 创建 NetworkAddress 实例。 * 静态工厂方法,通过 InetAddress 创建 NetworkAddress 实例。
* *
@@ -182,6 +198,31 @@ class NetworkAddress private constructor(domip: String) : Serializable {
} }
} }
/**
* 将IPv4地址转换为字节数组
*
* @return 返回表示IPv4地址的4字节数组
* @throws NetworkException 当当前地址不是IPv4地址时抛出异常
*/
fun toIpv4ByteArray(): ByteArray {
// 验证地址类型是否为IPv4
if (iPv != IPV4) {
throw NetworkException("该地址 不是IPv4地址")
}
// 将IP地址字符串按点分割,转换为整数并进行位运算处理,最后转为字节数组
return ip!!.split(".").map { it.toInt() and 0xFF }.map { it.toByte() }.toByteArray()
}
/**
* 将IPv4地址写入到指定的ByteBuffer中
*
* @param byteBuffer 要写入的ByteBuffer对象,IPv4地址将以字节数组形式写入到该缓冲区
* @return 返回写入了IPv4地址的ByteBuffer对象,便于链式调用
*/
fun writeIpv4ToByteBuffer(byteBuffer: ByteBuffer): ByteBuffer {
return byteBuffer.put(toIpv4ByteArray())
}
/** /**
* 将当前 NetworkAddress 转换为 InetAddress 对象。 * 将当前 NetworkAddress 转换为 InetAddress 对象。
* *
@@ -215,7 +256,54 @@ class NetworkPort : Serializable {
this.port = port this.port = port
} }
fun toByteArray(): ByteArray {
val byteArray = ByteArray(2)
byteArray[0] = (port shr 8 and 0xFF).toByte()
byteArray[1] = (port and 0xFF).toByte()
return byteArray
}
fun writeToByteBuffer(byteBuffer: ByteBuffer): ByteBuffer {
return byteBuffer.put(toByteArray())
}
companion object { companion object {
/**
* 创建NetworkPort实例
* @param port 端口号
* @return NetworkPort实例
*/
@JvmStatic
fun of(port: Int): NetworkPort {
return NetworkPort(port)
}
/**
* 从字节数组创建NetworkPort实例
* @param byteArray 包含端口信息的字节数组(长度至少为2)
* @return NetworkPort实例
*/
@JvmStatic
fun of(byteArray: ByteArray): NetworkPort {
// 将字节数组的前两个字节转换为端口号
val port = ((byteArray[0].toInt() and 0xFF) shl 8) or (byteArray[1].toInt() and 0xFF)
return of(port)
}
/**
* 从ByteBuffer创建NetworkPort实例
* @param byteBuffer 包含端口信息的ByteBuffer
* @return NetworkPort实例
*/
@JvmStatic
fun of(byteBuffer: ByteBuffer): NetworkPort {
val byteArray = ByteArray(2)
byteBuffer.get(byteArray)
return of(byteArray)
}
@JvmStatic
fun testPort(port: Int) { fun testPort(port: Int) {
// 验证端口号范围是否在0-65535之间 // 验证端口号范围是否在0-65535之间
if (port !in 0..65535) { if (port !in 0..65535) {
@@ -282,6 +370,42 @@ class NetworkEndpoint private constructor(
return NetworkEndpoint(networkAddress, networkPort) return NetworkEndpoint(networkAddress, networkPort)
} }
/**
* 从字节数组创建IPv4网络端点
*
* @param byteArray 包含IPv4地址和端口信息的字节数组,前4个字节表示IP地址,后2个字节表示端口号
* @return NetworkEndpoint对象,封装了IPv4地址和端口信息
*/
@JvmStatic
fun ofIpv4(byteArray: ByteArray): NetworkEndpoint {
// 提取前4个字节作为IP地址
val address = ByteArray(4) {
byteArray[it]
}
// 提取后2个字节作为端口号
val portInt = ByteArray(2) {
byteArray[it + 4]
}
return NetworkEndpoint(NetworkAddress.ofIpv4(address), NetworkPort.of(portInt))
}
/**
* 从字节缓冲区创建IPv4网络端点实例
*
* 该方法从给定的ByteBuffer中读取数据,构建一个包含IPv4地址和端口的网络端点对象。
* 该方法按照协议顺序从缓冲区中读取IPv4地址数据和端口数据。
*
* @param byteBuffer 包含IPv4地址和端口数据的字节缓冲区,缓冲区中的数据应按照先地址后端口的顺序排列
* @return 返回一个NetworkEndpoint实例,包含从缓冲区解析出的IPv4地址和端口信息
*/
@JvmStatic
fun ofIpv4(byteBuffer: ByteBuffer): NetworkEndpoint {
return NetworkEndpoint(
NetworkAddress.ofIpv4(byteBuffer),
NetworkPort.of(byteBuffer)
)
}
/** /**
* 根据"host:port"格式的字符串创建NetworkEndpoint实例。 * 根据"host:port"格式的字符串创建NetworkEndpoint实例。
* 例如:"127.0.0.1:8080" * 例如:"127.0.0.1:8080"
@@ -327,7 +451,7 @@ class NetworkEndpoint private constructor(
* @return 包含详细信息的字符串 * @return 包含详细信息的字符串
*/ */
override fun toString(): String { override fun toString(): String {
return "NetworkEndpoint(IP=${networkAddress.ip},Port=${networkPort.port},Endpoint=${toHostPortString()})" return "NetworkEndpoint(IP=${networkAddress.ip},Port=${networkPort.port})"
} }
/** /**
@@ -347,4 +471,39 @@ class NetworkEndpoint private constructor(
fun port(): Int { fun port(): Int {
return networkPort.port return networkPort.port
} }
/**
* 将网络地址和端口转换为IPv4字节数组
*
* 该函数将当前对象的网络地址转换为IPv4字节数组,并与端口字节数组合并,
* 生成一个包含6个字节的数组,其中前4个字节为IPv4地址,后2个字节为端口号
*
* @return ByteArray 包含6个字节的数组,前4个字节为IPv4地址,后2个字节为端口号
*/
fun toIpv4ByteArray(): ByteArray {
val ipv4ByteArray = networkAddress.toIpv4ByteArray()
val portByteArray = networkPort.toByteArray()
// 构建包含IPv4地址和端口的6字节数组
val byteArray = ByteArray(6) {
if (it < 4) {
ipv4ByteArray[it]
} else {
portByteArray[it - 4]
}
}
return byteArray
}
/**
* 将IPv4地址和端口信息写入字节缓冲区
*
* 该函数依次将网络地址的IPv4表示和网络端口写入到指定的字节缓冲区中
*
* @param byteBuffer 要写入数据的目标字节缓冲区
*/
fun writeIpv4toByteBuffer(byteBuffer: ByteBuffer): ByteBuffer {
networkAddress.writeIpv4ToByteBuffer(byteBuffer)
networkPort.writeToByteBuffer(byteBuffer)
return byteBuffer
}
} }
@@ -16,7 +16,7 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile OsPath.kt * CurrentFile OsPath.kt
* LastUpdate 2025-09-15 08:59:15 * LastUpdate 2025-09-18 09:47:43
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@@ -26,9 +26,8 @@ package com.mingliqiye.utils.path
import java.io.File import java.io.File
import java.net.URI import java.net.URI
import java.nio.file.* import java.nio.file.Path
import java.util.* import java.nio.file.Paths
import java.util.function.Consumer
class OsPath private constructor(private val path: Path) : Path by path { class OsPath private constructor(private val path: Path) : Path by path {
@@ -58,48 +57,4 @@ class OsPath private constructor(private val path: Path) : Path by path {
return OsPath(Paths.get("")) return OsPath(Paths.get(""))
} }
} }
override fun getParent(): Path? {
var parent = path.parent
if (parent == null) {
parent = path.toAbsolutePath().parent
}
return parent
}
override fun toRealPath(vararg options: LinkOption): Path {
return OsPath(path.toRealPath(*options))
}
override fun register(watcher: WatchService, vararg events: WatchEvent.Kind<*>): WatchKey {
return path.register(watcher, *events)
}
override fun register(
watcher: WatchService,
events: Array<out WatchEvent.Kind<*>>,
vararg modifiers: WatchEvent.Modifier
): WatchKey {
return path.register(watcher, events, *modifiers)
}
override fun iterator(): MutableIterator<Path> {
return path.iterator()
}
override fun compareTo(other: Path): Int {
return path.compareTo(other)
}
override fun toString(): String {
return path.toString()
}
override fun forEach(action: Consumer<in Path>) {
path.forEach(action)
}
override fun spliterator(): Spliterator<Path> {
return path.spliterator()
}
} }
@@ -16,7 +16,7 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile RandomBytes.kt * CurrentFile RandomBytes.kt
* LastUpdate 2025-09-15 22:27:36 * LastUpdate 2025-09-16 17:42:26
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@file:JvmName("RandomBytes") @file:JvmName("RandomBytes")
@@ -82,9 +82,10 @@ fun randomByteNoHave(from: Byte, to: Byte): Byte {
} }
val secureRandom: SecureRandom by lazy { val secureRandom: SecureRandom by lazy {
SecureRandom() SecureRandom.getInstanceStrong()
} }
fun randomByteSecure(size: Int): ByteArray { fun randomByteSecure(size: Int): ByteArray {
val bytes = ByteArray(size) val bytes = ByteArray(size)
secureRandom.nextBytes(bytes) secureRandom.nextBytes(bytes)
@@ -0,0 +1,225 @@
/*
* Copyright 2026 mingliqiye
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* ProjectName mingli-utils
* ModuleName mingli-utils.main
* CurrentFile Require.kt
* LastUpdate 2026-01-10 09:01:03
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.request
import com.mingliqiye.utils.functions.P1RFunction
import com.mingliqiye.utils.functions.RFunction
/**
* 扩展函数:基于布尔值创建Require对象,并指定异常消息和异常构造器
* @param message 异常消息
* @param exception 异常构造器函数
* @return Require对象
*/
fun Boolean.require(message: String, exception: P1RFunction<String, out Exception>): Require {
return Require(this, message, exception)
}
/**
* 扩展函数:基于布尔值创建Require对象,并指定异常消息和异常类型
* @param message 异常消息
* @param exception 异常类型,默认为IllegalArgumentException
* @return Require对象
*/
fun Boolean.require(
message: String,
exception: Class<out Exception> = IllegalArgumentException::class.java
): Require {
return Require(this, message, exception)
}
/**
* 条件检查工具类,用于验证条件并抛出相应异常
* @param must 需要验证的布尔条件
*/
class Require(private val must: Boolean) {
/**
* 构造函数:通过函数调用结果初始化条件检查器
* @param funs 返回布尔值的函数
*/
constructor(funs: RFunction<Boolean>) : this(funs.call())
/**
* 构造函数:通过函数调用结果初始化条件检查器,并立即执行检查
* @param must 返回布尔值的函数
* @param message 检查失败时的异常消息
*/
constructor(must: RFunction<Boolean>, message: String) : this(must) {
throws(message)
}
/**
* 构造函数:通过函数调用结果初始化条件检查器,并立即执行检查
* @param must 返回布尔值的函数
* @param message 检查失败时的异常消息
* @param exception 检查失败时抛出的异常类型,默认为IllegalArgumentException
*/
constructor(
must: RFunction<Boolean>,
message: String,
exception: Class<out Exception> = IllegalArgumentException::class.java
) : this(must) {
throws(message, exception)
}
/**
* 构造函数:通过布尔值初始化条件检查器,并立即执行检查
* @param must 需要验证的布尔条件
* @param message 检查失败时的异常消息
*/
constructor(must: Boolean, message: String) : this(must) {
throws(message)
}
/**
* 构造函数:通过布尔值初始化条件检查器,并立即执行检查
* @param must 需要验证的布尔条件
* @param message 检查失败时的异常消息
* @param exception 检查失败时抛出的异常类型,默认为IllegalArgumentException
*/
constructor(
must: Boolean, message: String, exception: Class<out Exception> = IllegalArgumentException::class.java
) : this(must) {
throws(message, exception)
}
/**
* 构造函数:通过布尔值初始化条件检查器,并立即执行检查
* @param must 需要验证的布尔条件
* @param message 检查失败时的异常消息
* @param exception 检查失败时抛出的异常构造器函数
*/
constructor(
must: Boolean, message: String, exception: P1RFunction<String, out Exception>
) : this(must) {
throws(message, exception)
}
companion object {
/**
* 工厂方法:创建Require对象并指定异常消息和异常类型
* @param must 需要验证的布尔条件
* @param message 检查失败时的异常消息
* @param exception 检查失败时抛出的异常类型,默认为IllegalArgumentException
* @return Require对象
*/
@JvmStatic
fun require(
must: Boolean, message: String, exception: Class<out Exception> = IllegalArgumentException::class.java
): Require {
return Require(must, message, exception)
}
/**
* 工厂方法:创建Require对象并指定异常消息
* @param must 需要验证的布尔条件
* @param message 检查失败时的异常消息
* @return Require对象
*/
@JvmStatic
fun require(must: Boolean, message: String): Require {
return Require(must, message)
}
/**
* 工厂方法:创建Require对象
* @param must 需要验证的布尔条件
* @return Require对象
*/
@JvmStatic
fun require(must: Boolean): Require {
return Require(must)
}
/**
* 工厂方法:创建Require对象并指定异常消息和异常类型
* @param must 返回布尔值的函数
* @param message 检查失败时的异常消息
* @param exception 检查失败时抛出的异常类型,默认为IllegalArgumentException
* @return Require对象
*/
@JvmStatic
fun require(
must: RFunction<Boolean>,
message: String,
exception: Class<out Exception> = IllegalArgumentException::class.java
): Require {
return Require(must, message, exception)
}
/**
* 工厂方法:创建Require对象并指定异常消息
* @param must 返回布尔值的函数
* @param message 检查失败时的异常消息
* @return Require对象
*/
@JvmStatic
fun require(must: RFunction<Boolean>, message: String): Require {
return Require(must, message)
}
/**
* 工厂方法:创建Require对象
* @param must 返回布尔值的函数
* @return Require对象
*/
@JvmStatic
fun require(must: RFunction<Boolean>): Require {
return Require(must)
}
}
/**
* 执行条件检查,如果条件为false则抛出IllegalArgumentException
* @param message 检查失败时的异常消息
*/
fun throws(message: String) {
if (!must) {
throw IllegalArgumentException(message)
}
}
/**
* 执行条件检查,如果条件为false则抛出指定类型的异常
* @param string 检查失败时的异常消息
* @param exception 检查失败时抛出的异常类型
*/
fun throws(string: String, exception: Class<out Exception>) {
if (!must) {
throw exception.getConstructor(String::class.java).newInstance(string)
}
}
/**
* 执行条件检查,如果条件为false则抛出由函数构造的异常
* @param string 检查失败时的异常消息
* @param exception 检查失败时抛出的异常构造器函数
*/
fun throws(string: String, exception: P1RFunction<String, out Exception>) {
if (!must) {
throw exception.call(string)
}
}
}
@@ -0,0 +1,87 @@
/*
* Copyright 2025 mingliqiye
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* ProjectName mingli-utils
* ModuleName mingli-utils.main
* CurrentFile ResourceUtils.kt
* LastUpdate 2025-09-20 10:26:47
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.resource
import java.io.IOException
class ResourceUtils {
companion object {
@JvmStatic
@Throws(IOException::class)
fun getResource(resourceName: String): ByteArray {
return getResource(resourceName, ResourceUtils::class.java)
}
@JvmStatic
@Throws(IOException::class)
fun getResource(resourceName: String, clazz: Class<*>): ByteArray {
return clazz.getResourceAsStream(resourceName)?.use {
it.readBytes()
} ?: throw IOException("Resource not found: $resourceName")
}
@JvmStatic
@Throws(IOException::class)
fun getStringResource(resourceName: String): String {
return getStringResource(resourceName, ResourceUtils::class.java)
}
@JvmStatic
@Throws(IOException::class)
fun getStringResource(resourceName: String, clazz: Class<*>): String {
return clazz.getResourceAsStream(resourceName)?.use {
it.readBytes().toString(charset = Charsets.UTF_8)
} ?: throw IOException("Resource not found: $resourceName")
}
@JvmStatic
@Throws(IOException::class)
fun getStringResourceCallers(resourceName: String): String {
return getStringResource(resourceName, getCallerClass())
}
@JvmStatic
@Throws(IOException::class)
fun getResourceCallers(resourceName: String): ByteArray {
return getResource(resourceName, getCallerClass())
}
private fun getCallerClass(): Class<*> {
val stackTrace = Thread.currentThread().stackTrace
for (i in 2 until stackTrace.size) {
val className = stackTrace[i].className
try {
val clazz = Class.forName(className)
if (clazz != ResourceUtils::class.java && clazz != Companion::class.java) {
return clazz
}
} catch (e: ClassNotFoundException) {
continue
}
}
return ResourceUtils::class.java
}
}
}
@@ -16,7 +16,7 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile AesUtils.kt * CurrentFile AesUtils.kt
* LastUpdate 2025-09-15 22:32:50 * LastUpdate 2025-09-19 20:18:09
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@@ -51,10 +51,4 @@ fun encryptAesGcmNoPadding(src: String, key: String, iv: ByteArray): ByteArray {
return encryptAesGcmNoPadding(src.toByteArray(), key.toByteArray(), iv) return encryptAesGcmNoPadding(src.toByteArray(), key.toByteArray(), iv)
} }
fun main() {
val iv = getRandomBytes(16)
println(encryptAesGcmNoPadding("mingliqiye", "key", iv))
}
@@ -16,7 +16,7 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile AutoConfiguration.kt * CurrentFile AutoConfiguration.kt
* LastUpdate 2025-09-15 22:20:25 * LastUpdate 2025-09-20 10:47:00
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@@ -34,7 +34,7 @@ import java.io.IOException
@org.springframework.boot.autoconfigure.AutoConfiguration @org.springframework.boot.autoconfigure.AutoConfiguration
@ComponentScan( @ComponentScan(
"com.mingliqiye.utils.bean.springboot", "com.mingliqiye.utils.springboot.bean",
"com.mingliqiye.utils.springboot.converters" "com.mingliqiye.utils.springboot.converters"
) )
open class AutoConfiguration { open class AutoConfiguration {
@@ -54,10 +54,7 @@ open class AutoConfiguration {
fun printBanner() { fun printBanner() {
val bannerBuilder = StringBuilder(banner) val bannerBuilder = StringBuilder(banner)
try { try {
val inputStream = AutoConfiguration::class.java.getResourceAsStream("/META-INF/meta-data") val inputStream = AutoConfiguration::class.java.getResourceAsStream("/META-INF/meta-data") ?: return
if (inputStream == null) {
return
}
inputStream.use { stream -> inputStream.use { stream ->
var readlen: Int var readlen: Int
val buffer = ByteArray(1024) val buffer = ByteArray(1024)
@@ -16,11 +16,11 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile SpringBeanUtils.kt * CurrentFile SpringBeanUtils.kt
* LastUpdate 2025-09-15 22:32:50 * LastUpdate 2025-09-19 20:07:08
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
package com.mingliqiye.utils.bean.springboot package com.mingliqiye.utils.springboot.bean
import org.springframework.beans.BeansException import org.springframework.beans.BeansException
import org.springframework.context.ApplicationContext import org.springframework.context.ApplicationContext
@@ -0,0 +1,29 @@
/*
* Copyright 2026 mingliqiye
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* ProjectName mingli-utils
* ModuleName mingli-utils.main
* CurrentFile StreamEmptyException.kt
* LastUpdate 2026-01-07 19:13:29
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.stream
class StreamEmptyException : RuntimeException {
constructor(message: String) : super(message)
constructor(message: String, cause: Throwable) : super(message, cause)
}
@@ -1,122 +0,0 @@
/*
* Copyright 2025 mingliqiye
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* ProjectName mingli-utils
* ModuleName mingli-utils.main
* CurrentFile SuperStream.kt
* LastUpdate 2025-09-15 17:17:48
* UpdateUser MingLiPro
*/
@file:JvmName("Colls")
package com.mingliqiye.utils.stream
import java.util.stream.Collector
import java.util.stream.Collectors
import java.util.stream.Stream
class SuperStream<T> private constructor(val stream: Stream<T>) : Stream<T> by stream {
companion object {
@JvmStatic
fun <T> of(stream: Stream<T>): SuperStream<T> {
return SuperStream(stream)
}
@JvmStatic
fun <T> of(collection: Collection<T>): SuperStream<T> {
return SuperStream(collection.stream())
}
@JvmStatic
fun <T : Map<K, V>, K, V> of(map: T): SuperStream<Map.Entry<K, V>> {
return of(map.entries)
}
@JvmStatic
fun <T> of(vararg array: T): SuperStream<T> {
return of(array.toList())
}
@JvmStatic
fun <T> of(iterator: Iterator<T>): SuperStream<T> {
val data = ArrayList<T>(20)
while (iterator.hasNext()) {
data.add(iterator.next())
}
return of(data)
}
}
}
interface Gettable<T> {
fun get(): T
}
interface KeyGettable<T> : Gettable<T> {
fun getKey(): T
override fun get(): T {
return getKey()
}
}
interface IdGettable<T> : Gettable<T> {
fun getId(): T
override fun get(): T {
return getId()
}
}
fun <T> getThis(t: T): T {
return t
}
fun <T, U> toMapValueThis(valueMapper: java.util.function.Function<in T, out U>): Collector<T, *, Map<T, U>> {
return Collectors.toMap(
java.util.function.Function<T, T> { it },
valueMapper
) as Collector<T, *, Map<T, U>>
}
fun <T, K> toMap(keyMapper: java.util.function.Function<in T, out K>): Collector<T, *, Map<K, T>> {
return Collectors.toMap(
keyMapper,
java.util.function.Function<T, T> { it },
) as Collector<T, *, Map<K, T>>
}
fun <K> toMapGet(): Collector<Gettable<K>, *, Map<K, Gettable<K>>> {
return Collectors.toMap(
java.util.function.Function<Gettable<K>, K> { it.get() },
java.util.function.Function<Gettable<K>, Gettable<K>> { it },
) as Collector<Gettable<K>, *, Map<K, Gettable<K>>>
}
fun <K, V> toMap(): Collector<Map.Entry<K, V>, *, Map<K, V>> {
return Collectors.toMap(
{ entry: Map.Entry<K, V> -> entry.key },
{ entry: Map.Entry<K, V> -> entry.value }
) as Collector<Map.Entry<K, V>, *, Map<K, V>>
}
fun <T> toList(): Collector<T, *, List<T>> {
return Collectors.toList<T>()
}
fun <T> toSet(): Collector<T, *, Set<T>> {
return Collectors.toSet<T>()
}
@@ -16,7 +16,7 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile StringUtils.kt * CurrentFile StringUtils.kt
* LastUpdate 2025-09-15 22:32:50 * LastUpdate 2025-09-18 09:26:41
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@file:JvmName("StringUtils") @file:JvmName("StringUtils")
@@ -28,14 +28,17 @@ import com.mingliqiye.utils.logger.mingLiLoggerFactory
val log = mingLiLoggerFactory.getLogger("StringUtils") val log = mingLiLoggerFactory.getLogger("StringUtils")
val NULLISH_STRINGS = setOf("null", "NaN", "undefined", "None", "none")
/** /**
* 判断`字符串`是否为空 * 判断`字符串`是否为空
* *
* @param str 待判断的字符串 * @param str 待判断的字符串
* @return `true`: 空 `false`: 非空 * @return `true`: 空 `false`: 非空
*/ */
fun isEmpty(str: String?): Boolean { @JvmName("isEmpty")
return str?.isEmpty() != null fun String?.isNullish(): Boolean {
return this == null || this.isBlank() || this in NULLISH_STRINGS
} }
/** /**
@@ -163,12 +166,51 @@ fun String.stringBuilder(): java.lang.StringBuilder {
return StringBuilder(this) return StringBuilder(this)
} }
/**
* 将字符串按照指定分隔符进行分割
* @param str 需要分割的字符串
* @param separator 分割符
* @return 分割后的字符串列表
*/
fun split(str: String, separator: String): List<String> { fun split(str: String, separator: String): List<String> {
return str.split(separator) return str.split(separator)
} }
fun List<String>.join(separator: String): String { /**
return this.joinToString(separator) * 将列表中的元素使用指定分隔符连接成字符串
* @param separator 连接分隔符
* @param getstring 转换函数,将列表元素转换为字符串,默认使用toString()方法
* @return 连接后的字符串
*/
fun <T> List<T>.join(separator: String, getstring: (T) -> String = { it.toString() }): String {
// 使用StringBuilder构建结果字符串
val sb = StringBuilder()
for (i in this.indices) {
sb.append(this[i])
// 除了最后一个元素外,都在后面添加分隔符
if (i != this.size - 1) {
sb.append(separator)
}
}
return sb.toString()
}
/**
* 使用当前字符串作为分隔符,将列表中的元素连接成字符串
* @param list 需要连接的元素列表
* @param getstring 转换函数,将列表元素转换为字符串,默认使用toString()方法
* @return 连接后的字符串
*/
fun <T> String.join(list: List<T>, getstring: (T) -> String = { it.toString() }): String {
// 使用StringBuilder构建结果字符串
val sb = StringBuilder()
for (i in list.indices) {
sb.append(getstring(list[i]))
// 除了最后一个元素外,都在后面添加当前字符串作为分隔符
if (i != list.size - 1) {
sb.append(this)
}
}
return sb.toString()
} }
@@ -16,13 +16,14 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile SystemUtil.kt * CurrentFile SystemUtil.kt
* LastUpdate 2025-09-15 22:19:57 * LastUpdate 2025-09-16 17:36:11
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@file:JvmName("SystemUtils") @file:JvmName("SystemUtils")
package com.mingliqiye.utils.system package com.mingliqiye.utils.system
import com.mingliqiye.utils.random.randomByteSecure
import java.lang.management.ManagementFactory import java.lang.management.ManagementFactory
import java.net.Inet4Address import java.net.Inet4Address
import java.net.InetAddress import java.net.InetAddress
@@ -273,3 +274,104 @@ private fun getEnvVar(name: String): String? {
null null
} }
} }
/**
* 获取本机MAC地址的字节数组形式
*
* @return MAC地址字节数组,如果无法获取则返回空数组
*/
val macAddressBytes: ByteArray by lazy {
try {
val interfaces = NetworkInterface.getNetworkInterfaces()
while (interfaces.hasMoreElements()) {
val networkInterface = interfaces.nextElement()
// 跳过回环接口和虚拟接口
if (networkInterface.isLoopback || networkInterface.isVirtual || !networkInterface.isUp) {
continue
}
val mac = networkInterface.hardwareAddress
if (mac != null && mac.isNotEmpty()) {
return@lazy mac
}
}
randomByteSecure(6)
} catch (e: SocketException) {
randomByteSecure(6)
} catch (e: Exception) {
randomByteSecure(6)
}
}
/**
* 获取本机MAC地址的十六进制字符串列表形式
*
* @return MAC地址字符串列表,每个元素表示一个字节的十六进制值(大写),如果无法获取则返回空列表
*/
val macAddressStringList: List<String> by lazy {
val macBytes = macAddressBytes
if (macBytes.isEmpty()) {
return@lazy emptyList()
}
macBytes.map { String.format("%02X", it) }
}
/**
* 获取本机MAC地址的格式化字符串形式(如 "00:11:22:33:44:55")
*
* @return 格式化的MAC地址字符串,如果无法获取则返回空字符串
*/
val macAddressFormattedString: String by lazy {
val macBytes = macAddressBytes
if (macBytes.isEmpty()) {
return@lazy ""
}
macBytes.joinToString(":") { String.format("%02X", it) }
}
/**
* 获取所有网络接口的MAC地址映射
*
* @return Map结构,key为网络接口名称,value为对应的MAC地址字节数组
*/
val allMacAddresses: Map<String, ByteArray> by lazy {
try {
val result = mutableMapOf<String, ByteArray>()
val interfaces = NetworkInterface.getNetworkInterfaces()
while (interfaces.hasMoreElements()) {
val networkInterface = interfaces.nextElement()
// 跳过回环接口和虚拟接口
if (networkInterface.isLoopback || networkInterface.isVirtual) {
continue
}
val mac = networkInterface.hardwareAddress
if (mac != null && mac.isNotEmpty()) {
result[networkInterface.name] = mac
}
}
result
} catch (e: SocketException) {
emptyMap()
} catch (e: Exception) {
emptyMap()
}
}
/**
* 获取所有网络接口的MAC地址字符串列表映射
*
* @return Map结构,key为网络接口名称,value为对应的MAC地址字符串列表
*/
val allMacAddressesStringList: Map<String, List<String>> by lazy {
allMacAddresses.mapValues { entry ->
entry.value.map { String.format("%02X", it) }
}
}
@@ -16,7 +16,7 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile DateTime.kt * CurrentFile DateTime.kt
* LastUpdate 2025-09-15 22:32:50 * LastUpdate 2025-09-17 19:06:39
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@@ -46,8 +46,7 @@ import kotlin.time.Instant
* @author MingLiPro * @author MingLiPro
*/ */
class DateTimeOffset private constructor( class DateTimeOffset private constructor(
val offsetType: ChronoUnit, val offsetType: ChronoUnit, val offset: Long
val offset: Long
) { ) {
companion object { companion object {
@@ -96,6 +95,8 @@ enum class Formatter(private val value: String) {
* 标准日期时间格式(7位毫秒):yyyy-MM-dd HH:mm:ss.SSSSSSS * 标准日期时间格式(7位毫秒):yyyy-MM-dd HH:mm:ss.SSSSSSS
*/ */
STANDARD_DATETIME_MILLISECOUND7("yyyy-MM-dd HH:mm:ss.SSSSSSS"), STANDARD_DATETIME_MILLISECOUND7("yyyy-MM-dd HH:mm:ss.SSSSSSS"),
STANDARD_DATETIME_MILLISECOUND8("yyyy-MM-dd HH:mm:ss.SSSSSSSS"),
STANDARD_DATETIME_MILLISECOUND9("yyyy-MM-dd HH:mm:ss.SSSSSSSSS"),
/** /**
* 标准日期时间格式(6位毫秒):yyyy-MM-dd HH:mm:ss.SSSSSS * 标准日期时间格式(6位毫秒):yyyy-MM-dd HH:mm:ss.SSSSSS
@@ -152,6 +153,7 @@ enum class Formatter(private val value: String) {
*/ */
COMPACT_DATETIME("yyyyMMddHHmmss"); COMPACT_DATETIME("yyyyMMddHHmmss");
private val len: Int = value.length private val len: Int = value.length
fun getLen(): Int { fun getLen(): Int {
@@ -179,15 +181,11 @@ enum class Formatter(private val value: String) {
* @see Instant * @see Instant
*/ */
class DateTime private constructor( class DateTime private constructor(
private var localDateTime: LocalDateTime, private var localDateTime: LocalDateTime, private val zoneId: ZoneId = ZoneId.systemDefault()
private val zoneId: ZoneId = ZoneId.systemDefault()
) : Serializable { ) : Serializable {
companion object { companion object {
private val WIN_KERNEL_32_API: WinKernel32Api? = if ( private val WIN_KERNEL_32_API: WinKernel32Api? = if (javaVersionAsInteger == 8 && isWindows) {
javaVersionAsInteger == 8 &&
isWindows
) {
val log: Logger = mingLiLoggerFactory.getLogger("mingli-utils DateTime") val log: Logger = mingLiLoggerFactory.getLogger("mingli-utils DateTime")
val a = getWinKernel32Apis() val a = getWinKernel32Apis()
@@ -219,9 +217,7 @@ class DateTime private constructor(
fun now(): DateTime { fun now(): DateTime {
if (WIN_KERNEL_32_API != null) { if (WIN_KERNEL_32_API != null) {
return DateTime( return DateTime(
WIN_KERNEL_32_API.getTime() WIN_KERNEL_32_API.getTime().atZone(ZoneId.systemDefault()).toLocalDateTime()
.atZone(ZoneId.systemDefault())
.toLocalDateTime()
) )
} }
return DateTime(LocalDateTime.now()) return DateTime(LocalDateTime.now())
@@ -273,9 +269,7 @@ class DateTime private constructor(
*/ */
@JvmStatic @JvmStatic
fun parse( fun parse(
timestr: String, timestr: String, formatter: String, fillZero: Boolean
formatter: String,
fillZero: Boolean
): DateTime { ): DateTime {
return DateTime( return DateTime(
LocalDateTime.parse( LocalDateTime.parse(
@@ -285,6 +279,20 @@ class DateTime private constructor(
) )
} }
@JvmStatic
fun parse(
timestr: String
): DateTime {
val formatterString = Formatter.STANDARD_DATETIME_MILLISECOUND9.getValue()
return DateTime(
LocalDateTime.parse(
getFillZeroByLen(timestr, formatterString),
DateTimeFormatter.ofPattern(formatterString)
)
)
}
/** /**
* 使用 Formatter 枚举解析时间字符串并生成 DateTime 实例。 * 使用 Formatter 枚举解析时间字符串并生成 DateTime 实例。
* *
@@ -295,9 +303,7 @@ class DateTime private constructor(
*/ */
@JvmStatic @JvmStatic
fun parse( fun parse(
timestr: String, timestr: String, formatter: Formatter, fillZero: Boolean
formatter: Formatter,
fillZero: Boolean
): DateTime { ): DateTime {
return parse(timestr, formatter.getValue(), fillZero) return parse(timestr, formatter.getValue(), fillZero)
} }
@@ -343,18 +349,14 @@ class DateTime private constructor(
modifiedDstr += "." modifiedDstr += "."
} }
val sb = StringBuilder(modifiedDstr) val sb = StringBuilder(modifiedDstr)
for (i in 0 until formats.length - dstr.length) { for (i in 0 until formats.length - sb.length) {
sb.append("0") sb.append("0")
} }
return sb.toString() return sb.toString()
} }
throw IllegalArgumentException( throw IllegalArgumentException(
String.format( String.format(
"Text: '%s' len %s < %s %s", "Text: '%s' len %s < %s %s", dstr, dstr.length, formats, formats.length
dstr,
dstr.length,
formats,
formats.length
) )
) )
} }
@@ -384,11 +386,7 @@ class DateTime private constructor(
*/ */
@JvmStatic @JvmStatic
fun of( fun of(
year: Int, year: Int, month: Int, day: Int, hour: Int, minute: Int
month: Int,
day: Int,
hour: Int,
minute: Int
): DateTime { ): DateTime {
return DateTime(LocalDateTime.of(year, month, day, hour, minute)) return DateTime(LocalDateTime.of(year, month, day, hour, minute))
} }
@@ -407,8 +405,7 @@ class DateTime private constructor(
// 2. 从纳秒时间戳创建 Instant // 2. 从纳秒时间戳创建 Instant
val instant = java.time.Instant.ofEpochSecond( val instant = java.time.Instant.ofEpochSecond(
unixNanos / 1_000_000_000L, unixNanos / 1_000_000_000L, unixNanos % 1_000_000_000L
unixNanos % 1_000_000_000L
) )
// 3. 转换为系统默认时区的 LocalDateTime // 3. 转换为系统默认时区的 LocalDateTime
@@ -428,12 +425,7 @@ class DateTime private constructor(
*/ */
@JvmStatic @JvmStatic
fun of( fun of(
year: Int, year: Int, month: Int, day: Int, hour: Int, minute: Int, second: Int
month: Int,
day: Int,
hour: Int,
minute: Int,
second: Int
): DateTime { ): DateTime {
return DateTime( return DateTime(
LocalDateTime.of(year, month, day, hour, minute, second) LocalDateTime.of(year, month, day, hour, minute, second)
@@ -454,13 +446,7 @@ class DateTime private constructor(
*/ */
@JvmStatic @JvmStatic
fun of( fun of(
year: Int, year: Int, month: Int, day: Int, hour: Int, minute: Int, second: Int, nano: Int
month: Int,
day: Int,
hour: Int,
minute: Int,
second: Int,
nano: Int
): DateTime { ): DateTime {
return DateTime( return DateTime(
LocalDateTime.of(year, month, day, hour, minute, second, nano) LocalDateTime.of(year, month, day, hour, minute, second, nano)
@@ -476,9 +462,14 @@ class DateTime private constructor(
@JvmStatic @JvmStatic
fun of(epochMilli: Long): DateTime { fun of(epochMilli: Long): DateTime {
return DateTime( return DateTime(
java.time.Instant.ofEpochMilli(epochMilli) java.time.Instant.ofEpochMilli(epochMilli).atZone(ZoneId.systemDefault()).toLocalDateTime()
.atZone(ZoneId.systemDefault()) )
.toLocalDateTime() }
@JvmStatic
fun of(seconds: Long, nanos: Long): DateTime {
return DateTime(
java.time.Instant.ofEpochSecond(seconds, nanos).atZone(ZoneId.systemDefault()).toLocalDateTime()
) )
} }
@@ -492,8 +483,7 @@ class DateTime private constructor(
@JvmStatic @JvmStatic
fun of(epochMilli: Long, zoneId: ZoneId): DateTime { fun of(epochMilli: Long, zoneId: ZoneId): DateTime {
return DateTime( return DateTime(
java.time.Instant.ofEpochMilli(epochMilli).atZone(zoneId).toLocalDateTime(), java.time.Instant.ofEpochMilli(epochMilli).atZone(zoneId).toLocalDateTime(), zoneId
zoneId
) )
} }
} }
@@ -525,8 +515,7 @@ class DateTime private constructor(
fun add(dateTimeOffset: DateTimeOffset): DateTime { fun add(dateTimeOffset: DateTimeOffset): DateTime {
return DateTime( return DateTime(
this.localDateTime.plus( this.localDateTime.plus(
dateTimeOffset.offset, dateTimeOffset.offset, dateTimeOffset.offsetType
dateTimeOffset.offsetType
) )
) )
} }
@@ -538,12 +527,7 @@ class DateTime private constructor(
* @return 返回修改后的 DateTime 实例 * @return 返回修改后的 DateTime 实例
*/ */
fun sub(dateTimeOffset: DateTimeOffset): DateTime { fun sub(dateTimeOffset: DateTimeOffset): DateTime {
return DateTime( return add(DateTimeOffset.of(-dateTimeOffset.offset, dateTimeOffset.offsetType))
this.localDateTime.plus(
-dateTimeOffset.offset,
dateTimeOffset.offsetType
)
)
} }
/** /**
@@ -566,6 +550,10 @@ class DateTime private constructor(
return format(formatter.getValue()) return format(formatter.getValue())
} }
fun format(): String {
return format(Formatter.STANDARD_DATETIME_MILLISECOUND9.getValue(), true)
}
/** /**
* 使用指定格式化模板将当前时间格式化为字符串,并可选择是否去除末尾多余的零。 * 使用指定格式化模板将当前时间格式化为字符串,并可选择是否去除末尾多余的零。
* *
@@ -602,10 +590,7 @@ class DateTime private constructor(
* @return 返回标准格式的时间字符串 * @return 返回标准格式的时间字符串
*/ */
override fun toString(): String { override fun toString(): String {
return String.format( return "DateTime(${format()})"
"DateTime(%s)",
format(Formatter.STANDARD_DATETIME_MILLISECOUND7, true)
)
} }
/** /**
@@ -675,4 +660,34 @@ class DateTime private constructor(
fun getZoneId(): ZoneId { fun getZoneId(): ZoneId {
return zoneId return zoneId
} }
/**
* 将 Instant 转换为纳秒时间戳
* @throws ArithmeticException 如果结果超出 Long 范围 (-2^63 到 2^63-1)
*/
fun toNanoTime(): Long {
val instant = toInstant()
return try {
val secondsInNanos = Math.multiplyExact(instant.epochSecond, 1_000_000_000L)
Math.addExact(secondsInNanos, instant.nano.toLong())
} catch (e: ArithmeticException) {
throw ArithmeticException(
"无法将 Instant(${instant.epochSecond}s, ${instant.nano}ns) 转换为纳秒: ${e.message}"
)
}
}
fun to100NanoTime(): Long {
return toInstant().let {
(it.epochSecond * 10_000_000L) + (it.nano / 100L)
}
}
fun toMillisecondTime(): Long {
return toInstant().let {
(it.epochSecond * 1000L) + (it.nano / 1_000_000L)
}
}
} }
@@ -1,5 +1,5 @@
/* /*
* Copyright 2025 mingliqiye * Copyright 2026 mingliqiye
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@@ -16,10 +16,10 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile MysqlUUIDv1.kt * CurrentFile MysqlUUIDv1.kt
* LastUpdate 2025-09-15 22:32:50 * LastUpdate 2026-01-08 08:22:14
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@file:JvmName("MysqlUUIDv1") @file:JvmName("MysqlUUIDConvertor")
package com.mingliqiye.utils.uuid package com.mingliqiye.utils.uuid
+609 -159
View File
@@ -1,5 +1,5 @@
/* /*
* Copyright 2025 mingliqiye * Copyright 2026 mingliqiye
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@@ -16,70 +16,195 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile UUID.kt * CurrentFile UUID.kt
* LastUpdate 2025-09-15 18:01:30 * LastUpdate 2026-01-08 13:21:00
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
package com.mingliqiye.utils.uuid package com.mingliqiye.utils.uuid
import com.github.f4b6a3.uuid.UuidCreator import com.mingliqiye.utils.base.BASE256
import com.mingliqiye.utils.base.BASE64
import com.mingliqiye.utils.base.BASE91
import com.mingliqiye.utils.random.randomByteSecure
import com.mingliqiye.utils.random.secureRandom
import com.mingliqiye.utils.system.macAddressBytes
import com.mingliqiye.utils.time.DateTime import com.mingliqiye.utils.time.DateTime
import com.mingliqiye.utils.time.DateTimeOffset import com.mingliqiye.utils.time.DateTimeOffset
import java.io.Serializable import java.io.Serializable
import java.nio.ByteBuffer import java.nio.ByteBuffer
import java.security.MessageDigest
import java.time.temporal.ChronoUnit import java.time.temporal.ChronoUnit
import java.util.*
import java.util.UUID as JUUID import java.util.UUID as JUUID
/**
* UUID 类用于生成和操作不同版本的 UUID(通用唯一标识符)。
* 支持 UUID 的序列化、转换、解析和时间/版本信息提取。
*/
class UUID : Serializable { class UUID : Serializable {
private val uuid: JUUID private val data: ByteArray
private val mostSigBits: Long
private val leastSigBits: Long
private val version: Int
companion object { companion object {
/** /**
* 获取 UUIDV1 版本的随机实例 * 预期 UUID 字符串中连字符的位置数组。
* @return UUID */
@JvmStatic
val expectedHyphenPositions = intArrayOf(8, 13, 18, 23)
/**
* UUID 纪元偏移量(以天为单位)。
*/
@JvmStatic
val UUID_EPOCH_OFFSET = 141427L
@JvmStatic
fun ofBase64ShortString(baseShortString: String): UUID {
return UUID(BASE64.decode(baseShortString))
}
@JvmStatic
fun ofBase256ShortString(baseShortString: String): UUID {
return UUID(BASE256.decode(baseShortString))
}
@JvmStatic
fun ofBase91ShortString(baseShortString: String): UUID {
return UUID(BASE91.decode(baseShortString))
}
/**
* 生成一个 UUID V1 版本,使用系统时钟、随机数和 MAC 地址。
* 如果 MAC 地址为空,则使用随机生成的 MAC 地址。
*
* @return UUID V1 实例
*/ */
@JvmStatic @JvmStatic
fun getV1(): UUID { fun getV1(): UUID {
return UUID(UuidCreator.getTimeBased()) val time = DateTime.now().add(DateTimeOffset.of(UUID_EPOCH_OFFSET, ChronoUnit.DAYS)).to100NanoTime()
val timeLow = (time and 0xFFFFFFFFL).toInt()
val timeMid = ((time shr 32) and 0xFFFFL).toShort()
val timeHighAndVersion = (((time shr 48) and 0x0FFFL) or 0x1000L).toShort()
val clockSeq = (secureRandom.nextInt(16384)) and 0x3FFF
val byteBuffer = ByteBuffer.wrap(ByteArray(16))
byteBuffer.putInt(timeLow)
byteBuffer.putShort(timeMid)
byteBuffer.putShort(timeHighAndVersion)
byteBuffer.putShort(clockSeq.toShort())
byteBuffer.put(macAddressBytes)
return UUID(byteBuffer.array())
} }
@Deprecated("使用 getV1()", ReplaceWith("getV1()"), level = DeprecationLevel.WARNING)
fun getTimeBased(): UUID = getV1()
/** /**
* 获取 UUIDV4 版本的随机实例 * 生成一个 UUID V4 版本,使用加密安全的随机数。
* @return UUID *
* @return UUID V4 实例
*/ */
@JvmStatic @JvmStatic
fun getV4(): UUID { fun getV4(): UUID {
return UUID(UuidCreator.getRandomBased()) val randomBytes = randomByteSecure(16)
randomBytes[6] = (randomBytes[6].toInt() and 0x0F).toByte()
randomBytes[6] = (randomBytes[6].toInt() or 0x40).toByte()
randomBytes[8] = (randomBytes[8].toInt() and 0x3F).toByte()
randomBytes[8] = (randomBytes[8].toInt() or 0x80).toByte()
return UUID(randomBytes)
} }
/** /**
* 获取 UUIDV1Fast 版本的随机实例 * 生成一个 UUID V3 版本,基于命名空间和名称的 MD5 哈希值。
* @return UUID *
* @param namepath 命名空间 UUID
* @param user 用户提供的字符串
* @return UUID V3 实例
*/ */
@JvmStatic @JvmStatic
fun getV4Fast(): UUID { fun getV3(namepath: UUID, user: String): UUID {
return UUID(UuidCreator.getRandomBasedFast()) val md = MessageDigest.getInstance("MD5")
val userB = user.toByteArray()
val array = md.digest(
ByteBuffer.wrap(ByteArray(16 + userB.size)).put(namepath.data).put(userB).array()
)
array[6] = (array[6].toInt() and 0x0F or 0x30).toByte()
array[8] = (array[8].toInt() and 0x3F or 0x80).toByte()
return UUID(array)
} }
/** /**
* 从2个8个字节转换到UUID * 生成一个 UUID V5 版本,基于命名空间和名称的 SHA-1 哈希值。
* @param lsb 高位 8 字节的 Long *
* @param msb 低位 8 字节的 Long * @param namepath 命名空间 UUID
* @return UUID * @param user 用户提供的字符串
* @return UUID V5 实例
*/ */
@JvmStatic @JvmStatic
fun of(msb: Long, lsb: Long): UUID { fun getV5(namepath: UUID, user: String): UUID {
return UUID(msb, lsb) val sha1 = MessageDigest.getInstance("SHA-1")
val userB = user.toByteArray()
val array = sha1.digest(
ByteBuffer.wrap(ByteArray(namepath.data.size + userB.size)).put(namepath.data).put(userB).array()
)
array[6] = (array[6].toInt() and 0x0F or 0x50).toByte()
array[8] = (array[8].toInt() and 0x3F or 0x80).toByte()
return UUID(ByteBuffer.wrap(ByteArray(16)).put(array, 0, 16).array())
} }
/** /**
* 从字符串格式化 * 生成一个 UUID V6 版本,使用时间戳和随机节点信息。
* @param uuid 字符串 *
* @return UUID * @return UUID V6 实例
*/
@JvmStatic
fun getV6(): UUID {
val timestamp = DateTime.now()
.add(DateTimeOffset.of(UUID_EPOCH_OFFSET, ChronoUnit.DAYS))
.to100NanoTime() and 0x0FFFFFFFFFFFFFFFL
val timeHigh = (timestamp ushr 12) and 0xFFFFFFFFFFFFL
val timeMid = timestamp and 0x0FFFL
val clockSeq = secureRandom.nextInt(16384) and 0x3FFF
val node = secureRandom.nextLong() and 0x0000FFFFFFFFFFFFL
val buffer = ByteBuffer.allocate(16)
buffer.putLong((timeHigh shl 16) or (0x6000L) or (timeMid and 0x0FFF))
buffer.putShort((0x8000 or (clockSeq and 0x3FFF)).toShort())
buffer.put((node shr 40).toByte())
buffer.put((node shr 32).toByte())
buffer.put((node shr 24).toByte())
buffer.put((node shr 16).toByte())
buffer.put((node shr 8).toByte())
buffer.put(node.toByte())
return UUID(buffer.array())
}
/**
* 生成一个 UUID V7 版本,使用毫秒级时间戳和随机数。
*
* @return UUID V7 实例
*/
@JvmStatic
fun getV7(): UUID {
val instant = DateTime.now().toMillisecondTime()
val buffer = ByteBuffer.allocate(16)
buffer.putInt((instant shr 16).toInt())
buffer.putShort((instant).toShort())
buffer.put(randomByteSecure(2))
buffer.putLong(secureRandom.nextLong())
val bytes = buffer.array()
bytes[6] = (bytes[6].toInt() and 0x0F or 0x70).toByte()
bytes[8] = (bytes[8].toInt() and 0x3F or 0x80).toByte()
return UUID(bytes)
}
/**
* 根据字符串创建 UUID 实例。
*
* @param uuid UUID 字符串
* @return UUID 实例
*/ */
@JvmStatic @JvmStatic
fun of(uuid: String): UUID { fun of(uuid: String): UUID {
@@ -87,135 +212,495 @@ class UUID : Serializable {
} }
/** /**
* 从Java的UUID * 根据字节数组创建 UUID 实例。
* @param uuid 字符串 *
* @return UUID * @param uuid UUID 字节数组
* @return UUID 实例
*/ */
@JvmStatic @JvmStatic
fun of(uuid: JUUID): UUID { fun of(uuid: ByteArray): UUID {
return UUID(uuid) return UUID(uuid)
} }
/** /**
* 从字节码转换到UUID * 根据高位和低位长整型创建 UUID 实例。
* @param array 16字节 *
* @return UUID * @param msb 高位长整型
* @param lsb 低位长整型
* @return UUID 实例
*/ */
@JvmStatic @JvmStatic
fun of(array: ByteArray): UUID { fun of(msb: Long, lsb: Long): UUID {
return UUID(array) return UUID(msb, lsb)
}
fun JUUID.toMlUUID(): UUID {
return of(this)
}
}
internal constructor(msb: Long, lsb: Long) {
uuid = JUUID(msb, lsb)
}
internal constructor(uuid: JUUID) {
this.uuid = uuid
}
internal constructor(array: ByteArray) {
val bb = ByteBuffer.wrap(array)
this.uuid = JUUID(bb.getLong(), bb.getLong())
}
constructor(uuid: String) {
this.uuid = JUUID.fromString(uuid)
}
/**
* 获取对应的字节码
* @return 字节码
*/
fun toBytes(): ByteArray {
val bb = ByteBuffer.wrap(ByteArray(16))
bb.putLong(uuid.mostSignificantBits)
bb.putLong(uuid.leastSignificantBits)
return bb.array()
} }
/** /**
* 获取Java的UUID对象 * 从ByteBuffer创建UUID对象
* @return Java的UUID对象
*/
fun getUuid(): JUUID {
return uuid
}
/**
* 将 UUID 转换为字符串表示,默认使用小写格式。
* @param u 是否大写
* @return UUID 字符串
*/
fun getString(u: Boolean): String {
return if (u) {
uuid.toString().uppercase(Locale.ROOT)
} else {
uuid.toString()
}
}
/**
* 将 UUID 转换为字符串表示,默认使用小写格式。
* *
* @return UUID 字符串 * @param byteBuffer 包含UUID字节数据的ByteBuffer对象,必须包含至少16个字节的数据
* @return 从ByteBuffer中读取的16个字节创建的UUID对象
*/ */
fun getString(): String { @JvmStatic
return getString(false) fun of(byteBuffer: ByteBuffer): UUID {
} val byte = ByteArray(16)
byteBuffer.get(byte)
@Deprecated("使用 getString()", ReplaceWith("getString"), level = DeprecationLevel.WARNING) return UUID(byte)
fun toUUIDString(): String {
return this.getString()
}
@Deprecated("使用 getString(u:Boolean)", ReplaceWith("getString(u)"), level = DeprecationLevel.WARNING)
fun toUUIDString(u: Boolean): String {
return this.getString(u)
} }
/** /**
* 从时间戳型 UUID 中提取时间戳并转换为 DateTime 对象。 * 根据 MySQL UUID 字节数组创建 UUID 实例。
* *
* @return 对应的 DateTime 对象;如果 不是 时间戳V1版本 返回 null * @param byteArray MySQL UUID 字节数组
* @return UUID 实例
*/ */
fun getDateTime(): DateTime? { @JvmStatic
if (uuid.version() != 1) { fun ofMysqlUUID(byteArray: ByteArray): UUID {
return null return UUID(mysqlToUuid(byteArray))
} }
return DateTime.of(uuid.timestamp() / 10000).add(
DateTimeOffset.of(-141427L, ChronoUnit.DAYS) /**
* 根据 MySQL UUID 实例创建 UUID 实例。
*
* @param uuid MySQL UUID 实例
* @return UUID 实例
*/
@JvmStatic
fun ofMysqlUUID(uuid: UUID): UUID {
return UUID(mysqlToUuid(uuid.data))
}
/**
* 获取最大 UUID(所有字节为 0xFF)。
*
* @return 最大 UUID 实例
*/
@JvmStatic
fun getMaxUUID(): UUID {
return UUID(
ByteArray(
16
) { 0xFF.toByte() }
) )
} }
/** /**
* 从时间戳型 UUID 中提取 MAC 地址,默认使用冒号分隔符。 * 获取最小 UUID(所有字节为 0x00)。
* *
* @return MAC 地址字符串 * @return 最小 UUID 实例
*/ */
fun extractMACFromUUID(): String { @JvmStatic
return extractMACFromUUID(null) fun getMinUUID(): UUID {
return UUID(
ByteArray(
16
) { 0x00.toByte() }
)
} }
/** /**
* 从时间戳型 UUID 中提取 MAC 地址,并允许自定义分隔符。 * 将 Java UUID 转换为自定义 UUID 实例。
*
* @receiver Java UUID 实例
* @return 自定义 UUID 实例
*/
@JvmStatic
@JvmName("ofJUUID")
fun JUUID.toMLUUID(): UUID {
return UUID(this)
}
/**
* 从字符串解析 UUID 字节数组。
*
* @param uuidString UUID 字符串
* @return UUID 字节数组
*/
private fun fromString(uuidString: String): ByteArray {
val cleanStr = when (uuidString.length) {
36 -> {
for (i in expectedHyphenPositions) {
if (uuidString[i] != '-') {
throw IllegalArgumentException("Invalid UUID string: $uuidString at index $i")
}
}
uuidString.replace("-", "")
}
32 -> uuidString
else -> throw IllegalArgumentException("Invalid UUID string: $uuidString")
}
// 直接按索引提取各段并校验
val segments = arrayOf(
cleanStr.take(8),
cleanStr.substring(8, 12),
cleanStr.substring(12, 16),
cleanStr.substring(16, 20),
cleanStr.substring(20, 32)
)
for (segment in segments) {
if (!segment.matches(Regex("^[0-9A-Fa-f]+$"))) {
throw IllegalArgumentException("Invalid UUID segment: $segment")
}
}
return cleanStr.chunked(2).map { it.toInt(16).toByte() }.toByteArray()
}
/**
* 将 MAC 地址字节数组转换为长整型。
*
* @param mac MAC 地址字节数组(必须为 6 字节)
* @return MAC 地址对应的长整型值
*/
private fun macBytesToLong(mac: ByteArray): Long {
require(mac.size == 6) { "MAC地址必须是6字节" }
var result = 0L
for (i in 0 until 6) {
result = (result shl 8) or (mac[i].toLong() and 0xFF)
}
return result
}
}
/**
* 构造函数,根据字节数组初始化 UUID。
*
* @param data UUID 字节数组(必须为 16 字节)
*/
constructor(data: ByteArray) {
require(data.size == 16) { "UUID byte array length must be 16" }
this.data = data
val bb: ByteBuffer = ByteBuffer.wrap(data)
mostSigBits = bb.long
leastSigBits = bb.long
version = (mostSigBits shr 12 and 0xF).toInt()
}
/**
* 构造函数,根据高位和低位长整型初始化 UUID。
*
* @param msb 高位长整型
* @param lsb 低位长整型
*/
constructor(msb: Long, lsb: Long) {
mostSigBits = msb
leastSigBits = lsb
val bb: ByteBuffer = ByteBuffer.wrap(ByteArray(16))
bb.putLong(msb)
bb.putLong(lsb)
this.data = bb.array()
version = (mostSigBits shr 12 and 0xF).toInt()
}
/**
* 构造函数,根据 Java UUID 初始化自定义 UUID。
*
* @param juuid Java UUID 实例
*/
constructor(juuid: JUUID) {
mostSigBits = juuid.mostSignificantBits
leastSigBits = juuid.leastSignificantBits
val bb: ByteBuffer = ByteBuffer.wrap(ByteArray(16))
bb.putLong(mostSigBits)
bb.putLong(leastSigBits)
this.data = bb.array()
version = (mostSigBits shr 12 and 0xF).toInt()
}
/**
* 构造函数,根据字符串初始化 UUID。
*
* @param uuid UUID 字符串
*/
constructor(uuid: String) {
fromString(uuid).let {
val bb: ByteBuffer = ByteBuffer.wrap(it)
mostSigBits = bb.long
leastSigBits = bb.long
this.data = it
version = (mostSigBits shr 12 and 0xF).toInt()
}
}
/**
* 返回 UUID 的字节数组表示。
*
* @return UUID 字节数组
*/
fun toBytes(): ByteArray {
return data
}
fun writeToByteBuffer(byteBuffer: ByteBuffer): ByteBuffer {
return byteBuffer.put(data)
}
/**
* 返回 UUID 的高位长整型部分。
*
* @return 高位长整型
*/
fun getMostSignificantBits(): Long {
return mostSigBits
}
/**
* 返回 UUID 的低位长整型部分。
*
* @return 低位长整型
*/
fun getLeastSignificantBits(): Long {
return leastSigBits
}
/**
* 返回 UUID 的字符串表示。
*
* @param isUpper 是否使用大写字母(默认为 false)
* @return UUID 字符串
*/
fun getString(isUpper: Boolean = false): String {
return getString().let {
if (isUpper) {
it.uppercase()
} else it
}
}
/**
* 返回 UUID 的字符串表示。
*
* @param isUpper 是否使用大写字母(默认为 false)
* @param isnotSpace 是否移除连字符(默认为 false)
* @return UUID 字符串
*/
fun getString(isUpper: Boolean = false, isnotSpace: Boolean = false): String {
return getString(isUpper).let {
if (isnotSpace) {
it.replace("-", "")
} else it
}
}
/**
* 返回标准格式的 UUID 字符串(带连字符)。
*
* @return 标准格式的 UUID 字符串
*/
// 优化后的 toString 方法
fun getString(): String {
return buildString(36) {
val msbHigh = (mostSigBits ushr 32).toInt()
val msbMid = ((mostSigBits ushr 16) and 0xFFFF).toInt()
val msbLow = (mostSigBits and 0xFFFF).toInt()
val lsbHigh = ((leastSigBits ushr 48) and 0xFFFF).toInt()
val lsbLow = (leastSigBits and 0xFFFFFFFFFFFFL)
append(msbHigh.toHexString())
append('-')
append(msbMid.toShort().toHexString(4))
append('-')
append(msbLow.toShort().toHexString(4))
append('-')
append(lsbHigh.toShort().toHexString(4))
append('-')
append(lsbLow.toHexString(12))
}
}
/**
* 将长整型转换为指定长度的十六进制字符串。
*
* @param length 字符串长度
* @return 十六进制字符串
*/
private fun Long.toHexString(length: Int): String {
return this.toString(16).padStart(length, '0')
}
/**
* 将短整型转换为指定长度的十六进制字符串。
*
* @param length 字符串长度
* @return 十六进制字符串
*/
private fun Short.toHexString(length: Int): String {
return this.toLong().and(0xFFFF).toString(16).padStart(length, '0')
}
/**
* 返回 MySQL 格式的 UUID 字节数组。
*
* @return MySQL 格式的 UUID 字节数组
*/
fun toMysql(): ByteArray {
return uuidToMysql(this.data)
}
/**
* 返回 MySQL 格式的 UUID 实例。
*
* @return MySQL 格式的 UUID 实例
*/
fun toMysqlUUID(): UUID {
return of(uuidToMysql(this.data))
}
/**
* 比较两个 UUID 是否相等。
*
* @param other 另一个对象
* @return 如果相等则返回 true,否则返回 false
*/
override fun equals(other: Any?): Boolean {
return when (other) {
is UUID -> {
this.data.contentEquals(other.data)
}
is JUUID -> {
other.mostSignificantBits == this.getMostSignificantBits() && other.leastSignificantBits == this.getLeastSignificantBits()
}
else -> {
false
}
}
}
/**
* 返回对应的 Java UUID 实例。
*
* @return Java UUID 实例
*/
fun getUuid(): JUUID {
return JUUID(mostSigBits, leastSigBits)
}
/**
* 返回 UUID 的版本号。
*
* @return 版本号
*/
fun getVersion(): Int {
return version
}
/**
* 计算 UUID 的哈希码。
*
* @return 哈希码
*/
override fun hashCode(): Int {
return data.contentHashCode()
}
/**
* 返回 UUID 的字符串表示。
*
* @return 包含 UUID 和版本号的字符串
*/
override fun toString(): String {
when (version) {
1 -> {
return "UUID(uuid=${getString()},version=${version},datetime=${getDateTime()},mac=${getMac()})"
}
6, 7 -> {
return "UUID(uuid=${getString()},version=${version},datetime=${getDateTime()})"
}
}
return "UUID(uuid=${getString()},version=${version})"
}
/**
* 根据 UUID 版本提取对应的时间信息。
*
* @return 对应的时间信息
*/
fun getDateTime(): DateTime {
when (version) {
1 -> {
val timestamp =
((mostSigBits and 0x0FFFL) shl 48 or (((mostSigBits shr 16) and 0x0FFFFL) shl 32) or (mostSigBits ushr 32))
val timestampBigInt = java.math.BigInteger.valueOf(timestamp)
val nanosecondsBigInt = timestampBigInt.multiply(java.math.BigInteger.valueOf(100L))
val divisor = java.math.BigInteger.valueOf(1_000_000_000L)
val seconds = nanosecondsBigInt.divide(divisor)
val nanos = nanosecondsBigInt.remainder(divisor)
return DateTime.of(seconds.toLong(), nanos.toLong())
.sub(DateTimeOffset.of(ChronoUnit.DAYS, UUID_EPOCH_OFFSET))
}
6 -> {
val timeHigh = (
((data[0].toLong() and 0xFF) shl 40) or
((data[1].toLong() and 0xFF) shl 32) or
((data[2].toLong() and 0xFF) shl 24) or
((data[3].toLong() and 0xFF) shl 16) or
((data[4].toLong() and 0xFF) shl 8) or
(data[5].toLong() and 0xFF)
)
val timeMidAndVersion = ((data[6].toInt() and 0xFF) shl 8) or (data[7].toInt() and 0xFF)
val timeMid = timeMidAndVersion and 0x0FFF
val hundredNanosSinceUuidEpoch = (timeHigh shl 12) or timeMid.toLong()
val seconds = hundredNanosSinceUuidEpoch / 10_000_000
val nanos = (hundredNanosSinceUuidEpoch % 10_000_000) * 100
return DateTime.of(seconds, nanos).sub(DateTimeOffset.of(ChronoUnit.DAYS, UUID_EPOCH_OFFSET))
}
7 -> {
val times =
(data[0].toLong() and 0xFF shl 40) or
(data[1].toLong() and 0xFF shl 32) or
(data[2].toLong() and 0xFF shl 24) or
(data[3].toLong() and 0xFF shl 16) or
(data[4].toLong() and 0xFF shl 8) or
(data[5].toLong() and 0xFF)
return DateTime.of(times)
}
else -> {
throw IllegalArgumentException("UUID version is $version not v1 or v6 or v7 : not supported ")
}
}
}
/**
* 提取 UUID V1 中的 MAC 地址,默认使用冒号分隔符。
* *
* @param spec 分隔符字符,默认为 ":"
* @return MAC 地址字符串 * @return MAC 地址字符串
*/ */
fun extractMACFromUUID(spec: String?): String { fun getMac(): String {
var spec = spec return getMac(":")
if (spec == null) { }
spec = ":"
fun getBase64ShortString(): String {
return BASE64.encode(data).substring(0, 22)
}
fun getBase91ShortString(): String {
return BASE91.encode(data)
}
fun getBase256ShortString(): String {
return BASE256.encode(data)
}
/**
* 提取 UUID V1 中的 MAC 地址。
*
* @param spec 分隔符(默认为冒号)
* @return MAC 地址字符串
*/
fun getMac(spec: String = ":"): String {
if (version != 1) {
throw IllegalArgumentException("UUID version is $version not v1 : not supported ")
} }
val leastSigBits = uuid.leastSignificantBits
val macLong = leastSigBits and 0xFFFFFFFFFFFFL val macLong = leastSigBits and 0xFFFFFFFFFFFFL
val macBytes = ByteArray(6) val macBytes = ByteArray(6)
for (i in 0..5) { for (i in 0..5) {
@@ -230,39 +715,4 @@ class UUID : Serializable {
} }
return mac.toString() return mac.toString()
} }
/**
* 返回此 UUID 的字符串表示,包含版本信息和时间戳(如果是版本1)。
*
* @return UUID 的详细字符串表示
*/
override fun toString(): String {
return "UUID(uuid=${getString()},version=${uuid.version()})"
}
/**
* 判断两个 UUID 是否相等。
*
* @param other 比较对象
* @return 如果相等返回 true,否则返回 false
*/
override fun equals(other: Any?): Boolean {
if (other is UUID) {
return uuid == other.uuid
} else if (other is JUUID) {
return uuid == other
}
return false
}
/**
* 计算此 UUID 的哈希码。
*
* @return 哈希码值
*/
override fun hashCode(): Int {
return uuid.hashCode()
}
} }