Compare commits

..
11 Commits
Author SHA1 Message Date
minglipro 6624c00553 feat(json): 修复Jackson3JsonApi Jvm 签名
Gitea Actions Build / Build (push) Canceled after 0s
2026-10-12 14:01:13 +08:00
minglipro 2c423c4aff feat(pool): 完善对象池并新增可复用线程池
Gitea Actions Build / Build (push) Canceled after 0s
pool:
- ObjectPool 移除 @Deprecated("未实现") 标记,完成实现
  * close() 正确设置关闭标志、销毁空闲对象并 signalAll 唤醒等待者
  * borrow() 修复竞态:循环重取避免 poll 返回 null;创建失败回滚计数
  * 区分「无限等待 / 立即超时 / 有限等待」三种超时语义
  * returnObject() 拒绝外来对象或已关闭状态,直接销毁以防污染
  * 空闲队列由 ConcurrentLinkedQueue 改为 ArrayDeque,所有访问统一持锁,
    移除冗余的 AtomicInteger;idleSize / activeSize / totalSize 返回精确值
  * 新增 snapshot() 提供 idle/active/total/closed 一致快照
- 新增 Pool.kt:抽取通用接口,use() 使用 try/finally 保证归还,
  新增 useResult() 支持带返回值场景
- 新增 ObjectPoolData.kt:池对象元数据包装,提供 release() 语法糖
- 新增 ThreadPool.kt:可复用线程池
  * 池对象为 Worker(长期存活的守护线程 + LinkedBlockingQueue 任务队列),
    线程通过循环消费任务实现真正复用,保留 ThreadLocal 状态
  * 提供 execute / call / submit / submitRunnable 四种任务投递方式
  * submit 返回 CompletableFuture,任务完成后自动归还 Worker
  * 内置 submitted/completed/failed 计数与 uncaughtHandler 兜底,
    任务异常不会导致 Worker 线程死亡
  * 提供 defaultPool / fixed / single 静态工厂与 closeAndAwait 优雅关闭

json:
- Jackson3JsonApi / JacksonJsonApi 暴露 getObjectMapper() 便于外部扩展

metadata:
- MingliUtilsMetaData 改为 data class,获得 equals/hashCode/copy/toString

mybatisplus:
- 修正 BaseMapperQuery @Deprecated 的 ReplaceWith 表达式(去掉多余的 <*>)
2026-10-12 13:57:14 +08:00
minglipro f7abd6c271 no message
Gitea Actions Build / Build (push) Canceled after 0s
2026-10-11 17:35:58 +08:00
minglipro 60ec0e2883 v 5.2.6 2026-06-21 10:41:28 +08:00
minglipro e00f8ad7a1 修复随机字符串长度不正确的问题 2026-03-23 09:35:48 +08:00
minglipro 454cd53553 v 5.0.9 2026-03-12 10:34:42 +08:00
minglipro bc8927db26 v 5.0.8 2026-03-11 08:47:22 +08:00
minglipro 450b4e1a93 feat(utils): 添加数组工具类和国际化支持
- 添加ByteArray.toHexString和String.toHexByteArray扩展函数
- 实现多种数组类型的copyTo和copyFrom扩展方法
- 在AutoConfiguration中集成I18N国际化功能
- 添加AutoService注解及处理器用于自动服务注册
- 新增BadGatewayException HTTP状态异常类
- 更新启动横幅格式并添加国际化文本支持
2026-02-08 03:17:14 +08:00
minglipro a5a532bc82 no message 2026-02-05 11:42:52 +08:00
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
202 changed files with 39532 additions and 3738 deletions
+83 -52
View File
@@ -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 2026-01-08 11:10:03 * LastUpdate 2026-10-11 16:44:37
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@@ -30,11 +30,16 @@ plugins {
`java-library` `java-library`
`maven-publish` `maven-publish`
kotlin("jvm") version "2.2.20" kotlin("jvm") version "2.2.20"
id("org.jetbrains.dokka") version "2.0.0" kotlin("kapt") version "2.2.20"
id("org.jetbrains.dokka") version "2.1.0"
id("org.jetbrains.dokka-javadoc") version "2.1.0"
kotlin("plugin.spring") version "2.1.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
val ARTIFACTID = project.properties["ARTIFACTID"] as String val ARTIFACTID = project.properties["ARTIFACTID"] as String
val JDKVERSIONS = (project.properties["JDKVERSIONS"] as String).toInt()
group = GROUPSID group = GROUPSID
version = VERSIONS version = VERSIONS
@@ -45,55 +50,82 @@ base {
val buildDir: java.nio.file.Path = File("build").toPath() val buildDir: java.nio.file.Path = File("build").toPath()
sourceSets {
main {
java {
srcDirs("src/main/java")
}
kotlin {
srcDirs("src/main/kotlin")
}
resources {
srcDirs("src/main/resources")
}
}
}
java { java {
toolchain.languageVersion.set(JavaLanguageVersion.of(JDKVERSIONS))
withSourcesJar() withSourcesJar()
toolchain.languageVersion.set(JavaLanguageVersion.of(8)) }
kotlin {
jvmToolchain(JDKVERSIONS)
} }
repositories {
mavenLocal()
maven {
url = uri("https://maven.mingliqiye.com/")
}
mavenCentral()
}
dependencies { dependencies {
implementation("org.slf4j:slf4j-api:2.0.17") implementation("org.slf4j:slf4j-api:2.0.17")
implementation(kotlin("reflect"))
implementation("com.mingliqiye.utils.jna:WinKernel32Api:1.0.1") api("com.mingliqiye.utils.aliasfor:alias-for:1.0.1")
compileOnly("org.mindrot:jbcrypt:0.4") compileOnly("org.mindrot:jbcrypt:0.4")
compileOnly("com.squareup.okhttp3:okhttp:5.3.2")
compileOnly("org.springframework.boot:spring-boot-starter:2.7.14") compileOnly("com.fasterxml.jackson.core:jackson-databind:2.21.0")
compileOnly("com.fasterxml.jackson.core:jackson-databind:2.19.2") compileOnly("com.fasterxml.jackson.module:jackson-module-kotlin:2.21.0")
compileOnly("com.google.code.gson:gson:2.13.1") compileOnly("org.springframework:spring-context:5.3.0")
compileOnly("org.springframework.boot:spring-boot-autoconfigure:2.7.16")
compileOnly("tools.jackson.core:jackson-databind:3.1.0")
compileOnly(fileTree("libs"))
compileOnly("com.google.code.gson:gson:2.13.2")
compileOnly("org.mybatis:mybatis:3.5.19") compileOnly("org.mybatis:mybatis:3.5.19")
compileOnly("com.alibaba.fastjson2:fastjson2:2.0.58") compileOnly("io.netty:netty-all:4.2.15.Final")
compileOnly("io.netty:netty-all:4.1.130.Final") compileOnly("com.baomidou:mybatis-plus-core:3.5.15")
compileOnly("com.baomidou:mybatis-plus-core:3.0.1")
compileOnly("net.java.dev.jna:jna:5.17.0") compileOnly("net.java.dev.jna:jna:5.17.0")
compileOnly("org.springdoc:springdoc-openapi-starter-webmvc-ui:2.8.8")
compileOnly("com.baomidou:mybatis-plus-extension:3.5.15")
testImplementation("org.junit.jupiter:junit-jupiter:5.7.1")
testRuntimeOnly("org.junit.platform:junit-platform-launcher")
testImplementation("com.mingliqiye.logger:logger-log4j2:1.0.9")
testImplementation("com.google.code.gson:gson:2.13.2")
testImplementation("com.fasterxml.jackson.core:jackson-databind:2.21.0")
testImplementation("com.fasterxml.jackson.module:jackson-module-kotlin:2.21.0")
testImplementation("tools.jackson.module:jackson-module-kotlin:3.1.0")
testImplementation("tools.jackson.core:jackson-databind:3.1.0")
testImplementation(kotlin("test"))
}
repositories {
mavenLocal()
} }
tasks.withType<JavaCompile> { tasks.withType<JavaCompile>().configureEach {
options.encoding = "UTF-8" options.encoding = "UTF-8"
} }
tasks.named<Test>("test") {
useJUnitPlatform()
}
tasks.withType<JavaExec>().configureEach {
jvmArgs = listOf( tasks.withType<JavaExec> {
jvmArgs(
"-Dfile.encoding=UTF-8", "-Dsun.stdout.encoding=UTF-8", "-Dsun.stderr.encoding=UTF-8" "-Dfile.encoding=UTF-8", "-Dsun.stdout.encoding=UTF-8", "-Dsun.stderr.encoding=UTF-8"
) )
} }
kapt {
arguments {
arg(
"kapt.kotlin.generated",
project.layout.buildDirectory.dir("generated/source/kapt/main").get().asFile.absolutePath
)
}
}
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("LICENSE") { into("META-INF") }
@@ -126,42 +158,34 @@ tasks.withType<org.gradle.jvm.tasks.Jar> {
} }
val isJdk8Build = project.findProperty("buildForJdk8") == "true" val isJdk8Build = project.findProperty("buildForJdk8") == "true"
repositories {
maven {
url = uri("https://maven.aliyun.com/repository/public/")
}
mavenCentral()
}
tasks.register<Jar>("javaDocJar") { tasks.register<Jar>("javaDocJar") {
group = "build" group = "build"
archiveClassifier.set("javadoc") archiveClassifier.set("javadoc-dec")
dependsOn("dokkaJavadoc") dependsOn("dokkaGeneratePublicationJavadoc")
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("javadoc")
dependsOn("dokkaHtml") dependsOn("dokkaGeneratePublicationHtml")
from(buildDir.resolve("dokka/html")) from(buildDir.resolve("dokka/html"))
} }
publishing { publishing {
repositories { repositories {
maven { maven {
name = "MavenRepositoryRaw" name = "mingliqiye"
url = uri("C:/data/git/maven-repository-raw") url = uri("https://repository.mingliqiye.com/repository/maven")
} credentials {
maven { username = System.getenv("mingliqiye.username")
name = "OSSRepository" password = System.getenv("mingliqiye.password")
url = uri("C:/data/git/maven-repository-raw-utils") }
} }
} }
publications { publications {
create<MavenPublication>("mavenJava") { create<MavenPublication>("mavenJava") {
from(components["java"]) from(components["java"])
artifact(tasks.named("javaDocJar"))
artifact(tasks.named("kotlinDocJar")) artifact(tasks.named("kotlinDocJar"))
artifactId = ARTIFACTID artifactId = ARTIFACTID
java.toolchain.languageVersion.set(JavaLanguageVersion.of(8))
pom { pom {
name = "mingli-utils" name = "mingli-utils"
url = "https://mingli-utils.mingliqiye.com" url = "https://mingli-utils.mingliqiye.com"
@@ -197,12 +221,10 @@ tasks.build {
} }
tasks.processResources { tasks.processResources {
duplicatesStrategy = DuplicatesStrategy.EXCLUDE duplicatesStrategy = DuplicatesStrategy.EXCLUDE
outputs.upToDateWhen { false } outputs.upToDateWhen { false }
filesMatching("META-INF/meta-data") { filesMatching(listOf("META-INF/meta-data", "fabric.mod.json")) {
expand( expand(
project.properties + mapOf( project.properties + mapOf(
"buildTime" to LocalDateTime.now().format( "buildTime" to LocalDateTime.now().format(
@@ -214,3 +236,12 @@ tasks.processResources {
) )
} }
} }
signing {
val secretKeyRingFile = System.getenv("SIGNING_SECRET_KEY_RING_FILE")
val keyId = System.getenv("SIGNING_KEY_ID")
useGpgCmd()
project.ext.set("signing.secretKeyRingFile", secretKeyRingFile)
project.ext.set("signing.keyId", keyId)
project.ext.set("signing.password", "")
}
+3 -6
View File
@@ -16,13 +16,10 @@
# ProjectName mingli-utils # ProjectName mingli-utils
# ModuleName mingli-utils # ModuleName mingli-utils
# CurrentFile gradle.properties # CurrentFile gradle.properties
# LastUpdate 2026-01-10 08:55:10 # LastUpdate 2026-10-12 13:57:03
# UpdateUser MingLiPro # UpdateUser MingLiPro
# #
JDKVERSIONS=1.8 JDKVERSIONS=17
GROUPSID=com.mingliqiye.utils GROUPSID=com.mingliqiye.utils
ARTIFACTID=mingli-utils ARTIFACTID=mingli-utils
VERSIONS=4.3.3 VERSIONS=5.3.2
signing.keyId=B22AA93B
signing.password=
signing.secretKeyRingFile=secret.gpg
-90
View File
@@ -1,90 +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.jdk8
* CurrentFile build.gradle.kts
* LastUpdate 2025-09-21 15:39:12
* UpdateUser MingLiPro
*/
plugins {
id("java-library")
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 VERSIONS = project.properties["VERSIONS"] as String
val ARTIFACTID = project.properties["ARTIFACTID"] as String
version = VERSIONS
group = GROUPSID
base.archivesName.set(ARTIFACTID)
publishing {
repositories {
maven {
name = "MavenRepositoryRaw"
url = uri("C:/data/git/maven-repository-raw")
}
maven {
name = "OSSRepository"
url = uri("C:/data/git/maven-repository-raw-utils")
}
}
publications {
create<MavenPublication>("mavenJava") {
from(components["java"])
artifactId = "$ARTIFACTID-win-jdk8"
java.toolchain.languageVersion.set(JavaLanguageVersion.of(8))
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))
dependencies {
api(rootProject)
implementation("com.mingliqiye.utils.jna:WinKernel32Platform:1.0.1")
}
Binary file not shown.
+14 -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,21 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils * ModuleName mingli-utils
* CurrentFile settings.gradle.kts * CurrentFile settings.gradle.kts
* LastUpdate 2025-09-16 12:32:52 * LastUpdate 2026-02-26 10:52:01
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
include("jdk8") plugins {
id("com.gradleup.nmcp.settings").version("1.4.4")
}
val ARTIFACTID: String by settings.extra val ARTIFACTID: String by settings.extra
rootProject.name = ARTIFACTID rootProject.name = ARTIFACTID
nmcpSettings {
centralPortal {
username = System.getenv("sonatype.username")
password = System.getenv("sonatype.password")
publishingType = "AUTOMATIC"
}
}
@@ -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,22 +15,20 @@
* *
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile JsonConverter.kt * CurrentFile Jackson3ApiJavaHelper.java
* LastUpdate 2025-09-15 11:12:07 * LastUpdate 2026-03-18 08:32:31
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
package com.mingliqiye.utils.json.converters package com.mingliqiye.utils.json.api;
interface JsonConverter<F, T> { import tools.jackson.databind.ObjectMapper;
fun convert(obj: F?): T? import tools.jackson.databind.cfg.MapperBuilder;
fun deConvert(obj: T?): F?
val tClass: Class<F>
fun getStringConverter(): JsonStringConverter<F>? {
if (this is JsonStringConverter<*>) { public class Jackson3ApiJavaHelper {
return this as JsonStringConverter<F> @SuppressWarnings("rawtypes")
} static MapperBuilder rebuild(ObjectMapper objectMapper) {
return null return objectMapper.rebuild();
} }
} }
@@ -0,0 +1,120 @@
/*
* 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 Main.java
* LastUpdate 2026-02-26 15:04:49
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.main;
import java.io.IOException;
import java.io.InputStream;
import java.lang.management.ManagementFactory;
import java.net.InetAddress;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
public class Main {
public final static String BANNER =
"| $$\\ $$\\ $$\\ $$\\ $$\\ $$$$$$$$\\ $$$$$$\\ \n" +
"| $$$\\ $$$ |$$ | $$ | $$ |\\__$$ __|$$ __$$\\ \n" +
"| $$$$\\ $$$$ |$$ | $$ | $$ | $$ | $$ / \\__| \n" +
"| $$\\$$\\$$ $$ |$$ | $$ | $$ | $$ | \\$$$$$$\\ \n" +
"| $$ \\$$$ $$ |$$ | $$ | $$ | $$ | \\____$$\\ \n" +
"| $$ |\\$ /$$ |$$ | $$ | $$ | $$ | $$\\ $$ | \n" +
"| $$ | \\_/ $$ |$$$$$$$$\\\\$$$$$$ | $$ | \\$$$$$$ \n" +
"| \\__| \\__|\\________|\\______/ \\__| \\______/ \n|\n";
public static void main(String[] args) {
try {
printb();
} catch (IOException ignored) {
}
}
public static String getPid() {
try {
var name = ManagementFactory.getRuntimeMXBean().getName();
var index = name.indexOf('@');
if (index > 0) {
return name.substring(0, index);
} else {
return "-1";
}
} catch (Exception e) {
return "-1";
}
}
public static String getComputerName() {
try {
var name = System.getenv("COMPUTERNAME");
if (name == null || name.isEmpty()) {
name = System.getenv("HOSTNAME");
}
if (name == null || name.isEmpty()) {
name = InetAddress.getLocalHost().getHostName();
}
return name != null ? name : "unknown";
} catch (Exception e) {
return "unknown";
}
}
public static String getUserName() {
try {
String user = System.getenv("USERNAME");
if (user == null || user.isEmpty()) {
user = System.getenv("USER");
}
if (user == null || user.isEmpty()) {
user = System.getenv("user.name");
}
if (user == null || user.isEmpty()) {
user = "unknown";
}
return user;
} catch (Exception e) {
return "unknown";
}
}
public static void printb() throws IOException {
InputStream inputStream = Main.class.getResourceAsStream("/META-INF/meta-data");
if (inputStream == null) return;
String data = new String(inputStream.readAllBytes());
inputStream.close();
StringBuilder sb = new StringBuilder(BANNER);
for (String sz : data.split("\n")) {
var d = sz.split("=");
sb.append("| -> ").append(d[0]).append(": ").append(d[1]).append("\n");
}
sb.append("| -> jdkVersion: ").append(System.getProperty("java.specification.version")).append("\n");
sb.append("| -> pid: ").append(getPid()).append("\n");
sb.append("| -> computerName: ").append(getComputerName()).append("\n");
sb.append("| -> userName: ").append(getUserName()).append("\n");
sb.append("| -> time: ")
.append(LocalDateTime.now()
.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSSSSSS")))
.append("\n");
System.out.println();
System.out.println(sb);
}
}
File diff suppressed because it is too large Load Diff
@@ -0,0 +1,133 @@
/*
* 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 SuprtStreamUtils.kt
* LastUpdate 2026-10-11 17:32:17
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.stream
import java.util.stream.Stream
/**
* [SuperStream] 的工厂工具类,提供把各类常见数据源(Java [Stream]、数组、集合、映射)
* 转换为 [SuperStream] 的扩展函数。
*
* 所有扩展函数均以 `toSuperStream` 命名,遵循 Kotlin 的 `toXxx` 转换命名惯例。
*
* 使用示例:
* ```kotlin
* intArrayOf(1, 2, 3).toSuperStream()
* listOf("a", "b").toSuperStream(parallel = true)
* mapOf(1 to "a").toSuperStream()
* ```
*/
object SuperStreamUtils {
/**
* 将 Java [Stream] 转换为 [SuperStream]。
*
* @param T 流中元素的类型,必须是不可空类型。
* @return 包装当前 [Stream] 的 [SuperStream]。
*/
fun <T : Any> Stream<T>.toSuperStream() = SuperStream.of(this)
/**
* 将 [ByteArray] 转换为 [SuperStream]。
*
* @param parallel 是否创建并行流,默认为 `false`(串行)。
* @return 由当前数组元素构成的 [SuperStream]。
*/
fun ByteArray.toSuperStream(parallel: Boolean = false) = SuperStream.of(this.toList(), parallel)
/**
* 将 [ShortArray] 转换为 [SuperStream]。
*
* @param parallel 是否创建并行流,默认为 `false`(串行)。
* @return 由当前数组元素构成的 [SuperStream]。
*/
fun ShortArray.toSuperStream(parallel: Boolean = false) = SuperStream.of(this.toList(), parallel)
/**
* 将 [IntArray] 转换为 [SuperStream]。
*
* @param parallel 是否创建并行流,默认为 `false`(串行)。
* @return 由当前数组元素构成的 [SuperStream]。
*/
fun IntArray.toSuperStream(parallel: Boolean = false) = SuperStream.of(this.toList(), parallel)
/**
* 将 [LongArray] 转换为 [SuperStream]。
*
* @param parallel 是否创建并行流,默认为 `false`(串行)。
* @return 由当前数组元素构成的 [SuperStream]。
*/
fun LongArray.toSuperStream(parallel: Boolean = false) = SuperStream.of(this.toList(), parallel)
/**
* 将 [FloatArray] 转换为 [SuperStream]。
*
* @param parallel 是否创建并行流,默认为 `false`(串行)。
* @return 由当前数组元素构成的 [SuperStream]。
*/
fun FloatArray.toSuperStream(parallel: Boolean = false) = SuperStream.of(this.toList(), parallel)
/**
* 将 [DoubleArray] 转换为 [SuperStream]。
*
* @param parallel 是否创建并行流,默认为 `false`(串行)。
* @return 由当前数组元素构成的 [SuperStream]。
*/
fun DoubleArray.toSuperStream(parallel: Boolean = false) = SuperStream.of(this.toList(), parallel)
/**
* 将 [BooleanArray] 转换为 [SuperStream]。
*
* @param parallel 是否创建并行流,默认为 `false`(串行)。
* @return 由当前数组元素构成的 [SuperStream]。
*/
fun BooleanArray.toSuperStream(parallel: Boolean = false) = SuperStream.of(this.toList(), parallel)
/**
* 将对象数组 [Array] 转换为 [SuperStream]。
*
* @param T 数组元素类型,必须是不可空类型。
* @param parallel 是否创建并行流,默认为 `false`(串行)。
* @return 由当前数组元素构成的 [SuperStream]。
*/
fun <T : Any> Array<T>.toSuperStream(parallel: Boolean = false) = SuperStream.of(this, parallel)
/**
* 将 [Collection] 转换为 [SuperStream]。
*
* @param T 集合元素类型,必须是不可空类型。
* @param parallel 是否创建并行流,默认为 `false`(串行)。
* @return 由当前集合元素构成的 [SuperStream]。
*/
fun <T : Any> Collection<T>.toSuperStream(parallel: Boolean = false) = SuperStream.of(this, parallel)
/**
* 将 [Map] 转换为 [SuperStream],流中元素为键值对 [Map.Entry]。
*
* @param K 键的类型。
* @param V 值的类型。
* @param parallel 是否创建并行流,默认为 `false`(串行)。
* @return 由当前映射的条目构成的 [SuperStream]。
*/
fun <K, V> Map<K, V>.toSuperStream(parallel: Boolean = false) = SuperStream.of(this, parallel)
}
@@ -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 AesUtils.kt * CurrentFile AesUtils.kt
* LastUpdate 2025-09-19 21:35:53 * LastUpdate 2026-03-12 10:34:36
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@@ -25,7 +25,7 @@
package com.mingliqiye.utils.aes package com.mingliqiye.utils.aes
import com.mingliqiye.utils.base.BASE64 import com.mingliqiye.utils.base.BaseType
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
@@ -71,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 BASE64.encode( return BaseType.BASE64.encode(
"${BASE64.encode(iv)}:${BASE64.encode(encrypted)}".toByteArray() "${BaseType.BASE64.encode(iv)}:${BaseType.BASE64.encode(encrypted)}".toByteArray()
) )
} }
@@ -85,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(BASE64.decode(sSrc)) val sSrcs = String(BaseType.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 = BASE64.decode(parts[0]!!) val iv = BaseType.BASE64.decode(parts[0]!!)
val encryptedData = BASE64.decode(parts[1]!!) val encryptedData = BaseType.BASE64.decode(parts[1]!!)
if (iv.size != GCM_IV_LENGTH) { if (iv.size != GCM_IV_LENGTH) {
return null return null
} }
@@ -121,4 +121,3 @@ 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,41 @@
/*
* 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 AutoService.kt
* LastUpdate 2026-02-07 17:00:39
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.annotation
import kotlin.reflect.KClass
/**
* 标记一个类为其提供自动服务注册功能的注解。
*
* 此注解用于标识那些需要被自动注册为服务的类。通过指定[value]参数,
* 可以声明该类实现的服务接口类型。注解的作用范围限定为类(CLASS),
* 并且仅在源码级别保留(SOURCE),不会编译到字节码中。
* @since 4.6.3
*
* @param value 需要注册的服务接口类型数组,默认为空数组。
*/
@Target(AnnotationTarget.CLASS)
@Retention(AnnotationRetention.SOURCE)
annotation class AutoService(
val value: Array<KClass<*>> = []
)
@@ -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,28 +15,25 @@
* *
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile QueryWrapper.kt * CurrentFile DateTimeJsonFormat.kt
* LastUpdate 2025-09-20 14:21:44 * LastUpdate 2026-02-07 08:05:39
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
package com.mingliqiye.utils.mybatisplus package com.mingliqiye.utils.annotation
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper import com.mingliqiye.utils.time.Formatter
import com.baomidou.mybatisplus.core.mapper.BaseMapper
/** /**
* BaseMapperQuery接口扩展了BaseMapper,提供了通用的查询包装器功能 * 日期时间JSON格式化注解,用于标注字段的日期时间格式化方式
* *
* @param T 实体类类型 * @property value 格式化器类型,默认为NONE
* @property formatter 自定义格式化字符串,默认为空字符串
* @property repcZero 是否替换零值,默认为true
*/ */
interface BaseMapperQuery<T> : BaseMapper<T> { @Target(AnnotationTarget.FIELD)
/** annotation class DateTimeJsonFormat(
* 创建并返回一个新的QueryWrapper实例 val value: Formatter = Formatter.NONE,
* val formatter: String = "",
* @return QueryWrapper<T> 返回类型化的查询包装器实例 val repcZero: Boolean = true,
*/ )
fun queryWrapper(): QueryWrapper<T> {
return QueryWrapper<T>()
}
}
@@ -0,0 +1,38 @@
/*
* 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 UUIDJsonFormat.kt
* LastUpdate 2026-02-07 08:05:58
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.annotation
import com.mingliqiye.utils.base.BaseType
import com.mingliqiye.utils.uuid.UUIDFormatType
/**
* UUID JSON格式化注解,用于指定UUID字段在JSON序列化/反序列化时的格式
*
* @property value UUID格式类型,默认为 NO_UPPER_SPACE
* @property base 基数类型,默认为 BASE16
*/
@Target(AnnotationTarget.FIELD)
annotation class UUIDJsonFormat(
val value: UUIDFormatType = UUIDFormatType.NO_UPPER_SPACE,
val base: BaseType = BaseType.BASE16
)
@@ -0,0 +1,104 @@
/*
* 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 AutoServiceProcessor.kt
* LastUpdate 2026-03-11 08:46:40
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.annotation.processor
import com.mingliqiye.utils.annotation.AutoService
import javax.annotation.processing.AbstractProcessor
import javax.annotation.processing.ProcessingEnvironment
import javax.annotation.processing.RoundEnvironment
import javax.annotation.processing.SupportedAnnotationTypes
import javax.lang.model.element.TypeElement
import javax.lang.model.type.MirroredTypesException
import javax.lang.model.type.TypeMirror
import javax.tools.StandardLocation
@SupportedAnnotationTypes("com.mingliqiye.utils.annotation.AutoService")
class AutoServiceProcessor : AbstractProcessor() {
override fun init(processingEnv: ProcessingEnvironment) {
super.init(processingEnv)
}
override fun process(
annotations: Set<TypeElement>,
roundEnv: RoundEnvironment,
): Boolean {
val service = mutableMapOf<String, MutableList<String>>()
val elements = roundEnv.getElementsAnnotatedWith(AutoService::class.java)
if (elements.isEmpty()) return false
for (element in elements) {
val autoServiceAnnotation = element.getAnnotation(AutoService::class.java)
var asd = (try {
autoServiceAnnotation!!.value.map { it.java.name }
} catch (e: MirroredTypesException) {
e.typeMirrors.map(TypeMirror::toString)
})
if (asd.isEmpty()) {
if (element is TypeElement) {
asd = element.interfaces.map { it.toString() }
}
}
for (data in asd) {
var ldata: MutableList<String>? = service[data]
if (ldata == null) {
ldata = mutableListOf()
service[data] = ldata
}
ldata.add(element.toString())
}
}
processClassAnnotation(service)
return true
}
fun processClassAnnotation(map: Map<String, MutableList<String>>) {
map.forEach { (interfaceName, implementations) ->
if (implementations.isEmpty()) {
println("警告: $interfaceName 的实现列表为空!")
return@forEach
}
try {
val serviceFile = processingEnv.filer.createResource(
StandardLocation.CLASS_OUTPUT,
"",
"META-INF/services/$interfaceName"
)
val content = StringBuilder()
serviceFile.openWriter().use { writer ->
implementations.forEach { impl ->
val line = "$impl\n"
content.append(line)
writer.write(line)
}
writer.flush()
}
} catch (e: Exception) {
println("文件创建失败: ${e.javaClass.name} - ${e.message}")
e.printStackTrace()
}
}
}
}
@@ -0,0 +1,340 @@
/*
* 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 ArrayUtils.kt
* LastUpdate 2026-03-12 10:08:42
* UpdateUser MingLiPro
*/
@file:JvmName("ArrayUtils")
package com.mingliqiye.utils.array
import com.mingliqiye.utils.base.BaseType
/**
* 将字节数组转换为十六进制字符串
*
* @return 大写的十六进制字符串,每两个字符表示一个字节
* @since 4.6.0
* @see toHexByteArray
*/
fun ByteArray.toHexString(): String = BaseType.BASE16.encode(this).uppercase()
/**
* 将十六进制字符串转换为字节数组
*
* @return 对应的字节数组
* @throws IllegalArgumentException 如果字符串包含非十六进制字符
* @since 4.6.0
* @see toHexString
*/
fun String.toHexByteArray(): ByteArray = BaseType.BASE16.decode(this.lowercase())
/**
* 将当前数组的指定范围复制到目标数组
*
* @param dest 目标数组
* @param srcPos 源数组起始位置(包含)
* @param distPos 目标数组起始位置(包含)
* @param len 要复制的元素数量
* @return 源数组自身(支持链式调用)
* @throws IndexOutOfBoundsException 如果索引超出范围
* @throws IllegalArgumentException 如果参数无效
* @since 4.6.0
*/
@JvmName("arrayCopy")
fun <T> Array<T>.copyTo(dest: Array<T>, srcPos: Int, distPos: Int, len: Int): Array<T> = this.also {
System.arraycopy(this, srcPos, dest, distPos, len)
}
/**
* 创建新数组并复制当前数组的指定范围
*
* @param srcPos 源数组起始位置(包含)
* @param distPos 目标数组起始位置(包含)
* @param len 要复制的元素数量,也作为新数组的长度
* @return 新创建的数组
* @throws IndexOutOfBoundsException 如果索引超出范围
* @since 4.6.2
*/
@JvmName("arrayCopy")
fun <T> Array<T>.copyTo(srcPos: Int, distPos: Int, len: Int): Array<T> =
java.lang.reflect.Array.newInstance(this.javaClass.componentType, len).also {
System.arraycopy(this, srcPos, it, distPos, len)
}.let {
@Suppress("UNCHECKED_CAST")
it as Array<T>
}
/**
* 将源数组的指定范围复制到当前数组
*
* @param src 源数组
* @param srcPos 源数组起始位置(包含)
* @param distPos 当前数组起始位置(包含)
* @param len 要复制的元素数量
* @return 当前数组自身(支持链式调用)
* @throws IndexOutOfBoundsException 如果索引超出范围
* @since 4.6.1
*/
@JvmName("arrayCopyFrom")
fun <T> Array<T>.copyFrom(src: Array<T>, srcPos: Int, distPos: Int, len: Int): Array<T> = this.also {
System.arraycopy(src, srcPos, this, distPos, len)
}
/* ==================== BooleanArray 扩展 ==================== */
/**
* @see Array.copyTo
* @since 4.6.0
*/
@JvmName("arrayCopy")
fun BooleanArray.copyTo(dest: BooleanArray, srcPos: Int, distPos: Int, len: Int): BooleanArray = this.also {
System.arraycopy(this, srcPos, dest, distPos, len)
}
/**
* @see Array.copyTo
* @since 4.6.2
*/
@JvmName("arrayCopy")
fun BooleanArray.copyTo(srcPos: Int, distPos: Int, len: Int): BooleanArray =
BooleanArray(len).also { newArray ->
System.arraycopy(this, srcPos, newArray, distPos, len)
}
/**
* @see Array.copyFrom
* @since 4.6.1
*/
@JvmName("arrayCopyFrom")
fun BooleanArray.copyFrom(src: BooleanArray, srcPos: Int, distPos: Int, len: Int): BooleanArray = this.also {
System.arraycopy(src, srcPos, this, distPos, len)
}
/* ==================== ByteArray 扩展 ==================== */
/**
* @see Array.copyTo
* @since 4.6.0
*/
@JvmName("arrayCopy")
fun ByteArray.copyTo(dest: ByteArray, srcPos: Int, distPos: Int, len: Int): ByteArray = this.also {
System.arraycopy(this, srcPos, dest, distPos, len)
}
/**
* @see Array.copyTo
* @since 4.6.2
*/
@JvmName("arrayCopy")
fun ByteArray.copyTo(srcPos: Int, distPos: Int, len: Int): ByteArray =
ByteArray(len).also { newArray ->
System.arraycopy(this, srcPos, newArray, distPos, len)
}
/**
* @see Array.copyFrom
* @since 4.6.1
*/
@JvmName("arrayCopyFrom")
fun ByteArray.copyFrom(src: ByteArray, srcPos: Int, distPos: Int, len: Int): ByteArray = this.also {
System.arraycopy(src, srcPos, this, distPos, len)
}
/* ==================== CharArray 扩展 ==================== */
/**
* @see Array.copyTo
* @since 4.6.0
*/
@JvmName("arrayCopy")
fun CharArray.copyTo(dest: CharArray, srcPos: Int, distPos: Int, len: Int): CharArray = this.also {
System.arraycopy(this, srcPos, dest, distPos, len)
}
/**
* @see Array.copyTo
* @since 4.6.2
*/
@JvmName("arrayCopy")
fun CharArray.copyTo(srcPos: Int, distPos: Int, len: Int): CharArray =
CharArray(len).also { newArray ->
System.arraycopy(this, srcPos, newArray, distPos, len)
}
/**
* @see Array.copyFrom
* @since 4.6.1
*/
@JvmName("arrayCopyFrom")
fun CharArray.copyFrom(src: CharArray, srcPos: Int, distPos: Int, len: Int): CharArray = this.also {
System.arraycopy(src, srcPos, this, distPos, len)
}
/* ==================== DoubleArray 扩展 ==================== */
/**
* @see Array.copyTo
* @since 4.6.0
*/
@JvmName("arrayCopy")
fun DoubleArray.copyTo(dest: DoubleArray, srcPos: Int, distPos: Int, len: Int): DoubleArray = this.also {
System.arraycopy(this, srcPos, dest, distPos, len)
}
/**
* @see Array.copyTo
* @since 4.6.2
*/
@JvmName("arrayCopy")
fun DoubleArray.copyTo(srcPos: Int, distPos: Int, len: Int): DoubleArray =
DoubleArray(len).also { newArray ->
System.arraycopy(this, srcPos, newArray, distPos, len)
}
/**
* @see Array.copyFrom
* @since 4.6.1
*/
@JvmName("arrayCopyFrom")
fun DoubleArray.copyFrom(src: DoubleArray, srcPos: Int, distPos: Int, len: Int): DoubleArray = this.also {
System.arraycopy(src, srcPos, this, distPos, len)
}
/* ==================== FloatArray 扩展 ==================== */
/**
* @see Array.copyTo
* @since 4.6.0
*/
@JvmName("arrayCopy")
fun FloatArray.copyTo(dest: FloatArray, srcPos: Int, distPos: Int, len: Int): FloatArray = this.also {
System.arraycopy(this, srcPos, dest, distPos, len)
}
/**
* @see Array.copyTo
* @since 4.6.2
*/
@JvmName("arrayCopy")
fun FloatArray.copyTo(srcPos: Int, distPos: Int, len: Int): FloatArray =
FloatArray(len).also { newArray ->
System.arraycopy(this, srcPos, newArray, distPos, len)
}
/**
* @see Array.copyFrom
* @since 4.6.1
*/
@JvmName("arrayCopyFrom")
fun FloatArray.copyFrom(src: FloatArray, srcPos: Int, distPos: Int, len: Int): FloatArray = this.also {
System.arraycopy(src, srcPos, this, distPos, len)
}
/* ==================== IntArray 扩展 ==================== */
/**
* @see Array.copyTo
* @since 4.6.0
*/
@JvmName("arrayCopy")
fun IntArray.copyTo(dest: IntArray, srcPos: Int, distPos: Int, len: Int): IntArray = this.also {
System.arraycopy(this, srcPos, dest, distPos, len)
}
/**
* @see Array.copyTo
* @since 4.6.2
*/
@JvmName("arrayCopy")
fun IntArray.copyTo(srcPos: Int, distPos: Int, len: Int): IntArray =
IntArray(len).also { newArray ->
System.arraycopy(this, srcPos, newArray, distPos, len)
}
/**
* @see Array.copyFrom
* @since 4.6.1
*/
@JvmName("arrayCopyFrom")
fun IntArray.copyFrom(src: IntArray, srcPos: Int, distPos: Int, len: Int): IntArray = this.also {
System.arraycopy(src, srcPos, this, distPos, len)
}
/* ==================== LongArray 扩展 ==================== */
/**
* @see Array.copyTo
* @since 4.6.0
*/
@JvmName("arrayCopy")
fun LongArray.copyTo(dest: LongArray, srcPos: Int, distPos: Int, len: Int): LongArray = this.also {
System.arraycopy(this, srcPos, dest, distPos, len)
}
/**
* @see Array.copyTo
* @since 4.6.2
*/
@JvmName("arrayCopy")
fun LongArray.copyTo(srcPos: Int, distPos: Int, len: Int): LongArray =
LongArray(len).also { newArray ->
System.arraycopy(this, srcPos, newArray, distPos, len)
}
/**
* @see Array.copyFrom
* @since 4.6.1
*/
@JvmName("arrayCopyFrom")
fun LongArray.copyFrom(src: LongArray, srcPos: Int, distPos: Int, len: Int): LongArray = this.also {
System.arraycopy(src, srcPos, this, distPos, len)
}
/* ==================== ShortArray 扩展 ==================== */
/**
* @see Array.copyTo
* @since 4.6.0
*/
@JvmName("arrayCopy")
fun ShortArray.copyTo(dest: ShortArray, srcPos: Int, distPos: Int, len: Int): ShortArray = this.also {
System.arraycopy(this, srcPos, dest, distPos, len)
}
/**
* @see Array.copyTo
* @since 4.6.2
*/
@JvmName("arrayCopy")
fun ShortArray.copyTo(srcPos: Int, distPos: Int, len: Int): ShortArray =
ShortArray(len).also { newArray ->
System.arraycopy(this, srcPos, newArray, distPos, len)
}
/**
* @see Array.copyFrom
* @since 4.6.1
*/
@JvmName("arrayCopyFrom")
fun ShortArray.copyFrom(src: ShortArray, srcPos: Int, distPos: Int, len: Int): ShortArray = this.also {
System.arraycopy(src, srcPos, this, distPos, len)
}
@@ -0,0 +1,68 @@
/*
* 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 Base10Codec.kt
* LastUpdate 2026-03-12 10:34:36
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.base
import java.math.BigInteger
internal class Base10Codec : BaseCodec {
/**
* 将字节数组编码为Base10字符串(十进制)
*
* @param bytes 需要编码的字节数组
* @return 编码后的Base10字符串(十进制数字)
*/
override fun encode(bytes: ByteArray): String {
if (bytes.isEmpty()) return "0"
// 将字节数组转换为正的大整数
val bigInt = BigInteger(1, bytes) // 参数1表示正数
return bigInt.toString(10) // 转换为10进制字符串
}
/**
* 将Base10字符串解码为字节数组
*
* @param string 需要解码的Base10字符串(十进制数字)
* @return 解码后的字节数组
*/
override fun decode(string: String): ByteArray {
// 验证输入是否为有效的十进制数字
if (!string.matches(Regex("\\d+"))) {
throw IllegalArgumentException("Base10字符串只能包含数字0-9")
}
val bigInt = BigInteger(string, 10) // 从10进制解析
// 转换为字节数组,并确保保留前导零
var byteArray = bigInt.toByteArray()
// BigInteger.toByteArray() 可能会添加一个符号字节
// 对于正数,如果第一个字节是0,需要移除它
if (byteArray.isNotEmpty() && byteArray[0] == 0.toByte()) {
byteArray = byteArray.copyOfRange(1, byteArray.size)
}
return byteArray
}
}
@@ -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,8 +15,8 @@
* *
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile Base16.kt * CurrentFile Base16Codec.kt
* LastUpdate 2025-09-17 10:56:07 * LastUpdate 2026-03-12 10:34:36
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@@ -26,7 +26,7 @@ package com.mingliqiye.utils.base
* Base16编解码器实现类 * Base16编解码器实现类
* 提供字节数组与十六进制字符串之间的相互转换功能 * 提供字节数组与十六进制字符串之间的相互转换功能
*/ */
class Base16 : BaseCodec { internal class Base16Codec : BaseCodec {
/** /**
* 将字节数组编码为十六进制字符串 * 将字节数组编码为十六进制字符串
* @param bytes 待编码的字节数组 * @param bytes 待编码的字节数组
@@ -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,8 +15,8 @@
* *
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile Base256.kt * CurrentFile Base256Codec.kt
* LastUpdate 2025-09-20 14:01:29 * LastUpdate 2026-03-12 10:34:36
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@@ -30,7 +30,7 @@ package com.mingliqiye.utils.base
* !#$%&()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~§±×÷←↑→↓⇒⇔∀∃∅∆∇∈∉∋∌∏∑−∓∕∗∘∙√∛∜∞∟∠∣∥∧∨∩∪∫∬∭∮∯∰∱∲∳∴∵∶∷≈≠≡≤≥≦≧≪≫≺≻⊂⊃⊆⊇⊈⊉⊊⊋⊕⊖⊗⊘⊙⊚⊛⊜⊝⊞⊟⊠⊡⊢⊣⊤⊥⊦⊧⊨⊩⊪⊫⊬⊭⊮⊯⋀⋁⋂⋃⋄⋅⋆⋇⋈⋉⋊⋋⋌⋍⋎⋏⋐⋑⋒⋓⋔⋕⋖⋗⋘⋙⋚⋛⋜⋝⋞⋟⋠⋡⋢⋣⋤⋥⋦⋧⋨⋩▁▂▃▄▅▆▇█▉▊▋▌▍▎▏▐░▒▓▔▕▖▗▘▙ * !#$%&()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~§±×÷←↑→↓⇒⇔∀∃∅∆∇∈∉∋∌∏∑−∓∕∗∘∙√∛∜∞∟∠∣∥∧∨∩∪∫∬∭∮∯∰∱∲∳∴∵∶∷≈≠≡≤≥≦≧≪≫≺≻⊂⊃⊆⊇⊈⊉⊊⊋⊕⊖⊗⊘⊙⊚⊛⊜⊝⊞⊟⊠⊡⊢⊣⊤⊥⊦⊧⊨⊩⊪⊫⊬⊭⊮⊯⋀⋁⋂⋃⋄⋅⋆⋇⋈⋉⋊⋋⋌⋍⋎⋏⋐⋑⋒⋓⋔⋕⋖⋗⋘⋙⋚⋛⋜⋝⋞⋟⋠⋡⋢⋣⋤⋥⋦⋧⋨⋩▁▂▃▄▅▆▇█▉▊▋▌▍▎▏▐░▒▓▔▕▖▗▘▙
* *
*/ */
class Base256 : BaseCodec { internal class Base256Codec : BaseCodec {
companion object { companion object {
val code = arrayOf( val code = arrayOf(
@@ -0,0 +1,59 @@
/*
* 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 Base2Codec.kt
* LastUpdate 2026-03-12 10:34:36
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.base
internal class Base2Codec : BaseCodec {
override fun encode(bytes: ByteArray): String {
if (bytes.isEmpty()) return ""
val result = StringBuilder()
for ((index, byte) in bytes.withIndex()) {
val unsignedByte = byte.toInt() and 0xFF
val binary = unsignedByte.toString(2).padStart(8, '0')
result.append(binary)
}
return result.toString()
}
override fun decode(string: String): ByteArray {
if (string.length % 8 != 0) {
throw IllegalArgumentException(
"BASE1字符串长度必须是8的倍数,当前长度: ${string.length}"
)
}
if (!string.matches(Regex("[01]+"))) {
throw IllegalArgumentException(
"BASE1字符串只能包含字符'0'和'1'"
)
}
val byteCount = string.length / 8
val result = ByteArray(byteCount)
for (i in 0 until byteCount) {
val startIndex = i * 8
val endIndex = startIndex + 8
val binaryStr = string.substring(startIndex, endIndex)
val byteValue = binaryStr.toInt(2)
result[i] = byteValue.toByte()
}
return result
}
}
@@ -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,30 +15,32 @@
* *
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile Base64.kt * CurrentFile Base64Codec.kt
* LastUpdate 2025-09-17 10:56:32 * LastUpdate 2026-03-12 10:34:36
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
package com.mingliqiye.utils.base package com.mingliqiye.utils.base
import java.util.*
/* /*
* Base64编解码工具类 * Base64编解码工具类
* 提供Base64编码和解码功能的实现 * 提供Base64编码和解码功能的实现
*/ */
class Base64 : BaseCodec { internal class Base64Codec : BaseCodec {
/* /*
* Base64编码器实例 * Base64编码器实例
* 用于执行字节数组到Base64字符串的编码操作 * 用于执行字节数组到Base64字符串的编码操作
*/ */
val BASE_64_ENCODER: java.util.Base64.Encoder = java.util.Base64.getEncoder() val encoder: Base64.Encoder = Base64.getEncoder()
/* /*
* Base64解码器实例 * Base64解码器实例
* 用于执行Base64字符串到字节数组的解码操作 * 用于执行Base64字符串到字节数组的解码操作
*/ */
val BASE_64_DECODER: java.util.Base64.Decoder = java.util.Base64.getDecoder() val decoder: Base64.Decoder = Base64.getDecoder()
/* /*
* 将字节数组编码为Base64字符串 * 将字节数组编码为Base64字符串
@@ -47,7 +49,7 @@ class Base64 : BaseCodec {
* @return 编码后的Base64字符串 * @return 编码后的Base64字符串
*/ */
override fun encode(bytes: ByteArray): String { override fun encode(bytes: ByteArray): String {
return BASE_64_ENCODER.encodeToString(bytes) return encoder.encodeToString(bytes)
} }
/* /*
@@ -57,6 +59,6 @@ class Base64 : BaseCodec {
* @return 解码后的字节数组 * @return 解码后的字节数组
*/ */
override fun decode(string: String): ByteArray { override fun decode(string: String): ByteArray {
return BASE_64_DECODER.decode(string) return decoder.decode(string)
} }
} }
@@ -0,0 +1,60 @@
/*
* 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 Base64UrlCodec.kt
* LastUpdate 2026-03-12 10:34:36
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.base
import java.util.*
internal class Base64UrlCodec : BaseCodec {
/*
* Base64编码器实例
* 用于执行字节数组到Base64字符串的编码操作
*/
val encoder: Base64.Encoder = Base64.getUrlEncoder()
/*
* Base64解码器实例
* 用于执行Base64字符串到字节数组的解码操作
*/
val decoder: Base64.Decoder = Base64.getUrlDecoder()
/*
* 将字节数组编码为Base64字符串
*
* @param bytes 待编码的字节数组
* @return 编码后的Base64字符串
*/
override fun encode(bytes: ByteArray): String {
return encoder.encodeToString(bytes)
}
/*
* 将Base64字符串解码为字节数组
*
* @param string 待解码的Base64字符串
* @return 解码后的字节数组
*/
override fun decode(string: String): ByteArray {
return decoder.decode(string)
}
}
@@ -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,8 +15,8 @@
* *
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile Base91.kt * CurrentFile Base91Codec.kt
* LastUpdate 2025-09-19 20:08:46 * LastUpdate 2026-03-12 10:34:36
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@@ -27,7 +27,7 @@ package com.mingliqiye.utils.base
* *
* Base91 是一种高效的二进制到文本的编码方式,相较于 Base64,它使用更少的字符来表示相同的数据。 * Base91 是一种高效的二进制到文本的编码方式,相较于 Base64,它使用更少的字符来表示相同的数据。
*/ */
class Base91 : BaseCodec { internal class Base91Codec : BaseCodec {
companion object { companion object {
/** /**
@@ -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,158 +16,163 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile BaseCodec.kt * CurrentFile BaseCodec.kt
* LastUpdate 2025-09-18 14:07:35 * LastUpdate 2026-10-11 16:52:16
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
package com.mingliqiye.utils.base package com.mingliqiye.utils.base
import com.mingliqiye.utils.exception.CodecException
import java.io.File import java.io.File
import java.io.IOException
import java.nio.file.Path import java.nio.file.Path
/**
* BaseCodec 接口定义了一组用于编码和解码数据的基本方法。
* 提供了对字节数组、字符串、文件和路径的编码与解码功能,
* 并支持安全操作(在发生异常时返回默认值或布尔状态)。
*/
interface BaseCodec { interface BaseCodec {
/** /**
* 将字节数组编码为Base64字符串 * 对字节数组进行编码,并捕获可能发生的异常。
* *
* @param bytes 需要编码的字节数组 * @param bytes 需要编码的字节数组
* @return 编码后的Base64字符串 * @return 编码后的字符串结果
* @throws CodecException 如果编码过程中发生异常
*/
fun catchEncode(bytes: ByteArray) = try {
encode(bytes)
} catch (e: Exception) {
throw CodecException(throwable = e)
}
/**
* 对字符串进行解码,并捕获可能发生的异常。
*
* @param string 需要解码的字符串
* @return 解码后的字节数组结果
* @throws CodecException 如果解码过程中发生异常
*/
fun catchDecode(string: String) = try {
decode(string)
} catch (e: Exception) {
throw CodecException(throwable = e)
}
/**
* 将字节数组编码为字符串。
*
* @param bytes 需要编码的字节数组
* @return 编码后的字符串结果
*/ */
fun encode(bytes: ByteArray): String fun encode(bytes: ByteArray): String
/** /**
* 将Base64字符串解码为字节数组 * 将字符串解码为字节数组。
* *
* @param string 需要解码的Base64字符串 * @param string 需要解码的字符串
* @return 解码后的字节数组 * @return 解码后的字节数组结果
*/ */
fun decode(string: String): ByteArray fun decode(string: String): ByteArray
/** /**
* 将文件内容编码为Base64字符串 * 对文件内容进行编码。
* *
* @param file 需要编码的文件 * @param file 需要编码的文件对象
* @return 文件内容的Base64编码字符串 * @return 文件内容编码后的字符串结果
* @throws IOException 当文件读取失败时抛出
*/ */
@Throws(IOException::class) fun encode(file: File) = catchEncode(file.readBytes())
fun encode(file: File): String {
return encode(file.readBytes()) /**
* 将字符串解码后写入指定文件。
*
* @param file 目标文件对象
* @param string 需要解码的字符串
*/
fun decode(file: File, string: String) =
file.writeBytes(catchDecode(string))
/**
* 安全地对文件内容进行编码,如果发生异常则返回 null。
*
* @param file 需要编码的文件对象
* @return 文件内容编码后的字符串结果,若失败则返回 null
*/
fun encodeSafe(file: File) = try {
encode(file)
} catch (_: Exception) {
null
} }
/** /**
* 将Base64字符串解码并写入文件 * 安全地将字符串解码并写入指定文件,如果成功则返回 true,否则返回 false。
* *
* @param file 目标文件 * @param file 目标文件对象
* @param string 需要解码的Base64字符串 * @param string 需要解码的字符串
* @throws IOException 当文件写入失败时抛出 * @return 操作是否成功的布尔值
*/ */
@Throws(IOException::class) fun decodeSafe(file: File, string: String) = try {
fun decode(file: File, string: String) { decode(file, string)
file.writeBytes(decode(string)) true
} catch (_: Exception) {
false
} }
/** /**
* 安全地将文件内容编码为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 需要编码的文件路径 * @param path 需要编码的文件路径
* @return 文件内容的Base64编码字符串 * @return 文件内容编码后的字符串结果
* @throws IOException 当文件读取失败时抛出
*/ */
@Throws(IOException::class) fun encode(path: Path) = catchEncode(path.toFile().readBytes())
fun encode(path: Path): String {
return encode(path.toFile().readBytes())
}
/** /**
* 将Base64字符串解码并写入路径指定的文件 * 将字符串解码后写入指定路径的文件。
* *
* @param path 目标文件路径 * @param path 目标文件路径
* @param string 需要解码的Base64字符串 * @param string 需要解码的字符串
* @throws IOException 当文件写入失败时抛出
*/ */
@Throws(IOException::class) fun decode(path: Path, string: String) = path.toFile().writeBytes(catchDecode(string))
fun decode(path: Path, string: String) {
path.toFile().writeBytes(decode(string))
}
/** /**
* 安全地将路径对应的文件内容编码为Base64字符串,出现异常时返回null * 安全地对路径指向的文件内容进行编码,如果发生异常则返回 null。
* *
* @param path 需要编码的文件路径 * @param path 需要编码的文件路径
* @return 文件内容的Base64编码字符串,失败时返回null * @return 文件内容编码后的字符串结果,若失败则返回 null
*/ */
fun encodeSafe(path: Path): String? { fun encodeSafe(path: Path) = try {
return try { encode(path)
encode(path) } catch (_: Exception) {
} catch (_: Exception) { null
null
}
} }
/** /**
* 安全地将Base64字符串解码并写入路径指定的文件,返回操作是否成功 * 安全地将字符串解码并写入指定路径的文件,如果成功则返回 true,否则返回 false。
* *
* @param path 目标文件路径 * @param path 目标文件路径
* @param string 需要解码的Base64字符串 * @param string 需要解码的字符串
* @return 操作成功返回true,失败返回false * @return 操作是否成功的布尔值
*/ */
fun decodeSafe(path: Path, string: String): Boolean { fun decodeSafe(path: Path, string: String) = try {
return try { decode(path, string)
decode(path, string) true
true } catch (_: Exception) {
} catch (_: Exception) { false
false
}
} }
/** /**
* 将字符串编码为Base64字符串 * 对字符串进行编码。
* *
* @param string 需要编码的字符串 * @param string 需要编码的字符串
* @return 编码后的Base64字符串 * @return 编码后的字符串结果
*/ */
fun encode(string: String): String { fun encode(string: String) = catchEncode(string.toByteArray())
return encode(string.toByteArray())
}
/** /**
* 将Base64字符串解码为字符串 * 将字符串解码为 UTF-8 格式的字符串。
* *
* @param string 需要解码的Base64字符串 * @param string 需要解码的字符串
* @return 解码后的字符串 * @return 解码后的 UTF-8 字符串结果
*/ */
fun decodetoString(string: String): String { fun decodetoString(string: String) = catchDecode(string).toString(Charsets.UTF_8)
return decode(string).toString(Charsets.UTF_8)
}
} }
@@ -0,0 +1,38 @@
/*
* 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 BaseType.kt
* LastUpdate 2026-03-12 10:08:42
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.base
enum class BaseType(val baseCodec: BaseCodec) : BaseCodec {
BASE2(com.mingliqiye.utils.base.code.BASE2),
BASE10(com.mingliqiye.utils.base.code.BASE10),
BASE16(com.mingliqiye.utils.base.code.BASE16),
BASE64(com.mingliqiye.utils.base.code.BASE64),
BASE64URL(com.mingliqiye.utils.base.code.BASE64URL),
BASE91(com.mingliqiye.utils.base.code.BASE91),
BASE256(com.mingliqiye.utils.base.code.BASE256);
override fun encode(bytes: ByteArray) = baseCodec.encode(bytes)
override fun decode(string: String) = baseCodec.decode(string)
}
@@ -1,63 +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 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()
}
@@ -0,0 +1,86 @@
/*
* 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 BaseCodes.kt
* LastUpdate 2026-03-12 10:03:32
* UpdateUser MingLiPro
*/
@file:JvmName("BaseCodes")
package com.mingliqiye.utils.base.code
import com.mingliqiye.utils.base.*
/**
* 提供Base2编码器的懒加载实例。
* 该编码器用于将数据编码为二进制格式。
*/
@get:JvmName("base2")
val BASE2: BaseCodec by lazy {
Base2Codec()
}
/**
* 提供Base10编码器的懒加载实例。
* 该编码器用于将数据编码为十进制格式。
*/
@get:JvmName("base10")
val BASE10: BaseCodec by lazy {
Base10Codec()
}
/**
* 提供Base16编码器的懒加载实例。
* 该编码器用于将数据编码为十六进制格式。
*/
@get:JvmName("base16")
val BASE16: BaseCodec by lazy {
Base16Codec()
}
/**
* 提供Base64编码器的懒加载实例。
* 该编码器用于将数据编码为Base64格式,常用于URL安全传输或存储。
*/
@get:JvmName("base64")
val BASE64: BaseCodec by lazy {
Base64Codec()
}
@get:JvmName("base64Url")
val BASE64URL: BaseCodec by lazy {
Base64UrlCodec()
}
/**
* 提供Base91编码器的懒加载实例。
* 该编码器用于将数据编码为Base91格式,具有较高的压缩效率。
*/
@get:JvmName("base91")
val BASE91: BaseCodec by lazy {
Base91Codec()
}
/**
* 提供Base256编码器的懒加载实例。
* 该编码器用于将数据编码为Base256格式,适用于字节级数据处理。
*/
@get:JvmName("base256")
val BASE256: BaseCodec by lazy {
Base256Codec()
}
File diff suppressed because it is too large Load Diff
@@ -0,0 +1,276 @@
/*
* 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 ByteBufferWrapperConvertor.kt
* LastUpdate 2026-03-15 11:05:48
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.buffer.convertor
import com.mingliqiye.utils.buffer.ByteBufferWrapper
import com.mingliqiye.utils.bytes.ByteFlags
import com.mingliqiye.utils.time.DateTime
import com.mingliqiye.utils.uuid.UUID
import java.math.BigDecimal
import java.math.BigInteger
import java.time.LocalDateTime
import java.util.*
import java.util.concurrent.ConcurrentHashMap
import java.util.UUID as JUUID
interface ByteBufferWrapperConvertorInterface<T : Any> {
fun write(obj: T, byteBufferWrapper: ByteBufferWrapper)
fun read(byteBufferWrapper: ByteBufferWrapper, parameters: Array<Any>): T
fun getType(): Class<T>
}
abstract class ByteBufferWrapperConvertor<T : Any> : ByteBufferWrapperConvertorInterface<T> {
override fun toString(): String {
return "ByteBufferWrapperConvertor(type=${getType()})"
}
companion object {
private val _instantiations =
ConcurrentHashMap<Class<ByteBufferWrapperConvertor<*>>, ByteBufferWrapperConvertor<*>>()
@JvmStatic
fun getInstantiation(clazz: Class<ByteBufferWrapperConvertor<*>>): ByteBufferWrapperConvertor<*> {
return _instantiations.getOrPut(clazz) {
clazz.getConstructor().newInstance()
}
}
@JvmStatic
@Suppress("UNCHECKED_CAST")
inline fun <reified T : ByteBufferWrapperConvertor<*>> getInstantiation(): ByteBufferWrapperConvertor<*> {
return getInstantiation(T::class.java as Class<ByteBufferWrapperConvertor<*>>)
}
fun defaultConvertorInstall() {
ByteBufferWrapper.addConvertor<BigDecimalBufferWrapperConvertor>()
ByteBufferWrapper.addConvertor<BigIntegerBufferWrapperConvertor>()
ByteBufferWrapper.addConvertor<BooleanBufferWrapperConvertor>()
ByteBufferWrapper.addConvertor<BytedBufferWrapperConvertor>()
ByteBufferWrapper.addConvertor<ByteFlagsBufferWrapperConvertor>()
ByteBufferWrapper.addConvertor<CharBufferWrapperConvertor>()
ByteBufferWrapper.addConvertor<DateBufferWrapperConvertor>()
ByteBufferWrapper.addConvertor<DateTimeFlagsBufferWrapperConvertor>()
ByteBufferWrapper.addConvertor<DoubleBufferWrapperConvertor>()
ByteBufferWrapper.addConvertor<FloatBufferWrapperConvertor>()
ByteBufferWrapper.addConvertor<IntBufferWrapperConvertor>()
ByteBufferWrapper.addConvertor<JUUIDBufferWrapperConvertor>()
ByteBufferWrapper.addConvertor<LocalDateTimeBufferWrapperConvertor>()
ByteBufferWrapper.addConvertor<LongBufferWrapperConvertor>()
ByteBufferWrapper.addConvertor<ShortBufferWrapperConvertor>()
ByteBufferWrapper.addConvertor<StringBufferWrapperConvertor>()
ByteBufferWrapper.addConvertor<UUIDBufferWrapperConvertor>()
ByteBufferWrapper.addConvertor<ByteArrayBufferWrapperConvertor>()
ByteBufferWrapper.addConvertor<CharArrayBufferWrapperConvertor>()
ByteBufferWrapper.addConvertor<ShortArrayBufferWrapperConvertor>()
ByteBufferWrapper.addConvertor<IntArrayBufferWrapperConvertor>()
ByteBufferWrapper.addConvertor<LongArrayBufferWrapperConvertor>()
ByteBufferWrapper.addConvertor<FloatArrayBufferWrapperConvertor>()
ByteBufferWrapper.addConvertor<DoubleArrayBufferWrapperConvertor>()
ByteBufferWrapper.addConvertor<BooleanArrayBufferWrapperConvertor>()
}
}
}
abstract class ObjectBufferWrapperConvertor<T : Any>(
val write: ByteBufferWrapper.(obj: T) -> Unit,
val read: ByteBufferWrapper.() -> T,
val typer: Class<T>,
) : ByteBufferWrapperConvertor<T>() {
override fun write(obj: T, byteBufferWrapper: ByteBufferWrapper) = write.invoke(byteBufferWrapper, obj)
override fun read(byteBufferWrapper: ByteBufferWrapper, parameters: Array<Any>): T =
read.invoke(byteBufferWrapper)
override fun getType(): Class<T> = typer
}
class BytedBufferWrapperConvertor : ObjectBufferWrapperConvertor<Byte>(
ByteBufferWrapper::putByte,
ByteBufferWrapper::getByte,
Byte::class.java,
)
class CharBufferWrapperConvertor : ObjectBufferWrapperConvertor<Char>(
ByteBufferWrapper::putChar,
ByteBufferWrapper::getChar,
Char::class.java,
)
class ShortBufferWrapperConvertor : ObjectBufferWrapperConvertor<Short>(
ByteBufferWrapper::putShort,
ByteBufferWrapper::getShort,
Short::class.java,
)
class IntBufferWrapperConvertor : ObjectBufferWrapperConvertor<Int>(
ByteBufferWrapper::putInt,
ByteBufferWrapper::getInt,
Int::class.java,
)
class LongBufferWrapperConvertor : ObjectBufferWrapperConvertor<Long>(
ByteBufferWrapper::putLong,
ByteBufferWrapper::getLong,
Long::class.java,
)
class DoubleBufferWrapperConvertor : ObjectBufferWrapperConvertor<Double>(
ByteBufferWrapper::putDouble,
ByteBufferWrapper::getDouble,
Double::class.java,
)
class FloatBufferWrapperConvertor : ObjectBufferWrapperConvertor<Float>(
ByteBufferWrapper::putFloat,
ByteBufferWrapper::getFloat,
Float::class.java,
)
class BigIntegerBufferWrapperConvertor : ObjectBufferWrapperConvertor<BigInteger>(
ByteBufferWrapper::putBigInteger,
ByteBufferWrapper::getBigInteger,
BigInteger::class.java,
)
class BigDecimalBufferWrapperConvertor : ObjectBufferWrapperConvertor<BigDecimal>(
ByteBufferWrapper::putBigDecimal,
ByteBufferWrapper::getBigDecimal,
BigDecimal::class.java,
)
class BooleanBufferWrapperConvertor : ObjectBufferWrapperConvertor<Boolean>(
ByteBufferWrapper::putBoolean,
ByteBufferWrapper::getBoolean,
Boolean::class.java,
)
class StringBufferWrapperConvertor : ObjectBufferWrapperConvertor<String>(
ByteBufferWrapper::putString,
ByteBufferWrapper::getString,
String::class.java,
)
class ByteFlagsBufferWrapperConvertor : ObjectBufferWrapperConvertor<ByteFlags>(
ByteBufferWrapper::putFlag,
ByteBufferWrapper::getFlag,
ByteFlags::class.java,
)
class JUUIDBufferWrapperConvertor : ObjectBufferWrapperConvertor<JUUID>(
ByteBufferWrapper::putUUID,
ByteBufferWrapper::getJUUID,
JUUID::class.java,
)
class UUIDBufferWrapperConvertor : ObjectBufferWrapperConvertor<UUID>(
ByteBufferWrapper::putUUID,
ByteBufferWrapper::getUUID,
UUID::class.java,
)
class DateTimeFlagsBufferWrapperConvertor : ObjectBufferWrapperConvertor<DateTime>(
ByteBufferWrapper::putDateTime,
ByteBufferWrapper::getDateTime,
DateTime::class.java,
)
class LocalDateTimeBufferWrapperConvertor : ObjectBufferWrapperConvertor<LocalDateTime>(
ByteBufferWrapper::putLocalDateTime,
ByteBufferWrapper::getLocalDateTime,
LocalDateTime::class.java,
)
class DateBufferWrapperConvertor : ObjectBufferWrapperConvertor<Date>(
ByteBufferWrapper::putDate,
ByteBufferWrapper::getDate,
Date::class.java,
)
abstract class ArrayBufferWrapperConvertor<T : Any>(
val write: ByteBufferWrapper.(obj: T) -> Unit,
val read: ByteBufferWrapper.(size: Int) -> T,
val typer: Class<T>,
) : ByteBufferWrapperConvertor<T>() {
override fun write(obj: T, byteBufferWrapper: ByteBufferWrapper) = write.invoke(byteBufferWrapper, obj)
override fun read(byteBufferWrapper: ByteBufferWrapper, parameters: Array<Any>): T {
if (parameters.isEmpty()) {
throw IllegalArgumentException("parameters cannot be empty, must has a Int")
}
val size = parameters[0]
if (size !is Int)
throw IllegalArgumentException("parameters[0] cannot be Int, must has a Int")
return read.invoke(byteBufferWrapper, size)
}
override fun getType(): Class<T> = typer
}
class ByteArrayBufferWrapperConvertor : ArrayBufferWrapperConvertor<ByteArray>(
ByteBufferWrapper::putByteArray,
ByteBufferWrapper::getByteArray,
ByteArray::class.java,
)
class CharArrayBufferWrapperConvertor : ArrayBufferWrapperConvertor<CharArray>(
ByteBufferWrapper::putCharArray,
ByteBufferWrapper::getCharArray,
CharArray::class.java,
)
class ShortArrayBufferWrapperConvertor : ArrayBufferWrapperConvertor<ShortArray>(
ByteBufferWrapper::putShortArray,
ByteBufferWrapper::getShortArray,
ShortArray::class.java,
)
class IntArrayBufferWrapperConvertor : ArrayBufferWrapperConvertor<IntArray>(
ByteBufferWrapper::putIntArray,
ByteBufferWrapper::getIntArray,
IntArray::class.java,
)
class LongArrayBufferWrapperConvertor : ArrayBufferWrapperConvertor<LongArray>(
ByteBufferWrapper::putLongArray,
ByteBufferWrapper::getLongArray,
LongArray::class.java,
)
class FloatArrayBufferWrapperConvertor : ArrayBufferWrapperConvertor<FloatArray>(
ByteBufferWrapper::putFloatArray,
ByteBufferWrapper::getFloatArray,
FloatArray::class.java,
)
class DoubleArrayBufferWrapperConvertor : ArrayBufferWrapperConvertor<DoubleArray>(
ByteBufferWrapper::putDoubleArray,
ByteBufferWrapper::getDoubleArray,
DoubleArray::class.java,
)
class BooleanArrayBufferWrapperConvertor : ArrayBufferWrapperConvertor<BooleanArray>(
ByteBufferWrapper::putBooleanArray,
ByteBufferWrapper::getBooleanArray,
BooleanArray::class.java,
)
@@ -16,14 +16,17 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile ByteBufferUtils.kt * CurrentFile ByteBufferUtils.kt
* LastUpdate 2026-01-07 10:01:45 * LastUpdate 2026-07-02 09:31:01
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@file:JvmName("ByteBufferUtil") @file:JvmName("ByteBufferUtils")
package com.mingliqiye.utils.bytes package com.mingliqiye.utils.bytes
import java.io.IOException
import java.io.OutputStream
import java.nio.BufferUnderflowException
import java.nio.ByteBuffer import java.nio.ByteBuffer
import java.nio.charset.Charset import java.nio.charset.Charset
@@ -203,3 +206,93 @@ fun ByteBuffer.putBoolean(boolean: Boolean): ByteBuffer = this.put(if (boolean)
fun ByteArray.toByteBuffer(): ByteBuffer { fun ByteArray.toByteBuffer(): ByteBuffer {
return ByteBuffer.wrap(this) 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,50 @@
/*
* 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 ByteConvertible.kt
* LastUpdate 2026-02-08 10:25:22
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.bytes
import java.io.OutputStream
import java.io.Serializable
import java.nio.ByteBuffer
interface ByteConvertible : Serializable {
fun toBytes(): ByteArray
fun writeToStream(outputStream: OutputStream) {
outputStream.write(toBytes())
}
fun putToByteBuffer(byteBuffer: ByteBuffer) {
byteBuffer.put(toBytes())
}
companion object {
fun OutputStream.write(byteConvertible: ByteConvertible) {
byteConvertible.writeToStream(this)
}
fun ByteBuffer.put(byteConvertible: ByteConvertible) {
byteConvertible.putToByteBuffer(this)
}
}
}
@@ -16,7 +16,7 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile ByteFlags.kt * CurrentFile ByteFlags.kt
* LastUpdate 2026-01-07 09:37:09 * LastUpdate 2026-06-21 10:40:58
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@@ -47,7 +47,7 @@ data class ByteFlags(
/** 第 6 位(0x40) */ /** 第 6 位(0x40) */
var b6: Boolean = false, var b6: Boolean = false,
/** 第 7 位(最高位,0x80) */ /** 第 7 位(最高位,0x80) */
var b7: Boolean = false var b7: Boolean = false,
) { ) {
/** /**
@@ -410,7 +410,7 @@ data class ByteFlags(
* @return 全 1 的 ByteFlags(值为 0xFF) * @return 全 1 的 ByteFlags(值为 0xFF)
*/ */
fun allTrue(): ByteFlags { fun allTrue(): ByteFlags {
return ByteFlags(true, true, true, true, true, true, true, true) return ByteFlags(b0 = true, b1 = true, b2 = true, b3 = true, b4 = true, b5 = true, b6 = true, b7 = true)
} }
/** /**
@@ -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,36 +16,88 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile ByteUtils.kt * CurrentFile ByteUtils.kt
* LastUpdate 2025-09-20 11:49:05 * LastUpdate 2026-05-22 13:26:55
* 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.BaseType
import com.mingliqiye.utils.stream.SuperStream 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().map { a -> String.format("0X%02X", a!!.toInt() and 0xFF) } return this.toList().stream().map { a -> String.format("0X%02X", a!!.toInt() and 0xFF) }
.collect(SuperStream.toList()) as MutableList<String> .collect(SuperStream.toListCollector()) as MutableList<String>
} }
/**
* 将十六进制字符转换为对应的数值
* @receiver 十六进制字符
* @return 对应的数值(0-15)
* @throws NumberFormatException 当字符不是有效的十六进制字符时抛出
*/
fun Char.hexDigitToValue(): Int { fun Char.hexDigitToValue(): Int {
return when (this) { return when (this) {
in '0'..'9' -> this - '0' in '0'..'9' -> this - '0'
@@ -55,6 +107,23 @@ fun Char.hexDigitToValue(): Int {
} }
} }
private fun hexStringToByteArray(string: String): ByteArray { /**
* 将十六进制字符串转换为字节数组
*
* @param string 输入的十六进制字符串
* @return 转换后的字节数组
*/
fun hexStringToByteArray(string: String): ByteArray {
return string.hexToByteArray() return string.hexToByteArray()
} }
/**
* 将字节数组转换为十六进制字符串表示。
*
* @param bytes 输入的字节数组
* @return 对应的十六进制字符串
*/
fun bytesToHex(bytes: ByteArray): String {
return BaseType.BASE16.encode(bytes)
}
@@ -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,17 +15,17 @@
* *
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile NumberUtils.kt * CurrentFile StreamUtils.kt
* LastUpdate 2025-09-16 15:59:45 * LastUpdate 2026-01-11 09:41:14
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@file:JvmName("StreamUtils")
@file:JvmName("NumberUtils") package com.mingliqiye.utils.bytes
package com.mingliqiye.utils.number
import java.io.IOException import java.io.IOException
import java.io.InputStream import java.io.InputStream
import java.io.OutputStream
/** /**
@@ -35,25 +35,22 @@ import java.io.InputStream
* - 如果最高位为1,则表示还有下一个字节; * - 如果最高位为1,则表示还有下一个字节;
* - 如果最高位为0,则表示当前字节是最后一个字节。 * - 如果最高位为0,则表示当前字节是最后一个字节。
* *
* @param input 输入流,用于读取数据。
* @param size 最大允许读取的字节数,默认为8(即Long类型的最大长度)。 * @param size 最大允许读取的字节数,默认为8(即Long类型的最大长度)。
* @return 解码后的长整型数值。 * @return 解码后的长整型数值。
* @throws IOException 当读取过程中发生IO异常或到达流末尾时抛出。 * @throws IOException 当读取过程中发生IO异常或到达流末尾时抛出。
*/ */
@Throws(IOException::class) @Throws(IOException::class)
fun readVarNumber(input: InputStream, size: Int = 10): Long { fun InputStream.readVarNumber(size: Int = 8): Long {
var numRead = 0 var numRead = 0
var result: Long = 0 var result: Long = 0
var read: Byte var read: Byte
do { do {
read = input.read().let { read = this.read().let {
if (it == -1) { if (it == -1) {
throw IOException("Reached end of stream") throw IOException("Reached end of stream")
} }
it.toByte() it.toByte()
} }
// 将当前字节的有效7位数据左移相应位数,并与结果进行或运算
result = result or ((read.toLong() and 127) shl (7 * numRead)) result = result or ((read.toLong() and 127) shl (7 * numRead))
numRead++ numRead++
if (numRead > size) { if (numRead > size) {
@@ -66,35 +63,84 @@ fun readVarNumber(input: InputStream, size: Int = 10): Long {
/** /**
* 从输入流中读取一个变长整数(VarInt),最大长度限制为4个字节。 * 从输入流中读取一个变长整数(VarInt),最大长度限制为4个字节。
* *
* @param input 输入流,用于读取数据。
* @return 解码后的整型数值。 * @return 解码后的整型数值。
* @throws IOException 当读取过程中发生IO异常时抛出。 * @throws IOException 当读取过程中发生IO异常时抛出。
*/ */
@Throws(IOException::class) @Throws(IOException::class)
fun readVarInt(input: InputStream): Int { fun InputStream.readVarInt(): Int = this.readVarNumber(4).toInt()
return readVarNumber(input, size = 4).toInt()
}
/** /**
* 从输入流中读取一个变长短整数(VarShort),最大长度限制为2个字节。 * 从输入流中读取一个变长短整数(VarShort),最大长度限制为2个字节。
* *
* @param input 输入流,用于读取数据。
* @return 解码后的短整型数值。 * @return 解码后的短整型数值。
* @throws IOException 当读取过程中发生IO异常时抛出。 * @throws IOException 当读取过程中发生IO异常时抛出。
*/ */
@Throws(IOException::class) @Throws(IOException::class)
fun readVarShort(input: InputStream): Short { fun InputStream.readVarShort(): Short = this.readVarNumber(2).toShort()
return readVarNumber(input, size = 2).toShort()
}
/** /**
* 从输入流中读取一个变长长整数(VarLong),最大长度默认为8个字节。 * 从输入流中读取一个变长长整数(VarLong),最大长度默认为8个字节。
* *
* @param input 输入流,用于读取数据。
* @return 解码后的长整型数值。 * @return 解码后的长整型数值。
* @throws IOException 当读取过程中发生IO异常时抛出。 * @throws IOException 当读取过程中发生IO异常时抛出。
*/ */
@Throws(IOException::class) @Throws(IOException::class)
fun readVarLong(input: InputStream): Long { fun InputStream.readVarLong(): Long = this.readVarNumber()
return readVarNumber(input)
/**
* 将长整型数值编码为变长格式并写入输出流
*
* 变长整数使用可变长度编码方式,每个字节的最高位表示是否还有后续字节:
* - 如果数值还有更多字节,则最高位设为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)
@@ -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,26 +16,26 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile CloneUtils.kt * CurrentFile CloneUtils.kt
* LastUpdate 2025-09-20 14:01:29 * LastUpdate 2026-02-08 10:36:51
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@file:JvmName("CloneUtils") @file:JvmName("CloneUtils")
package com.mingliqiye.utils.clone package com.mingliqiye.utils.clone
import com.mingliqiye.utils.json.JsonApi import com.mingliqiye.utils.exception.JsonException
import com.mingliqiye.utils.json.JsonException import com.mingliqiye.utils.json.api.JSONA
import java.io.* import java.io.*
inline fun <reified T> Serializable.deepClone(): T { @JvmName("_inline_deepClone")
return deepClone(this) as T inline fun <reified T : Serializable> T.deepClone(): T {
return deepClone(this)
} }
inline fun <reified T> T.deepJsonClone(jsonApi: JsonApi): T { inline fun <reified T> T.deepJsonClone(): T {
try { try {
return jsonApi.convert(this, this!!.javaClass) as T return JSONA.convert(this as Any, this!!.javaClass) as T
} catch (e: Exception) { } catch (e: Exception) {
throw JsonException( throw JsonException(
"Failed to deep clone object using JSON", e "Failed to deep clone object using JSON", e
@@ -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 IsChanged.kt * CurrentFile IsChanged.kt
* LastUpdate 2025-09-19 20:17:07 * LastUpdate 2026-01-31 21:13:45
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@@ -39,17 +39,14 @@ class IsChanged<T> {
*/ */
private val atomicReferenceData: AtomicReference<T> = AtomicReference() private val atomicReferenceData: AtomicReference<T> = AtomicReference()
/** constructor()
* 默认构造函数,初始化数据为 null
*/
constructor() : this(null)
/** /**
* 带参数的构造函数,使用指定的初始值初始化 * 带参数的构造函数,使用指定的初始值初始化
* *
* @param data 初始数据值 * @param data 初始数据值
*/ */
constructor(data: T?) : super() { constructor(data: T) : super() {
atomicReferenceData.set(data) atomicReferenceData.set(data)
} }
@@ -67,7 +64,7 @@ class IsChanged<T> {
* *
* @return 当前数据值 * @return 当前数据值
*/ */
fun get(): T? { fun get(): T {
return atomicReferenceData.get() return atomicReferenceData.get()
} }
@@ -77,7 +74,7 @@ class IsChanged<T> {
* @param data 要设置的新数据值 * @param data 要设置的新数据值
* @return 设置前的旧数据值 * @return 设置前的旧数据值
*/ */
fun setAndGet(data: T): T? { fun setAndGet(data: T): T {
return atomicReferenceData.getAndSet(data) return atomicReferenceData.getAndSet(data)
} }
@@ -89,7 +86,7 @@ class IsChanged<T> {
* @return 如果值发生变化返回 true,否则返回 false * @return 如果值发生变化返回 true,否则返回 false
*/ */
fun setAndChanged(data: T): Boolean { fun setAndChanged(data: T): Boolean {
var currentData: T? var currentData: T
do { do {
currentData = get() currentData = get()
// 如果新值与当前值相等,则认为没有变化,直接返回 false // 如果新值与当前值相等,则认为没有变化,直接返回 false
@@ -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 ConfigurationProp.kt * CurrentFile ConfigurationProp.kt
* LastUpdate 2025-09-19 11:30:04 * LastUpdate 2026-07-01 12:37:05
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@@ -156,7 +156,7 @@ open class ConfigurationProps {
private fun <T : ConfigurationProps> processFields( private fun <T : ConfigurationProps> processFields(
clazz: Class<T>, clazz: Class<T>,
instance: T, instance: T,
mapsArgs: Map<String, List<String>> mapsArgs: Map<String, List<String>>,
) { ) {
val fields = clazz.declaredFields val fields = clazz.declaredFields
@@ -194,7 +194,7 @@ open class ConfigurationProps {
private fun convertValue( private fun convertValue(
type: Class<*>, type: Class<*>,
values: List<String>, values: List<String>,
annotation: ConfigurationProp annotation: ConfigurationProp,
): Any? { ): Any? {
val lastValue = values.lastOrNull() ?: return null val lastValue = values.lastOrNull() ?: return null
@@ -248,9 +248,9 @@ open class ConfigurationProps {
val configurationProp = field.getAnnotation(ConfigurationProp::class.java) val configurationProp = field.getAnnotation(ConfigurationProp::class.java)
if (configurationProp != null && configurationProp.showHelper) { if (configurationProp != null && configurationProp.showHelper) {
val fieldName = configurationProp.name.ifEmpty { field.name } val fieldName = configurationProp.name.ifEmpty { field.name }
help.append("$fieldName -> 类型: ${field.type.simpleName}") help.append("$fieldName -> Type: ${field.type.simpleName}")
if (configurationProp.description.isNotEmpty()) { if (configurationProp.description.isNotEmpty()) {
help.append(" 描述: ${configurationProp.description}") help.append(" Description: ${configurationProp.description}")
} }
help.append("\n") help.append("\n")
} }
@@ -0,0 +1,34 @@
/*
* 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 BadGatewayException.kt
* LastUpdate 2026-02-05 14:55:04
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.exception
/**
* 表示 HTTP 502 Bad Gateway 异常。
*
* @param message 异常信息,默认为 "Bad Gateway"
* @param cause 异常原因,默认为 null
*/
class BadGatewayException(
override val message: String? = "Bad Gateway",
override val cause: Throwable? = null,
) : HttpStatusException(502, message, cause)
@@ -0,0 +1,34 @@
/*
* 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 BadRequestException.kt
* LastUpdate 2026-02-05 14:55:04
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.exception
/**
* 表示 HTTP 400 Bad Request 异常。
*
* @param message 异常信息,默认为 "Bad Request"
* @param cause 异常原因,默认为 null
*/
class BadRequestException(
override val message: String? = "Bad Request",
override val cause: Throwable? = null,
) : HttpStatusException(400, message, cause)
@@ -0,0 +1,30 @@
/*
* 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 CodecException.kt
* LastUpdate 2026-10-11 16:51:36
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.exception
class CodecException @JvmOverloads constructor(
message: String? = null,
throwable: Throwable? = null,
enableSuppression: Boolean = false,
writableStackTrace: Boolean = true,
) : MingLiUtilsBaseException(message, throwable, enableSuppression, writableStackTrace)
@@ -0,0 +1,34 @@
/*
* 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 ConflictException.kt
* LastUpdate 2026-02-05 14:55:04
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.exception
/**
* 表示 HTTP 409 Conflict 异常。
*
* @param message 异常信息,默认为 "Conflict"
* @param cause 异常原因,默认为 null
*/
class ConflictException(
override val message: String? = "Conflict",
override val cause: Throwable? = null,
) : HttpStatusException(409, message, cause)
@@ -0,0 +1,30 @@
/*
* 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 EmptyJsonException.kt
* LastUpdate 2026-10-11 16:53:26
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.exception
class EmptyJsonException @JvmOverloads constructor(
message: String? = null,
throwable: Throwable? = null,
enableSuppression: Boolean = false,
writableStackTrace: Boolean = true,
) : JsonException(message, throwable, enableSuppression, writableStackTrace)
@@ -0,0 +1,34 @@
/*
* 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 ForbiddenException.kt
* LastUpdate 2026-02-05 14:55:04
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.exception
/**
* 表示 HTTP 403 Forbidden 异常。
*
* @param message 异常信息,默认为 "Forbidden"
* @param cause 异常原因,默认为 null
*/
class ForbiddenException(
override val message: String? = "Forbidden",
override val cause: Throwable? = null,
) : HttpStatusException(403, message, cause)
@@ -0,0 +1,34 @@
/*
* 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 FoundException.kt
* LastUpdate 2026-02-05 14:55:04
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.exception
/**
* 表示 HTTP 302 Found 异常。
*
* @param message 异常信息,默认为 "Found"
* @param cause 异常原因,默认为 null
*/
class FoundException(
override val message: String? = "Found",
override val cause: Throwable? = null,
) : HttpStatusException(302, message, cause)
@@ -0,0 +1,34 @@
/*
* 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 GatewayTimeoutException.kt
* LastUpdate 2026-02-05 14:55:04
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.exception
/**
* 表示 HTTP 504 Gateway Timeout 异常。
*
* @param message 异常信息,默认为 "Gateway Timeout"
* @param cause 异常原因,默认为 null
*/
class GatewayTimeoutException(
override val message: String? = "Gateway Timeout",
override val cause: Throwable? = null,
) : HttpStatusException(504, message, cause)
@@ -0,0 +1,34 @@
/*
* 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 GoneException.kt
* LastUpdate 2026-02-05 14:55:04
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.exception
/**
* 表示 HTTP 410 Gone 异常。
*
* @param message 异常信息,默认为 "Gone"
* @param cause 异常原因,默认为 null
*/
class GoneException(
override val message: String? = "Gone",
override val cause: Throwable? = null,
) : HttpStatusException(410, message, cause)
@@ -0,0 +1,30 @@
/*
* 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 HttpException.kt
* LastUpdate 2026-10-11 16:52:48
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.exception
open class HttpException @JvmOverloads constructor(
message: String? = null,
throwable: Throwable? = null,
enableSuppression: Boolean = false,
writableStackTrace: Boolean = true,
) : MingLiUtilsBaseException(message, throwable, enableSuppression, writableStackTrace)
@@ -0,0 +1,38 @@
/*
* 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 HttpStatusException.kt
* LastUpdate 2026-10-11 17:02:06
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.exception
/**
* 表示 HTTP 异常的基类,继承自 [RuntimeException]。
*
* @param statusCode HTTP 状态码
* @param message 异常信息,默认为 null
* @param cause 异常原因,默认为 null
*/
open class HttpStatusException @JvmOverloads constructor(
val statusCode: Int,
message: String? = null,
throwable: Throwable? = null,
enableSuppression: Boolean = false,
writableStackTrace: Boolean = true,
) : MingLiUtilsBaseException(message, throwable, enableSuppression, writableStackTrace)
@@ -0,0 +1,30 @@
/*
* 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 HttpUrlException.kt
* LastUpdate 2026-10-11 16:53:00
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.exception
open class HttpUrlException @JvmOverloads constructor(
message: String? = null,
throwable: Throwable? = null,
enableSuppression: Boolean = false,
writableStackTrace: Boolean = true,
) : MingLiUtilsBaseException(message, throwable, enableSuppression, writableStackTrace)
@@ -0,0 +1,34 @@
/*
* 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 HttpVersionNotSupportedException.kt
* LastUpdate 2026-02-05 14:55:04
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.exception
/**
* 表示 HTTP 505 HTTP Version Not Supported 异常。
*
* @param message 异常信息,默认为 "HTTP Version Not Supported"
* @param cause 异常原因,默认为 null
*/
class HttpVersionNotSupportedException(
override val message: String? = "HTTP Version Not Supported",
override val cause: Throwable? = null,
) : HttpStatusException(505, message, cause)
@@ -0,0 +1,34 @@
/*
* 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 InternalServerErrorException.kt
* LastUpdate 2026-02-05 14:55:04
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.exception
/**
* 表示 HTTP 500 Internal Server Error 异常。
*
* @param message 异常信息,默认为 "Internal Server Error"
* @param cause 异常原因,默认为 null
*/
class InternalServerErrorException(
override val message: String? = "Internal Server Error",
override val cause: Throwable? = null,
) : HttpStatusException(500, message, cause)
@@ -0,0 +1,30 @@
/*
* 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 InvalidJsonException.kt
* LastUpdate 2026-10-11 16:53:31
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.exception
class InvalidJsonException @JvmOverloads constructor(
message: String? = null,
throwable: Throwable? = null,
enableSuppression: Boolean = false,
writableStackTrace: Boolean = true,
) : JsonException(message, throwable, enableSuppression, writableStackTrace)
@@ -0,0 +1,38 @@
/*
* 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 JsonException.kt
* LastUpdate 2026-10-11 16:53:07
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.exception
/**
* 自定义异常类,用于处理 JSON 相关操作中出现的错误。
*
* 该类继承自 [RuntimeException],提供了三种构造函数以支持不同的异常场景:
* 1. 仅包含错误信息的构造函数。
* 2. 包含错误信息和原因(Throwable)的构造函数。
* 3. 仅包含原因(Throwable)的构造函数。
*/
open class JsonException @JvmOverloads constructor(
message: String? = null,
throwable: Throwable? = null,
enableSuppression: Boolean = false,
writableStackTrace: Boolean = true,
) : MingLiUtilsBaseException(message, throwable, enableSuppression, writableStackTrace)
@@ -0,0 +1,30 @@
/*
* 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 JsonObjectCastException.kt
* LastUpdate 2026-10-11 16:53:36
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.exception
class JsonObjectCastException @JvmOverloads constructor(
message: String? = null,
throwable: Throwable? = null,
enableSuppression: Boolean = false,
writableStackTrace: Boolean = true,
) : JsonException(message, throwable, enableSuppression, writableStackTrace)
@@ -0,0 +1,30 @@
/*
* 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 JsonParserException.kt
* LastUpdate 2026-10-11 16:53:41
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.exception
class JsonParserException @JvmOverloads constructor(
message: String? = null,
throwable: Throwable? = null,
enableSuppression: Boolean = false,
writableStackTrace: Boolean = true,
) : JsonException(message, throwable, enableSuppression, writableStackTrace)
@@ -0,0 +1,30 @@
/*
* 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 JsonTypeException.kt
* LastUpdate 2026-10-11 16:53:45
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.exception
class JsonTypeException @JvmOverloads constructor(
message: String? = null,
throwable: Throwable? = null,
enableSuppression: Boolean = false,
writableStackTrace: Boolean = true,
) : JsonException(message, throwable, enableSuppression, writableStackTrace)
@@ -0,0 +1,34 @@
/*
* 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 LengthRequiredException.kt
* LastUpdate 2026-02-05 14:55:04
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.exception
/**
* 表示 HTTP 411 Length Required 异常。
*
* @param message 异常信息,默认为 "Length Required"
* @param cause 异常原因,默认为 null
*/
class LengthRequiredException(
override val message: String? = "Length Required",
override val cause: Throwable? = null,
) : HttpStatusException(411, message, cause)
@@ -0,0 +1,34 @@
/*
* 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 MethodNotAllowedException.kt
* LastUpdate 2026-02-05 14:55:04
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.exception
/**
* 表示 HTTP 405 Method Not Allowed 异常。
*
* @param message 异常信息,默认为 "Method Not Allowed"
* @param cause 异常原因,默认为 null
*/
class MethodNotAllowedException(
override val message: String? = "Method Not Allowed",
override val cause: Throwable? = null,
) : HttpStatusException(405, message, cause)
@@ -0,0 +1,30 @@
/*
* 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 MingLiUtilsBaseException.kt
* LastUpdate 2026-10-11 16:39:21
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.exception
open class MingLiUtilsBaseException @JvmOverloads constructor(
message: String? = null,
cause: Throwable? = null,
enableSuppression: Boolean = false,
writableStackTrace: Boolean = true,
) : RuntimeException(message, cause, enableSuppression, writableStackTrace)
@@ -0,0 +1,34 @@
/*
* 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 MovedPermanentlyException.kt
* LastUpdate 2026-02-05 14:55:04
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.exception
/**
* 表示 HTTP 301 Moved Permanently 异常。
*
* @param message 异常信息,默认为 "Moved Permanently"
* @param cause 异常原因,默认为 null
*/
class MovedPermanentlyException(
override val message: String? = "Moved Permanently",
override val cause: Throwable? = null,
) : HttpStatusException(301, message, cause)
@@ -0,0 +1,34 @@
/*
* 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 MultipleChoicesException.kt
* LastUpdate 2026-02-05 14:55:04
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.exception
/**
* 表示 HTTP 300 Multiple Choices 异常。
*
* @param message 异常信息,默认为 "Multiple Choices"
* @param cause 异常原因,默认为 null
*/
class MultipleChoicesException(
override val message: String? = "Multiple Choices",
override val cause: Throwable? = null,
) : HttpStatusException(300, message, cause)
@@ -0,0 +1,34 @@
/*
* 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 NotAcceptableException.kt
* LastUpdate 2026-02-05 14:55:04
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.exception
/**
* 表示 HTTP 406 Not Acceptable 异常。
*
* @param message 异常信息,默认为 "Not Acceptable"
* @param cause 异常原因,默认为 null
*/
class NotAcceptableException(
override val message: String? = "Not Acceptable",
override val cause: Throwable? = null,
) : HttpStatusException(406, message, cause)
@@ -0,0 +1,34 @@
/*
* 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 NotFoundException.kt
* LastUpdate 2026-02-05 14:55:04
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.exception
/**
* 表示 HTTP 404 Not Found 异常。
*
* @param message 异常信息,默认为 "Not Found"
* @param cause 异常原因,默认为 null
*/
class NotFoundException(
override val message: String? = "Not Found",
override val cause: Throwable? = null,
) : HttpStatusException(404, message, cause)
@@ -0,0 +1,30 @@
/*
* 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 NotFoundResourceException.kt
* LastUpdate 2026-10-11 16:53:58
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.exception
class NotFoundResourceException @JvmOverloads constructor(
message: String? = null,
throwable: Throwable? = null,
enableSuppression: Boolean = false,
writableStackTrace: Boolean = true,
) : MingLiUtilsBaseException(message, throwable, enableSuppression, writableStackTrace)
@@ -0,0 +1,34 @@
/*
* 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 NotImplementedException.kt
* LastUpdate 2026-02-05 14:55:04
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.exception
/**
* 表示 HTTP 501 Not Implemented 异常。
*
* @param message 异常信息,默认为 "Not Implemented"
* @param cause 异常原因,默认为 null
*/
class NotImplementedException(
override val message: String? = "Not Implemented",
override val cause: Throwable? = null,
) : HttpStatusException(501, message, cause)
@@ -0,0 +1,34 @@
/*
* 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 NotModifiedException.kt
* LastUpdate 2026-02-05 14:55:04
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.exception
/**
* 表示 HTTP 304 Not Modified 异常。
*
* @param message 异常信息,默认为 "Not Modified"
* @param cause 异常原因,默认为 null
*/
class NotModifiedException(
override val message: String? = "Not Modified",
override val cause: Throwable? = null,
) : HttpStatusException(304, message, cause)
@@ -0,0 +1,34 @@
/*
* 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 PaymentRequiredException.kt
* LastUpdate 2026-02-05 14:55:04
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.exception
/**
* 表示 HTTP 402 Payment Required 异常。
*
* @param message 异常信息,默认为 "Payment Required"
* @param cause 异常原因,默认为 null
*/
class PaymentRequiredException(
override val message: String? = "Payment Required",
override val cause: Throwable? = null,
) : HttpStatusException(402, message, cause)
@@ -0,0 +1,34 @@
/*
* 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 PreconditionFailedException.kt
* LastUpdate 2026-02-05 14:55:04
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.exception
/**
* 表示 HTTP 412 Precondition Failed 异常。
*
* @param message 异常信息,默认为 "Precondition Failed"
* @param cause 异常原因,默认为 null
*/
class PreconditionFailedException(
override val message: String? = "Precondition Failed",
override val cause: Throwable? = null,
) : HttpStatusException(412, message, cause)
@@ -0,0 +1,34 @@
/*
* 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 ProxyAuthenticationRequiredException.kt
* LastUpdate 2026-02-05 14:55:04
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.exception
/**
* 表示 HTTP 407 Proxy Authentication Required 异常。
*
* @param message 异常信息,默认为 "Proxy Authentication Required"
* @param cause 异常原因,默认为 null
*/
class ProxyAuthenticationRequiredException(
override val message: String? = "Proxy Authentication Required",
override val cause: Throwable? = null,
) : HttpStatusException(407, message, cause)
@@ -0,0 +1,34 @@
/*
* 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 RequestEntityTooLargeException.kt
* LastUpdate 2026-02-05 14:55:04
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.exception
/**
* 表示 HTTP 413 Request Entity Too Large 异常。
*
* @param message 异常信息,默认为 "Request Entity Too Large"
* @param cause 异常原因,默认为 null
*/
class RequestEntityTooLargeException(
override val message: String? = "Request Entity Too Large",
override val cause: Throwable? = null,
) : HttpStatusException(413, message, cause)
@@ -0,0 +1,34 @@
/*
* 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 RequestTimeoutException.kt
* LastUpdate 2026-02-05 14:55:04
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.exception
/**
* 表示 HTTP 408 Request Timeout 异常。
*
* @param message 异常信息,默认为 "Request Timeout"
* @param cause 异常原因,默认为 null
*/
class RequestTimeoutException(
override val message: String? = "Request Timeout",
override val cause: Throwable? = null,
) : HttpStatusException(408, message, cause)
@@ -0,0 +1,34 @@
/*
* 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 RequestUriTooLargeException.kt
* LastUpdate 2026-02-05 14:55:04
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.exception
/**
* 表示 HTTP 414 Request URI Too Large 异常。
*
* @param message 异常信息,默认为 "Request URI Too Large"
* @param cause 异常原因,默认为 null
*/
class RequestUriTooLargeException(
override val message: String? = "Request URI Too Large",
override val cause: Throwable? = null,
) : HttpStatusException(414, message, cause)
@@ -0,0 +1,34 @@
/*
* 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 RequestedRangeNotSatisfiableException.kt
* LastUpdate 2026-02-05 14:55:04
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.exception
/**
* 表示 HTTP 416 Requested Range Not Satisfiable 异常。
*
* @param message 异常信息,默认为 "Requested Range Not Satisfiable"
* @param cause 异常原因,默认为 null
*/
class RequestedRangeNotSatisfiableException(
override val message: String? = "Requested Range Not Satisfiable",
override val cause: Throwable? = null,
) : HttpStatusException(416, message, cause)
@@ -0,0 +1,34 @@
/*
* 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 SeeOtherException.kt
* LastUpdate 2026-02-05 14:55:04
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.exception
/**
* 表示 HTTP 303 See Other 异常。
*
* @param message 异常信息,默认为 "See Other"
* @param cause 异常原因,默认为 null
*/
class SeeOtherException(
override val message: String? = "See Other",
override val cause: Throwable? = null,
) : HttpStatusException(303, message, cause)
@@ -0,0 +1,34 @@
/*
* 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 ServiceUnavailableException.kt
* LastUpdate 2026-02-05 14:55:04
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.exception
/**
* 表示 HTTP 503 Service Unavailable 异常。
*
* @param message 异常信息,默认为 "Service Unavailable"
* @param cause 异常原因,默认为 null
*/
class ServiceUnavailableException(
override val message: String? = "Service Unavailable",
override val cause: Throwable? = null,
) : HttpStatusException(503, message, cause)
@@ -0,0 +1,34 @@
/*
* 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 TemporaryRedirectException.kt
* LastUpdate 2026-02-05 14:55:04
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.exception
/**
* 表示 HTTP 307 Temporary Redirect 异常。
*
* @param message 异常信息,默认为 "Temporary Redirect"
* @param cause 异常原因,默认为 null
*/
class TemporaryRedirectException(
override val message: String? = "Temporary Redirect",
override val cause: Throwable? = null,
) : HttpStatusException(307, message, cause)
@@ -0,0 +1,34 @@
/*
* 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 UnauthorizedException.kt
* LastUpdate 2026-02-05 14:55:04
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.exception
/**
* 表示 HTTP 401 Unauthorized 异常。
*
* @param message 异常信息,默认为 "Unauthorized"
* @param cause 异常原因,默认为 null
*/
class UnauthorizedException(
override val message: String? = "Unauthorized",
override val cause: Throwable? = null,
) : HttpStatusException(401, message, cause)
@@ -0,0 +1,34 @@
/*
* 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 UnsupportedMediaTypeException.kt
* LastUpdate 2026-02-05 14:55:04
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.exception
/**
* 表示 HTTP 415 Unsupported Media Type 异常。
*
* @param message 异常信息,默认为 "Unsupported Media Type"
* @param cause 异常原因,默认为 null
*/
class UnsupportedMediaTypeException(
override val message: String? = "Unsupported Media Type",
override val cause: Throwable? = null,
) : HttpStatusException(415, message, cause)
@@ -0,0 +1,34 @@
/*
* 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 UseProxyException.kt
* LastUpdate 2026-02-05 14:55:04
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.exception
/**
* 表示 HTTP 305 Use Proxy 异常。
*
* @param message 异常信息,默认为 "Use Proxy"
* @param cause 异常原因,默认为 null
*/
class UseProxyException(
override val message: String? = "Use Proxy",
override val cause: Throwable? = null,
) : HttpStatusException(305, message, cause)
@@ -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-28 10:49:14
* 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
/** // 读取文件内容为字符串
* 读取文件内容为字符串
*
* @param filePath 文件路径
* @return 文件内容字符串
* @throws IOException 读取文件时发生错误
*/
@Throws(IOException::class) @Throws(IOException::class)
fun readFileToString(filePath: String): String { /**
return readFileToString(filePath, DEFAULT_CHARSET) * 读取文件内容为字符串,使用默认字符集
*
* @return 文件内容的字符串表示
* @throws IOException 读取文件时发生错误
*/
fun String.readFileToString(): String {
return this.readFileToString(DEFAULT_CHARSET)
} }
/**
* 读取文件内容为字符串
*
* @param filePath 文件路径
* @param charset 字符集
* @return 文件内容字符串
* @throws IOException 读取文件时发生错误
*/
@Throws(IOException::class) @Throws(IOException::class)
fun readFileToString(filePath: String, charset: Charset): String { /**
val path = OsPath.of(filePath) * 读取文件内容为字符串
*
* @param charset 字符编码格式
* @return 文件内容的字符串表示
* @throws IOException 读取文件时发生错误
*/
fun String.readFileToString(charset: Charset): String {
val path = OsPath.of(this)
val bytes = Files.readAllBytes(path) val bytes = Files.readAllBytes(path)
return String(bytes, charset) return String(bytes, charset)
} }
/** // 将字符串写入文件
* 将字符串写入文件
*
* @param filePath 文件路径
* @param content 要写入的内容
* @throws IOException 写入文件时发生错误
*/
@Throws(IOException::class) @Throws(IOException::class)
fun writeStringToFile(filePath: String, content: String) { /**
writeStringToFile(filePath, content, DEFAULT_CHARSET) * 将字符串写入文件,使用默认字符集
*
* @param content 要写入的字符串内容
* @throws IOException 写入文件时发生错误
*/
fun String.writeStringToFile(content: String) {
this.writeStringToFile(content, DEFAULT_CHARSET)
} }
/**
* 将字符串写入文件
*
* @param filePath 文件路径
* @param content 要写入的内容
* @param charset 字符集
* @throws IOException 写入文件时发生错误
*/
@Throws(IOException::class) @Throws(IOException::class)
fun writeStringToFile(filePath: String, content: String, charset: Charset) { /**
val path = Paths.get(filePath) * 将字符串写入文件
*
* @param content 要写入的字符串内容
* @param charset 字符编码格式
* @throws IOException 写入文件时发生错误
*/
fun String.writeStringToFile(content: String, charset: Charset) {
val path = Paths.get(this)
path.parent?.let { Files.createDirectories(it) } path.parent?.let { Files.createDirectories(it) }
Files.write(path, content.toByteArray(charset)) Files.write(path, content.toByteArray(charset))
} }
/** // 读取文件内容为字符串列表(按行分割)
* 读取文件内容为字符串列表(按行分割)
*
* @param filePath 文件路径
* @return 文件内容按行分割的字符串列表
* @throws IOException 读取文件时发生错误
*/
@Throws(IOException::class) @Throws(IOException::class)
fun readLines(filePath: String): List<String> { /**
return readLines(filePath, DEFAULT_CHARSET) * 读取文件内容为字符串列表(按行分割),使用默认字符集
*
* @return 按行分割的字符串列表
* @throws IOException 读取文件时发生错误
*/
fun String.readLines(): List<String> {
return this.readLines(DEFAULT_CHARSET)
} }
/**
* 读取文件内容为字符串列表(按行分割)
*
* @param filePath 文件路径
* @param charset 字符集
* @return 文件内容按行分割的字符串列表
* @throws IOException 读取文件时发生错误
*/
@Throws(IOException::class) @Throws(IOException::class)
fun readLines(filePath: String, charset: Charset): List<String> { /**
val path = Paths.get(filePath) * 读取文件内容为字符串列表(按行分割)
*
* @param charset 字符编码格式
* @return 按行分割的字符串列表
* @throws IOException 读取文件时发生错误
*/
fun String.readLines(charset: Charset): List<String> {
val path = Paths.get(this)
return Files.readAllLines(path, charset) return Files.readAllLines(path, charset)
} }
/** // 将字符串列表写入文件(每行一个元素)
* 将字符串列表写入文件(每行一个元素)
*
* @param filePath 文件路径
* @param lines 要写入的行内容列表
* @throws IOException 写入文件时发生错误
*/
@Throws(IOException::class) @Throws(IOException::class)
fun writeLines(filePath: String, lines: List<String>) { /**
writeLines(filePath, lines, DEFAULT_CHARSET) * 将字符串列表写入文件(每行一个元素),使用默认字符集
*
* @param lines 要写入的字符串列表
* @throws IOException 写入文件时发生错误
*/
fun String.writeLines(lines: List<String>) {
this.writeLines(lines, DEFAULT_CHARSET)
} }
/**
* 将字符串列表写入文件(每行一个元素)
*
* @param filePath 文件路径
* @param lines 要写入的行内容列表
* @param charset 字符集
* @throws IOException 写入文件时发生错误
*/
@Throws(IOException::class) @Throws(IOException::class)
fun writeLines(filePath: String, lines: List<String>, charset: Charset) { /**
val path = Paths.get(filePath) * 将字符串列表写入文件(每行一个元素)
*
* @param lines 要写入的字符串列表
* @param charset 字符编码格式
* @throws IOException 写入文件时发生错误
*/
fun String.writeLines(lines: List<String>, charset: Charset) {
val path = Paths.get(this)
Files.createDirectories(path.parent) Files.createDirectories(path.parent)
Files.write(path, lines, charset) Files.write(path, lines, charset)
} }
/** // 复制文件
* 复制文件
*
* @param sourcePath 源文件路径
* @param targetPath 目标文件路径
* @throws IOException 复制文件时发生错误
*/
@Throws(IOException::class) @Throws(IOException::class)
fun copyFile(sourcePath: String, targetPath: String) { /**
val source = Paths.get(sourcePath) * 复制文件到目标路径
*
* @param targetPath 目标文件路径
* @throws IOException 复制文件时发生错误
*/
fun String.copyFile(targetPath: String) {
val source = Paths.get(this)
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 {
} }
} }
/** // 读取文件内容为字节数组
* 获取文件扩展名
*
* @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 文件内容的字节数组
* @throws IOException 读取文件时发生错误
*/
@Throws(IOException::class) @Throws(IOException::class)
fun readFileToByteArray(filePath: String): ByteArray { /**
val path = Paths.get(filePath) * 读取文件内容为字节数组
*
* @return 文件内容的字节数组表示
* @throws IOException 读取文件时发生错误
*/
fun String.readByteArray(): ByteArray {
val path = Paths.get(this)
return Files.readAllBytes(path) return Files.readAllBytes(path)
} }
/** // 将字节数组写入文件
* 将字节数组写入文件
*
* @param filePath 文件路径
* @param data 要写入的字节数据
* @throws IOException 写入文件时发生错误
*/
@Throws(IOException::class) @Throws(IOException::class)
fun writeByteArrayToFile(filePath: String, data: ByteArray) { /**
val path = Paths.get(filePath) * 将字节数组写入文件
*
* @param data 要写入的字节数组
* @throws IOException 写入文件时发生错误
*/
fun String.writeByteArray(data: ByteArray) {
val path = Paths.get(this)
Files.createDirectories(path.parent) Files.createDirectories(path.parent)
Files.write(path, data) Files.write(path, data)
} }
/** // 将字节数组追加到文件末尾
* 将字节数组追加到文件末尾
*
* @param filePath 文件路径
* @param data 要追加的字节数据
* @throws IOException 追加数据时发生错误
*/
@Throws(IOException::class) @Throws(IOException::class)
fun appendByteArrayToFile(filePath: String, data: ByteArray) { /**
val path = Paths.get(filePath) * 将字节数组追加到文件末尾
*
* @param data 要追加的字节数组
* @throws IOException 追加文件时发生错误
*/
fun String.appendByteArray(data: ByteArray) {
val path = Paths.get(this)
Files.createDirectories(path.parent) Files.createDirectories(path.parent)
Files.write( Files.write(
path, data, StandardOpenOption.CREATE, StandardOpenOption.APPEND path, data, StandardOpenOption.CREATE, StandardOpenOption.APPEND
) )
} }
/** // 分块读取大文件为字节数组列表
* 分块读取大文件为字节数组列表
*
* @param filePath 文件路径
* @param chunkSize 每块大小(字节)
* @return 文件内容按指定大小分割的字节数组列表
* @throws IOException 读取文件时发生错误
*/
@Throws(IOException::class) @Throws(IOException::class)
fun readFileToByteArrayChunks(filePath: String, chunkSize: Int): List<ByteArray> { /**
* 分块读取大文件为字节数组列表
*
* @param chunkSize 每个块的大小
* @return 字节数组列表
* @throws IOException 读取文件时发生错误
*/
fun String.readByteArrayChunks(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
} }
/** // 将字节数组列表写入文件
* 将字节数组列表写入文件
*
* @param filePath 文件路径
* @param chunks 字节数组列表
* @throws IOException 写入文件时发生错误
*/
@Throws(IOException::class) @Throws(IOException::class)
fun writeByteArrayChunksToFile(filePath: String, chunks: List<ByteArray>) { /**
val path = Paths.get(filePath) * 将字节数组列表写入文件
*
* @param chunks 字节数组列表
* @throws IOException 写入文件时发生错误
*/
fun String.writeByteArrayChunks(chunks: List<ByteArray>) {
val path = Paths.get(this)
Files.createDirectories(path.parent) Files.createDirectories(path.parent)
Files.newOutputStream(path).use { outputStream -> Files.newOutputStream(path).use { outputStream ->
@@ -344,3 +300,445 @@ 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 文件大小(字节),如果文件不存在则返回-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)
}
}
}
@@ -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 ForEach.kt * CurrentFile ForEach.kt
* LastUpdate 2025-09-15 12:44:46 * LastUpdate 2026-02-27 12:45:39
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@file:JvmName("ForEach") @file:JvmName("ForEach")
@@ -58,10 +58,8 @@ fun <T> forEach(
else -> { else -> {
// 对于其他类型的可迭代对象,使用增强 for 循环并手动维护索引 // 对于其他类型的可迭代对象,使用增强 for 循环并手动维护索引
var index = 0 for ((index, element) in iterable.withIndex()) {
for (element in iterable) {
action.call(element, index) action.call(element, index)
index++
} }
} }
} }
@@ -0,0 +1,84 @@
/*
* 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-05-23 10:30:38
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.functions
import com.mingliqiye.utils.netty.NamedThreadFactory
import java.util.concurrent.*
/**
* 防抖器类,用于实现防抖功能,防止在短时间内重复执行相同任务
*
* @author MingLiPro
*/
class Debouncer(private val delay: Long, unit: TimeUnit) {
private val scheduler: ScheduledExecutorService = Executors.newSingleThreadScheduledExecutor(
NamedThreadFactory { clazz, poolNumber, threadNumber ->
"Debouncer-$poolNumber-$threadNumber"
}
)
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
)
)
// 如果之前存在任务,则取消它
prev?.cancel(true)
}
/**
* 关闭防抖器,取消所有待执行的任务并关闭调度器
*/
fun shutdown() {
// 先取消所有延迟任务
for (future in delayedMap.values) {
future.cancel(true)
}
delayedMap.clear()
// 再关闭调度器
scheduler.shutdownNow()
}
}
@@ -16,68 +16,25 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile Functions.kt * CurrentFile Functions.kt
* LastUpdate 2026-01-09 08:12:01 * LastUpdate 2026-02-05 11:20:59
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@file:JvmName("Functions")
package com.mingliqiye.utils.functions package com.mingliqiye.utils.functions
import java.util.concurrent.* fun <T> T.with(function: Function): T = function.call().let {
this
}
/** fun <T> T.with(function: P1Function<T>): T = function.call(this).let {
* 防抖器类,用于实现防抖功能,防止在短时间内重复执行相同任务 this
* }
* @author MingLiPro
*/
class Debouncer(private val delay: Long, unit: TimeUnit) {
private val scheduler: ScheduledExecutorService = Executors.newSingleThreadScheduledExecutor() @FunctionalInterface
private val delayedMap: ConcurrentHashMap<Any, Future<*>> = ConcurrentHashMap() fun interface Function {
private val delayMillis: Long = unit.toMillis(delay) fun call()
/**
* 执行防抖操作,如果在指定延迟时间内再次调用相同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
@@ -184,3 +141,597 @@ fun interface P10Function<P, P1, P2, P3, P4, P5, P6, P7, P8, P9> {
fun interface P10RFunction<P, P1, P2, P3, P4, P5, P6, P7, P8, P9, R> { fun interface P10RFunction<P, P1, P2, P3, P4, P5, P6, P7, P8, P9, R> {
fun call(p: P, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9): R fun call(p: P, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9): R
} }
@FunctionalInterface
fun interface P11Function<P, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10> {
fun call(p: P, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, p10: P10)
}
@FunctionalInterface
fun interface P11RFunction<P, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, R> {
fun call(p: P, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, p10: P10): R
}
@FunctionalInterface
fun interface P12Function<P, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11> {
fun call(p: P, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, p10: P10, p11: P11)
}
@FunctionalInterface
fun interface P12RFunction<P, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, R> {
fun call(p: P, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, p10: P10, p11: P11): R
}
@FunctionalInterface
fun interface P13Function<P, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12> {
fun call(p: P, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, p10: P10, p11: P11, p12: P12)
}
@FunctionalInterface
fun interface P13RFunction<P, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, R> {
fun call(
p: P,
p1: P1,
p2: P2,
p3: P3,
p4: P4,
p5: P5,
p6: P6,
p7: P7,
p8: P8,
p9: P9,
p10: P10,
p11: P11,
p12: P12
): R
}
@FunctionalInterface
fun interface P14Function<P, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13> {
fun call(
p: P,
p1: P1,
p2: P2,
p3: P3,
p4: P4,
p5: P5,
p6: P6,
p7: P7,
p8: P8,
p9: P9,
p10: P10,
p11: P11,
p12: P12,
p13: P13
)
}
@FunctionalInterface
fun interface P14RFunction<P, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, R> {
fun call(
p: P,
p1: P1,
p2: P2,
p3: P3,
p4: P4,
p5: P5,
p6: P6,
p7: P7,
p8: P8,
p9: P9,
p10: P10,
p11: P11,
p12: P12,
p13: P13
): R
}
@FunctionalInterface
fun interface P15Function<P, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14> {
fun call(
p: P,
p1: P1,
p2: P2,
p3: P3,
p4: P4,
p5: P5,
p6: P6,
p7: P7,
p8: P8,
p9: P9,
p10: P10,
p11: P11,
p12: P12,
p13: P13,
p14: P14
)
}
@FunctionalInterface
fun interface P15RFunction<P, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, R> {
fun call(
p: P,
p1: P1,
p2: P2,
p3: P3,
p4: P4,
p5: P5,
p6: P6,
p7: P7,
p8: P8,
p9: P9,
p10: P10,
p11: P11,
p12: P12,
p13: P13,
p14: P14
): R
}
@FunctionalInterface
fun interface P16Function<P, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15> {
fun call(
p: P,
p1: P1,
p2: P2,
p3: P3,
p4: P4,
p5: P5,
p6: P6,
p7: P7,
p8: P8,
p9: P9,
p10: P10,
p11: P11,
p12: P12,
p13: P13,
p14: P14,
p15: P15
)
}
@FunctionalInterface
fun interface P16RFunction<P, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, R> {
fun call(
p: P,
p1: P1,
p2: P2,
p3: P3,
p4: P4,
p5: P5,
p6: P6,
p7: P7,
p8: P8,
p9: P9,
p10: P10,
p11: P11,
p12: P12,
p13: P13,
p14: P14,
p15: P15
): R
}
@FunctionalInterface
fun interface P17Function<P, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16> {
fun call(
p: P,
p1: P1,
p2: P2,
p3: P3,
p4: P4,
p5: P5,
p6: P6,
p7: P7,
p8: P8,
p9: P9,
p10: P10,
p11: P11,
p12: P12,
p13: P13,
p14: P14,
p15: P15,
p16: P16
)
}
@FunctionalInterface
fun interface P17RFunction<P, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, R> {
fun call(
p: P,
p1: P1,
p2: P2,
p3: P3,
p4: P4,
p5: P5,
p6: P6,
p7: P7,
p8: P8,
p9: P9,
p10: P10,
p11: P11,
p12: P12,
p13: P13,
p14: P14,
p15: P15,
p16: P16
): R
}
@FunctionalInterface
fun interface P18Function<P, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17> {
fun call(
p: P,
p1: P1,
p2: P2,
p3: P3,
p4: P4,
p5: P5,
p6: P6,
p7: P7,
p8: P8,
p9: P9,
p10: P10,
p11: P11,
p12: P12,
p13: P13,
p14: P14,
p15: P15,
p16: P16,
p17: P17
)
}
@FunctionalInterface
fun interface P18RFunction<P, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, R> {
fun call(
p: P,
p1: P1,
p2: P2,
p3: P3,
p4: P4,
p5: P5,
p6: P6,
p7: P7,
p8: P8,
p9: P9,
p10: P10,
p11: P11,
p12: P12,
p13: P13,
p14: P14,
p15: P15,
p16: P16,
p17: P17
): R
}
@FunctionalInterface
fun interface P19Function<P, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18> {
fun call(
p: P,
p1: P1,
p2: P2,
p3: P3,
p4: P4,
p5: P5,
p6: P6,
p7: P7,
p8: P8,
p9: P9,
p10: P10,
p11: P11,
p12: P12,
p13: P13,
p14: P14,
p15: P15,
p16: P16,
p17: P17,
p18: P18
)
}
@FunctionalInterface
fun interface P19RFunction<P, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, R> {
fun call(
p: P,
p1: P1,
p2: P2,
p3: P3,
p4: P4,
p5: P5,
p6: P6,
p7: P7,
p8: P8,
p9: P9,
p10: P10,
p11: P11,
p12: P12,
p13: P13,
p14: P14,
p15: P15,
p16: P16,
p17: P17,
p18: P18
): R
}
@FunctionalInterface
fun interface P20Function<P, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19> {
fun call(
p: P,
p1: P1,
p2: P2,
p3: P3,
p4: P4,
p5: P5,
p6: P6,
p7: P7,
p8: P8,
p9: P9,
p10: P10,
p11: P11,
p12: P12,
p13: P13,
p14: P14,
p15: P15,
p16: P16,
p17: P17,
p18: P18,
p19: P19
)
}
@FunctionalInterface
fun interface P20RFunction<P, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, R> {
fun call(
p: P,
p1: P1,
p2: P2,
p3: P3,
p4: P4,
p5: P5,
p6: P6,
p7: P7,
p8: P8,
p9: P9,
p10: P10,
p11: P11,
p12: P12,
p13: P13,
p14: P14,
p15: P15,
p16: P16,
p17: P17,
p18: P18,
p19: P19
): R
}
@FunctionalInterface
fun interface P21Function<P, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20> {
fun call(
p: P,
p1: P1,
p2: P2,
p3: P3,
p4: P4,
p5: P5,
p6: P6,
p7: P7,
p8: P8,
p9: P9,
p10: P10,
p11: P11,
p12: P12,
p13: P13,
p14: P14,
p15: P15,
p16: P16,
p17: P17,
p18: P18,
p19: P19,
p20: P20
)
}
@FunctionalInterface
fun interface P21RFunction<P, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, R> {
fun call(
p: P,
p1: P1,
p2: P2,
p3: P3,
p4: P4,
p5: P5,
p6: P6,
p7: P7,
p8: P8,
p9: P9,
p10: P10,
p11: P11,
p12: P12,
p13: P13,
p14: P14,
p15: P15,
p16: P16,
p17: P17,
p18: P18,
p19: P19,
p20: P20
): R
}
@FunctionalInterface
fun interface P22Function<P, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21> {
fun call(
p: P,
p1: P1,
p2: P2,
p3: P3,
p4: P4,
p5: P5,
p6: P6,
p7: P7,
p8: P8,
p9: P9,
p10: P10,
p11: P11,
p12: P12,
p13: P13,
p14: P14,
p15: P15,
p16: P16,
p17: P17,
p18: P18,
p19: P19,
p20: P20,
p21: P21
)
}
@FunctionalInterface
fun interface P22RFunction<P, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, R> {
fun call(
p: P,
p1: P1,
p2: P2,
p3: P3,
p4: P4,
p5: P5,
p6: P6,
p7: P7,
p8: P8,
p9: P9,
p10: P10,
p11: P11,
p12: P12,
p13: P13,
p14: P14,
p15: P15,
p16: P16,
p17: P17,
p18: P18,
p19: P19,
p20: P20,
p21: P21
): R
}
@FunctionalInterface
fun interface P23Function<P, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22> {
fun call(
p: P,
p1: P1,
p2: P2,
p3: P3,
p4: P4,
p5: P5,
p6: P6,
p7: P7,
p8: P8,
p9: P9,
p10: P10,
p11: P11,
p12: P12,
p13: P13,
p14: P14,
p15: P15,
p16: P16,
p17: P17,
p18: P18,
p19: P19,
p20: P20,
p21: P21,
p22: P22
)
}
@FunctionalInterface
fun interface P23RFunction<P, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22, R> {
fun call(
p: P,
p1: P1,
p2: P2,
p3: P3,
p4: P4,
p5: P5,
p6: P6,
p7: P7,
p8: P8,
p9: P9,
p10: P10,
p11: P11,
p12: P12,
p13: P13,
p14: P14,
p15: P15,
p16: P16,
p17: P17,
p18: P18,
p19: P19,
p20: P20,
p21: P21,
p22: P22
): R
}
@FunctionalInterface
fun interface P24Function<P, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22, P23> {
fun call(
p: P,
p1: P1,
p2: P2,
p3: P3,
p4: P4,
p5: P5,
p6: P6,
p7: P7,
p8: P8,
p9: P9,
p10: P10,
p11: P11,
p12: P12,
p13: P13,
p14: P14,
p15: P15,
p16: P16,
p17: P17,
p18: P18,
p19: P19,
p20: P20,
p21: P21,
p22: P22,
p23: P23
)
}
@FunctionalInterface
fun interface P24RFunction<P, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22, P23, R> {
fun call(
p: P,
p1: P1,
p2: P2,
p3: P3,
p4: P4,
p5: P5,
p6: P6,
p7: P7,
p8: P8,
p9: P9,
p10: P10,
p11: P11,
p12: P12,
p13: P13,
p14: P14,
p15: P15,
p16: P16,
p17: P17,
p18: P18,
p19: P19,
p20: P20,
p21: P21,
p22: P22,
p23: P23
): R
}
@@ -0,0 +1,305 @@
/*
* 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 Pipeline.kt
* LastUpdate 2026-02-24 09:10:26
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.functions
import com.mingliqiye.utils.require.Require
import kotlin.reflect.KClass
/**
* 流水线操作类,提供链式调用的操作方式来处理数据转换和操作
* @param T 泛型类型,表示流水线中处理的数据类型
*/
class Pipeline<T>(private val value: T) {
/**
* 对当前值进行转换操作,并返回新的Pipeline实例
* @param transformer 转换函数,接收当前值并返回转换后的结果
* @return 包含转换后结果的新Pipeline实例
*/
fun <R> transform(transformer: P1RFunction<T, R>): Pipeline<R> = Pipeline(transformer.call(value))
/**
* 对当前值进行转换操作,功能与transform相同,提供不同的方法名选择
* @param transformer 转换函数,接收当前值并返回转换后的结果
* @return 包含转换后结果的新Pipeline实例
*/
fun <R> then(transformer: P1RFunction<T, R>): Pipeline<R> = transform(transformer)
/**
* 消费当前值但不改变流水线状态,用于执行副作用操作
* @param consumer 消费函数,接收当前值进行消费操作
* @return 当前Pipeline实例,支持链式调用
*/
fun consume(consumer: P1Function<T>): Pipeline<T> {
consumer.call(value)
return this
}
/**
* 判断当前值是否为null
* @return true表示当前值为null,false表示不为null
*/
fun isNull(): Boolean = (value == null)
/**
* 判断当前值是否不为null
* @return true表示当前值不为null,false表示为null
*/
fun isNotNull(): Boolean = (value != null)
/**
* 根据条件过滤当前值,如果条件满足则保持原值,否则设置为null
* @param predicate 过滤条件函数,接收当前值并返回布尔值
* @return 包含过滤后结果的Pipeline实例
*/
fun filter(predicate: P1RFunction<T, Boolean>): Pipeline<T?> =
if (predicate.call(value)) Pipeline(value) else Pipeline(null)
/**
* 获取当前流水线中的值
* @return 当前流水线中存储的值
*/
fun getValue(): T = value
/**
* 安全地转换当前值,允许转换结果为null
* @param transformer 转换函数,可能返回null
* @return 包含转换后结果(可能为null)的Pipeline实例
*/
fun <R> safeTransform(transformer: P1RFunction<T, R?>): Pipeline<R?> = Pipeline(transformer.call(value))
/**
* 将当前值映射为另一个Pipeline实例
* @param mapper 映射函数,接收当前值并返回Pipeline实例
* @return 映射后的Pipeline实例
*/
fun <R> flatMap(mapper: P1RFunction<T, Pipeline<R>>): Pipeline<R> = mapper.call(value)
/**
* 将当前值映射为非null结果,如果当前值为null则直接返回null
* @param mapper 映射函数,可能返回null
* @return 包含映射后结果的Pipeline实例
*/
fun <R> mapNotNull(mapper: P1RFunction<T, R?>): Pipeline<out R?> =
if (value != null) Pipeline(mapper.call(value)!!) else Pipeline(null)
/**
* 将当前值强制转换为指定类型
* @param type 目标类型Class对象
* @return 包含转换后类型的Pipeline实例
* @throws ClassCastException 当类型转换失败时抛出异常
*/
@Throws(ClassCastException::class)
@Suppress("UNCHECKED_CAST")
fun <E> cast(type: Class<E>): Pipeline<E> = Pipeline(value as E)
/**
* 根据条件判断是否保留当前值,条件满足时保留,否则返回null
* @param predicate 条件判断函数
* @return 包含条件判断结果的Pipeline实例
*/
fun takeIf(predicate: P1RFunction<T, Boolean>): Pipeline<T?> = Pipeline(if (predicate.call(value)) value else null)
/**
* 根据条件判断是否保留当前值,条件不满足时保留,否则返回null
* @param predicate 条件判断函数
* @return 包含条件判断结果的Pipeline实例
*/
fun takeUnless(predicate: P1RFunction<T, Boolean>): Pipeline<T?> =
Pipeline(if (!predicate.call(value)) value else null)
/**
* 在当前值上执行指定操作并返回操作结果
* @param block 执行函数,接收当前值并返回结果
* @return 包含执行结果的Pipeline实例
*/
fun <R> let(block: P1RFunction<T, R>): Pipeline<R> = Pipeline(block.call(value))
/**
* 如果当前值不为null则返回自身,否则返回默认值的Pipeline实例
* @param defaultValue 默认值
* @return 当前值或默认值的Pipeline实例
*/
fun orElse(defaultValue: T): Pipeline<T> = if (value != null) this else Pipeline(defaultValue)
/**
* 如果当前值不为null则返回自身,否则通过供应商函数获取默认值
* @param supplier 默认值供应商函数
* @return 当前值或供应商提供的值的Pipeline实例
*/
fun orElseGet(supplier: RFunction<T>): Pipeline<T> = if (value != null) this else Pipeline(supplier.call())
/**
* 验证当前值是否等于指定值,如果不相等则抛出异常
* @param any 比较的目标值
* @param message 错误消息
* @param exception 异常类型,默认为IllegalArgumentException
* @return 当前Pipeline实例
*/
fun require(
any: Any, message: String, exception: Class<out Exception> = IllegalArgumentException::class.java
): Pipeline<T> {
Require.require(any == value, message, exception)
return this
}
/**
* 验证当前值是否等于指定值,如果不相等则抛出IllegalArgumentException异常
* @param any 比较的目标值
* @param message 错误消息
* @return 当前Pipeline实例
*/
fun require(
any: Any, message: String
): Pipeline<T> {
Require.require(any == value, message)
return this
}
/**
* 使用P1RFunction验证当前值是否满足条件,不满足则抛出异常
* @param must 验证条件函数
* @param message 错误消息
* @param exception 异常类型,默认为IllegalArgumentException
* @return 当前Pipeline实例
*/
fun require(
must: P1RFunction<T, Boolean>,
message: String,
exception: Class<out Throwable> = IllegalArgumentException::class.java
): Pipeline<T> {
Require.require(must.call(value), message, exception)
return this
}
/**
* 验证当前值是否等于指定值,如果不相等则抛出异常
* @param any 比较的目标值
* @param message 错误消息
* @param exception 异常类型,默认为IllegalArgumentException
* @return 当前Pipeline实例
*/
fun require(
any: Any,
message: String,
exception: KClass<out Throwable> = IllegalArgumentException::class
): Pipeline<T> {
Require.require(any == value, message, exception)
return this
}
/**
* 使用P1RFunction验证当前值是否满足条件,不满足则抛出异常
* @param must 验证条件函数
* @param message 错误消息
* @param exception 异常类型,默认为IllegalArgumentException
* @return 当前Pipeline实例
*/
fun require(
must: P1RFunction<T, Boolean>,
message: String,
exception: KClass<out Throwable> = IllegalArgumentException::class
): Pipeline<T> {
Require.require(must.call(value), message, exception)
return this
}
/**
* 使用P1RFunction验证当前值是否满足条件,不满足则抛出IllegalArgumentException异常
* @param must 验证条件函数
* @param message 错误消息
* @return 当前Pipeline实例
*/
fun require(
must: P1RFunction<T, Boolean>, message: String
): Pipeline<T> {
Require.require(must.call(value), message, IllegalArgumentException::class.java)
return this
}
/**
* 对当前值执行指定操作但不改变流水线状态
* @param block 执行函数,接收当前值
* @return 当前Pipeline实例
*/
fun also(block: P1Function<T>): Pipeline<T> {
block.call(value)
return this
}
/**
* 验证当前值是否满足指定条件,不满足则抛出IllegalArgumentException异常
* @param predicate 验证条件函数
* @param lazyMessage 延迟错误消息生成函数,默认返回"Requirement failed"
* @return 当前Pipeline实例
*/
fun require(
predicate: P1RFunction<T, Boolean>,
lazyMessage: P1RFunction<T, Any> = P1RFunction { "Requirement failed" }
): Pipeline<T> {
if (!predicate.call(value)) {
throw IllegalArgumentException(lazyMessage.call(value).toString())
}
return this
}
/**
* 使用比较器比较当前值与另一个值
* @param other 另一个比较值
* @param comparator 比较器
* @return 比较结果,负数表示小于,0表示相等,正数表示大于
*/
fun compareWith(other: T, comparator: Comparator<in T>): Int = comparator.compare(value, other)
/**
* 使用选择器将当前值转换为可比较类型后与另一个值比较
* @param other 另一个比较值
* @param selector 选择器函数,将当前值转换为可比较类型
* @return 比较结果
*/
fun <R : Comparable<R>> compareTo(other: R, selector: P1RFunction<T, R>): Int =
selector.call(value).compareTo(other)
companion object {
/**
* 创建包含指定值的Pipeline实例
* @param value 要包装的值
* @return 新的Pipeline实例
*/
@JvmStatic
fun <T> of(value: T): Pipeline<T> = Pipeline(value)
/**
* 通过供应商函数创建Pipeline实例
* @param transformer 值供应商函数
* @return 新的Pipeline实例
*/
@JvmStatic
fun <T> of(transformer: RFunction<T>): Pipeline<T> = Pipeline(transformer.call())
}
}
@@ -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 HashUtils.kt * CurrentFile HashUtils.kt
* LastUpdate 2025-09-19 20:24:33 * LastUpdate 2026-01-11 09:09:52
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@file:JvmName("HashUtils") @file:JvmName("HashUtils")
@@ -24,9 +24,9 @@
package com.mingliqiye.utils.hash package com.mingliqiye.utils.hash
import com.mingliqiye.utils.base.BASE16
import com.mingliqiye.utils.bcrypt.checkpw import com.mingliqiye.utils.bcrypt.checkpw
import com.mingliqiye.utils.bcrypt.hashpw 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
@@ -64,16 +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 {
return BASE16.encode(bytes)
}
/** /**
* 使用 BCrypt 算法对字符串进行加密。 * 使用 BCrypt 算法对字符串进行加密。
* *
File diff suppressed because it is too large Load Diff
@@ -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 MediaTypeUtils.kt
* LastUpdate 2026-02-27 22:15:03
* UpdateUser MingLiPro
*/
@file:JvmName("MediaTypeUtils")
package com.mingliqiye.utils.http
import okhttp3.MediaType.Companion.toMediaType
fun MediaType.okhttp(): okhttp3.MediaType = this.value.toMediaType()
@@ -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,48 +16,290 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile Response.kt * CurrentFile Response.kt
* LastUpdate 2025-09-15 09:04:05 * LastUpdate 2026-03-14 08:01:32
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
package com.mingliqiye.utils.http package com.mingliqiye.utils.http
import com.mingliqiye.utils.time.DateTime import com.mingliqiye.utils.time.DateTime
import com.mingliqiye.utils.time.Formatter
/**
* HTTP响应数据类
* 封装了时间、消息、数据和状态码等响应信息
*
* 该类用于统一API响应的格式,支持链式调用和不可变对象的创建。
* 提供了多种工厂方法用于创建不同类型的响应对象。
*
* @param T 响应数据的类型
* @property time 响应时间(格式化的字符串)
* @property message 响应消息
* @property data 响应数据,可能为空
* @property statusCode HTTP状态码
*/
data class Response<T>( data class Response<T>(
val time: String, private val time: String, // 响应时间,一旦创建不可修改
var message: String, private var message: String, // 响应消息,可通过setter修改
var data: T?, private var data: T?, // 响应数据,可通过setter修改
var statusCode: Int private var statusCode: Int, // HTTP状态码,可通过setter修改
) { ) {
companion object { companion object {
@JvmStatic /**
fun <T> ok(data: T): Response<T?> { * 创建一个默认的成功响应对象
return Response(DateTime.now().format(Formatter.STANDARD_DATETIME_MILLISECOUND7), "操作成功", data, 200) * 使用默认消息"操作成功",无数据,状态码200
} *
* @return Response<Nothing> 默认的成功响应对象
*/
fun ok() = ok("操作成功")
/**
* 创建一个默认的错误响应对象
* 使用默认消息"服务器错误",无数据,状态码500
*
* @return Response<Nothing> 默认的成功响应对象
*/
fun error() = error("服务器错误")
/**
* 创建一个成功的响应对象(仅包含消息)
*
* @param message 响应消息
* @return Response<Any> 成功的响应对象,数据为null
*/
@JvmStatic @JvmStatic
fun <T> ok(message: String): Response<T?> { fun ok(message: String) = Response(
return Response(DateTime.now().format(Formatter.STANDARD_DATETIME_MILLISECOUND7), message, null, 200) time = DateTime.now().format(),
} message = message,
data = null,
statusCode = 200
)
/**
* 创建一个错误的响应对象
*
* @param message 错误消息,默认为"服务器错误"
* @param statusCode HTTP状态码,默认为500
* @return Response<Any> 错误的响应对象
*/
fun error(message: String = "服务器错误", statusCode: Int = 500) = ok(message).withStatusCode(statusCode)
/**
* 创建一个成功的响应对象(仅包含数据)
* 使用默认消息"操作成功"
*
* @param T 响应数据的类型
* @param data 响应数据
* @return Response<T> 成功的响应对象,包含数据
*/
@JvmStatic
fun <T> okData(data: T) = Response(
time = DateTime.now().format(),
message = "操作成功",
data = data,
statusCode = 200
)
/**
* 创建一个成功的响应对象(包含数据和消息)
*
* @param T 响应数据的类型
* @param data 响应数据
* @param message 响应消息
* @return Response<T> 成功的响应对象,包含数据和消息
*/
@JvmStatic
fun <T> okData(data: T, message: String) = Response(
time = DateTime.now().format(),
message = message,
data = data,
statusCode = 200
)
/**
* 创建一个指定状态码的响应对象(仅包含状态码)
* 使用默认消息"操作成功",无数据
*
* @param statusCode HTTP状态码
* @return Response<Any> 指定状态码的响应对象
*/
@JvmStatic
fun code(statusCode: Int) = Response(
time = DateTime.now().format(),
message = "操作成功",
data = null,
statusCode = statusCode
)
/**
* 创建一个指定状态码的响应对象(包含状态码和消息)
* 无数据
*
* @param statusCode HTTP状态码
* @param message 响应消息
* @return Response<Any> 指定状态码和消息的响应对象
*/
@JvmStatic
fun code(statusCode: Int, message: String) = Response(
time = DateTime.now().format(),
message = message,
data = null,
statusCode = statusCode
)
} }
/**
* 默认构造函数,创建一个默认的成功响应对象
* 使用当前时间、默认消息"操作成功"、状态码200、无数据
*/
constructor() : this(
time = DateTime.now().format(),
message = "操作成功",
statusCode = 200,
data = null
)
/**
* 获取格式化后的时间字符串。
*
* @return 格式化后的时间字符串
*/
fun getTime(): String = time
/**
* 获取响应消息
*
* @return String 当前响应消息
*/
fun getMessage(): String = message
/**
* 设置响应消息
*
* 该方法允许修改响应消息,并返回当前对象以支持链式调用。
*
* @param message 新的响应消息
* @return Response<T> 当前响应对象(支持链式调用)
*/
fun setMessage(message: String): Response<T> { fun setMessage(message: String): Response<T> {
this.message = message this.message = message
return this return this
} }
fun setData(data: T): Response<T?> { /**
this.data = data * 获取响应数据
return ok(this.data) *
.setMessage(this.message) * 返回的响应数据可能为null,调用前应进行空值检查。
.setStatusCode(this.statusCode) *
* @return T? 响应数据,可能为空
*/
fun getData(): T? = data
/**
* 获取非空数据对象
*
* 该方法强制解包data属性,如果data为null则会抛出NullPointerException异常。
* 适用于确定data不为null的场景,避免重复的空值检查。
*
* @return T 非空的数据对象
* @throws NullPointerException 当data属性为null时抛出此异常
*/
@Throws(NullPointerException::class)
fun notNullData(): T {
return data ?: throw NullPointerException("at Response.notNullData() because data is null")
} }
/**
* 设置响应数据
*
* 该方法允许修改响应数据,并返回当前对象以支持链式调用。
*
* @param data 新的响应数据
* @return Response<T> 当前响应对象(支持链式调用)
*/
fun setData(data: T): Response<T> {
this.data = data
return this
}
/**
* 创建一个新的Response对象,使用指定的时间
*
* 该方法用于创建具有新时间的响应对象,遵循不可变对象的设计模式。
* 如果时间相同,则返回原对象避免不必要的对象创建。
*
* @param time 新的响应时间
* @return Response<T> 新的响应对象(如果时间相同则返回原对象)
*/
fun withTime(time: String): Response<T> =
if (this.time == time) this else Response(time, message, data, statusCode)
/**
* 创建一个新的Response对象,使用指定的数据
*
* 该方法允许改变响应数据的类型,创建一个新的响应对象。
* 适用于需要在保持其他字段不变的情况下更新数据类型的场景。
*
* @param D 新的数据类型
* @param data 新的响应数据
* @return Response<D> 新的响应对象,数据类型为D
*/
fun <D> withData(data: D): Response<D> =
Response(this.time, this.message, data, this.statusCode)
/**
* 创建一个新的Response对象,使用指定的消息
*
* 该方法用于创建具有新消息的响应对象,遵循不可变对象的设计模式。
* 如果消息相同,则返回原对象避免不必要的对象创建。
*
* @param message 新的响应消息
* @return Response<T> 新的响应对象(如果消息相同则返回原对象)
*/
fun withMessage(message: String): Response<T> =
if (this.message == message) this else Response(time, message, data, statusCode)
/**
* 创建一个新的Response对象,使用指定的状态码
*
* 该方法用于创建具有新状态码的响应对象,遵循不可变对象的设计模式。
* 如果状态码相同,则返回原对象避免不必要的对象创建。
*
* @param statusCode 新的状态码
* @return Response<T> 新的响应对象(如果状态码相同则返回原对象)
*/
fun withStatusCode(statusCode: Int): Response<T> =
if (this.statusCode == statusCode) this else Response(time, message, data, statusCode)
/**
* 获取状态码
*
* @return Int 当前HTTP状态码
*/
fun getStatusCode(): Int = statusCode
/**
* 设置状态码
*
* 该方法允许修改状态码,并返回当前对象以支持链式调用。
*
* @param statusCode 新的HTTP状态码
* @return Response<T> 当前响应对象(支持链式调用)
*/
fun setStatusCode(statusCode: Int): Response<T> { fun setStatusCode(statusCode: Int): Response<T> {
this.statusCode = statusCode this.statusCode = statusCode
return this return this
} }
/**
* 返回响应对象的字符串表示
*
* 重写toString方法以提供更有意义的对象表示,便于日志记录和调试。
* 显示时间、消息、数据类型和值以及状态码。
*
* @return 格式化的字符串表示
*/
override fun toString(): String =
"Response<${data?.javaClass?.simpleName ?: "Nothing"}>(time=${getTime()}, message=${getMessage()}, data=${getData()}, statusCode=${getStatusCode()})"
} }
@@ -0,0 +1,50 @@
/*
* 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 OkHttpUtils.kt
* LastUpdate 2026-02-27 22:16:15
* UpdateUser MingLiPro
*/
@file:JvmName("OkHttpUtils")
package com.mingliqiye.utils.http.okhttp
import com.mingliqiye.utils.http.MediaType
import com.mingliqiye.utils.http.okhttp
import com.mingliqiye.utils.json.api.JSONA
import com.mingliqiye.utils.json.api.JSONA.toJson
import okhttp3.OkHttpClient
import okhttp3.Request
import okhttp3.RequestBody.Companion.toRequestBody
import okhttp3.Response
inline fun <reified T> Response.json() = body.use {
JSONA.parse<T>(it.bytes())
}
fun Response.text() = body.use {
String(it.bytes())
}
fun OkHttpClient.request() = Request.Builder()
fun Request.Builder.call(okHttpClient: OkHttpClient) = okHttpClient.newCall(this.build())
fun Request.Builder.postWithJson(data: Any): Request.Builder {
data.toJson().toRequestBody(MediaType.APPLICATION_JSON.okhttp())
return this
}
@@ -1,63 +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 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)
}
}
}
@@ -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 InputStreamUtils.kt * CurrentFile InputStreamUtils.kt
* LastUpdate 2025-09-15 17:26:34 * LastUpdate 2026-03-11 08:46:40
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@file:JvmName("InputStreamUtils") @file:JvmName("InputStreamUtils")
@@ -28,23 +28,16 @@ import java.io.OutputStream
import java.nio.charset.Charset import java.nio.charset.Charset
fun InputStream.readAllText(charset: Charset = Charsets.UTF_8): String { fun InputStream.readAllText(charset: Charset = Charsets.UTF_8) = this.readAllBytes().toString(charset)
return this.readAllBytes().toString(charset)
}
fun InputStream.readAllBytes(): ByteArray {
return this.readBytes()
}
fun InputStream.exportBytes(out: OutputStream) { fun InputStream.exportBytes(out: OutputStream) {
out.write(this.readAllBytes()) out.write(this.readAllBytes())
out.flush() out.flush()
} }
fun InputStream.readToList(): List<Byte> { fun InputStream.readToList(): List<Byte> = this.readBytes().toList()
return this.readBytes().toList()
}
@Suppress("EXTENSION_SHADOWED_BY_MEMBER")
@JvmName("readInputStreamAllBytes")
fun InputStream.readAllBytes(): ByteArray = this.readBytes()
@@ -0,0 +1,339 @@
/*
* 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 SIO.kt
* LastUpdate 2026-06-21 10:40:58
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.io
import com.mingliqiye.utils.array.toHexString
import com.mingliqiye.utils.logger.MingLiLoggerFactory
import com.mingliqiye.utils.string.join
import org.slf4j.Logger
import java.io.OutputStream
import java.io.PrintStream
/**
* 已弃用的IO对象,所有方法都委托给SIO对象
* @deprecated 请使用SIO对象替代
*/
@Deprecated("This IO is deprecated. reName SIO", replaceWith = ReplaceWith("SIO"), level = DeprecationLevel.WARNING)
object IO {
/**
* 打印多个参数,使用空格分隔
* @param args 要打印的参数数组
*/
@JvmStatic
fun print(vararg args: Any?) = SIO.print(*args)
/**
* 打印多个参数并换行,使用空格分隔
* @param args 要打印的参数数组
*/
@JvmStatic
fun println(vararg args: Any?) = SIO.println(*args)
/**
* 打印多个参数并换行,指定分隔符
* @param sp 分隔符
* @param args 要打印的参数数组
*/
@JvmStatic
fun printlnA(sp: String, vararg args: Any?) = SIO.printlnA(sp, *args)
/**
* 打印多个参数,指定分隔符
* @param sp 分隔符,默认为空字符串
* @param args 要打印的参数数组
*/
@JvmStatic
fun printA(sp: String = "", vararg args: Any?) = SIO.printA(sp, *args)
/**
* 重定向 System.out 到 INFO 级别日志
*/
@JvmStatic
fun redirectOutToInfo() = SIO.redirectOutToInfo()
/**
* 重定向 System.err 到 ERROR 级别
*/
@JvmStatic
fun redirectErrToError() = SIO.redirectErrToError()
/**
* 完全重定向(包括第三方库的输出)
*/
@JvmStatic
fun redirectAll() = SIO.redirectAll()
/**
* 恢复原始输出流
*/
@JvmStatic
fun restore() = SIO.restore()
}
/**
* IO工具类,提供打印功能和系统输出流重定向到日志的功能
*/
object SIO {
/**
* 扩展函数:将字节数组以十六进制格式打印,每两个字符用空格分隔
* @return 原始字节数组
*/
@JvmStatic
fun ByteArray.println(): ByteArray {
this.toHexString().chunked(2).println()
return this
}
fun <T> T.ifOr(boolean: Boolean, pd: T.() -> T): T = if (boolean) {
this
} else pd(this)
fun <T> T.ifOrElse(boolean: Boolean, pd: T.() -> T): T = if (!boolean) {
this
} else pd(this)
/**
* 扩展函数:将列表以花括号格式打印,元素间用逗号分隔
* @return 原始列表
*/
@JvmStatic
fun <T> List<T>.println(): List<T> {
println("{" + ",".join(this) + "}")
return this
}
/**
* 扩展函数:将数组以花括号格式打印,元素间用逗号分隔
* @return 原始数组
*/
@JvmStatic
fun <T> Array<T>.println(): Array<T> {
println("{" + ",".join(this) + "}")
return this
}
/**
* 扩展函数:打印任意对象并返回该对象
* @return 原始对象
*/
@JvmStatic
fun <T> T.println(): T {
println(this)
return this
}
/**
* 原始标准输出流的备份
*/
@JvmStatic
val originalOut: PrintStream = System.out
/**
* 原始错误输出流的备份
*/
@JvmStatic
val originalErr: PrintStream = System.err
/**
* 用于记录标准输出的日志记录器
*/
@JvmStatic
val outLog: Logger = MingLiLoggerFactory.getLogger("out")
/**
* 用于记录错误输出的日志记录器
*/
@JvmStatic
val errLog: Logger = MingLiLoggerFactory.getLogger("err")
/**
* 打印多个参数,使用空格分隔
* @param args 要打印的参数数组
*/
@JvmStatic
fun print(vararg args: Any?) {
printA(" ", *args)
}
/**
* 打印多个参数并换行,使用空格分隔
* @param args 要打印的参数数组
*/
@JvmStatic
fun println(vararg args: Any?) {
printlnA(" ", *args)
}
/**
* 打印多个参数并换行,指定分隔符
* @param sp 分隔符
* @param args 要打印的参数数组
*/
@JvmStatic
fun printlnA(sp: String, vararg args: Any?) {
printA(" ", *args)
kotlin.io.println()
}
/**
* 打印多个参数,指定分隔符
* @param sp 分隔符,默认为空字符串
* @param args 要打印的参数数组
*/
@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)
}
/**
* 重定向 System.out 到 INFO 级别日志
* 创建自定义PrintStream,将输出内容缓冲并记录到INFO级别日志中
*/
@JvmStatic
fun redirectOutToInfo() {
val outLogger = PrintStream(object : OutputStream() {
private val buffer = StringBuilder()
override fun write(b: Int) {
if (b == '\n'.code) {
flushBuffer()
} else {
buffer.append(b.toChar())
}
}
override fun write(b: ByteArray, off: Int, len: Int) {
val str = String(b, off, len)
if (str.contains("\n")) {
val lines = str.split("\n")
lines.forEachIndexed { index, line ->
if (index == lines.size - 1 && !str.endsWith("\n")) {
buffer.append(line)
} else {
buffer.append(line)
flushBuffer()
}
}
} else {
buffer.append(str)
}
}
private fun flushBuffer() {
val message = buffer.toString().trim()
if (message.isNotBlank()) {
outLog.info(message)
}
buffer.clear()
}
override fun flush() {
flushBuffer()
super.flush()
}
}, true)
System.setOut(outLogger)
}
/**
* 重定向 System.err 到 ERROR 级别
* 创建自定义PrintStream,将错误输出内容缓冲并记录到ERROR级别日志中
*/
@JvmStatic
fun redirectErrToError() {
val errLogger = PrintStream(object : OutputStream() {
private val buffer = StringBuilder()
override fun write(b: Int) {
if (b == '\n'.code) {
flushBuffer()
} else {
buffer.append(b.toChar())
}
}
override fun write(b: ByteArray, off: Int, len: Int) {
val str = String(b, off, len)
if (str.contains("\n")) {
val lines = str.split("\n")
lines.forEachIndexed { index, line ->
if (index == lines.size - 1 && !str.endsWith("\n")) {
buffer.append(line)
} else {
buffer.append(line)
flushBuffer()
}
}
} else {
buffer.append(str)
}
}
private fun flushBuffer() {
val message = buffer.toString().trim()
if (message.isNotBlank()) {
errLog.error(message)
}
buffer.clear()
}
override fun flush() {
flushBuffer()
super.flush()
}
}, true)
System.setErr(errLogger)
}
/**
* 完全重定向(包括第三方库的输出)
* 同时重定向标准输出和错误输出到对应的日志级别
*/
@JvmStatic
fun redirectAll() {
redirectOutToInfo()
redirectErrToError()
}
/**
* 恢复原始输出流
* 将System.out和System.err恢复到原始状态
*/
@JvmStatic
fun restore() {
System.setOut(originalOut)
System.setErr(originalErr)
}
}
@@ -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 FieldStructure.kt * CurrentFile FieldStructure.kt
* LastUpdate 2025-09-15 22:32:50 * LastUpdate 2026-07-02 10:22:42
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@@ -30,7 +30,7 @@ import java.lang.reflect.Modifier
* 该类继承自JNA的Structure类,通过反射自动获取子类的公共非静态字段, * 该类继承自JNA的Structure类,通过反射自动获取子类的公共非静态字段,
* 并按声明顺序返回字段名列表,用于JNA结构体的字段映射。 * 并按声明顺序返回字段名列表,用于JNA结构体的字段映射。
*/ */
class FieldStructure : Structure() { open class FieldStructure : Structure() {
/** /**
* 获取结构体字段顺序列表 * 获取结构体字段顺序列表
* 通过反射遍历当前类及其父类的所有声明字段,过滤出公共非静态字段, * 通过反射遍历当前类及其父类的所有声明字段,过滤出公共非静态字段,
@@ -1,231 +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 GsonJsonApi.kt
* LastUpdate 2025-09-15 22:07:43
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.json
import com.google.gson.*
import com.mingliqiye.utils.json.converters.JsonConverter
import com.mingliqiye.utils.json.converters.JsonStringConverter
class GsonJsonApi : JsonApi {
private var gsonUnicode: Gson
private var gsonPretty: Gson
private var gsonPrettyUnicode: Gson
private var gson: Gson
constructor() {
gson = GsonBuilder()
.setObjectToNumberStrategy(ToNumberPolicy.LONG_OR_DOUBLE)
.create()
gsonUnicode = GsonBuilder()
.disableHtmlEscaping()
.setObjectToNumberStrategy(ToNumberPolicy.LONG_OR_DOUBLE)
.create()
gsonPretty = GsonBuilder()
.setPrettyPrinting()
.setObjectToNumberStrategy(ToNumberPolicy.LONG_OR_DOUBLE)
.create()
gsonPrettyUnicode = GsonBuilder()
.setPrettyPrinting()
.disableHtmlEscaping()
.setObjectToNumberStrategy(ToNumberPolicy.LONG_OR_DOUBLE)
.create()
}
constructor(gson: Gson) {
this.gson = gson
.newBuilder()
.setObjectToNumberStrategy(ToNumberPolicy.LONG_OR_DOUBLE)
.create()
this.gsonUnicode = gson
.newBuilder()
.disableHtmlEscaping()
.setObjectToNumberStrategy(ToNumberPolicy.LONG_OR_DOUBLE)
.create()
this.gsonPretty = gson
.newBuilder()
.setPrettyPrinting()
.setObjectToNumberStrategy(ToNumberPolicy.LONG_OR_DOUBLE)
.create()
this.gsonPrettyUnicode = gson
.newBuilder()
.setPrettyPrinting()
.disableHtmlEscaping()
.setObjectToNumberStrategy(ToNumberPolicy.LONG_OR_DOUBLE)
.create()
}
override fun <T> parse(json: String, clazz: Class<T>): T {
return gson.fromJson(json, clazz)
}
override fun <T> parse(json: String, type: JsonTypeReference<T>): T {
return gson.fromJson(json, type.type)
}
override fun format(obj: Any): String {
return gson.toJson(obj)
}
override fun formatUnicode(obj: Any): String {
return gsonUnicode.toJson(obj)
}
override fun formatPretty(obj: Any): String {
return gsonPretty.toJson(obj)
}
override fun formatPrettyUnicode(obj: Any): String {
return gsonPrettyUnicode.toJson(obj)
}
override fun isValidJson(json: String): Boolean {
return try {
JsonParser.parseString(json)
true
} catch (e: JsonSyntaxException) {
false
} catch (e: Exception) {
false
}
}
override fun merge(vararg jsons: String): String {
val merged = JsonObject()
for (json in jsons) {
if (json.isNullOrEmpty()) {
continue
}
try {
val obj = JsonParser.parseString(json).asJsonObject
for (key in obj.keySet()) {
merged.add(key, obj.get(key))
}
} catch (e: Exception) {
// 忽略无效的 JSON 字符串
}
}
return gson.toJson(merged)
}
override fun getNodeValue(json: String, path: String): String? {
return try {
var element = JsonParser.parseString(json)
val paths = path.split("\\.".toRegex()).toTypedArray()
var current = element
for (p in paths) {
if (current.isJsonObject) {
current = current.asJsonObject.get(p)
} else {
return null
}
if (current == null) {
return null
}
}
if (current.isJsonPrimitive) current.asString else current.toString()
} catch (e: Exception) {
null
}
}
override fun updateNodeValue(json: String, path: String, newValue: Any): String {
return try {
val obj = JsonParser.parseString(json).asJsonObject
val paths = path.split("\\.".toRegex()).toTypedArray()
var current = obj
// 导航到倒数第二层
for (i in 0 until paths.size - 1) {
val p = paths[i]
if (!current.has(p) || !current.get(p).isJsonObject) {
current.add(p, JsonObject())
}
current = current.getAsJsonObject(p)
}
// 设置最后一层的值
val lastPath = paths[paths.size - 1]
val element = gson.toJsonTree(newValue)
current.add(lastPath, element)
gson.toJson(obj)
} catch (e: Exception) {
json
}
}
override fun <T, D> convert(source: T, destinationClass: Class<D>): D {
val json = gson.toJson(source)
return gson.fromJson(json, destinationClass)
}
override fun <T, D> convert(source: T, destinationType: JsonTypeReference<D>): D {
val json = gson.toJson(source)
return gson.fromJson(json, destinationType.type)
}
override fun addJsonConverter(c: JsonConverter<*, *>) {
c.getStringConverter()?.let {
gson = gson
.newBuilder()
.registerTypeAdapter(
it.tClass,
it.gsonJsonStringConverterAdapter
)
.create()
gsonUnicode = gsonUnicode
.newBuilder()
.registerTypeAdapter(
it.tClass,
it.gsonJsonStringConverterAdapter
)
.create()
gsonPretty = gsonPretty
.newBuilder()
.registerTypeAdapter(
it.tClass,
it.gsonJsonStringConverterAdapter
)
.create()
gsonPrettyUnicode = gsonPrettyUnicode
.newBuilder()
.registerTypeAdapter(
it.tClass,
it.gsonJsonStringConverterAdapter
)
.create()
}
}
override fun addJsonStringConverter(c: JsonStringConverter<*>) {
addJsonConverter(c)
}
}
@@ -1,393 +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 JsonApi.kt
* LastUpdate 2025-09-15 22:32:50
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.json
import com.mingliqiye.utils.json.converters.JsonConverter
import com.mingliqiye.utils.json.converters.JsonStringConverter
import java.io.*
import java.nio.file.Files
import java.nio.file.Path
import java.nio.file.Paths
/**
* JSON处理接口,提供JSON字符串与Java对象之间的相互转换功能
*/
interface JsonApi {
/**
* 将JSON字符串解析为指定类型的对象
*
* @param json 待解析的JSON字符串
* @param clazz 目标对象的Class类型
* @param <T> 泛型参数,表示目标对象的类型
* @return 解析后的对象实例
</T> */
fun <T> parse(json: String, clazz: Class<T>): T
/**
* 将JSON字符串解析为指定泛型类型对象
*
* @param json 待解析的JSON字符串
* @param type 目标对象的Type类型(支持泛型)
* @param <T> 泛型参数,表示目标对象的类型
* @return 解析后的对象实例
</T> */
fun <T> parse(json: String, type: JsonTypeReference<T>): T
/**
* 将对象格式化为JSON字符串
*
* @param obj 待格式化的对象
* @return 格式化后的JSON字符串
*/
fun format(obj: Any): String
fun formatUnicode(obj: Any): String
@Throws(IOException::class)
fun <T> parseFrom(path: String, clazz: Class<T>): T {
return parseFrom(Paths.get(path), clazz)
}
@Throws(IOException::class)
fun <T> parseFrom(path: Path, clazz: Class<T>): T {
return parseFrom(path.toFile(), clazz)
}
@Throws(IOException::class)
fun <T> parseFrom(file: File, clazz: Class<T>): T {
Files.newInputStream(file.toPath()).use { inputStream ->
return parseFrom(inputStream, clazz)
}
}
@Throws(IOException::class)
fun <T> parseFrom(inputStream: InputStream, clazz: Class<T>): T {
val bytes = ByteArray(1024)
ByteArrayOutputStream().use { bos ->
var readlength: Int
while ((inputStream.read(bytes).also { readlength = it }) != -1) {
bos.write(bytes, 0, readlength)
}
return parse(bos.toByteArray(), clazz)
}
}
@Throws(IOException::class)
fun <T> parseFrom(path: String, type: JsonTypeReference<T>): T {
return parseFrom(Paths.get(path), type)
}
@Throws(IOException::class)
fun <T> parseFrom(path: Path, type: JsonTypeReference<T>): T {
return parseFrom(path.toFile(), type)
}
@Throws(IOException::class)
fun <T> parseFrom(file: File, type: JsonTypeReference<T>): T {
Files.newInputStream(file.toPath()).use { inputStream ->
return parseFrom<T>(inputStream, type)
}
}
@Throws(IOException::class)
fun <T> parseFrom(inputStream: InputStream, type: JsonTypeReference<T>): T {
val bytes = ByteArray(1024)
ByteArrayOutputStream().use { bos ->
var readlength: Int
while ((inputStream.read(bytes).also { readlength = it }) != -1) {
bos.write(bytes, 0, readlength)
}
return parse(bos.toByteArray(), type)
}
}
/**
* 将字节数组形式的JSON解析为指定类型的对象
*
* @param json 待解析的JSON字节数组
* @param clazz 目标对象的Class类型
* @param <T> 泛型参数,表示目标对象的类型
* @return 解析后的对象实例
</T> */
fun <T> parse(json: ByteArray, clazz: Class<T>): T {
return parse(String(json), clazz)
}
/**
* 将字节数组形式的JSON解析为指定泛型类型对象
*
* @param json 待解析的JSON字节数组
* @param type 目标对象的Type类型(支持泛型)
* @param <T> 泛型参数,表示目标对象的类型
* @return 解析后的对象实例
</T> */
fun <T> parse(json: ByteArray, type: JsonTypeReference<T>): T {
return parse(String(json), type)
}
/**
* 将JSON字符串解析为指定类型的对象,解析失败时返回默认值
*
* @param json 待解析的JSON字符串
* @param clazz 目标对象的Class类型
* @param defaultValue 解析失败时返回的默认值
* @param <T> 泛型参数,表示目标对象的类型
* @return 解析后的对象实例或默认值
</T> */
fun <T> parse(json: String, clazz: Class<T>, defaultValue: T): T {
try {
return parse(json, clazz)
} catch (e: Exception) {
return defaultValue
}
}
/**
* 将JSON字符串解析为指定泛型类型对象,解析失败时返回默认值
*
* @param json 待解析的JSON字符串
* @param type 目标对象的Type类型(支持泛型)
* @param defaultValue 解析失败时返回的默认值
* @param <T> 泛型参数,表示目标对象的类型
* @return 解析后的对象实例或默认值
**/
fun <T> parse(
json: String,
type: JsonTypeReference<T>,
defaultValue: T
): T {
try {
return parse<T>(json, type)
} catch (e: Exception) {
return defaultValue
}
}
/**
* 将对象格式化为美化格式的JSON字符串(带缩进和换行)
*
* @param object 待格式化的对象
* @return 格式化后的美化JSON字符串
*/
fun formatPretty(obj: Any): String
fun formatPrettyBytes(obj: Any): ByteArray {
return formatPretty(obj)!!.toByteArray()
}
fun formatPrettyUnicode(obj: Any): String
fun formatPrettyUnicodeBytes(obj: Any): ByteArray {
return formatPrettyUnicode(obj)!!.toByteArray()
}
@Throws(IOException::class)
fun formatPretty(obj: Any, file: String) {
formatPretty(obj, Paths.get(file))
}
@Throws(IOException::class)
fun formatPretty(obj: Any, file: Path) {
formatPretty(obj, file.toFile())
}
@Throws(IOException::class)
fun formatPretty(obj: Any, file: File) {
FileOutputStream(file).use { fos ->
formatPretty(obj, fos)
}
}
@Throws(IOException::class)
fun formatPretty(obj: Any, stream: OutputStream) {
stream.write(formatPrettyBytes(obj))
}
@Throws(IOException::class)
fun formatPrettyUnicode(obj: Any, file: String) {
formatPrettyUnicode(obj, Paths.get(file))
}
@Throws(IOException::class)
fun formatPrettyUnicode(obj: Any, file: Path) {
formatPrettyUnicode(obj, file.toFile())
}
@Throws(IOException::class)
fun formatPrettyUnicode(obj: Any, file: File) {
FileOutputStream(file).use { fos ->
formatPrettyUnicode(obj, fos)
}
}
@Throws(IOException::class)
fun formatPrettyUnicode(obj: Any, stream: OutputStream) {
stream.write(formatPrettyUnicodeBytes(obj))
}
fun formatBytes(obj: Any): ByteArray {
return format(obj)!!.toByteArray()
}
fun formatUnicodeBytes(obj: Any): ByteArray {
return formatUnicode(obj)!!.toByteArray()
}
@Throws(IOException::class)
fun format(obj: Any, file: String) {
format(obj, Paths.get(file))
}
@Throws(IOException::class)
fun format(obj: Any, file: Path) {
format(obj, file.toFile())
}
@Throws(IOException::class)
fun format(obj: Any, file: File) {
FileOutputStream(file).use { fos ->
format(obj, fos)
}
}
@Throws(IOException::class)
fun format(obj: Any, stream: OutputStream) {
stream.write(formatPrettyBytes(obj))
}
@Throws(IOException::class)
fun formatUnicode(obj: Any, file: String) {
formatUnicode(obj, Paths.get(file))
}
@Throws(IOException::class)
fun formatUnicode(obj: Any, file: Path) {
formatUnicode(obj, file.toFile())
}
@Throws(IOException::class)
fun formatUnicode(obj: Any, file: File) {
FileOutputStream(file).use { fos ->
formatUnicode(obj, fos)
}
}
@Throws(IOException::class)
fun formatUnicode(obj: Any, stream: OutputStream) {
stream.write(formatPrettyUnicodeBytes(obj))
}
/**
* 将JSON字符串解析为指定元素类型的List集合
*
* @param json 待解析的JSON字符串
* @param elementType List中元素的类型
* @param <T> 泛型参数,表示List中元素的类型
* @return 解析后的List集合
</T> */
fun <T> parseList(json: String, elementType: Class<T>): List<T> {
return parse(json, type = listType(elementType))
}
/**
* 将JSON字符串解析为指定键值类型的Map集合
*
* @param json 待解析的JSON字符串
* @param keyType Map中键的类型
* @param valueType Map中值的类型
* @param <K> 泛型参数,表示Map中键的类型
* @param <V> 泛型参数,表示Map中值的类型
* @return 解析后的Map集合
</V></K> */
fun <K, V> parseMap(
json: String,
keyType: Class<K>,
valueType: Class<V>
): MutableMap<K, V> {
val mapType: JsonTypeReference<MutableMap<K, V>> = object : JsonTypeReference<MutableMap<K, V>>() {}
return parse<MutableMap<K, V>>(json, mapType)
}
/**
* 验证字符串是否为有效的JSON格式
*
* @param json 待验证的字符串
* @return 如果是有效的JSON格式返回true,否则返回false
*/
fun isValidJson(json: String): Boolean
/**
* 将对象转换为JSON字节数组
*
* @param object 待转换的对象
* @return 转换后的JSON字节数组
*/
fun toBytes(obj: Any): ByteArray {
return format(obj)!!.toByteArray()
}
/**
* 将对象转换为美化格式的JSON字节数组
*
* @param object 待转换的对象
* @return 转换后的美化格式JSON字节数组
*/
fun toBytesPretty(obj: Any): ByteArray {
return formatPretty(obj)!!.toByteArray()
}
/**
* 合并多个JSON字符串为一个JSON对象
*
* @param jsons 待合并的JSON字符串数组
* @return 合并后的JSON字符串
*/
fun merge(vararg jsons: String): String
/**
* 获取JSON字符串中指定路径节点的值
*
* @param json JSON字符串
* @param path 节点路径(如:"user.name")
* @return 节点值的字符串表示
*/
fun getNodeValue(json: String, path: String): String?
/**
* 更新JSON字符串中指定路径节点的值
*
* @param json 原始JSON字符串
* @param path 节点路径(如:"user.name")
* @param newValue 新的节点值
* @return 更新后的JSON字符串
*/
fun updateNodeValue(json: String, path: String, newValue: Any): String
fun <T, D> convert(source: T, destinationClass: Class<D>): D
fun <T, D> convert(source: T, destinationType: JsonTypeReference<D>): D
fun addJsonConverter(c: JsonConverter<*, *>)
fun addJsonStringConverter(c: JsonStringConverter<*>)
}
@@ -0,0 +1,623 @@
/*
* 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 JSONA.kt
* LastUpdate 2026-03-18 09:14:06
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.json.api
import com.fasterxml.jackson.databind.ObjectMapper
import com.fasterxml.jackson.module.kotlin.kotlinModule
import com.mingliqiye.utils.json.api.base.JsonApi
import com.mingliqiye.utils.json.api.type.JsonTypeReference
import com.mingliqiye.utils.json.api.type.listType
import com.mingliqiye.utils.json.converters.base.BaseJsonConverter
import com.mingliqiye.utils.json.converters.base.getJsonConverter
import com.mingliqiye.utils.json.objects.base.JsonItem
import java.io.File
import java.io.IOException
import java.io.InputStream
import java.io.OutputStream
import java.nio.file.Path
import kotlin.io.path.readBytes
/**
* JSON工具类,提供静态方法访问JSON API功能
*/
object JSONA {
@JvmStatic
private var jsonApi: JsonApi? = null
/**
* 获取JSON API实例
*
* @return JSON API实例
* @throws NullPointerException 当JSON API未初始化时抛出异常
*/
@Throws(NullPointerException::class)
@JvmStatic
fun getJsonApi(): JsonApi {
if (jsonApi == null) {
throw NullPointerException("jsonApi is null plase setJsonApi first")
}
return jsonApi!!
}
/**
* 设置JSON API实例
*
* @param jsa JSON API实例
*/
@JvmStatic
fun setJsonApi(jsa: JsonApi) {
jsonApi = jsa
}
/**
* 使用反射创建并设置指定类型的JSON API实例
*
* @param T 继承自JsonApi的具体实现类
*/
inline fun <reified T : JsonApi> setJsonApi() {
setJsonApi(T::class.java.getConstructor().newInstance() as JsonApi)
}
/**
* 将JSON字符串解析为指定类型的对象
*
* @param json 待解析的JSON字符串
* @param clazz 目标对象的Class类型
* @param <T> 泛型参数,表示目标对象的类型
* @return 解析后的对象实例
*/
@JvmStatic
fun <T> parse(json: String, clazz: Class<T>): T = getJsonApi().parse(json, clazz)
/**
* 将JSON字符串解析为指定泛型类型对象
*
* @param json 待解析的JSON字符串
* @param <T> 泛型参数,表示目标对象的类型
* @return 解析后的对象实例
*/
@JvmStatic
inline fun <reified T> parse(json: String): T {
return getJsonApi().parse(json, (object : JsonTypeReference<T>() {}))
}
/**
* 将字节数组形式的JSON解析为指定泛型类型对象
*
* @param json 待解析的JSON字节数组
* @param <T> 泛型参数,表示目标对象的类型
* @return 解析后的对象实例
*/
@JvmStatic
inline fun <reified T> parse(json: ByteArray): T = getJsonApi().parse(json, object : JsonTypeReference<T>() {})
/**
* 将JSON字符串解析为指定泛型类型对象
*
* @param json 待解析的JSON字符串
* @param type 目标对象的Type类型(支持泛型)
* @param <T> 泛型参数,表示目标对象的类型
* @return 解析后的对象实例
*/
@JvmStatic
fun <T> parse(json: String, type: JsonTypeReference<T>): T = getJsonApi().parse(json, type)
/**
* 将对象格式化为JSON字符串
*
* @param obj 待格式化的对象
* @return 格式化后的JSON字符串
*/
@JvmStatic
fun format(obj: Any): String = getJsonApi().format(obj)
/**
* 从文件路径解析JSON为指定类型的对象
*
* @param path 文件路径
* @param clazz 目标对象的Class类型
* @param <T> 泛型参数,表示目标对象的类型
* @return 解析后的对象实例
*/
@JvmStatic
fun <T> parseFrom(path: String, clazz: Class<T>): T = getJsonApi().parseFrom(path, clazz)
/**
* 从Path对象解析JSON为指定类型的对象
*
* @param path Path对象
* @param clazz 目标对象的Class类型
* @param <T> 泛型参数,表示目标对象的类型
* @return 解析后的对象实例
*/
@JvmStatic
fun <T> parseFrom(path: Path, clazz: Class<T>): T = getJsonApi().parseFrom(path, clazz)
/**
* 从File对象解析JSON为指定类型的对象
*
* @param file File对象
* @param clazz 目标对象的Class类型
* @param <T> 泛型参数,表示目标对象的类型
* @return 解析后的对象实例
*/
@JvmStatic
fun <T> parseFrom(file: File, clazz: Class<T>): T = getJsonApi().parseFrom(file, clazz)
/**
* 从InputStream解析JSON为指定类型的对象
*
* @param inputStream InputStream对象
* @param clazz 目标对象的Class类型
* @param <T> 泛型参数,表示目标对象的类型
* @return 解析后的对象实例
*/
@JvmStatic
fun <T> parseFrom(inputStream: InputStream, clazz: Class<T>): T = getJsonApi().parseFrom(inputStream, clazz)
/**
* 从文件路径解析JSON为指定泛型类型对象
*
* @param path 文件路径
* @param type 目标对象的Type类型(支持泛型)
* @param <T> 泛型参数,表示目标对象的类型
* @return 解析后的对象实例
*/
@JvmStatic
fun <T> parseFrom(path: String, type: JsonTypeReference<T>): T = getJsonApi().parseFrom(path, type)
/**
* 从Path对象解析JSON为指定泛型类型对象
*
* @param path Path对象
* @param type 目标对象的Type类型(支持泛型)
* @param <T> 泛型参数,表示目标对象的类型
* @return 解析后的对象实例
*/
@JvmStatic
fun <T> parseFrom(path: Path, type: JsonTypeReference<T>): T = getJsonApi().parseFrom(path, type)
/**
* 从File对象解析JSON为指定泛型类型对象
*
* @param file File对象
* @param type 目标对象的Type类型(支持泛型)
* @param <T> 泛型参数,表示目标对象的类型
* @return 解析后的对象实例
*/
@JvmStatic
fun <T> parseFrom(file: File, type: JsonTypeReference<T>): T = getJsonApi().parseFrom(file, type)
/**
* 从InputStream解析JSON为指定泛型类型对象
*
* @param inputStream InputStream对象
* @param type 目标对象的Type类型(支持泛型)
* @param <T> 泛型参数,表示目标对象的类型
* @return 解析后的对象实例
*/
@JvmStatic
fun <T> parseFrom(inputStream: InputStream, type: JsonTypeReference<T>): T =
getJsonApi().parseFrom(inputStream, type)
/**
* 将字节数组形式的JSON解析为指定类型的对象
*
* @param json 待解析的JSON字节数组
* @param clazz 目标对象的Class类型
* @param <T> 泛型参数,表示目标对象的类型
* @return 解析后的对象实例
*/
@JvmStatic
fun <T> parse(json: ByteArray, clazz: Class<T>): T = getJsonApi().parse(json, clazz)
/**
* 将字节数组形式的JSON解析为指定泛型类型对象
*
* @param json 待解析的JSON字节数组
* @param type 目标对象的Type类型(支持泛型)
* @param <T> 泛型参数,表示目标对象的类型
* @return 解析后的对象实例
*/
@JvmStatic
fun <T> parse(json: ByteArray, type: JsonTypeReference<T>): T = getJsonApi().parse(json, type)
/**
* 将JSON字符串解析为指定类型的对象,解析失败时返回默认值
*
* @param json 待解析的JSON字符串
* @param clazz 目标对象的Class类型
* @param defaultValue 解析失败时返回的默认值
* @param <T> 泛型参数,表示目标对象的类型
* @return 解析后的对象实例或默认值
*/
@JvmStatic
fun <T> parse(json: String, clazz: Class<T>, defaultValue: T): T = getJsonApi().parse(json, clazz, defaultValue)
/**
* 将JSON字符串解析为指定泛型类型对象,解析失败时返回默认值
*
* @param json 待解析的JSON字符串
* @param type 目标对象的Type类型(支持泛型)
* @param defaultValue 解析失败时返回的默认值
* @param <T> 泛型参数,表示目标对象的类型
* @return 解析后的对象实例或默认值
*/
@JvmStatic
fun <T> parse(
json: String, type: JsonTypeReference<T>, defaultValue: T,
): T = getJsonApi().parse(json, type, defaultValue)
/**
* 将对象格式化为美化格式的JSON字符串(带缩进和换行)
*
* @param obj 待格式化的对象
* @return 格式化后的美化JSON字符串
*/
@JvmStatic
fun formatPretty(obj: Any): String = getJsonApi().formatPretty(obj)
/**
* 将对象格式化为美化格式的JSON字节数组
*
* @param obj 待格式化的对象
* @return 格式化后的美化JSON字节数组
*/
@JvmStatic
fun formatPrettyBytes(obj: Any): ByteArray = getJsonApi().formatPrettyBytes(obj)
/**
* 将对象格式化为美化格式的JSON字符串并写入文件
*
* @param obj 待格式化的对象
* @param file 文件路径
*/
@JvmStatic
fun formatPretty(obj: Any, file: String) = getJsonApi().formatPretty(obj, file)
/**
* 将对象格式化为美化格式的JSON字符串并写入文件
*
* @param obj 待格式化的对象
* @param file Path对象
*/
@JvmStatic
fun formatPretty(obj: Any, file: Path) = getJsonApi().formatPretty(obj, file)
/**
* 将对象格式化为美化格式的JSON字符串并写入文件
*
* @param obj 待格式化的对象
* @param file File对象
*/
@JvmStatic
fun formatPretty(obj: Any, file: File) = getJsonApi().formatPretty(obj, file)
/**
* 将对象格式化为美化格式的JSON字符串并写入输出流
*
* @param obj 待格式化的对象
* @param stream OutputStream对象
*/
@JvmStatic
fun formatPretty(obj: Any, stream: OutputStream) = getJsonApi().formatPretty(obj, stream)
/**
* 将对象格式化为JSON字节数组
*
* @param obj 待格式化的对象
* @return 格式化后的JSON字节数组
*/
@JvmStatic
fun formatBytes(obj: Any): ByteArray = getJsonApi().formatBytes(obj)
/**
* 将对象格式化为JSON字符串并写入文件
*
* @param obj 待格式化的对象
* @param file 文件路径
*/
@JvmStatic
fun format(obj: Any, file: String) = getJsonApi().format(obj, file)
/**
* 将对象格式化为JSON字符串并写入文件
*
* @param obj 待格式化的对象
* @param file Path对象
*/
@JvmStatic
fun format(obj: Any, file: Path) = getJsonApi().format(obj, file)
/**
* 将对象格式化为JSON字符串并写入文件
*
* @param obj 待格式化的对象
* @param file File对象
*/
@JvmStatic
fun format(obj: Any, file: File) = getJsonApi().format(obj, file)
/**
* 将对象格式化为JSON字符串并写入输出流
*
* @param obj 待格式化的对象
* @param stream OutputStream对象
*/
@JvmStatic
fun format(obj: Any, stream: OutputStream) = getJsonApi().format(obj, stream)
/**
* 将JSON字符串解析为指定元素类型的List集合
*
* @param json 待解析的JSON字符串
* @param elementType List中元素的类型
* @param <T> 泛型参数,表示List中元素的类型
* @return 解析后的List集合
*/
@JvmStatic
fun <T> parseList(json: String, elementType: Class<T>): List<T> = parse(json, listType(elementType))
/**
* 将JSON字符串解析为指定元素类型的List集合
*
* @param json 待解析的JSON字符串
* @param <T> 泛型参数,表示List中元素的类型
* @return 解析后的List集合
*/
@JvmStatic
inline fun <reified T> parseList(json: String): List<T> = parse(json, listType(T::class.java))
/**
* 将JSON字符串解析为指定键值类型的Map集合
*
* @param json 待解析的JSON字符串
* @param keyType Map中键的类型
* @param valueType Map中值的类型
* @param <K> 泛型参数,表示Map中键的类型
* @param <V> 泛型参数,表示Map中值的类型
* @return 解析后的Map集合
*/
@JvmStatic
fun <K, V> parseMap(
json: String, keyType: Class<K>, valueType: Class<V>,
): MutableMap<K, V> = getJsonApi().parseMap(json, keyType, valueType)
/**
* 将JSON字符串解析为指定键值类型的Map集合
*
* @param json 待解析的JSON字符串
* @param <K> 泛型参数,表示Map中键的类型
* @param <V> 泛型参数,表示Map中值的类型
* @return 解析后的Map集合
*/
@JvmStatic
inline fun <reified K, reified V> parseMap(
json: String,
): MutableMap<K, V> = getJsonApi().parseMap(json, K::class.java, V::class.java)
/**
* 验证字符串是否为有效的JSON格式
*
* @param json 待验证的字符串
* @return 如果是有效的JSON格式返回true,否则返回false
*/
@JvmStatic
fun isValidJson(json: String): Boolean = getJsonApi().isValidJson(json)
/**
* 将对象转换为JSON字节数组
*
* @return 转换后的JSON字节数组
*/
@JvmStatic
fun toBytes(obj: Any): ByteArray = getJsonApi().toBytes(obj)
/**
* 将对象转换为美化格式的JSON字节数组
*
* @return 转换后的美化格式JSON字节数组
*/
@JvmStatic
fun toBytesPretty(obj: Any): ByteArray = getJsonApi().toBytesPretty(obj)
/**
* 合并多个JSON字符串为一个JSON对象
*
* @param jsons 待合并的JSON字符串数组
* @return 合并后的JSON字符串
*/
@JvmStatic
fun merge(vararg jsons: String): String = getJsonApi().merge(*jsons)
/**
* 获取JSON字符串中指定路径节点的值
*
* @param json JSON字符串
* @param path 节点路径(如:"user.name")
* @return 节点值的字符串表示
*/
@JvmStatic
fun getNodeValue(json: String, path: String): String? = getJsonApi().getNodeValue(json, path)
/**
* 更新JSON字符串中指定路径节点的值
*
* @param json 原始JSON字符串
* @param path 节点路径(如:"user.name")
* @param newValue 新的节点值
* @return 更新后的JSON字符串
*/
@JvmStatic
fun updateNodeValue(json: String, path: String, newValue: Any): String =
getJsonApi().updateNodeValue(json, path, newValue)
/**
* 将源对象转换为目标类型的对象
*
* @param D 目标对象的类型
* @param source 需要转换的源对象
* @param destinationClass 目标对象的Class类型
* @return 转换后的目标类型对象
*/
@JvmStatic
fun <D> convert(source: Any, destinationClass: Class<D>): D = getJsonApi().convert(source, destinationClass)
/**
* 使用内联函数和reified类型参数将源对象转换为目标类型的对象
*
* @param D 目标对象的类型(通过reified类型参数推断)
* @param source 需要转换的源对象
* @return 转换后的目标类型对象
*/
@JvmStatic
inline fun <reified D> convert(source: Any): D = getJsonApi().convert(source, object : JsonTypeReference<D>() {})
/**
* 将源对象转换为目标类型的对象,使用JsonTypeReference指定目标类型
*
* @param D 目标对象的类型
* @param source 需要转换的源对象
* @param destinationType 目标对象的JsonTypeReference类型引用
* @return 转换后的目标类型对象
*/
@JvmStatic
fun <D> convert(source: Any, destinationType: JsonTypeReference<D>): D =
getJsonApi().convert(source, destinationType)
/**
* 添加JSON转换器到API中
*
* @param c 需要添加的JSON转换器实例
*/
@JvmStatic
fun addJsonConverter(c: BaseJsonConverter<*, *>) = getJsonApi().addJsonConverter(c)
/**
* 使用反射创建并添加指定类型的JSON转换器到API中
*
* @param T 继承自BaseJsonConverter的具体实现类
*/
inline fun <reified T : BaseJsonConverter<*, *>> addJsonConverter() = addJsonConverter(getJsonConverter<T>())
inline fun <reified T> String.parseJson() = parse<T>(this)
inline fun <reified T> ByteArray.parseJson() = parse<T>(this)
inline fun <reified T> InputStream.parseJson() = this.use { parse<T>(readBytes()) }
inline fun <reified T> File.parseJson() = this.inputStream().parseJson<T>()
inline fun <reified T> Path.parseJson() = this.toFile().inputStream().parseJson<T>()
fun Any.toJson() = format(this)
@JvmStatic
fun jacksonKotlinObjectMapper(): ObjectMapper = ObjectMapper().jacksonKotlinObjectMapper()
@JvmStatic
fun ObjectMapper.jacksonKotlinObjectMapper(): ObjectMapper = this.registerModule(kotlinModule())
/**
* 将 JSON 字符串解析为 JsonItem 对象
*
* @param json JSON 格式的字符串
* @return 解析后的 JsonItem 对象,可以是 JsonObject、JsonArray 或 JsonValue
*/
@JvmStatic
fun parseJsonItem(json: String): JsonItem = getJsonApi().parseJsonItem(json)
/**
* 将字节数组解析为 JsonItem 对象
* 字节数组会被转换为字符串后再解析
*
* @param byte JSON 格式的字节数组(通常是 UTF-8 编码)
* @return 解析后的 JsonItem 对象
*/
@JvmStatic
fun parseJsonItem(byte: ByteArray): JsonItem {
return parseJsonItem(String(byte))
}
/**
* 将输入流解析为 JsonItem 对象
* 会自动关闭输入流
*
* @param inputStream JSON 数据的输入流
* @return 解析后的 JsonItem 对象
* @throws IOException 当读取输入流失败时抛出
*
* 使用示例:
* ```
* val inputStream = FileInputStream("data.json")
* val jsonItem = converter.parseJsonItem(inputStream)
* ```
*/
@JvmStatic
@Throws(IOException::class)
fun parseJsonItem(inputStream: InputStream): JsonItem {
inputStream.use {
return parseJsonItem(it.readAllBytes())
}
}
/**
* 将文件解析为 JsonItem 对象
*
* @param file 包含 JSON 数据的文件
* @return 解析后的 JsonItem 对象
* @throws IOException 当读取文件失败时抛出
*
* 使用示例:
* ```
* val file = File("config.json")
* val jsonItem = converter.parseJsonItem(file)
* ```
*/
@JvmStatic
@Throws(IOException::class)
fun parseJsonItem(file: File): JsonItem {
return parseJsonItem(file.readBytes())
}
/**
* 将文件路径解析为 JsonItem 对象
*
* @param path 包含 JSON 数据的文件路径
* @return 解析后的 JsonItem 对象
* @throws IOException 当读取文件失败时抛出
*
* 使用示例:
* ```
* val path = Paths.get("data/user.json")
* val jsonItem = converter.parseJsonItem(path)
* ```
*/
@JvmStatic
@Throws(IOException::class)
fun parseJsonItem(path: Path): JsonItem {
return parseJsonItem(path.readBytes())
}
}
@@ -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 Jackson3JsonApi.kt
* LastUpdate 2026-10-12 13:59:59
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.json.api
import com.mingliqiye.utils.exception.JsonException
import com.mingliqiye.utils.json.api.JackSon3JsonItem.Companion.getJsonItem
import com.mingliqiye.utils.json.api.base.JsonApi
import com.mingliqiye.utils.json.api.type.JsonTypeReference
import com.mingliqiye.utils.json.converters.base.BaseJsonConverter
import com.mingliqiye.utils.json.converters.base.getJackson3Module
import com.mingliqiye.utils.json.objects.base.*
import tools.jackson.core.type.TypeReference
import tools.jackson.databind.JsonNode
import tools.jackson.databind.ObjectMapper
import tools.jackson.databind.node.JsonNodeType
import tools.jackson.databind.node.ObjectNode
import java.lang.reflect.Type
class Jackson3JsonApi : JsonApi {
var get: () -> ObjectMapper = { _prObjectMapper!! }
var set: (ObjectMapper) -> Unit = { _prObjectMapper = it }
private var _prObjectMapper: ObjectMapper? = null
var objectMapper: ObjectMapper
get() = get()
private set(value) = set(value)
constructor(objectMapper: ObjectMapper) {
_prObjectMapper = objectMapper
}
constructor(
get: () -> ObjectMapper,
set: (ObjectMapper) -> Unit,
) {
this.get = get
this.set = set
}
constructor() {
_prObjectMapper = ObjectMapper()
}
override fun <T> parse(json: String, clazz: Class<T>): T {
try {
return objectMapper.readValue(json, clazz)
} catch (e: Exception) {
throw JsonException("Failed to parse JSON to ${clazz.simpleName}", e)
}
}
override fun <T> parse(json: String, type: JsonTypeReference<T>): T {
try {
return objectMapper.readValue(json, object : TypeReference<T>() {
override fun getType(): Type = type.type
})
} catch (e: Exception) {
throw JsonException("Failed to parse JSON to type: $type", e)
}
}
override fun format(obj: Any): String {
try {
return objectMapper.writeValueAsString(obj)
} catch (e: Exception) {
throw JsonException("Failed to format object to JSON: ${obj.javaClass.simpleName}", e)
}
}
override fun formatPretty(obj: Any): String {
try {
return objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(obj)
} catch (e: Exception) {
throw JsonException("Failed to format object to pretty JSON: ${obj.javaClass.simpleName}", e)
}
}
override fun isValidJson(json: String): Boolean {
return try {
objectMapper.readTree(json)
true
} catch (_: Exception) {
false
}
}
override fun merge(vararg jsons: String): String {
try {
if (jsons.isEmpty()) return "{}"
val resultNode = objectMapper.createObjectNode()
for (json in jsons) {
val node = objectMapper.readTree(json)
if (node is ObjectNode) {
resultNode.setAll(node)
} else {
throw JsonException("Cannot merge non-object JSON: $json")
}
}
return objectMapper.writeValueAsString(resultNode)
} catch (e: Exception) {
throw JsonException("Failed to merge JSON objects", e)
}
}
override fun getNodeValue(json: String, path: String): String? {
try {
val rootNode = objectMapper.readTree(json)
val node = rootNode.at(path)
return if (node.isMissingNode || node.isNull) {
null
} else {
node.asString()
}
} catch (e: Exception) {
throw JsonException("Failed to get node value at path: $path", e)
}
}
override fun updateNodeValue(json: String, path: String, newValue: Any): String {
try {
val rootNode = objectMapper.readTree(json)
// 处理 JSON Pointer 路径
val pathParts = path.split("/").filter { it.isNotEmpty() }
if (pathParts.isEmpty()) {
// 替换整个根节点
return objectMapper.writeValueAsString(newValue)
}
when (val parentNode = findParentNode(rootNode, pathParts)) {
is ObjectNode -> {
val fieldName = pathParts.last()
val valueNode = objectMapper.valueToTree<JsonNode>(newValue)
parentNode.replace(fieldName, valueNode)
}
else -> {
throw JsonException("Cannot update node: parent is not an object node at path: $path")
}
}
return objectMapper.writeValueAsString(rootNode)
} catch (e: Exception) {
throw JsonException("Failed to update node value at path: $path", e)
}
}
override fun <D> convert(source: Any, destinationClass: Class<D>): D {
try {
return objectMapper.convertValue(source, destinationClass)
} catch (e: Exception) {
throw JsonException(
"Failed to convert from ${source.javaClass.simpleName} to ${destinationClass.simpleName}", e
)
}
}
override fun <D> convert(
source: Any,
destinationType: JsonTypeReference<D>,
): D {
try {
return objectMapper.convertValue(source, object : TypeReference<D>() {
override fun getType(): Type = destinationType.type
})
} catch (e: Exception) {
throw JsonException("Failed to convert from ${source.javaClass.simpleName} to type: $destinationType", e)
}
}
// 辅助方法:查找父节点
private fun findParentNode(root: JsonNode, pathParts: List<String>): JsonNode {
var current: JsonNode = root
// 遍历到最后一个元素之前(即找到父节点)
for (i in 0 until pathParts.size - 1) {
val part = pathParts[i]
current = when {
part.matches(Regex("\\d+")) -> current.get(part.toInt())
else -> current.get(part)
} ?: throw JsonException("Path not found: ${pathParts.subList(0, i + 1).joinToString("/")}")
}
return current
}
override fun addJsonConverter(c: BaseJsonConverter<*, *>) {
val mapperBuilder = Jackson3ApiJavaHelper.rebuild(objectMapper)
mapperBuilder.addModule(c.getJackson3Module())
this.objectMapper = mapperBuilder.build()
}
override fun parseJsonItem(json: String): JsonItem {
try {
return getJsonItem(objectMapper.readTree(json))
} catch (e: Exception) {
throw JsonException("Failed to parseJsonItem", e)
}
}
}
class JackSon3JsonItem : JsonItem {
companion object {
fun getJsonItem(node: JsonNode): JsonItem {
return when (node.nodeType) {
JsonNodeType.OBJECT -> JackSon3JsonObject(node)
JsonNodeType.ARRAY -> JackSon3JsonArray(node)
JsonNodeType.BOOLEAN -> JackSon3JsonBoolean(node)
JsonNodeType.NULL -> JsonNull()
JsonNodeType.NUMBER -> JackSon3JsonNumber(node)
JsonNodeType.STRING -> JackSon3JsonString(node)
else -> throw IllegalStateException("unknown type ${node.nodeType}")
}
}
}
}
class JackSon3JsonNumber(node: JsonNode) : JsonNumber(node.asString())
class JackSon3JsonBoolean(node: JsonNode) : JsonBoolean(node.asBoolean())
class JackSon3JsonString(node: JsonNode) : JsonString(node.asString())
class JackSon3JsonArray(val node: JsonNode) : JsonArray() {
override fun getIndex(index: Int): JsonItem {
return JackSon3JsonItem.getJsonItem(node.get(index))
}
override fun iteratorArray(): Iterator<IndexedValue<JsonItem>> {
val iteet = node.iterator().withIndex()
return object : Iterator<IndexedValue<JsonItem>> {
override fun next(): IndexedValue<JsonItem> {
val it = iteet.next()
return IndexedValue(it.index, JackSon3JsonItem.getJsonItem(it.value))
}
override fun hasNext(): Boolean {
return iteet.hasNext()
}
}
}
}
class JackSon3JsonObject(val node: JsonNode) : JsonObject() {
override fun getField(name: String): JsonItem {
return JackSon3JsonItem.getJsonItem(node.get(name))
}
override fun iteratorObject(): Iterator<Map.Entry<String, JsonItem>> {
return object : Iterator<Map.Entry<String, JsonItem>> {
val it = node.properties().iterator()
override fun next(): Map.Entry<String, JsonItem> {
val utem = it.next()
return object : Map.Entry<String, JsonItem> {
override val key: String
get() = utem.key
override val value: JsonItem
get() = JackSon3JsonItem.getJsonItem(utem.value)
}
}
override fun hasNext(): Boolean {
return it.hasNext()
}
}
}
}
@@ -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,21 +16,26 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile JacksonJsonApi.kt * CurrentFile JacksonJsonApi.kt
* LastUpdate 2025-09-15 22:07:43 * LastUpdate 2026-10-12 10:48:31
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
package com.mingliqiye.utils.json package com.mingliqiye.utils.json.api
import com.fasterxml.jackson.core.JsonGenerator import com.fasterxml.jackson.core.JsonGenerator
import com.fasterxml.jackson.core.JsonProcessingException import com.fasterxml.jackson.core.JsonProcessingException
import com.fasterxml.jackson.databind.JsonNode import com.fasterxml.jackson.databind.JsonNode
import com.fasterxml.jackson.databind.ObjectMapper import com.fasterxml.jackson.databind.ObjectMapper
import com.fasterxml.jackson.databind.ObjectReader import com.fasterxml.jackson.databind.ObjectReader
import com.fasterxml.jackson.databind.node.JsonNodeType
import com.fasterxml.jackson.databind.node.ObjectNode import com.fasterxml.jackson.databind.node.ObjectNode
import com.mingliqiye.utils.json.converters.JsonConverter import com.mingliqiye.utils.exception.JsonException
import com.mingliqiye.utils.json.converters.JsonStringConverter import com.mingliqiye.utils.json.api.JackSonJsonItem.Companion.getJsonItem
import java.io.IOException import com.mingliqiye.utils.json.api.base.JsonApi
import com.mingliqiye.utils.json.api.type.JsonTypeReference
import com.mingliqiye.utils.json.converters.base.BaseJsonConverter
import com.mingliqiye.utils.json.converters.base.getJacksonModule
import com.mingliqiye.utils.json.objects.base.*
/** /**
* 基于Jackson的JSON处理实现类,提供JSON字符串解析、格式化、合并、节点操作等功能。 * 基于Jackson的JSON处理实现类,提供JSON字符串解析、格式化、合并、节点操作等功能。
@@ -46,13 +51,15 @@ class JacksonJsonApi : JsonApi {
this.objectMapper = ObjectMapper() this.objectMapper = ObjectMapper()
} }
fun getObjectMapper() = objectMapper
/** /**
* 使用指定的ObjectMapper构造实例 * 使用指定的ObjectMapper构造实例
* *
* @param objectMapper 自定义的ObjectMapper实例 * @param objectMapper 自定义的ObjectMapper实例
*/ */
constructor(objectMapper: ObjectMapper) { constructor(objectMapper: ObjectMapper) {
this.objectMapper = objectMapper.copy() this.objectMapper = objectMapper
} }
/** /**
@@ -67,7 +74,7 @@ class JacksonJsonApi : JsonApi {
override fun <T> parse(json: String, clazz: Class<T>): T { override fun <T> parse(json: String, clazz: Class<T>): T {
return try { return try {
objectMapper.readValue(json, clazz) objectMapper.readValue(json, clazz)
} catch (e: IOException) { } catch (e: Exception) {
throw JsonException("Failed to parse JSON string", e) throw JsonException("Failed to parse JSON string", e)
} }
} }
@@ -87,7 +94,7 @@ class JacksonJsonApi : JsonApi {
objectMapper.constructType(type.type) objectMapper.constructType(type.type)
) )
reader.readValue(json) reader.readValue(json)
} catch (e: IOException) { } catch (e: Exception) {
throw JsonException("Failed to parse JSON string", e) throw JsonException("Failed to parse JSON string", e)
} }
} }
@@ -95,62 +102,50 @@ class JacksonJsonApi : JsonApi {
/** /**
* 将对象格式化为JSON字符串 * 将对象格式化为JSON字符串
* *
* @param `object` 待格式化的对象
* @return 格式化后的JSON字符串 * @return 格式化后的JSON字符串
* @throws JsonException 当格式化失败时抛出异常 * @throws JsonException 当格式化失败时抛出异常
*/ */
override fun format(obj: Any): String { override fun format(obj: Any): String {
return try { return try {
objectMapper.writeValueAsString(obj) objectMapper.writeValueAsString(obj)
} catch (e: JsonProcessingException) { } catch (e: Exception) {
throw JsonException( throw JsonException(
"Failed to format object to JSON string", "Failed to format object to JSON string", e
e
) )
} }
} }
override fun formatUnicode(obj: Any): String { fun formatUnicode(obj: Any): String {
return try { return try {
objectMapper objectMapper.writer().with(JsonGenerator.Feature.ESCAPE_NON_ASCII).writeValueAsString(obj)
.writer() } catch (e: Exception) {
.with(JsonGenerator.Feature.ESCAPE_NON_ASCII) throw JsonException(throwable = e)
.writeValueAsString(obj)
} catch (e: JsonProcessingException) {
throw JsonException(e)
} }
} }
/** /**
* 将对象格式化为美化(带缩进)的JSON字符串 * 将对象格式化为美化(带缩进)的JSON字符串
* *
* @param `object` 待格式化的对象
* @return 美化后的JSON字符串 * @return 美化后的JSON字符串
* @throws JsonException 当格式化失败时抛出异常 * @throws JsonException 当格式化失败时抛出异常
*/ */
override fun formatPretty(obj: Any): String { override fun formatPretty(obj: Any): String {
return try { return try {
objectMapper objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(obj)
.writerWithDefaultPrettyPrinter() } catch (e: Exception) {
.writeValueAsString(obj)
} catch (e: JsonProcessingException) {
throw JsonException( throw JsonException(
"Failed to format object to pretty JSON string", "Failed to format object to pretty JSON string", e
e
) )
} }
} }
override fun formatPrettyUnicode(obj: Any): String { fun formatPrettyUnicode(obj: Any): String {
return try { return try {
objectMapper objectMapper.writerWithDefaultPrettyPrinter().with(JsonGenerator.Feature.ESCAPE_NON_ASCII)
.writerWithDefaultPrettyPrinter()
.with(JsonGenerator.Feature.ESCAPE_NON_ASCII)
.writeValueAsString(obj) .writeValueAsString(obj)
} catch (e: JsonProcessingException) { } catch (e: Exception) {
throw JsonException( throw JsonException(
"Failed to format object to pretty JSON string", "Failed to format object to pretty JSON string", e
e
) )
} }
} }
@@ -166,7 +161,7 @@ class JacksonJsonApi : JsonApi {
return try { return try {
objectMapper.readTree(json) objectMapper.readTree(json)
true true
} catch (e: Exception) { } catch (_: Exception) {
false false
} }
} }
@@ -186,8 +181,7 @@ class JacksonJsonApi : JsonApi {
if (node.isObject) { if (node.isObject) {
result.setAll<JsonNode>(node as ObjectNode) result.setAll<JsonNode>(node as ObjectNode)
} }
} catch (e: IOException) { } catch (_: Exception) {
// 忽略无效的JSON字符串
} }
} }
return try { return try {
@@ -213,7 +207,7 @@ class JacksonJsonApi : JsonApi {
node = node.get(p) node = node.get(p)
} }
node.asText() node.asText()
} catch (e: IOException) { } catch (e: Exception) {
throw JsonException("Failed to get node value", e) throw JsonException("Failed to get node value", e)
} }
} }
@@ -247,15 +241,14 @@ class JacksonJsonApi : JsonApi {
if (current is ObjectNode) { if (current is ObjectNode) {
val parent: ObjectNode = current val parent: ObjectNode = current
parent.set<JsonNode>( parent.set<JsonNode>(
paths[paths.size - 1], paths[paths.size - 1], objectMapper.valueToTree(newValue)
objectMapper.valueToTree(newValue)
) )
} }
objectMapper.writeValueAsString(objectNode) objectMapper.writeValueAsString(objectNode)
} }
json json
} catch (e: IOException) { } catch (e: Exception) {
throw JsonException("Failed to update node value", e) throw JsonException("Failed to update node value", e)
} }
} }
@@ -269,8 +262,12 @@ class JacksonJsonApi : JsonApi {
* @param <D> 目标对象类型 * @param <D> 目标对象类型
* @return 转换后的对象 * @return 转换后的对象
*/ */
override fun <T, D> convert(source: T, destinationClass: Class<D>): D { override fun <D> convert(source: Any, destinationClass: Class<D>): D {
return objectMapper.convertValue(source, destinationClass) try {
return objectMapper.convertValue(source, destinationClass)
} catch (e: Exception) {
throw JsonException("Failed to update node value", e)
}
} }
/** /**
@@ -282,20 +279,96 @@ class JacksonJsonApi : JsonApi {
* @param <D> 目标对象类型 * @param <D> 目标对象类型
* @return 转换后的对象 * @return 转换后的对象
*/ */
override fun <T, D> convert(source: T, destinationType: JsonTypeReference<D>): D { override fun <D> convert(source: Any, destinationType: JsonTypeReference<D>): D {
return objectMapper.convertValue( try {
source, return objectMapper.convertValue(
objectMapper.constructType(destinationType.type) source, objectMapper.constructType(destinationType.type)
) )
} } catch (e: Exception) {
throw JsonException("Failed to update node value", e)
override fun addJsonConverter(c: JsonConverter<*, *>) {
c.getStringConverter()?.let {
objectMapper.registerModule(it.jacksonJsonStringConverterAdapter.jacksonModule)
} }
} }
override fun addJsonStringConverter(c: JsonStringConverter<*>) { override fun addJsonConverter(c: BaseJsonConverter<*, *>) {
addJsonConverter(c) try {
objectMapper.registerModule(c.getJacksonModule())
} catch (e: Exception) {
throw JsonException("Failed to update node value", e)
}
}
override fun parseJsonItem(json: String): JsonItem {
try {
return getJsonItem(objectMapper.readTree(json))
} catch (e: Exception) {
throw JsonException("Failed to parseJsonItem", e)
}
}
}
class JackSonJsonItem : JsonItem {
companion object {
fun getJsonItem(node: JsonNode): JsonItem {
return when (node.nodeType) {
JsonNodeType.OBJECT -> JackSonJsonObject(node)
JsonNodeType.ARRAY -> JackSonJsonArray(node)
JsonNodeType.BOOLEAN -> JackSonJsonBoolean(node)
JsonNodeType.NULL -> JsonNull()
JsonNodeType.NUMBER -> JackSonJsonNumber(node)
JsonNodeType.STRING -> JackSonJsonString(node)
else -> throw IllegalStateException("unknown type ${node.nodeType}")
}
}
}
}
class JackSonJsonNumber(node: JsonNode) : JsonNumber(node.asText())
class JackSonJsonBoolean(node: JsonNode) : JsonBoolean(node.asBoolean())
class JackSonJsonString(node: JsonNode) : JsonString(node.asText())
class JackSonJsonArray(val node: JsonNode) : JsonArray() {
override fun getIndex(index: Int): JsonItem {
return getJsonItem(node.get(index))
}
override fun iteratorArray(): Iterator<IndexedValue<JsonItem>> {
val iteet = node.iterator().withIndex()
return object : Iterator<IndexedValue<JsonItem>> {
override fun next(): IndexedValue<JsonItem> {
val it = iteet.next()
return IndexedValue(it.index, getJsonItem(it.value))
}
override fun hasNext(): Boolean {
return iteet.hasNext()
}
}
}
}
class JackSonJsonObject(val node: JsonNode) : JsonObject() {
override fun getField(name: String): JsonItem {
return getJsonItem(node.get(name))
}
override fun iteratorObject(): Iterator<Map.Entry<String, JsonItem>> {
return object : Iterator<Map.Entry<String, JsonItem>> {
val it = node.properties().iterator()
override fun next(): Map.Entry<String, JsonItem> {
val utem = it.next()
return object : Map.Entry<String, JsonItem> {
override val key: String
get() = utem.key
override val value: JsonItem
get() = getJsonItem(utem.value)
}
}
override fun hasNext(): Boolean {
return it.hasNext()
}
}
} }
} }
@@ -0,0 +1,606 @@
/*
* 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 JsonApi.kt
* LastUpdate 2026-03-27 14:19:31
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.json.api.base
import com.mingliqiye.utils.exception.JsonParserException
import com.mingliqiye.utils.json.api.type.JsonTypeReference
import com.mingliqiye.utils.json.api.type.listType
import com.mingliqiye.utils.json.converters.base.BaseJsonConverter
import com.mingliqiye.utils.json.converters.base.getJsonConverter
import com.mingliqiye.utils.json.objects.base.JsonItem
import okio.IOException
import java.io.*
import java.nio.file.Files
import java.nio.file.Path
import java.nio.file.Paths
import kotlin.io.path.readBytes
/**
* JSON处理接口,提供JSON字符串与Java对象之间的相互转换功能
*/
interface JsonApi {
companion object {
/**
* 将JSON字符串解析为指定泛型类型对象
*
* @param json 待解析的JSON字符串
* @param T 泛型参数,表示目标对象的类型
* @return 解析后的对象实例
*/
inline fun <reified T> JsonApi.parse(json: String): T = parse(json, object : JsonTypeReference<T>() {})
/**
* 将JSON字节数组解析为指定泛型类型对象
*
* @param json 待解析的JSON字节数组
* @param T 泛型参数,表示目标对象的类型
* @return 解析后的对象实例
*/
inline fun <reified T> JsonApi.parse(json: ByteArray): T = parse(json, object : JsonTypeReference<T>() {})
/**
* 将JSON字符串解析为指定泛型类型对象,解析失败时返回默认值
*
* @param json 待解析的JSON字符串
* @param defect 解析失败时返回的默认值
* @param T 泛型参数,表示目标对象的类型
* @return 解析后的对象实例或默认值
*/
inline fun <reified T> JsonApi.parse(json: String, defect: T): T =
parse(json, object : JsonTypeReference<T>() {}, defect)
/**
* 从文件路径读取JSON并解析为指定泛型类型对象
*
* @param path 文件路径
* @param T 泛型参数,表示目标对象的类型
* @return 解析后的对象实例
*/
inline fun <reified T> JsonApi.parseFrom(path: String): T = parseFrom(path, object : JsonTypeReference<T>() {})
/**
* 从文件读取JSON并解析为指定泛型类型对象
*
* @param path 文件对象
* @param T 泛型参数,表示目标对象的类型
* @return 解析后的对象实例
*/
inline fun <reified T> JsonApi.parseFrom(path: File): T = parseFrom(path, object : JsonTypeReference<T>() {})
/**
* 从输入流读取JSON并解析为指定泛型类型对象
*
* @param path 输入流
* @param T 泛型参数,表示目标对象的类型
* @return 解析后的对象实例
*/
inline fun <reified T> JsonApi.parseFrom(path: InputStream): T =
parseFrom(path, object : JsonTypeReference<T>() {})
/**
* 从路径读取JSON并解析为指定泛型类型对象
*
* @param path 路径对象
* @param T 泛型参数,表示目标对象的类型
* @return 解析后的对象实例
*/
inline fun <reified T> JsonApi.parseFrom(path: Path): T = parseFrom(path, object : JsonTypeReference<T>() {})
/**
* 将JSON字符串解析为指定键值类型的Map集合
*
* @param json 待解析的JSON字符串
* @param K 泛型参数,表示Map中键的类型
* @param V 泛型参数,表示Map中值的类型
* @return 解析后的Map集合
*/
inline fun <reified K, reified V> JsonApi.parseMap(
json: String,
): MutableMap<K, V> = parseMap(json, K::class.java, V::class.java)
/**
* 使用内联函数和reified类型参数将源对象转换为目标类型的对象
*
* @param T 源对象的类型
* @param D 目标对象的类型(通过reified类型参数推断)
* @param source 需要转换的源对象
* @return 转换后的目标类型对象
*/
@JvmStatic
inline fun <reified D> JsonApi.convert(source: Any): D = convert(source, object : JsonTypeReference<D>() {})
/**
* 添加JSON转换器到API中
*
* @param T 需要添加的JSON转换器类
*/
@JvmStatic
inline fun <reified T : BaseJsonConverter<*, *>> JsonApi.addJsonConverter() {
addJsonConverter(getJsonConverter<T>())
}
}
/**
* 将JSON字符串解析为指定类型的对象
*
* @param json 待解析的JSON字符串
* @param clazz 目标对象的Class类型
* @param <T> 泛型参数,表示目标对象的类型
* @return 解析后的对象实例
</T> */
fun <T> parse(json: String, clazz: Class<T>): T
/**
* 将JSON字符串解析为指定泛型类型对象
*
* @param json 待解析的JSON字符串
* @param type 目标对象的Type类型(支持泛型)
* @param <T> 泛型参数,表示目标对象的类型
* @return 解析后的对象实例
</T> */
fun <T> parse(json: String, type: JsonTypeReference<T>): T
/**
* 将对象格式化为JSON字符串
*
* @param obj 待格式化的对象
* @return 格式化后的JSON字符串
*/
fun format(obj: Any): String
/**
* 从文件路径读取JSON并解析为指定类型对象
*
* @param path 文件路径
* @param clazz 目标对象的Class类型
* @param <T> 泛型参数,表示目标对象的类型
* @return 解析后的对象实例
*/
fun <T> parseFrom(path: String, clazz: Class<T>): T {
return parseFrom(Paths.get(path), clazz)
}
/**
* 从路径读取JSON并解析为指定类型对象
*
* @param path 路径对象
* @param clazz 目标对象的Class类型
* @param <T> 泛型参数,表示目标对象的类型
* @return 解析后的对象实例
*/
fun <T> parseFrom(path: Path, clazz: Class<T>): T {
return parseFrom(path.toFile(), clazz)
}
/**
* 从文件读取JSON并解析为指定类型对象
*
* @param file 文件对象
* @param clazz 目标对象的Class类型
* @param <T> 泛型参数,表示目标对象的类型
* @return 解析后的对象实例
*/
fun <T> parseFrom(file: File, clazz: Class<T>): T {
Files.newInputStream(file.toPath()).use { inputStream ->
return parseFrom(inputStream, clazz)
}
}
/**
* 从输入流读取JSON并解析为指定类型对象
*
* @param inputStream 输入流
* @param clazz 目标对象的Class类型
* @param <T> 泛型参数,表示目标对象的类型
* @return 解析后的对象实例
*/
fun <T> parseFrom(inputStream: InputStream, clazz: Class<T>): T {
val bytes = ByteArray(1024)
ByteArrayOutputStream().use { bos ->
var readlength: Int
while ((inputStream.read(bytes).also { readlength = it }) != -1) {
bos.write(bytes, 0, readlength)
}
return parse(bos.toByteArray(), clazz)
}
}
/**
* 从文件路径读取JSON并解析为指定泛型类型对象
*
* @param path 文件路径
* @param type 目标对象的Type类型(支持泛型)
* @param <T> 泛型参数,表示目标对象的类型
* @return 解析后的对象实例
*/
fun <T> parseFrom(path: String, type: JsonTypeReference<T>): T {
return parseFrom(Paths.get(path), type)
}
/**
* 从路径读取JSON并解析为指定泛型类型对象
*
* @param path 路径对象
* @param type 目标对象的Type类型(支持泛型)
* @param <T> 泛型参数,表示目标对象的类型
* @return 解析后的对象实例
*/
fun <T> parseFrom(path: Path, type: JsonTypeReference<T>): T {
return parseFrom(path.toFile(), type)
}
/**
* 从文件读取JSON并解析为指定泛型类型对象
*
* @param file 文件对象
* @param type 目标对象的Type类型(支持泛型)
* @param <T> 泛型参数,表示目标对象的类型
* @return 解析后的对象实例
*/
fun <T> parseFrom(file: File, type: JsonTypeReference<T>): T {
Files.newInputStream(file.toPath()).use { inputStream ->
return parseFrom<T>(inputStream, type)
}
}
/**
* 从输入流读取JSON并解析为指定泛型类型对象
*
* @param inputStream 输入流
* @param type 目标对象的Type类型(支持泛型)
* @param <T> 泛型参数,表示目标对象的类型
* @return 解析后的对象实例
*/
fun <T> parseFrom(inputStream: InputStream, type: JsonTypeReference<T>): T {
val bytes = ByteArray(1024)
ByteArrayOutputStream().use { bos ->
var readlength: Int
while ((inputStream.read(bytes).also { readlength = it }) != -1) {
bos.write(bytes, 0, readlength)
}
return parse(bos.toByteArray(), type)
}
}
/**
* 将字节数组形式的JSON解析为指定类型的对象
*
* @param json 待解析的JSON字节数组
* @param clazz 目标对象的Class类型
* @param <T> 泛型参数,表示目标对象的类型
* @return 解析后的对象实例
</T> */
fun <T> parse(json: ByteArray, clazz: Class<T>): T {
return parse(String(json), clazz)
}
/**
* 将字节数组形式的JSON解析为指定泛型类型对象
*
* @param json 待解析的JSON字节数组
* @param type 目标对象的Type类型(支持泛型)
* @param <T> 泛型参数,表示目标对象的类型
* @return 解析后的对象实例
</T> */
fun <T> parse(json: ByteArray, type: JsonTypeReference<T>): T {
return parse(String(json), type)
}
/**
* 将JSON字符串解析为指定类型的对象,解析失败时返回默认值
*
* @param json 待解析的JSON字符串
* @param clazz 目标对象的Class类型
* @param defaultValue 解析失败时返回的默认值
* @param <T> 泛型参数,表示目标对象的类型
* @return 解析后的对象实例或默认值
</T> */
fun <T> parse(json: String, clazz: Class<T>, defaultValue: T): T {
return try {
parse(json, clazz)
} catch (e: Exception) {
defaultValue
}
}
/**
* 将JSON字符串解析为指定泛型类型对象,解析失败时返回默认值
*
* @param json 待解析的JSON字符串
* @param type 目标对象的Type类型(支持泛型)
* @param defaultValue 解析失败时返回的默认值
* @param <T> 泛型参数,表示目标对象的类型
* @return 解析后的对象实例或默认值
**/
fun <T> parse(
json: String, type: JsonTypeReference<T>, defaultValue: T,
): T {
return try {
parse<T>(json, type)
} catch (e: Exception) {
defaultValue
}
}
/**
* 将对象格式化为美化格式的JSON字符串(带缩进和换行)
*
* @param object 待格式化的对象
* @return 格式化后的美化JSON字符串
*/
fun formatPretty(obj: Any): String
fun formatPrettyBytes(obj: Any): ByteArray {
return formatPretty(obj)!!.toByteArray()
}
fun formatPretty(obj: Any, file: String) {
formatPretty(obj, Paths.get(file))
}
fun formatPretty(obj: Any, file: Path) {
formatPretty(obj, file.toFile())
}
fun formatPretty(obj: Any, file: File) {
FileOutputStream(file).use { fos ->
formatPretty(obj, fos)
}
}
fun formatPretty(obj: Any, stream: OutputStream) {
stream.write(formatPrettyBytes(obj))
}
fun formatBytes(obj: Any): ByteArray {
return format(obj).toByteArray()
}
fun format(obj: Any, file: String) {
format(obj, Paths.get(file))
}
fun format(obj: Any, file: Path) {
format(obj, file.toFile())
}
fun format(obj: Any, file: File) {
FileOutputStream(file).use { fos ->
format(obj, fos)
}
}
fun format(obj: Any, stream: OutputStream) {
stream.write(formatPrettyBytes(obj))
}
/**
* 将JSON字符串解析为指定元素类型的List集合
*
* @param json 待解析的JSON字符串
* @param elementType List中元素的类型
* @param <T> 泛型参数,表示List中元素的类型
* @return 解析后的List集合
</T> */
fun <T> parseList(json: String, elementType: Class<T>): List<T> {
return parse(json, type = listType(elementType))
}
/**
* 将JSON字符串解析为指定键值类型的Map集合
*
* @param json 待解析的JSON字符串
* @param keyType Map中键的类型
* @param valueType Map中值的类型
* @param <K> 泛型参数,表示Map中键的类型
* @param <V> 泛型参数,表示Map中值的类型
* @return 解析后的Map集合
</V></K> */
fun <K, V> parseMap(
json: String, keyType: Class<K>, valueType: Class<V>,
): MutableMap<K, V> {
val mapType: JsonTypeReference<MutableMap<K, V>> = object : JsonTypeReference<MutableMap<K, V>>() {}
return parse<MutableMap<K, V>>(json, mapType)
}
/**
* 验证字符串是否为有效的JSON格式
*
* @param json 待验证的字符串
* @return 如果是有效的JSON格式返回true,否则返回false
*/
fun isValidJson(json: String): Boolean
/**
* 将对象转换为JSON字节数组
*
* @param object 待转换的对象
* @return 转换后的JSON字节数组
*/
fun toBytes(obj: Any): ByteArray {
return format(obj)!!.toByteArray()
}
/**
* 将对象转换为美化格式的JSON字节数组
*
* @param object 待转换的对象
* @return 转换后的美化格式JSON字节数组
*/
fun toBytesPretty(obj: Any): ByteArray {
return formatPretty(obj)!!.toByteArray()
}
/**
* 合并多个JSON字符串为一个JSON对象
*
* @param jsons 待合并的JSON字符串数组
* @return 合并后的JSON字符串
*/
fun merge(vararg jsons: String): String
/**
* 获取JSON字符串中指定路径节点的值
*
* @param json JSON字符串
* @param path 节点路径(如:"user.name")
* @return 节点值的字符串表示
*/
fun getNodeValue(json: String, path: String): String?
/**
* 更新JSON字符串中指定路径节点的值
*
* @param json 原始JSON字符串
* @param path 节点路径(如:"user.name")
* @param newValue 新的节点值
* @return 更新后的JSON字符串
*/
fun updateNodeValue(json: String, path: String, newValue: Any): String
/**
* 将任意对象转换为指定类型的对象
*
* @param source 源对象,可以是 JSON 字符串、JsonItem 或其他对象
* @param destinationClass 目标类型的 Class 对象
* @return 转换后的目标类型对象
*
* @param <D> 目标类型泛型参数
*/
fun <D> convert(source: Any, destinationClass: Class<D>): D
/**
* 将任意对象转换为指定泛型类型的对象
* 用于处理带泛型的复杂类型,如 List<User>、Map<String, User> 等
*
* @param source 源对象,可以是 JSON 字符串、JsonItem 或其他对象
* @param destinationType 目标类型的类型引用,包含泛型信息
* @return 转换后的目标类型对象
*
* @param <D> 目标类型泛型参数
*
* 使用示例:
* ```
* val typeRef = object : JsonTypeReference<List<User>>() {}
* val userList = converter.convert(jsonString, typeRef)
* ```
*/
fun <D> convert(source: Any, destinationType: JsonTypeReference<D>): D
/**
* 注册自定义的 JSON 转换器
* 用于处理特定类型的自定义序列化和反序列化逻辑
*
* @param c 自定义的 JSON 转换器实例
*
* 使用示例:
* ```
* converter.addJsonConverter(DateJsonConverter())
* converter.addJsonConverter(LocalDateTimeJsonConverter())
* ```
*/
fun addJsonConverter(c: BaseJsonConverter<*, *>)
/**
* 将 JSON 字符串解析为 JsonItem 对象
*
* @param json JSON 格式的字符串
* @return 解析后的 JsonItem 对象,可以是 JsonObject、JsonArray 或 JsonValue
* @throws JsonParserException 当 JSON 格式错误时抛出
*/
fun parseJsonItem(json: String): JsonItem
/**
* 将字节数组解析为 JsonItem 对象
* 字节数组会被转换为字符串后再解析
*
* @param byte JSON 格式的字节数组(通常是 UTF-8 编码)
* @return 解析后的 JsonItem 对象
* @throws JsonParserException 当 JSON 格式错误时抛出
*/
fun parseJsonItem(byte: ByteArray): JsonItem {
return parseJsonItem(String(byte))
}
/**
* 将输入流解析为 JsonItem 对象
* 会自动关闭输入流
*
* @param inputStream JSON 数据的输入流
* @return 解析后的 JsonItem 对象
* @throws JsonParserException 当 JSON 格式错误时抛出
* @throws IOException 当读取输入流失败时抛出
*
* 使用示例:
* ```
* val inputStream = FileInputStream("data.json")
* val jsonItem = converter.parseJsonItem(inputStream)
* ```
*/
fun parseJsonItem(inputStream: InputStream): JsonItem {
inputStream.use {
return parseJsonItem(it.readAllBytes())
}
}
/**
* 将文件解析为 JsonItem 对象
*
* @param file 包含 JSON 数据的文件
* @return 解析后的 JsonItem 对象
* @throws IOException 当读取文件失败时抛出
*
* 使用示例:
* ```
* val file = File("config.json")
* val jsonItem = converter.parseJsonItem(file)
* ```
*/
@Throws(IOException::class)
fun parseJsonItem(file: File): JsonItem {
return parseJsonItem(file.readBytes())
}
/**
* 将文件路径解析为 JsonItem 对象
*
* @param path 包含 JSON 数据的文件路径
* @return 解析后的 JsonItem 对象
* @throws IOException 当读取文件失败时抛出
*
* 使用示例:
* ```
* val path = Paths.get("data/user.json")
* val jsonItem = converter.parseJsonItem(path)
* ```
*/
fun parseJsonItem(path: Path): JsonItem {
return parseJsonItem(path.readBytes())
}
}
@@ -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,11 +16,11 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile JsonTypeReference.kt * CurrentFile JsonTypeReference.kt
* LastUpdate 2025-09-15 22:32:50 * LastUpdate 2026-02-05 11:12:36
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
package com.mingliqiye.utils.json package com.mingliqiye.utils.json.api.type
import java.lang.reflect.ParameterizedType import java.lang.reflect.ParameterizedType
import java.lang.reflect.Type import java.lang.reflect.Type
@@ -68,8 +68,7 @@ abstract class JsonTypeReference<T> : Comparable<JsonTypeReference<T>> {
* @return 类型引用实例 * @return 类型引用实例
*/ */
companion object { companion object {
@JvmStatic inline fun <reified T> of(): JsonTypeReference<T> {
fun <T> of(): JsonTypeReference<T> {
return object : JsonTypeReference<T>() {} return object : JsonTypeReference<T>() {}
} }
@@ -116,6 +115,11 @@ abstract class JsonTypeReference<T> : Comparable<JsonTypeReference<T>> {
throw IllegalStateException("无法获取原始类型: $type") throw IllegalStateException("无法获取原始类型: $type")
} }
/**
* 判断两个 JsonTypeReference 实例是否相等
* @param other 另一个对象
* @return 是否相等
*/
override fun equals(other: Any?): Boolean { override fun equals(other: Any?): Boolean {
if (this === other) return true if (this === other) return true
if (other == null || this.javaClass != other.javaClass) return false if (other == null || this.javaClass != other.javaClass) return false
@@ -142,6 +146,10 @@ abstract class JsonTypeReference<T> : Comparable<JsonTypeReference<T>> {
return Objects.equals(type, that.type) return Objects.equals(type, that.type)
} }
/**
* 计算当前实例的哈希码
* @return 哈希码值
*/
override fun hashCode(): Int { override fun hashCode(): Int {
if (type is ParameterizedType) { if (type is ParameterizedType) {
val paramType = type as ParameterizedType val paramType = type as ParameterizedType
@@ -154,10 +162,19 @@ abstract class JsonTypeReference<T> : Comparable<JsonTypeReference<T>> {
return Objects.hash(type) return Objects.hash(type)
} }
/**
* 返回当前实例的字符串表示形式
* @return 字符串描述
*/
override fun toString(): String { override fun toString(): String {
return "JsonTypeReference{$type}" return "com.mingliqiye.utils.json.JsonTypeReference<${TypeReference.getRawString(type)}>"
} }
/**
* 比较当前实例与另一个实例的大小关系
* @param other 另一个 JsonTypeReference 实例
* @return 比较结果
*/
override fun compareTo(other: JsonTypeReference<T>): Int { override fun compareTo(other: JsonTypeReference<T>): Int {
return this.type.toString().compareTo(other.type.toString()) return this.type.toString().compareTo(other.type.toString())
} }
@@ -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,12 +16,12 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile JsonTypeUtils.kt * CurrentFile JsonTypeUtils.kt
* LastUpdate 2025-09-17 11:12:06 * LastUpdate 2026-02-04 21:00:48
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@file:JvmName("JsonTypeUtils") @file:JvmName("JsonTypeUtils")
package com.mingliqiye.utils.json package com.mingliqiye.utils.json.api.type
import java.lang.reflect.ParameterizedType import java.lang.reflect.ParameterizedType
import java.lang.reflect.Type import java.lang.reflect.Type

Some files were not shown because too many files have changed in this diff Show More