Compare commits

..
Author SHA1 Message Date
minglipro 31987b9b14 a 2026-10-20 20:05:40 +08:00
minglipro 474071e43b feat(thread): 新增线程工具集与线程池构建体系
- ThreadPoolBuilder: DSL 风格线程池构建器,含 fixed/single/cached/io/cpu/scheduled 预设
- GlobalThreadPool: 全局 IO/CPU/定时三类共享线程池及便捷提交函数
- ThreadPoolMonitor: 线程池运行快照与周期监控
- ThreadPoolExt: ExecutorService/Future/CompletableFuture 便捷扩展
- AsyncTasks: 并行执行、竞速执行、重试与定时任务编排
- ThreadLocalDelegates: ThreadLocal 属性委托
- ThreadExt: Thread/Runnable 扩展与守护线程便捷创建
- ThreadUtils 增强: 休眠、线程枚举、全线程栈转储
- ThreadEvent 增强: operator invoke、属性委托、isSet 与超时取数
- 移除 pool 包旧 ThreadPool.kt
- 新增 5 个测试类共 83 个单元测试
2026-10-19 21:09:57 +08:00
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
137 changed files with 33164 additions and 3441 deletions
+58 -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-02-08 03:14:06 * LastUpdate 2026-10-11 16:44:37
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@@ -30,12 +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" 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
@@ -46,64 +50,69 @@ base {
val buildDir: java.nio.file.Path = File("build").toPath() val buildDir: java.nio.file.Path = File("build").toPath()
sourceSets {
main {
java { java {
srcDirs("src/main/java") toolchain.languageVersion.set(JavaLanguageVersion.of(JDKVERSIONS))
withSourcesJar()
} }
kotlin { kotlin {
srcDirs("src/main/kotlin") jvmToolchain(JDKVERSIONS)
}
resources {
srcDirs("src/main/resources")
}
}
} }
tasks.test { repositories {
useJUnitPlatform() mavenLocal()
maven {
url = uri("https://maven.mingliqiye.com/")
} }
mavenCentral()
java {
withSourcesJar()
toolchain.languageVersion.set(JavaLanguageVersion.of(8))
} }
dependencies { dependencies {
implementation("org.slf4j:slf4j-api:2.0.17") implementation("org.slf4j:slf4j-api:2.0.17")
implementation("com.mingliqiye.utils.jna:WinKernel32Api:1.0.1")
implementation(kotlin("reflect")) implementation(kotlin("reflect"))
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("com.squareup.okhttp3:okhttp:5.3.2")
compileOnly("com.fasterxml.jackson.core:jackson-databind:2.21.0") compileOnly("com.fasterxml.jackson.core:jackson-databind:2.21.0")
compileOnly("com.fasterxml.jackson.module:jackson-module-kotlin:2.21.0") compileOnly("com.fasterxml.jackson.module:jackson-module-kotlin:2.21.0")
compileOnly("org.springframework.boot:spring-boot-starter-web:2.7.18") 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("com.google.code.gson:gson:2.13.2")
compileOnly("org.mybatis:mybatis:3.5.19") compileOnly("org.mybatis:mybatis:3.5.19")
compileOnly("io.netty:netty-all:4.1.130.Final") compileOnly("io.netty:netty-all:4.2.15.Final")
compileOnly("com.baomidou:mybatis-plus-core:3.5.15") compileOnly("com.baomidou:mybatis-plus-core:3.5.15")
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") compileOnly("com.baomidou:mybatis-plus-extension:3.5.15")
testImplementation("org.junit.jupiter:junit-jupiter-api:5.8.1") testImplementation("org.junit.jupiter:junit-jupiter:5.7.1")
testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine:5.8.1") testRuntimeOnly("org.junit.platform:junit-platform-launcher")
// testImplementation("com.squareup.okhttp3:okhttp:5.3.2") testImplementation("com.mingliqiye.logger:logger-log4j2:1.0.9")
testImplementation("com.mingliqiye.logger:logger-log4j2:1.0.5")
testImplementation("com.google.code.gson:gson:2.13.2") testImplementation("com.google.code.gson:gson:2.13.2")
testImplementation("com.fasterxml.jackson.core:jackson-databind:2.21.0") testImplementation("com.fasterxml.jackson.core:jackson-databind:2.21.0")
testImplementation("com.fasterxml.jackson.module:jackson-module-kotlin: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"
) )
} }
@@ -149,44 +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 {
username = System.getenv("mingliqiye.username")
password = System.getenv("mingliqiye.password")
} }
maven {
name = "OSSRepository"
url = uri("C:/data/git/maven-repository-raw-utils")
} }
} }
publications { publications {
create<MavenPublication>("mavenJava") { create<MavenPublication>("mavenJava") {
from(components["java"]) from(components["java"])
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"
@@ -222,8 +221,6 @@ tasks.build {
} }
tasks.processResources { tasks.processResources {
duplicatesStrategy = DuplicatesStrategy.EXCLUDE duplicatesStrategy = DuplicatesStrategy.EXCLUDE
outputs.upToDateWhen { false } outputs.upToDateWhen { false }
@@ -239,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-02-08 03:15:06 # 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.6.4 VERSIONS=5.3.2
signing.keyId=B22AA93B
signing.password=
signing.secretKeyRingFile=secret.gpg
-89
View File
@@ -1,89 +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
}
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")
}
-23
View File
@@ -1,23 +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 gradle.properties
# LastUpdate 2025-09-16 12:14:37
# UpdateUser MingLiPro
#
signing.secretKeyRingFile=../secret.gpg
Binary file not shown.
+13 -2
View File
@@ -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 2026-02-07 17:00:59 * 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"
}
}
@@ -15,17 +15,20 @@
* *
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile TestAnnotation.kt * CurrentFile Jackson3ApiJavaHelper.java
* LastUpdate 2026-02-07 08:44:25 * LastUpdate 2026-03-18 08:32:31
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
package com.mingliqiye.utils.annotation package com.mingliqiye.utils.json.api;
@Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY) import tools.jackson.databind.ObjectMapper;
@Retention(AnnotationRetention.SOURCE) import tools.jackson.databind.cfg.MapperBuilder;
annotation class TestAnnotation(val value: String = "test")
@Target(AnnotationTarget.FIELD)
@Retention(AnnotationRetention.SOURCE) public class Jackson3ApiJavaHelper {
annotation class TestFieldAnnotation(val required: Boolean = true) @SuppressWarnings("rawtypes")
static MapperBuilder rebuild(ObjectMapper objectMapper) {
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);
}
}
@@ -16,7 +16,7 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile SuperStream.java * CurrentFile SuperStream.java
* LastUpdate 2026-01-20 13:27:09 * LastUpdate 2026-10-11 17:23:57
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@@ -103,6 +103,17 @@ public class SuperStream<T> implements Stream<T> {
return of(Collections.newArrayLists(args)); return of(Collections.newArrayLists(args));
} }
/**
* 创建一个包含指定布尔元素的SuperStream
*
* @param args 可变参数的布尔数组
* @return 包含指定布尔的SuperStream实例
*/
public static SuperStream<Boolean> of(boolean... args) {
return of(Collections.newArrayLists(args));
}
/** /**
* 创建一个包含指定浮点数元素的SuperStream * 创建一个包含指定浮点数元素的SuperStream
* *
@@ -696,7 +707,7 @@ public class SuperStream<T> implements Stream<T> {
* @param <T> 输入元素的类型 * @param <T> 输入元素的类型
* @return 产生List的收集器 * @return 产生List的收集器
*/ */
public static <T> Collector<T, ?, List<T>> toList() { public static <T> Collector<T, ?, List<T>> toListCollector() {
return Collectors.toList(); return Collectors.toList();
} }
@@ -1219,7 +1230,7 @@ public class SuperStream<T> implements Stream<T> {
* @return 包含流中所有元素的List * @return 包含流中所有元素的List
*/ */
public List<T> toAList() { public List<T> toAList() {
return collect(toList()); return collect(toListCollector());
} }
} }
@@ -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)
} }
@@ -16,14 +16,13 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile AutoServiceProcessor.kt * CurrentFile AutoServiceProcessor.kt
* LastUpdate 2026-02-08 01:24:16 * LastUpdate 2026-03-11 08:46:40
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
package com.mingliqiye.utils.annotation.processor package com.mingliqiye.utils.annotation.processor
import com.mingliqiye.utils.annotation.AutoService import com.mingliqiye.utils.annotation.AutoService
import com.mingliqiye.utils.io.IO.println
import javax.annotation.processing.AbstractProcessor import javax.annotation.processing.AbstractProcessor
import javax.annotation.processing.ProcessingEnvironment import javax.annotation.processing.ProcessingEnvironment
import javax.annotation.processing.RoundEnvironment import javax.annotation.processing.RoundEnvironment
@@ -42,7 +41,7 @@ class AutoServiceProcessor : AbstractProcessor() {
override fun process( override fun process(
annotations: Set<TypeElement>, annotations: Set<TypeElement>,
roundEnv: RoundEnvironment roundEnv: RoundEnvironment,
): Boolean { ): Boolean {
val service = mutableMapOf<String, MutableList<String>>() val service = mutableMapOf<String, MutableList<String>>()
@@ -16,7 +16,7 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile ArrayUtils.kt * CurrentFile ArrayUtils.kt
* LastUpdate 2026-02-06 14:01:56 * LastUpdate 2026-03-12 10:08:42
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@@ -25,7 +25,7 @@
package com.mingliqiye.utils.array package com.mingliqiye.utils.array
import com.mingliqiye.utils.base.BASE16 import com.mingliqiye.utils.base.BaseType
/** /**
@@ -35,7 +35,7 @@ import com.mingliqiye.utils.base.BASE16
* @since 4.6.0 * @since 4.6.0
* @see toHexByteArray * @see toHexByteArray
*/ */
fun ByteArray.toHexString(): String = BASE16.encode(this).uppercase() fun ByteArray.toHexString(): String = BaseType.BASE16.encode(this).uppercase()
/** /**
* 将十六进制字符串转换为字节数组 * 将十六进制字符串转换为字节数组
@@ -45,9 +45,7 @@ fun ByteArray.toHexString(): String = BASE16.encode(this).uppercase()
* @since 4.6.0 * @since 4.6.0
* @see toHexString * @see toHexString
*/ */
fun String.toHexByteArray(): ByteArray = BASE16.decode(this.lowercase()) fun String.toHexByteArray(): ByteArray = BaseType.BASE16.decode(this.lowercase())
/* ==================== 数组复制扩展函数 ==================== */
/** /**
* 将当前数组的指定范围复制到目标数组 * 将当前数组的指定范围复制到目标数组
@@ -15,8 +15,8 @@
* *
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile Base10.kt * CurrentFile Base10Codec.kt
* LastUpdate 2026-02-08 03:08:10 * LastUpdate 2026-03-12 10:34:36
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@@ -24,7 +24,7 @@ package com.mingliqiye.utils.base
import java.math.BigInteger import java.math.BigInteger
internal class Base10 : BaseCodec { internal class Base10Codec : BaseCodec {
/** /**
* 将字节数组编码为Base10字符串(十进制) * 将字节数组编码为Base10字符串(十进制)
@@ -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 2026-02-08 03:08:10 * LastUpdate 2026-03-12 10:34:36
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@@ -26,7 +26,7 @@ package com.mingliqiye.utils.base
* Base16编解码器实现类 * Base16编解码器实现类
* 提供字节数组与十六进制字符串之间的相互转换功能 * 提供字节数组与十六进制字符串之间的相互转换功能
*/ */
internal class Base16 : BaseCodec { internal class Base16Codec : BaseCodec {
/** /**
* 将字节数组编码为十六进制字符串 * 将字节数组编码为十六进制字符串
* @param bytes 待编码的字节数组 * @param bytes 待编码的字节数组
@@ -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 2026-02-08 03:08:10 * 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{|}~§±×÷←↑→↓⇒⇔∀∃∅∆∇∈∉∋∌∏∑−∓∕∗∘∙√∛∜∞∟∠∣∥∧∨∩∪∫∬∭∮∯∰∱∲∳∴∵∶∷≈≠≡≤≥≦≧≪≫≺≻⊂⊃⊆⊇⊈⊉⊊⊋⊕⊖⊗⊘⊙⊚⊛⊜⊝⊞⊟⊠⊡⊢⊣⊤⊥⊦⊧⊨⊩⊪⊫⊬⊭⊮⊯⋀⋁⋂⋃⋄⋅⋆⋇⋈⋉⋊⋋⋌⋍⋎⋏⋐⋑⋒⋓⋔⋕⋖⋗⋘⋙⋚⋛⋜⋝⋞⋟⋠⋡⋢⋣⋤⋥⋦⋧⋨⋩▁▂▃▄▅▆▇█▉▊▋▌▍▎▏▐░▒▓▔▕▖▗▘▙
* *
*/ */
internal class Base256 : BaseCodec { internal class Base256Codec : BaseCodec {
companion object { companion object {
val code = arrayOf( val code = arrayOf(
@@ -15,14 +15,14 @@
* *
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile Base2.kt * CurrentFile Base2Codec.kt
* LastUpdate 2026-02-08 03:06:23 * LastUpdate 2026-03-12 10:34:36
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
package com.mingliqiye.utils.base package com.mingliqiye.utils.base
internal class Base2 : BaseCodec { internal class Base2Codec : BaseCodec {
override fun encode(bytes: ByteArray): String { override fun encode(bytes: ByteArray): String {
if (bytes.isEmpty()) return "" if (bytes.isEmpty()) return ""
val result = StringBuilder() val result = StringBuilder()
@@ -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 2026-02-08 03:08:10 * 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编码和解码功能的实现
*/ */
internal 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 @@ internal 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 @@ internal 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)
}
}
@@ -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 2026-02-08 03:08:10 * LastUpdate 2026-03-12 10:34:36
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@@ -27,7 +27,7 @@ package com.mingliqiye.utils.base
* *
* Base91 是一种高效的二进制到文本的编码方式,相较于 Base64,它使用更少的字符来表示相同的数据。 * Base91 是一种高效的二进制到文本的编码方式,相较于 Base64,它使用更少的字符来表示相同的数据。
*/ */
internal 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
interface BaseCodec {
/** /**
* 将字节数组编码为Base64字符串 * BaseCodec 接口定义了一组用于编码和解码数据的基本方法。
* 提供了对字节数组、字符串、文件和路径的编码与解码功能,
* 并支持安全操作(在发生异常时返回默认值或布尔状态)。
*/
interface BaseCodec {
/**
* 对字节数组进行编码,并捕获可能发生的异常。
* *
* @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())
}
/** /**
* 将Base64字符串解码并写入文件 * 将字符串解码后写入指定文件。
* *
* @param file 目标文件 * @param file 目标文件对象
* @param string 需要解码的Base64字符串 * @param string 需要解码的字符串
* @throws IOException 当文件写入失败时抛出
*/ */
@Throws(IOException::class) fun decode(file: File, string: String) =
fun decode(file: File, string: String) { file.writeBytes(catchDecode(string))
file.writeBytes(decode(string))
}
/** /**
* 安全地将文件内容编码为Base64字符串,出现异常时返回null * 安全地对文件内容进行编码,如果发生异常则返回 null。
* *
* @param file 需要编码的文件 * @param file 需要编码的文件对象
* @return 文件内容的Base64编码字符串,失败时返回null * @return 文件内容编码后的字符串结果,若失败则返回 null
*/ */
fun encodeSafe(file: File): String? { fun encodeSafe(file: File) = try {
return try {
encode(file) encode(file)
} catch (_: Exception) { } catch (_: Exception) {
null null
} }
}
/** /**
* 安全地将Base64字符串解码并写入文件,返回操作是否成功 * 安全地将字符串解码并写入指定文件,如果成功则返回 true,否则返回 false。
* *
* @param file 目标文件 * @param file 目标文件对象
* @param string 需要解码的Base64字符串 * @param string 需要解码的字符串
* @return 操作成功返回true,失败返回false * @return 操作是否成功的布尔值
*/ */
fun decodeSafe(file: File, string: String): Boolean { fun decodeSafe(file: File, string: String) = try {
return try {
decode(file, string) decode(file, string)
true true
} catch (_: Exception) { } catch (_: Exception) {
false 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)
}
} }
@@ -16,15 +16,23 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile BaseType.kt * CurrentFile BaseType.kt
* LastUpdate 2026-02-04 21:54:04 * LastUpdate 2026-03-12 10:08:42
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
package com.mingliqiye.utils.base package com.mingliqiye.utils.base
enum class BaseType(val baseCodec: BaseCodec) { enum class BaseType(val baseCodec: BaseCodec) : BaseCodec {
BASE16(com.mingliqiye.utils.base.BASE16),
BASE64(com.mingliqiye.utils.base.BASE64), BASE2(com.mingliqiye.utils.base.code.BASE2),
BASE91(com.mingliqiye.utils.base.BASE91), BASE10(com.mingliqiye.utils.base.code.BASE10),
BASE256(com.mingliqiye.utils.base.BASE256), 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,72 +0,0 @@
/*
* 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 BaseUtils.kt
* LastUpdate 2026-02-08 03:00:37
* UpdateUser MingLiPro
*/
@file:JvmName("BaseUtils")
package com.mingliqiye.utils.base
import com.mingliqiye.utils.base.code.Base10
import com.mingliqiye.utils.base.code.Base16
import com.mingliqiye.utils.base.code.Base256
import com.mingliqiye.utils.base.code.Base64
import com.mingliqiye.utils.base.code.Base91
@Deprecated(
"重命名", replaceWith = ReplaceWith(
expression = "Base10", imports = ["com.mingliqiye.utils.base.code"]
)
)
val BASE10: BaseCodec
get() = Base10
@Deprecated(
"重命名", replaceWith = ReplaceWith(
expression = "Base16", imports = ["com.mingliqiye.utils.base.code"]
)
)
val BASE16: BaseCodec
get() = Base16
@Deprecated(
"重命名", replaceWith = ReplaceWith(
expression = "Base64", imports = ["com.mingliqiye.utils.base.code"]
)
)
val BASE64: BaseCodec
get() = Base64
@Deprecated(
"重命名", replaceWith = ReplaceWith(
expression = "Base91", imports = ["com.mingliqiye.utils.base.code"]
)
)
val BASE91: BaseCodec
get() = Base91
@Deprecated(
"重命名", replaceWith = ReplaceWith(
expression = "Base256", imports = ["com.mingliqiye.utils.base.code"]
)
)
val BASE256: BaseCodec
get() = Base256
@@ -16,7 +16,7 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile BaseCodes.kt * CurrentFile BaseCodes.kt
* LastUpdate 2026-02-08 03:10:03 * LastUpdate 2026-03-12 10:03:32
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@@ -30,52 +30,57 @@ import com.mingliqiye.utils.base.*
* 提供Base2编码器的懒加载实例。 * 提供Base2编码器的懒加载实例。
* 该编码器用于将数据编码为二进制格式。 * 该编码器用于将数据编码为二进制格式。
*/ */
@get:JvmName("Base2") @get:JvmName("base2")
val Base2: BaseCodec by lazy { val BASE2: BaseCodec by lazy {
Base2() Base2Codec()
} }
/** /**
* 提供Base10编码器的懒加载实例。 * 提供Base10编码器的懒加载实例。
* 该编码器用于将数据编码为十进制格式。 * 该编码器用于将数据编码为十进制格式。
*/ */
@get:JvmName("Base10") @get:JvmName("base10")
val Base10: BaseCodec by lazy { val BASE10: BaseCodec by lazy {
Base10() Base10Codec()
} }
/** /**
* 提供Base16编码器的懒加载实例。 * 提供Base16编码器的懒加载实例。
* 该编码器用于将数据编码为十六进制格式。 * 该编码器用于将数据编码为十六进制格式。
*/ */
@get:JvmName("Base16") @get:JvmName("base16")
val Base16: BaseCodec by lazy { val BASE16: BaseCodec by lazy {
Base16() Base16Codec()
} }
/** /**
* 提供Base64编码器的懒加载实例。 * 提供Base64编码器的懒加载实例。
* 该编码器用于将数据编码为Base64格式,常用于URL安全传输或存储。 * 该编码器用于将数据编码为Base64格式,常用于URL安全传输或存储。
*/ */
@get:JvmName("Base64") @get:JvmName("base64")
val Base64: BaseCodec by lazy { val BASE64: BaseCodec by lazy {
Base64() Base64Codec()
}
@get:JvmName("base64Url")
val BASE64URL: BaseCodec by lazy {
Base64UrlCodec()
} }
/** /**
* 提供Base91编码器的懒加载实例。 * 提供Base91编码器的懒加载实例。
* 该编码器用于将数据编码为Base91格式,具有较高的压缩效率。 * 该编码器用于将数据编码为Base91格式,具有较高的压缩效率。
*/ */
@get:JvmName("Base91") @get:JvmName("base91")
val Base91: BaseCodec by lazy { val BASE91: BaseCodec by lazy {
Base91() Base91Codec()
} }
/** /**
* 提供Base256编码器的懒加载实例。 * 提供Base256编码器的懒加载实例。
* 该编码器用于将数据编码为Base256格式,适用于字节级数据处理。 * 该编码器用于将数据编码为Base256格式,适用于字节级数据处理。
*/ */
@get:JvmName("Base256") @get:JvmName("base256")
val Base256: BaseCodec by lazy { val BASE256: BaseCodec by lazy {
Base256() 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,7 +16,7 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile ByteBufferUtils.kt * CurrentFile ByteBufferUtils.kt
* LastUpdate 2026-01-11 09:44:19 * LastUpdate 2026-07-02 09:31:01
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@@ -26,6 +26,7 @@ package com.mingliqiye.utils.bytes
import java.io.IOException import java.io.IOException
import java.io.OutputStream 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
@@ -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)
} }
/** /**
@@ -16,14 +16,14 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile ByteUtils.kt * CurrentFile ByteUtils.kt
* LastUpdate 2026-01-14 13:01:44 * 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.BASE16 import com.mingliqiye.utils.base.BaseType
import com.mingliqiye.utils.stream.SuperStream import com.mingliqiye.utils.stream.SuperStream
/** /**
@@ -88,7 +88,7 @@ const val ESC_RESERVED: Byte = 0x06
*/ */
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>
} }
@@ -125,5 +125,5 @@ fun hexStringToByteArray(string: String): ByteArray {
* @return 对应的十六进制字符串 * @return 对应的十六进制字符串
*/ */
fun bytesToHex(bytes: ByteArray): String { fun bytesToHex(bytes: ByteArray): String {
return BASE16.encode(bytes) return BaseType.BASE16.encode(bytes)
} }
@@ -16,7 +16,7 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile CloneUtils.kt * CurrentFile CloneUtils.kt
* LastUpdate 2026-02-05 14:41:27 * LastUpdate 2026-02-08 10:36:51
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@file:JvmName("CloneUtils") @file:JvmName("CloneUtils")
@@ -24,17 +24,18 @@
package com.mingliqiye.utils.clone package com.mingliqiye.utils.clone
import com.mingliqiye.utils.exception.JsonException import com.mingliqiye.utils.exception.JsonException
import com.mingliqiye.utils.json.api.base.JsonApi 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 as Any, 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 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,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)
@@ -16,21 +16,15 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile EmptyJsonException.kt * CurrentFile EmptyJsonException.kt
* LastUpdate 2026-02-07 14:45:12 * LastUpdate 2026-10-11 16:53:26
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
package com.mingliqiye.utils.exception package com.mingliqiye.utils.exception
class EmptyJsonException : JsonException { class EmptyJsonException @JvmOverloads constructor(
constructor()
constructor(message: String) : super(message)
constructor(throwable: Throwable) : super(throwable)
constructor(message: String, throwable: Throwable) : super(message, throwable)
constructor(
message: String? = null, message: String? = null,
throwable: Throwable? = null, throwable: Throwable? = null,
enableSuppression: Boolean = false, enableSuppression: Boolean = false,
writableStackTrace: Boolean = false writableStackTrace: Boolean = true,
) : super(message, throwable, enableSuppression, writableStackTrace) ) : JsonException(message, throwable, enableSuppression, writableStackTrace)
}
@@ -16,21 +16,15 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile HttpException.kt * CurrentFile HttpException.kt
* LastUpdate 2026-02-05 14:44:15 * LastUpdate 2026-10-11 16:52:48
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
package com.mingliqiye.utils.exception package com.mingliqiye.utils.exception
open class HttpException : MingLiUtilsBaseException { open class HttpException @JvmOverloads constructor(
constructor()
constructor(message: String) : super(message)
constructor(throwable: Throwable) : super(throwable)
constructor(message: String, throwable: Throwable) : super(message, throwable)
constructor(
message: String? = null, message: String? = null,
throwable: Throwable? = null, throwable: Throwable? = null,
enableSuppression: Boolean = false, enableSuppression: Boolean = false,
writableStackTrace: Boolean = false writableStackTrace: Boolean = true,
) : super(message, throwable, enableSuppression, writableStackTrace) ) : MingLiUtilsBaseException(message, throwable, enableSuppression, writableStackTrace)
}
@@ -16,7 +16,7 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile HttpStatusException.kt * CurrentFile HttpStatusException.kt
* LastUpdate 2026-02-05 14:55:04 * LastUpdate 2026-10-11 17:02:06
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@@ -29,8 +29,10 @@ package com.mingliqiye.utils.exception
* @param message 异常信息,默认为 null * @param message 异常信息,默认为 null
* @param cause 异常原因,默认为 null * @param cause 异常原因,默认为 null
*/ */
sealed class HttpStatusException( open class HttpStatusException @JvmOverloads constructor(
open val statusCode: Int, val statusCode: Int,
override val message: String? = null, message: String? = null,
override val cause: Throwable? = null throwable: Throwable? = null,
) : MingLiUtilsBaseException(message, cause) enableSuppression: Boolean = false,
writableStackTrace: Boolean = true,
) : MingLiUtilsBaseException(message, throwable, enableSuppression, writableStackTrace)
@@ -16,21 +16,15 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile HttpUrlException.kt * CurrentFile HttpUrlException.kt
* LastUpdate 2026-02-05 15:21:48 * LastUpdate 2026-10-11 16:53:00
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
package com.mingliqiye.utils.exception package com.mingliqiye.utils.exception
open class HttpUrlException : HttpException { open class HttpUrlException @JvmOverloads constructor(
constructor()
constructor(message: String) : super(message)
constructor(throwable: Throwable) : super(throwable)
constructor(message: String, throwable: Throwable) : super(message, throwable)
constructor(
message: String? = null, message: String? = null,
throwable: Throwable? = null, throwable: Throwable? = null,
enableSuppression: Boolean = false, enableSuppression: Boolean = false,
writableStackTrace: Boolean = false writableStackTrace: Boolean = true,
) : super(message, throwable, enableSuppression, writableStackTrace) ) : MingLiUtilsBaseException(message, throwable, enableSuppression, writableStackTrace)
}
@@ -16,21 +16,15 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile InvalidJsonException.kt * CurrentFile InvalidJsonException.kt
* LastUpdate 2026-02-07 13:18:32 * LastUpdate 2026-10-11 16:53:31
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
package com.mingliqiye.utils.exception package com.mingliqiye.utils.exception
class InvalidJsonException : JsonException { class InvalidJsonException @JvmOverloads constructor(
constructor()
constructor(message: String) : super(message)
constructor(throwable: Throwable) : super(throwable)
constructor(message: String, throwable: Throwable) : super(message, throwable)
constructor(
message: String? = null, message: String? = null,
throwable: Throwable? = null, throwable: Throwable? = null,
enableSuppression: Boolean = false, enableSuppression: Boolean = false,
writableStackTrace: Boolean = false writableStackTrace: Boolean = true,
) : super(message, throwable, enableSuppression, writableStackTrace) ) : JsonException(message, throwable, enableSuppression, writableStackTrace)
}
@@ -16,7 +16,7 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile JsonException.kt * CurrentFile JsonException.kt
* LastUpdate 2026-02-07 13:17:50 * LastUpdate 2026-10-11 16:53:07
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@@ -30,15 +30,9 @@ package com.mingliqiye.utils.exception
* 2. 包含错误信息和原因(Throwable)的构造函数。 * 2. 包含错误信息和原因(Throwable)的构造函数。
* 3. 仅包含原因(Throwable)的构造函数。 * 3. 仅包含原因(Throwable)的构造函数。
*/ */
open class JsonException : MingLiUtilsBaseException { open class JsonException @JvmOverloads constructor(
constructor()
constructor(message: String) : super(message)
constructor(throwable: Throwable) : super(throwable)
constructor(message: String, throwable: Throwable) : super(message, throwable)
constructor(
message: String? = null, message: String? = null,
throwable: Throwable? = null, throwable: Throwable? = null,
enableSuppression: Boolean = false, enableSuppression: Boolean = false,
writableStackTrace: Boolean = false writableStackTrace: Boolean = true,
) : super(message, throwable, enableSuppression, writableStackTrace) ) : MingLiUtilsBaseException(message, throwable, enableSuppression, writableStackTrace)
}
@@ -16,21 +16,15 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile JsonObjectCastException.kt * CurrentFile JsonObjectCastException.kt
* LastUpdate 2026-02-07 15:11:42 * LastUpdate 2026-10-11 16:53:36
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
package com.mingliqiye.utils.exception package com.mingliqiye.utils.exception
class JsonObjectCastException : JsonException { class JsonObjectCastException @JvmOverloads constructor(
constructor()
constructor(message: String) : super(message)
constructor(throwable: Throwable) : super(throwable)
constructor(message: String, throwable: Throwable) : super(message, throwable)
constructor(
message: String? = null, message: String? = null,
throwable: Throwable? = null, throwable: Throwable? = null,
enableSuppression: Boolean = false, enableSuppression: Boolean = false,
writableStackTrace: Boolean = false writableStackTrace: Boolean = true,
) : super(message, throwable, enableSuppression, writableStackTrace) ) : JsonException(message, throwable, enableSuppression, writableStackTrace)
}
@@ -16,21 +16,15 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile JsonParserException.kt * CurrentFile JsonParserException.kt
* LastUpdate 2026-02-07 14:45:12 * LastUpdate 2026-10-11 16:53:41
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
package com.mingliqiye.utils.exception package com.mingliqiye.utils.exception
class JsonParserException : JsonException { class JsonParserException @JvmOverloads constructor(
constructor()
constructor(message: String) : super(message)
constructor(throwable: Throwable) : super(throwable)
constructor(message: String, throwable: Throwable) : super(message, throwable)
constructor(
message: String? = null, message: String? = null,
throwable: Throwable? = null, throwable: Throwable? = null,
enableSuppression: Boolean = false, enableSuppression: Boolean = false,
writableStackTrace: Boolean = false writableStackTrace: Boolean = true,
) : super(message, throwable, enableSuppression, writableStackTrace) ) : JsonException(message, throwable, enableSuppression, writableStackTrace)
}
@@ -16,21 +16,15 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile JsonTypeException.kt * CurrentFile JsonTypeException.kt
* LastUpdate 2026-02-07 13:28:02 * LastUpdate 2026-10-11 16:53:45
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
package com.mingliqiye.utils.exception package com.mingliqiye.utils.exception
class JsonTypeException : JsonException { class JsonTypeException @JvmOverloads constructor(
constructor()
constructor(message: String) : super(message)
constructor(throwable: Throwable) : super(throwable)
constructor(message: String, throwable: Throwable) : super(message, throwable)
constructor(
message: String? = null, message: String? = null,
throwable: Throwable? = null, throwable: Throwable? = null,
enableSuppression: Boolean = false, enableSuppression: Boolean = false,
writableStackTrace: Boolean = false writableStackTrace: Boolean = true,
) : super(message, throwable, enableSuppression, writableStackTrace) ) : JsonException(message, throwable, enableSuppression, writableStackTrace)
}
@@ -16,22 +16,15 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile MingLiUtilsBaseException.kt * CurrentFile MingLiUtilsBaseException.kt
* LastUpdate 2026-02-05 14:41:27 * LastUpdate 2026-10-11 16:39:21
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
package com.mingliqiye.utils.exception package com.mingliqiye.utils.exception
open class MingLiUtilsBaseException : RuntimeException { open class MingLiUtilsBaseException @JvmOverloads constructor(
constructor()
constructor(message: String) : super(message)
constructor(throwable: Throwable) : super(throwable)
constructor(message: String, throwable: Throwable) : super(message, throwable)
constructor(
message: String? = null, message: String? = null,
throwable: Throwable? = null, cause: Throwable? = null,
enableSuppression: Boolean = false, enableSuppression: Boolean = false,
writableStackTrace: Boolean = false writableStackTrace: Boolean = true,
) : super(message, throwable, enableSuppression, writableStackTrace) ) : RuntimeException(message, cause, 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 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)
@@ -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++
} }
} }
} }
@@ -16,12 +16,13 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile Debouncer.kt * CurrentFile Debouncer.kt
* LastUpdate 2026-01-11 09:10:30 * LastUpdate 2026-05-23 10:30:38
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
package com.mingliqiye.utils.functions package com.mingliqiye.utils.functions
import com.mingliqiye.utils.netty.NamedThreadFactory
import java.util.concurrent.* import java.util.concurrent.*
/** /**
@@ -31,7 +32,11 @@ import java.util.concurrent.*
*/ */
class Debouncer(private val delay: Long, unit: TimeUnit) { class Debouncer(private val delay: Long, unit: TimeUnit) {
private val scheduler: ScheduledExecutorService = Executors.newSingleThreadScheduledExecutor() private val scheduler: ScheduledExecutorService = Executors.newSingleThreadScheduledExecutor(
NamedThreadFactory { clazz, poolNumber, threadNumber ->
"Debouncer-$poolNumber-$threadNumber"
}
)
private val delayedMap: ConcurrentHashMap<Any, Future<*>> = ConcurrentHashMap() private val delayedMap: ConcurrentHashMap<Any, Future<*>> = ConcurrentHashMap()
private val delayMillis: Long = unit.toMillis(delay) private val delayMillis: Long = unit.toMillis(delay)
@@ -60,9 +65,7 @@ class Debouncer(private val delay: Long, unit: TimeUnit) {
) )
// 如果之前存在任务,则取消它 // 如果之前存在任务,则取消它
if (prev != null) { prev?.cancel(true)
prev.cancel(true)
}
} }
/** /**
@@ -16,14 +16,14 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile Pipeline.kt * CurrentFile Pipeline.kt
* LastUpdate 2026-02-05 15:22:21 * LastUpdate 2026-02-24 09:10:26
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
package com.mingliqiye.utils.functions package com.mingliqiye.utils.functions
import com.mingliqiye.utils.require.Require import com.mingliqiye.utils.require.Require
import java.util.* import kotlin.reflect.KClass
/** /**
* 流水线操作类,提供链式调用的操作方式来处理数据转换和操作 * 流水线操作类,提供链式调用的操作方式来处理数据转换和操作
@@ -112,6 +112,7 @@ class Pipeline<T>(private val value: T) {
* @throws ClassCastException 当类型转换失败时抛出异常 * @throws ClassCastException 当类型转换失败时抛出异常
*/ */
@Throws(ClassCastException::class) @Throws(ClassCastException::class)
@Suppress("UNCHECKED_CAST")
fun <E> cast(type: Class<E>): Pipeline<E> = Pipeline(value as E) fun <E> cast(type: Class<E>): Pipeline<E> = Pipeline(value as E)
/** /**
@@ -160,7 +161,7 @@ class Pipeline<T>(private val value: T) {
fun require( fun require(
any: Any, message: String, exception: Class<out Exception> = IllegalArgumentException::class.java any: Any, message: String, exception: Class<out Exception> = IllegalArgumentException::class.java
): Pipeline<T> { ): Pipeline<T> {
Require.require(Objects.equals(any, value), message, exception) Require.require(any == value, message, exception)
return this return this
} }
@@ -174,7 +175,7 @@ class Pipeline<T>(private val value: T) {
fun require( fun require(
any: Any, message: String any: Any, message: String
): Pipeline<T> { ): Pipeline<T> {
Require.RequireLayz.require(any == value, message) Require.require(any == value, message)
return this return this
} }
@@ -194,6 +195,38 @@ class Pipeline<T>(private val value: T) {
return this 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异常 * 使用P1RFunction验证当前值是否满足条件,不满足则抛出IllegalArgumentException异常
* @param must 验证条件函数 * @param must 验证条件函数
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()
@@ -16,61 +16,86 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile Response.kt * CurrentFile Response.kt
* LastUpdate 2026-02-07 22:18:42 * 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.annotation.DateTimeJsonFormat
import com.mingliqiye.utils.json.converters.DateTimeJsonConverter
import com.mingliqiye.utils.json.converters.base.AnnotationGetter
import com.mingliqiye.utils.time.DateTime import com.mingliqiye.utils.time.DateTime
/** /**
* HTTP响应数据类 * HTTP响应数据类
* 封装了时间、消息、数据和状态码等响应信息 * 封装了时间、消息、数据和状态码等响应信息
* *
* 该类用于统一API响应的格式,支持链式调用和不可变对象的创建。
* 提供了多种工厂方法用于创建不同类型的响应对象。
*
* @param T 响应数据的类型 * @param T 响应数据的类型
* @property time 响应时间 * @property time 响应时间(格式化的字符串)
* @property message 响应消息 * @property message 响应消息
* @property data 响应数据 * @property data 响应数据,可能为空
* @property statusCode 状态码 * @property statusCode HTTP状态码
*/ */
data class Response<T>( data class Response<T>(
private var time: DateTime, private val time: String, // 响应时间,一旦创建不可修改
private var message: String, private var message: String, // 响应消息,可通过setter修改
private var data: T?, private var data: T?, // 响应数据,可通过setter修改
private var statusCode: Int, private var statusCode: Int, // HTTP状态码,可通过setter修改
) { ) {
private var timeFormat: DateTimeJsonFormat = DateTimeJsonFormat()
companion object { companion object {
/**
* 创建一个默认的成功响应对象
* 使用默认消息"操作成功",无数据,状态码200
*
* @return Response<Nothing> 默认的成功响应对象
*/
fun ok() = ok("操作成功")
/**
* 创建一个默认的错误响应对象
* 使用默认消息"服务器错误",无数据,状态码500
*
* @return Response<Nothing> 默认的成功响应对象
*/
fun error() = error("服务器错误")
/** /**
* 创建一个成功的响应对象(仅包含消息) * 创建一个成功的响应对象(仅包含消息)
* *
* @param message 响应消息 * @param message 响应消息
* @return Response<Any> 成功的响应对象 * @return Response<Any> 成功的响应对象,数据为null
*/ */
@JvmStatic @JvmStatic
fun ok(message: String) = Response( fun ok(message: String) = Response(
time = DateTime.now(), time = DateTime.now().format(),
message = message, message = message,
data = null, data = null,
statusCode = 200 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 T 响应数据的类型
* @param data 响应数据 * @param data 响应数据
* @return Response<T> 成功的响应对象 * @return Response<T> 成功的响应对象,包含数据
*/ */
@JvmStatic @JvmStatic
fun <T> okData(data: T) = Response( fun <T> okData(data: T) = Response(
time = DateTime.now(), time = DateTime.now().format(),
message = "操作成功", message = "操作成功",
data = data, data = data,
statusCode = 200 statusCode = 200
@@ -82,26 +107,26 @@ data class Response<T>(
* @param T 响应数据的类型 * @param T 响应数据的类型
* @param data 响应数据 * @param data 响应数据
* @param message 响应消息 * @param message 响应消息
* @return Response<T> 成功的响应对象 * @return Response<T> 成功的响应对象,包含数据和消息
*/ */
@JvmStatic @JvmStatic
fun <T> okData(data: T, message: String) = Response( fun <T> okData(data: T, message: String) = Response(
time = DateTime.now(), time = DateTime.now().format(),
message = message, message = message,
data = data, data = data,
statusCode = 200 statusCode = 200
) )
/** /**
* 创建一个指定状态码的响应对象(仅包含状态码) * 创建一个指定状态码的响应对象(仅包含状态码)
* 使用默认消息"操作成功",无数据
* *
* @param statusCode 状态码 * @param statusCode HTTP状态码
* @return Response<Any> 指定状态码的响应对象 * @return Response<Any> 指定状态码的响应对象
*/ */
@JvmStatic @JvmStatic
fun code(statusCode: Int) = Response( fun code(statusCode: Int) = Response(
time = DateTime.now(), time = DateTime.now().format(),
message = "操作成功", message = "操作成功",
data = null, data = null,
statusCode = statusCode statusCode = statusCode
@@ -109,14 +134,15 @@ data class Response<T>(
/** /**
* 创建一个指定状态码的响应对象(包含状态码和消息) * 创建一个指定状态码的响应对象(包含状态码和消息)
* 无数据
* *
* @param statusCode 状态码 * @param statusCode HTTP状态码
* @param message 响应消息 * @param message 响应消息
* @return Response<Any> 指定状态码的响应对象 * @return Response<Any> 指定状态码和消息的响应对象
*/ */
@JvmStatic @JvmStatic
fun code(statusCode: Int, message: String) = Response( fun code(statusCode: Int, message: String) = Response(
time = DateTime.now(), time = DateTime.now().format(),
message = message, message = message,
data = null, data = null,
statusCode = statusCode statusCode = statusCode
@@ -125,45 +151,36 @@ data class Response<T>(
/** /**
* 默认构造函数,创建一个默认的成功响应对象 * 默认构造函数,创建一个默认的成功响应对象
* 使用当前时间、默认消息"操作成功"、状态码200、无数据
*/ */
constructor() : this( constructor() : this(
time = DateTime.now(), message = "操作成功", statusCode = 200, data = null time = DateTime.now().format(),
message = "操作成功",
statusCode = 200,
data = null
) )
/** /**
* 获取格式化后的时间字符串。 * 获取格式化后的时间字符串。
* *
* @return 格式化后的时间字符串,使用 [DateTimeJsonConverter] 和 [timeFormat] 注解进行转换。 * @return 格式化后的时间字符串
*/ */
fun getTime(): String = fun getTime(): String = time
DateTimeJsonConverter.getJsonConverter().convert(time, AnnotationGetter.oneGetter(timeFormat))!!
/**
* 设置时间字段的值。
*
* @param dateTime 格式化后的时间字符串,将被反序列化为内部时间对象。
* @return 返回当前对象实例,支持链式调用。
*/
fun setTime(dateTime: String): Response<T> {
// 使用 DateTimeJsonConverter 将输入的字符串反序列化为时间对象,并更新内部 time 字段
time = DateTimeJsonConverter.getJsonConverter().deConvert(dateTime, AnnotationGetter.oneGetter(timeFormat))!!
return this
}
/** /**
* 获取响应消息 * 获取响应消息
* *
* @return String 响应消息 * @return String 当前响应消息
*/ */
fun getMessage(): String = message fun getMessage(): String = message
/** /**
* 设置响应消息 * 设置响应消息
* *
* @param message 响应消息 * 该方法允许修改响应消息,并返回当前对象以支持链式调用。
* @return Response<T> 当前响应对象(用于链式调用) *
* @param message 新的响应消息
* @return Response<T> 当前响应对象(支持链式调用)
*/ */
fun setMessage(message: String): Response<T> { fun setMessage(message: String): Response<T> {
this.message = message this.message = message
@@ -173,6 +190,8 @@ data class Response<T>(
/** /**
* 获取响应数据 * 获取响应数据
* *
* 返回的响应数据可能为null,调用前应进行空值检查。
*
* @return T? 响应数据,可能为空 * @return T? 响应数据,可能为空
*/ */
fun getData(): T? = data fun getData(): T? = data
@@ -180,10 +199,10 @@ data class Response<T>(
/** /**
* 获取非空数据对象 * 获取非空数据对象
* *
* 此方法强制解包data属性,如果data为null则会抛出NullPointerException异常 * 该方法强制解包data属性,如果data为null则会抛出NullPointerException异常。
* 适用于确定data不为null的场景,避免重复的空值检查。
* *
* @param T 泛型类型参数,表示返回的数据类型 * @return T 非空的数据对象
* @return 返回非空的数据对象,类型为T
* @throws NullPointerException 当data属性为null时抛出此异常 * @throws NullPointerException 当data属性为null时抛出此异常
*/ */
@Throws(NullPointerException::class) @Throws(NullPointerException::class)
@@ -191,14 +210,13 @@ data class Response<T>(
return data ?: throw NullPointerException("at Response.notNullData() because data is null") return data ?: throw NullPointerException("at Response.notNullData() because data is null")
} }
/** /**
* 设置响应数据 * 设置响应数据
* *
* @param D 数据类型 * 该方法允许修改响应数据,并返回当前对象以支持链式调用。
* @param data 响应数据
* @return Response<D> 当前响应对象(用于链式调用)
* *
* @param data 新的响应数据
* @return Response<T> 当前响应对象(支持链式调用)
*/ */
fun setData(data: T): Response<T> { fun setData(data: T): Response<T> {
this.data = data this.data = data
@@ -208,18 +226,24 @@ data class Response<T>(
/** /**
* 创建一个新的Response对象,使用指定的时间 * 创建一个新的Response对象,使用指定的时间
* *
* 该方法用于创建具有新时间的响应对象,遵循不可变对象的设计模式。
* 如果时间相同,则返回原对象避免不必要的对象创建。
*
* @param time 新的响应时间 * @param time 新的响应时间
* @return Response<T> 新的响应对象 * @return Response<T> 新的响应对象(如果时间相同则返回原对象)
*/ */
fun withTime(time: DateTime): Response<T> = fun withTime(time: String): Response<T> =
if (this.time == time) this else Response(time, message, data, statusCode) if (this.time == time) this else Response(time, message, data, statusCode)
/** /**
* 创建一个新的Response对象,使用指定的数据 * 创建一个新的Response对象,使用指定的数据
* *
* 该方法允许改变响应数据的类型,创建一个新的响应对象。
* 适用于需要在保持其他字段不变的情况下更新数据类型的场景。
*
* @param D 新的数据类型 * @param D 新的数据类型
* @param data 新的响应数据 * @param data 新的响应数据
* @return Response<D> 新的响应对象 * @return Response<D> 新的响应对象,数据类型为D
*/ */
fun <D> withData(data: D): Response<D> = fun <D> withData(data: D): Response<D> =
Response(this.time, this.message, data, this.statusCode) Response(this.time, this.message, data, this.statusCode)
@@ -227,8 +251,11 @@ data class Response<T>(
/** /**
* 创建一个新的Response对象,使用指定的消息 * 创建一个新的Response对象,使用指定的消息
* *
* 该方法用于创建具有新消息的响应对象,遵循不可变对象的设计模式。
* 如果消息相同,则返回原对象避免不必要的对象创建。
*
* @param message 新的响应消息 * @param message 新的响应消息
* @return Response<T> 新的响应对象 * @return Response<T> 新的响应对象(如果消息相同则返回原对象)
*/ */
fun withMessage(message: String): Response<T> = fun withMessage(message: String): Response<T> =
if (this.message == message) this else Response(time, message, data, statusCode) if (this.message == message) this else Response(time, message, data, statusCode)
@@ -236,8 +263,11 @@ data class Response<T>(
/** /**
* 创建一个新的Response对象,使用指定的状态码 * 创建一个新的Response对象,使用指定的状态码
* *
* 该方法用于创建具有新状态码的响应对象,遵循不可变对象的设计模式。
* 如果状态码相同,则返回原对象避免不必要的对象创建。
*
* @param statusCode 新的状态码 * @param statusCode 新的状态码
* @return Response<T> 新的响应对象 * @return Response<T> 新的响应对象(如果状态码相同则返回原对象)
*/ */
fun withStatusCode(statusCode: Int): Response<T> = fun withStatusCode(statusCode: Int): Response<T> =
if (this.statusCode == statusCode) this else Response(time, message, data, statusCode) if (this.statusCode == statusCode) this else Response(time, message, data, statusCode)
@@ -245,31 +275,31 @@ data class Response<T>(
/** /**
* 获取状态码 * 获取状态码
* *
* @return Int 状态码 * @return Int 当前HTTP状态码
*/ */
fun getStatusCode(): Int = statusCode fun getStatusCode(): Int = statusCode
/** /**
* 设置状态码 * 设置状态码
* *
* @param statusCode 状态码 * 该方法允许修改状态码,并返回当前对象以支持链式调用。
* @return Response<T> 当前响应对象(用于链式调用) *
* @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
} }
fun writeTimeFormat(timeFormat: DateTimeJsonFormat): Response<T> {
this.timeFormat = timeFormat
return this
}
fun readTimeFormat(): DateTimeJsonFormat = timeFormat
/** /**
* 返回响应对象的字符串表示 * 返回响应对象的字符串表示
*
* 重写toString方法以提供更有意义的对象表示,便于日志记录和调试。
* 显示时间、消息、数据类型和值以及状态码。
*
* @return 格式化的字符串表示
*/ */
override fun toString(): String = override fun toString(): String =
"Response(time=${getTime()}, message=${getMessage()}, data:[${data?.javaClass?.simpleName}]=${getData()}, statusCode=${getStatusCode()})" "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,964 +0,0 @@
/*
* 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 I18N.kt
* LastUpdate 2026-02-05 22:39:07
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.i18n
import com.fasterxml.jackson.databind.ObjectMapper
import org.slf4j.Logger
object I18N {
@JvmStatic
private var _Internationalization: Internationalization = Internationalization(
clazz = I18N::class.java,
objectMapper = ObjectMapper(),
isloadSlef = true
)
fun setInternationalization(value: Internationalization) {
this._Internationalization = value
}
fun getInternationalization() = _Internationalization
@JvmStatic
fun getString(string: String, vararg any: Any): String = _Internationalization.getString(string, *any)
@JvmStatic
fun getString(string: String): String = _Internationalization.getString(string)
@JvmStatic
fun getKeyString(key: String): String = _Internationalization.getKeyString(key)
fun Logger.infoTranslater(string: String, vararg any: Any) = this.info(getString(string, *any))
fun Logger.warnTranslater(string: String, vararg any: Any) = this.warn(getString(string, *any))
fun Logger.debugTranslater(string: String, vararg any: Any) = this.debug(getString(string, *any))
fun Logger.traceTranslater(string: String, vararg any: Any) = this.trace(getString(string, *any))
// 0 个参数
fun Logger.errorTranslater(string: String, any1: Any) {
this.error(getString(string))
}
fun Logger.errorTranslater(string: String) {
this.error(getString(string))
}
// 2 个参数
fun Logger.errorTranslater(string: String, any1: Any, any2: Any) {
this.error(getString(string, any1, any2))
}
// 3 个参数
fun Logger.errorTranslater(string: String, any1: Any, any2: Any, any3: Any) {
this.error(getString(string, any1, any2, any3))
}
// 4 个参数
fun Logger.errorTranslater(
string: String,
any1: Any,
any2: Any,
any3: Any,
any4: Any,
) {
this.error(getString(string, any1, any2, any3, any4))
}
// 5 个参数
fun Logger.errorTranslater(
string: String,
any1: Any,
any2: Any,
any3: Any,
any4: Any,
any5: Any,
) {
this.error(getString(string, any1, any2, any3, any4, any5))
}
// 6 个参数
fun Logger.errorTranslater(
string: String,
any1: Any,
any2: Any,
any3: Any,
any4: Any,
any5: Any,
any6: Any,
) {
this.error(getString(string, any1, any2, any3, any4, any5, any6))
}
// 7 个参数
fun Logger.errorTranslater(
string: String,
any1: Any,
any2: Any,
any3: Any,
any4: Any,
any5: Any,
any6: Any,
any7: Any,
) {
this.error(getString(string, any1, any2, any3, any4, any5, any6, any7))
}
// 8 个参数
fun Logger.errorTranslater(
string: String,
any1: Any,
any2: Any,
any3: Any,
any4: Any,
any5: Any,
any6: Any,
any7: Any,
any8: Any,
) {
this.error(getString(string, any1, any2, any3, any4, any5, any6, any7, any8))
}
// 9 个参数
fun Logger.errorTranslater(
string: String,
any1: Any,
any2: Any,
any3: Any,
any4: Any,
any5: Any,
any6: Any,
any7: Any,
any8: Any,
any9: Any,
) {
this.error(getString(string, any1, any2, any3, any4, any5, any6, any7, any8, any9))
}
// 10 个参数
fun Logger.errorTranslater(
string: String,
any1: Any,
any2: Any,
any3: Any,
any4: Any,
any5: Any,
any6: Any,
any7: Any,
any8: Any,
any9: Any,
any10: Any,
) {
this.error(getString(string, any1, any2, any3, any4, any5, any6, any7, any8, any9, any10))
}
// 11 个参数
fun Logger.errorTranslater(
string: String,
any1: Any, any2: Any, any3: Any, any4: Any, any5: Any,
any6: Any, any7: Any, any8: Any, any9: Any, any10: Any, any11: Any,
) {
this.error(getString(string, any1, any2, any3, any4, any5, any6, any7, any8, any9, any10, any11))
}
// 12 个参数
fun Logger.errorTranslater(
string: String,
any1: Any, any2: Any, any3: Any, any4: Any, any5: Any,
any6: Any, any7: Any, any8: Any, any9: Any, any10: Any, any11: Any, any12: Any,
) {
this.error(
getString(string, any1, any2, any3, any4, any5, any6, any7, any8, any9, any10, any11, any12)
)
}
// 13 个参数
fun Logger.errorTranslater(
string: String,
any1: Any, any2: Any, any3: Any, any4: Any, any5: Any,
any6: Any, any7: Any, any8: Any, any9: Any, any10: Any, any11: Any, any12: Any, any13: Any,
) {
this.error(
getString(string, any1, any2, any3, any4, any5, any6, any7, any8, any9, any10, any11, any12, any13),
)
}
// 14 个参数
fun Logger.errorTranslater(
string: String,
any1: Any, any2: Any, any3: Any, any4: Any, any5: Any,
any6: Any, any7: Any, any8: Any, any9: Any, any10: Any, any11: Any, any12: Any, any13: Any, any14: Any,
) {
this.error(
getString(
string, any1, any2, any3, any4, any5, any6, any7, any8, any9, any10, any11, any12, any13, any14
)
)
}
// 15 个参数
fun Logger.errorTranslater(
string: String,
any1: Any,
any2: Any,
any3: Any,
any4: Any,
any5: Any,
any6: Any,
any7: Any,
any8: Any,
any9: Any,
any10: Any,
any11: Any,
any12: Any,
any13: Any,
any14: Any,
any15: Any,
) {
this.error(
getString(
string, any1, any2, any3, any4, any5, any6, any7, any8, any9, any10, any11, any12, any13, any14, any15
)
)
}
// 16 个参数
fun Logger.errorTranslater(
string: String,
any1: Any,
any2: Any,
any3: Any,
any4: Any,
any5: Any,
any6: Any,
any7: Any,
any8: Any,
any9: Any,
any10: Any,
any11: Any,
any12: Any,
any13: Any,
any14: Any,
any15: Any,
any16: Any,
) {
this.error(
getString(
string,
any1,
any2,
any3,
any4,
any5,
any6,
any7,
any8,
any9,
any10,
any11,
any12,
any13,
any14,
any15,
any16
)
)
}
// 17 个参数
fun Logger.errorTranslater(
string: String,
any1: Any,
any2: Any,
any3: Any,
any4: Any,
any5: Any,
any6: Any,
any7: Any,
any8: Any,
any9: Any,
any10: Any,
any11: Any,
any12: Any,
any13: Any,
any14: Any,
any15: Any,
any16: Any,
any17: Any,
) {
this.error(
getString(
string,
any1,
any2,
any3,
any4,
any5,
any6,
any7,
any8,
any9,
any10,
any11,
any12,
any13,
any14,
any15,
any16,
any17
)
)
}
// 18 个参数
fun Logger.errorTranslater(
string: String,
any1: Any,
any2: Any,
any3: Any,
any4: Any,
any5: Any,
any6: Any,
any7: Any,
any8: Any,
any9: Any,
any10: Any,
any11: Any,
any12: Any,
any13: Any,
any14: Any,
any15: Any,
any16: Any,
any17: Any,
any18: Any,
) {
this.error(
getString(
string,
any1,
any2,
any3,
any4,
any5,
any6,
any7,
any8,
any9,
any10,
any11,
any12,
any13,
any14,
any15,
any16,
any17,
any18
)
)
}
// 19 个参数
fun Logger.errorTranslater(
string: String,
any1: Any,
any2: Any,
any3: Any,
any4: Any,
any5: Any,
any6: Any,
any7: Any,
any8: Any,
any9: Any,
any10: Any,
any11: Any,
any12: Any,
any13: Any,
any14: Any,
any15: Any,
any16: Any,
any17: Any,
any18: Any,
any19: Any,
) {
this.error(
getString(
string,
any1,
any2,
any3,
any4,
any5,
any6,
any7,
any8,
any9,
any10,
any11,
any12,
any13,
any14,
any15,
any16,
any17,
any18,
any19
)
)
}
// 20 个参数
fun Logger.errorTranslater(
string: String,
any1: Any,
any2: Any,
any3: Any,
any4: Any,
any5: Any,
any6: Any,
any7: Any,
any8: Any,
any9: Any,
any10: Any,
any11: Any,
any12: Any,
any13: Any,
any14: Any,
any15: Any,
any16: Any,
any17: Any,
any18: Any,
any19: Any,
any20: Any,
) {
this.error(
getString(
string,
any1,
any2,
any3,
any4,
any5,
any6,
any7,
any8,
any9,
any10,
any11,
any12,
any13,
any14,
any15,
any16,
any17,
any18,
any19,
any20
)
)
}
fun Logger.errorTranslater(string: String, throwable: Throwable) {
this.error(getString(string), throwable)
}
// 1 个参数
fun Logger.errorTranslater(string: String, any1: Any, throwable: Throwable) {
this.error(getString(string, any1), throwable)
}
// 2 个参数
fun Logger.errorTranslater(string: String, any1: Any, any2: Any, throwable: Throwable) {
this.error(getString(string, any1, any2), throwable)
}
// 3 个参数
fun Logger.errorTranslater(string: String, any1: Any, any2: Any, any3: Any, throwable: Throwable) {
this.error(getString(string, any1, any2, any3), throwable)
}
// 4 个参数
fun Logger.errorTranslater(
string: String, any1: Any, any2: Any, any3: Any, any4: Any, throwable: Throwable
) {
this.error(getString(string, any1, any2, any3, any4), throwable)
}
// 5 个参数
fun Logger.errorTranslater(
string: String, any1: Any, any2: Any, any3: Any, any4: Any, any5: Any, throwable: Throwable
) {
this.error(getString(string, any1, any2, any3, any4, any5), throwable)
}
// 6 个参数
fun Logger.errorTranslater(
string: String, any1: Any, any2: Any, any3: Any, any4: Any, any5: Any, any6: Any, throwable: Throwable
) {
this.error(getString(string, any1, any2, any3, any4, any5, any6), throwable)
}
// 7 个参数
fun Logger.errorTranslater(
string: String,
any1: Any,
any2: Any,
any3: Any,
any4: Any,
any5: Any,
any6: Any,
any7: Any,
throwable: Throwable
) {
this.error(getString(string, any1, any2, any3, any4, any5, any6, any7), throwable)
}
// 8 个参数
fun Logger.errorTranslater(
string: String,
any1: Any,
any2: Any,
any3: Any,
any4: Any,
any5: Any,
any6: Any,
any7: Any,
any8: Any,
throwable: Throwable
) {
this.error(getString(string, any1, any2, any3, any4, any5, any6, any7, any8), throwable)
}
// 9 个参数
fun Logger.errorTranslater(
string: String,
any1: Any,
any2: Any,
any3: Any,
any4: Any,
any5: Any,
any6: Any,
any7: Any,
any8: Any,
any9: Any,
throwable: Throwable
) {
this.error(getString(string, any1, any2, any3, any4, any5, any6, any7, any8, any9), throwable)
}
// 10 个参数
fun Logger.errorTranslater(
string: String,
any1: Any,
any2: Any,
any3: Any,
any4: Any,
any5: Any,
any6: Any,
any7: Any,
any8: Any,
any9: Any,
any10: Any,
throwable: Throwable
) {
this.error(getString(string, any1, any2, any3, any4, any5, any6, any7, any8, any9, any10), throwable)
}
// 11 个参数
fun Logger.errorTranslater(
string: String,
any1: Any,
any2: Any,
any3: Any,
any4: Any,
any5: Any,
any6: Any,
any7: Any,
any8: Any,
any9: Any,
any10: Any,
any11: Any,
throwable: Throwable
) {
this.error(getString(string, any1, any2, any3, any4, any5, any6, any7, any8, any9, any10, any11), throwable)
}
// 12 个参数
fun Logger.errorTranslater(
string: String,
any1: Any,
any2: Any,
any3: Any,
any4: Any,
any5: Any,
any6: Any,
any7: Any,
any8: Any,
any9: Any,
any10: Any,
any11: Any,
any12: Any,
throwable: Throwable
) {
this.error(
getString(string, any1, any2, any3, any4, any5, any6, any7, any8, any9, any10, any11, any12), throwable
)
}
// 13 个参数
fun Logger.errorTranslater(
string: String,
any1: Any,
any2: Any,
any3: Any,
any4: Any,
any5: Any,
any6: Any,
any7: Any,
any8: Any,
any9: Any,
any10: Any,
any11: Any,
any12: Any,
any13: Any,
throwable: Throwable
) {
this.error(
getString(string, any1, any2, any3, any4, any5, any6, any7, any8, any9, any10, any11, any12, any13),
throwable
)
}
// 14 个参数
fun Logger.errorTranslater(
string: String,
any1: Any,
any2: Any,
any3: Any,
any4: Any,
any5: Any,
any6: Any,
any7: Any,
any8: Any,
any9: Any,
any10: Any,
any11: Any,
any12: Any,
any13: Any,
any14: Any,
throwable: Throwable
) {
this.error(
getString(
string, any1, any2, any3, any4, any5, any6, any7, any8, any9, any10, any11, any12, any13, any14
), throwable
)
}
// 15 个参数
fun Logger.errorTranslater(
string: String,
any1: Any,
any2: Any,
any3: Any,
any4: Any,
any5: Any,
any6: Any,
any7: Any,
any8: Any,
any9: Any,
any10: Any,
any11: Any,
any12: Any,
any13: Any,
any14: Any,
any15: Any,
throwable: Throwable
) {
this.error(
getString(
string, any1, any2, any3, any4, any5, any6, any7, any8, any9, any10, any11, any12, any13, any14, any15
), throwable
)
}
// 16 个参数
fun Logger.errorTranslater(
string: String,
any1: Any,
any2: Any,
any3: Any,
any4: Any,
any5: Any,
any6: Any,
any7: Any,
any8: Any,
any9: Any,
any10: Any,
any11: Any,
any12: Any,
any13: Any,
any14: Any,
any15: Any,
any16: Any,
throwable: Throwable
) {
this.error(
getString(
string,
any1,
any2,
any3,
any4,
any5,
any6,
any7,
any8,
any9,
any10,
any11,
any12,
any13,
any14,
any15,
any16
), throwable
)
}
// 17 个参数
fun Logger.errorTranslater(
string: String,
any1: Any,
any2: Any,
any3: Any,
any4: Any,
any5: Any,
any6: Any,
any7: Any,
any8: Any,
any9: Any,
any10: Any,
any11: Any,
any12: Any,
any13: Any,
any14: Any,
any15: Any,
any16: Any,
any17: Any,
throwable: Throwable
) {
this.error(
getString(
string,
any1,
any2,
any3,
any4,
any5,
any6,
any7,
any8,
any9,
any10,
any11,
any12,
any13,
any14,
any15,
any16,
any17
), throwable
)
}
// 18 个参数
fun Logger.errorTranslater(
string: String,
any1: Any,
any2: Any,
any3: Any,
any4: Any,
any5: Any,
any6: Any,
any7: Any,
any8: Any,
any9: Any,
any10: Any,
any11: Any,
any12: Any,
any13: Any,
any14: Any,
any15: Any,
any16: Any,
any17: Any,
any18: Any,
throwable: Throwable
) {
this.error(
getString(
string,
any1,
any2,
any3,
any4,
any5,
any6,
any7,
any8,
any9,
any10,
any11,
any12,
any13,
any14,
any15,
any16,
any17,
any18
), throwable
)
}
// 19 个参数
fun Logger.errorTranslater(
string: String,
any1: Any,
any2: Any,
any3: Any,
any4: Any,
any5: Any,
any6: Any,
any7: Any,
any8: Any,
any9: Any,
any10: Any,
any11: Any,
any12: Any,
any13: Any,
any14: Any,
any15: Any,
any16: Any,
any17: Any,
any18: Any,
any19: Any,
throwable: Throwable
) {
this.error(
getString(
string,
any1,
any2,
any3,
any4,
any5,
any6,
any7,
any8,
any9,
any10,
any11,
any12,
any13,
any14,
any15,
any16,
any17,
any18,
any19
), throwable
)
}
// 20 个参数
fun Logger.errorTranslater(
string: String,
any1: Any,
any2: Any,
any3: Any,
any4: Any,
any5: Any,
any6: Any,
any7: Any,
any8: Any,
any9: Any,
any10: Any,
any11: Any,
any12: Any,
any13: Any,
any14: Any,
any15: Any,
any16: Any,
any17: Any,
any18: Any,
any19: Any,
any20: Any,
throwable: Throwable
) {
this.error(
getString(
string,
any1,
any2,
any3,
any4,
any5,
any6,
any7,
any8,
any9,
any10,
any11,
any12,
any13,
any14,
any15,
any16,
any17,
any18,
any19,
any20
), throwable
)
}
}
@@ -1,144 +0,0 @@
/*
* 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 Internationalization.kt
* LastUpdate 2026-02-06 08:47:26
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.i18n
import com.fasterxml.jackson.databind.JsonNode
import com.fasterxml.jackson.databind.ObjectMapper
import com.mingliqiye.utils.logger.MingLiLoggerFactory
import org.slf4j.Logger
import java.net.URL
import java.util.*
class Internationalization {
var clazz: Class<*>
var objectMapper: ObjectMapper
var locale: Locale
var backLocale: Locale
val langPath: String
val thisName: String
val thisBackName: String
private var log: Logger = MingLiLoggerFactory.getLogger<Internationalization>()
constructor(
clazz: Class<*>,
objectMapper: ObjectMapper,
locale: Locale = Locale.getDefault(),
backLocale: Locale = Locale.US,
langPath: String = "/lang",
isloadSlef: Boolean = false
) {
this.clazz = clazz
this.objectMapper = objectMapper
this.locale = locale
this.backLocale = backLocale
this.langPath = langPath
thisName = getLanguageName(locale)
thisBackName = getLanguageName(backLocale)
readJson("/assets/mingli-utils/lang/${thisName}.json", Internationalization::class.java, thisName)
if (!isloadSlef) {
if (!readJson(fileName = "$langPath/${thisName}.json", lang = thisName)) {
log.warn(getString("com.mingliqiye.utils.i18n.readjson.error", "$langPath/${thisName}.json"))
}
}
if (thisName != thisBackName) {
readJson("/assets/mingli-utils/lang/${thisBackName}.json", Internationalization::class.java, thisBackName)
if (!isloadSlef) {
if (!readJson(fileName = "$langPath/${thisBackName}.json", lang = thisBackName)) {
log.warn(getString("com.mingliqiye.utils.i18n.readjson.error", "$langPath/${thisBackName}.json"))
}
}
}
}
fun getString(string: String, vararg any: Any): String {
return getString(string).format(*any)
}
fun getString(string: String): String {
return getKeyString(string)
}
fun getKeyString(key: String): String {
val s = localesData[thisName]?.get(key) ?: localesData[thisBackName]?.get(key)
if (s == null) {
return key
}
return s
}
fun getLanguageName(locale: Locale): String =
if (locale.country == null || locale.language == null) locale.country + locale.language else locale.language + '_' + locale.country
constructor(
clazz: Class<*>,
objectMapper: ObjectMapper,
) : this(
locale = Locale.getDefault(), clazz = clazz, objectMapper = objectMapper
)
constructor(
clazz: Class<*>, objectMapper: ObjectMapper, langPath: String = "/lang"
) : this(
locale = Locale.getDefault(), clazz = clazz, langPath = langPath, objectMapper = objectMapper
)
val localesData: MutableMap<String, MutableMap<String, String>> = mutableMapOf()
fun getlangFile(
clazzd: Class<*>, fileName: String
): URL? {
return clazzd.getResource(fileName)
}
fun readJson(
fileName: String, clazzd: Class<*> = clazz, lang: String
): Boolean {
val byteArray: ByteArray? = getlangFile(clazzd, fileName)?.openStream()?.use { it.readBytes() }
if (byteArray == null) return false
val node: JsonNode = objectMapper.readTree(byteArray)
if (node.isArray) return false
if (node.isEmpty) return false
var m = localesData[lang]
if (m == null) {
m = mutableMapOf()
localesData[lang] = m
}
readJsonNode(node, "", m)
return true
}
fun readJsonNode(node: JsonNode, path: String, map: MutableMap<String, String>) {
val fields = node.properties().iterator()
while (fields.hasNext()) {
val (k, v) = fields.next()
val pathName = if (path.isEmpty()) path + k else "$path.$k"
if (v.isTextual) {
map[pathName] = v.asText()
} else if (v.isObject) {
readJsonNode(v, pathName, map)
}
}
}
}
@@ -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()
@@ -15,8 +15,8 @@
* *
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile IO.kt * CurrentFile SIO.kt
* LastUpdate 2026-02-06 13:21:33 * LastUpdate 2026-06-21 10:40:58
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@@ -29,46 +29,142 @@ import org.slf4j.Logger
import java.io.OutputStream import java.io.OutputStream
import java.io.PrintStream 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工具类,提供打印功能和系统输出流重定向到日志的功能 * IO工具类,提供打印功能和系统输出流重定向到日志的功能
*/ */
object IO { object SIO {
/**
* 扩展函数:将字节数组以十六进制格式打印,每两个字符用空格分隔
* @return 原始字节数组
*/
@JvmStatic @JvmStatic
fun ByteArray.println(): ByteArray { fun ByteArray.println(): ByteArray {
this.toHexString().chunked(2).println() this.toHexString().chunked(2).println()
return this 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 @JvmStatic
fun <T> List<T>.println(): List<T> { fun <T> List<T>.println(): List<T> {
println("{" + ",".join(this) + "}") println("{" + ",".join(this) + "}")
return this return this
} }
/**
* 扩展函数:将数组以花括号格式打印,元素间用逗号分隔
* @return 原始数组
*/
@JvmStatic @JvmStatic
fun <T> Array<T>.println(): Array<T> { fun <T> Array<T>.println(): Array<T> {
println("{" + ",".join(this) + "}") println("{" + ",".join(this) + "}")
return this return this
} }
/**
* 扩展函数:打印任意对象并返回该对象
* @return 原始对象
*/
@JvmStatic @JvmStatic
fun <T> T.println(): T { fun <T> T.println(): T {
println(this) println(this)
return this return this
} }
/**
* 原始标准输出流的备份
*/
@JvmStatic @JvmStatic
var originalOut: PrintStream = System.out val originalOut: PrintStream = System.out
/**
* 原始错误输出流的备份
*/
@JvmStatic @JvmStatic
var originalErr: PrintStream = System.err val originalErr: PrintStream = System.err
/**
* 用于记录标准输出的日志记录器
*/
@JvmStatic @JvmStatic
val outLog: Logger = MingLiLoggerFactory.getLogger("out") val outLog: Logger = MingLiLoggerFactory.getLogger("out")
/**
* 用于记录错误输出的日志记录器
*/
@JvmStatic @JvmStatic
val errLog: Logger = MingLiLoggerFactory.getLogger("err") val errLog: Logger = MingLiLoggerFactory.getLogger("err")
@@ -119,10 +215,11 @@ object IO {
kotlin.io.print(sb) kotlin.io.print(sb)
} }
@JvmStatic
/** /**
* 重定向 System.out 到 INFO 级别日志 * 重定向 System.out 到 INFO 级别日志
* 创建自定义PrintStream,将输出内容缓冲并记录到INFO级别日志中
*/ */
@JvmStatic
fun redirectOutToInfo() { fun redirectOutToInfo() {
val outLogger = PrintStream(object : OutputStream() { val outLogger = PrintStream(object : OutputStream() {
private val buffer = StringBuilder() private val buffer = StringBuilder()
@@ -169,10 +266,11 @@ object IO {
System.setOut(outLogger) System.setOut(outLogger)
} }
@JvmStatic
/** /**
* 重定向 System.err 到 ERROR 级别 * 重定向 System.err 到 ERROR 级别
* 创建自定义PrintStream,将错误输出内容缓冲并记录到ERROR级别日志中
*/ */
@JvmStatic
fun redirectErrToError() { fun redirectErrToError() {
val errLogger = PrintStream(object : OutputStream() { val errLogger = PrintStream(object : OutputStream() {
private val buffer = StringBuilder() private val buffer = StringBuilder()
@@ -219,19 +317,21 @@ object IO {
System.setErr(errLogger) System.setErr(errLogger)
} }
@JvmStatic
/** /**
* 完全重定向(包括第三方库的输出) * 完全重定向(包括第三方库的输出)
* 同时重定向标准输出和错误输出到对应的日志级别
*/ */
@JvmStatic
fun redirectAll() { fun redirectAll() {
redirectOutToInfo() redirectOutToInfo()
redirectErrToError() redirectErrToError()
} }
@JvmStatic
/** /**
* 恢复原始输出流 * 恢复原始输出流
* 将System.out和System.err恢复到原始状态
*/ */
@JvmStatic
fun restore() { fun restore() {
System.setOut(originalOut) System.setOut(originalOut)
System.setErr(originalErr) 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() {
/** /**
* 获取结构体字段顺序列表 * 获取结构体字段顺序列表
* 通过反射遍历当前类及其父类的所有声明字段,过滤出公共非静态字段, * 通过反射遍历当前类及其父类的所有声明字段,过滤出公共非静态字段,
@@ -16,7 +16,7 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile JSONA.kt * CurrentFile JSONA.kt
* LastUpdate 2026-02-05 10:34:30 * LastUpdate 2026-03-18 09:14:06
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@@ -28,10 +28,14 @@ import com.mingliqiye.utils.json.api.base.JsonApi
import com.mingliqiye.utils.json.api.type.JsonTypeReference import com.mingliqiye.utils.json.api.type.JsonTypeReference
import com.mingliqiye.utils.json.api.type.listType import com.mingliqiye.utils.json.api.type.listType
import com.mingliqiye.utils.json.converters.base.BaseJsonConverter 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.File
import java.io.IOException
import java.io.InputStream import java.io.InputStream
import java.io.OutputStream import java.io.OutputStream
import java.nio.file.Path import java.nio.file.Path
import kotlin.io.path.readBytes
/** /**
* JSON工具类,提供静态方法访问JSON API功能 * JSON工具类,提供静态方法访问JSON API功能
@@ -71,7 +75,7 @@ object JSONA {
* @param T 继承自JsonApi的具体实现类 * @param T 继承自JsonApi的具体实现类
*/ */
inline fun <reified T : JsonApi> setJsonApi() { inline fun <reified T : JsonApi> setJsonApi() {
setJsonApi(T::class.java.newInstance() as JsonApi) setJsonApi(T::class.java.getConstructor().newInstance() as JsonApi)
} }
/** /**
@@ -127,14 +131,6 @@ object JSONA {
@JvmStatic @JvmStatic
fun format(obj: Any): String = getJsonApi().format(obj) fun format(obj: Any): String = getJsonApi().format(obj)
/**
* 将对象格式化为带Unicode转义的JSON字符串
*
* @param obj 待格式化的对象
* @return 格式化后的带Unicode转义的JSON字符串
*/
@JvmStatic
fun formatUnicode(obj: Any): String = getJsonApi().formatPrettyUnicode(obj)
/** /**
* 从文件路径解析JSON为指定类型的对象 * 从文件路径解析JSON为指定类型的对象
@@ -270,7 +266,7 @@ object JSONA {
*/ */
@JvmStatic @JvmStatic
fun <T> parse( fun <T> parse(
json: String, type: JsonTypeReference<T>, defaultValue: T json: String, type: JsonTypeReference<T>, defaultValue: T,
): T = getJsonApi().parse(json, type, defaultValue) ): T = getJsonApi().parse(json, type, defaultValue)
/** /**
@@ -291,24 +287,6 @@ object JSONA {
@JvmStatic @JvmStatic
fun formatPrettyBytes(obj: Any): ByteArray = getJsonApi().formatPrettyBytes(obj) fun formatPrettyBytes(obj: Any): ByteArray = getJsonApi().formatPrettyBytes(obj)
/**
* 将对象格式化为带Unicode转义的美化JSON字符串
*
* @param obj 待格式化的对象
* @return 格式化后的带Unicode转义的美化JSON字符串
*/
@JvmStatic
fun formatPrettyUnicode(obj: Any): String = getJsonApi().formatPrettyUnicode(obj)
/**
* 将对象格式化为带Unicode转义的美化JSON字节数组
*
* @param obj 待格式化的对象
* @return 格式化后的带Unicode转义的美化JSON字节数组
*/
@JvmStatic
fun formatPrettyUnicodeBytes(obj: Any): ByteArray = getJsonApi().formatPrettyUnicodeBytes(obj)
/** /**
* 将对象格式化为美化格式的JSON字符串并写入文件 * 将对象格式化为美化格式的JSON字符串并写入文件
* *
@@ -345,41 +323,6 @@ object JSONA {
@JvmStatic @JvmStatic
fun formatPretty(obj: Any, stream: OutputStream) = getJsonApi().formatPretty(obj, stream) fun formatPretty(obj: Any, stream: OutputStream) = getJsonApi().formatPretty(obj, stream)
/**
* 将对象格式化为带Unicode转义的美化JSON字符串并写入文件
*
* @param obj 待格式化的对象
* @param file 文件路径
*/
@JvmStatic
fun formatPrettyUnicode(obj: Any, file: String) = getJsonApi().formatPrettyUnicode(obj, file)
/**
* 将对象格式化为带Unicode转义的美化JSON字符串并写入文件
*
* @param obj 待格式化的对象
* @param file Path对象
*/
@JvmStatic
fun formatPrettyUnicode(obj: Any, file: Path) = getJsonApi().formatPrettyUnicode(obj, file)
/**
* 将对象格式化为带Unicode转义的美化JSON字符串并写入文件
*
* @param obj 待格式化的对象
* @param file File对象
*/
@JvmStatic
fun formatPrettyUnicode(obj: Any, file: File) = getJsonApi().formatPrettyUnicode(obj, file)
/**
* 将对象格式化为带Unicode转义的美化JSON字符串并写入输出流
*
* @param obj 待格式化的对象
* @param stream OutputStream对象
*/
@JvmStatic
fun formatPrettyUnicode(obj: Any, stream: OutputStream) = getJsonApi().formatPrettyUnicode(obj, stream)
/** /**
* 将对象格式化为JSON字节数组 * 将对象格式化为JSON字节数组
@@ -390,14 +333,6 @@ object JSONA {
@JvmStatic @JvmStatic
fun formatBytes(obj: Any): ByteArray = getJsonApi().formatBytes(obj) fun formatBytes(obj: Any): ByteArray = getJsonApi().formatBytes(obj)
/**
* 将对象格式化为带Unicode转义的JSON字节数组
*
* @param obj 待格式化的对象
* @return 格式化后的带Unicode转义的JSON字节数组
*/
@JvmStatic
fun formatUnicodeBytes(obj: Any): ByteArray = getJsonApi().formatUnicodeBytes(obj)
/** /**
* 将对象格式化为JSON字符串并写入文件 * 将对象格式化为JSON字符串并写入文件
@@ -435,41 +370,6 @@ object JSONA {
@JvmStatic @JvmStatic
fun format(obj: Any, stream: OutputStream) = getJsonApi().format(obj, stream) fun format(obj: Any, stream: OutputStream) = getJsonApi().format(obj, stream)
/**
* 将对象格式化为带Unicode转义的JSON字符串并写入文件
*
* @param obj 待格式化的对象
* @param file 文件路径
*/
@JvmStatic
fun formatUnicode(obj: Any, file: String) = getJsonApi().formatUnicode(obj, file)
/**
* 将对象格式化为带Unicode转义的JSON字符串并写入文件
*
* @param obj 待格式化的对象
* @param file Path对象
*/
@JvmStatic
fun formatUnicode(obj: Any, file: Path) = getJsonApi().formatUnicode(obj, file)
/**
* 将对象格式化为带Unicode转义的JSON字符串并写入文件
*
* @param obj 待格式化的对象
* @param file File对象
*/
@JvmStatic
fun formatUnicode(obj: Any, file: File) = getJsonApi().formatUnicode(obj, file)
/**
* 将对象格式化为带Unicode转义的JSON字符串并写入输出流
*
* @param obj 待格式化的对象
* @param stream OutputStream对象
*/
@JvmStatic
fun formatUnicode(obj: Any, stream: OutputStream) = getJsonApi().formatUnicode(obj, stream)
/** /**
* 将JSON字符串解析为指定元素类型的List集合 * 将JSON字符串解析为指定元素类型的List集合
@@ -504,7 +404,7 @@ object JSONA {
*/ */
@JvmStatic @JvmStatic
fun <K, V> parseMap( fun <K, V> parseMap(
json: String, keyType: Class<K>, valueType: Class<V> json: String, keyType: Class<K>, valueType: Class<V>,
): MutableMap<K, V> = getJsonApi().parseMap(json, keyType, valueType) ): MutableMap<K, V> = getJsonApi().parseMap(json, keyType, valueType)
/** /**
@@ -517,7 +417,7 @@ object JSONA {
*/ */
@JvmStatic @JvmStatic
inline fun <reified K, reified V> parseMap( inline fun <reified K, reified V> parseMap(
json: String json: String,
): MutableMap<K, V> = getJsonApi().parseMap(json, K::class.java, V::class.java) ): MutableMap<K, V> = getJsonApi().parseMap(json, K::class.java, V::class.java)
/** /**
@@ -532,7 +432,6 @@ object JSONA {
/** /**
* 将对象转换为JSON字节数组 * 将对象转换为JSON字节数组
* *
* @param object 待转换的对象
* @return 转换后的JSON字节数组 * @return 转换后的JSON字节数组
*/ */
@JvmStatic @JvmStatic
@@ -541,7 +440,6 @@ object JSONA {
/** /**
* 将对象转换为美化格式的JSON字节数组 * 将对象转换为美化格式的JSON字节数组
* *
* @param object 待转换的对象
* @return 转换后的美化格式JSON字节数组 * @return 转换后的美化格式JSON字节数组
*/ */
@JvmStatic @JvmStatic
@@ -581,7 +479,6 @@ object JSONA {
/** /**
* 将源对象转换为目标类型的对象 * 将源对象转换为目标类型的对象
* *
* @param T 源对象的类型
* @param D 目标对象的类型 * @param D 目标对象的类型
* @param source 需要转换的源对象 * @param source 需要转换的源对象
* @param destinationClass 目标对象的Class类型 * @param destinationClass 目标对象的Class类型
@@ -593,7 +490,6 @@ object JSONA {
/** /**
* 使用内联函数和reified类型参数将源对象转换为目标类型的对象 * 使用内联函数和reified类型参数将源对象转换为目标类型的对象
* *
* @param T 源对象的类型
* @param D 目标对象的类型(通过reified类型参数推断) * @param D 目标对象的类型(通过reified类型参数推断)
* @param source 需要转换的源对象 * @param source 需要转换的源对象
* @return 转换后的目标类型对象 * @return 转换后的目标类型对象
@@ -604,7 +500,6 @@ object JSONA {
/** /**
* 将源对象转换为目标类型的对象,使用JsonTypeReference指定目标类型 * 将源对象转换为目标类型的对象,使用JsonTypeReference指定目标类型
* *
* @param T 源对象的类型
* @param D 目标对象的类型 * @param D 目标对象的类型
* @param source 需要转换的源对象 * @param source 需要转换的源对象
* @param destinationType 目标对象的JsonTypeReference类型引用 * @param destinationType 目标对象的JsonTypeReference类型引用
@@ -627,8 +522,7 @@ object JSONA {
* *
* @param T 继承自BaseJsonConverter的具体实现类 * @param T 继承自BaseJsonConverter的具体实现类
*/ */
inline fun <reified T : BaseJsonConverter<*, *>> addJsonConverter() = inline fun <reified T : BaseJsonConverter<*, *>> addJsonConverter() = addJsonConverter(getJsonConverter<T>())
addJsonConverter(T::class.java.newInstance())
inline fun <reified T> String.parseJson() = parse<T>(this) inline fun <reified T> String.parseJson() = parse<T>(this)
@@ -639,6 +533,91 @@ object JSONA {
fun Any.toJson() = format(this) fun Any.toJson() = format(this)
@JvmStatic
fun jacksonKotlinObjectMapper(): ObjectMapper = ObjectMapper().jacksonKotlinObjectMapper() fun jacksonKotlinObjectMapper(): ObjectMapper = ObjectMapper().jacksonKotlinObjectMapper()
@JvmStatic
fun ObjectMapper.jacksonKotlinObjectMapper(): ObjectMapper = this.registerModule(kotlinModule()) 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()
}
}
}
}
@@ -16,7 +16,7 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile JacksonJsonApi.kt * CurrentFile JacksonJsonApi.kt
* LastUpdate 2026-02-05 14:41:27 * LastUpdate 2026-10-12 10:48:31
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@@ -27,11 +27,15 @@ 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.exception.JsonException import com.mingliqiye.utils.exception.JsonException
import com.mingliqiye.utils.json.api.JackSonJsonItem.Companion.getJsonItem
import com.mingliqiye.utils.json.api.base.JsonApi import com.mingliqiye.utils.json.api.base.JsonApi
import com.mingliqiye.utils.json.api.type.JsonTypeReference import com.mingliqiye.utils.json.api.type.JsonTypeReference
import com.mingliqiye.utils.json.converters.base.BaseJsonConverter 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字符串解析、格式化、合并、节点操作等功能。
@@ -47,6 +51,8 @@ class JacksonJsonApi : JsonApi {
this.objectMapper = ObjectMapper() this.objectMapper = ObjectMapper()
} }
fun getObjectMapper() = objectMapper
/** /**
* 使用指定的ObjectMapper构造实例 * 使用指定的ObjectMapper构造实例
* *
@@ -96,7 +102,6 @@ class JacksonJsonApi : JsonApi {
/** /**
* 将对象格式化为JSON字符串 * 将对象格式化为JSON字符串
* *
* @param `object` 待格式化的对象
* @return 格式化后的JSON字符串 * @return 格式化后的JSON字符串
* @throws JsonException 当格式化失败时抛出异常 * @throws JsonException 当格式化失败时抛出异常
*/ */
@@ -110,18 +115,17 @@ class JacksonJsonApi : JsonApi {
} }
} }
override fun formatUnicode(obj: Any): String { fun formatUnicode(obj: Any): String {
return try { return try {
objectMapper.writer().with(JsonGenerator.Feature.ESCAPE_NON_ASCII).writeValueAsString(obj) objectMapper.writer().with(JsonGenerator.Feature.ESCAPE_NON_ASCII).writeValueAsString(obj)
} catch (e: Exception) { } catch (e: Exception) {
throw JsonException(e) throw JsonException(throwable = e)
} }
} }
/** /**
* 将对象格式化为美化(带缩进)的JSON字符串 * 将对象格式化为美化(带缩进)的JSON字符串
* *
* @param `object` 待格式化的对象
* @return 美化后的JSON字符串 * @return 美化后的JSON字符串
* @throws JsonException 当格式化失败时抛出异常 * @throws JsonException 当格式化失败时抛出异常
*/ */
@@ -135,7 +139,7 @@ class JacksonJsonApi : JsonApi {
} }
} }
override fun formatPrettyUnicode(obj: Any): String { fun formatPrettyUnicode(obj: Any): String {
return try { return try {
objectMapper.writerWithDefaultPrettyPrinter().with(JsonGenerator.Feature.ESCAPE_NON_ASCII) objectMapper.writerWithDefaultPrettyPrinter().with(JsonGenerator.Feature.ESCAPE_NON_ASCII)
.writeValueAsString(obj) .writeValueAsString(obj)
@@ -157,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
} }
} }
@@ -177,7 +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: Exception) { } catch (_: Exception) {
} }
} }
return try { return try {
@@ -292,4 +296,79 @@ class JacksonJsonApi : JsonApi {
throw JsonException("Failed to update node value", e) 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()
}
}
}
} }
@@ -16,19 +16,24 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile JsonApi.kt * CurrentFile JsonApi.kt
* LastUpdate 2026-02-04 21:00:48 * LastUpdate 2026-03-27 14:19:31
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
package com.mingliqiye.utils.json.api.base 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.JsonTypeReference
import com.mingliqiye.utils.json.api.type.listType import com.mingliqiye.utils.json.api.type.listType
import com.mingliqiye.utils.json.converters.base.BaseJsonConverter 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.io.*
import java.nio.file.Files import java.nio.file.Files
import java.nio.file.Path import java.nio.file.Path
import java.nio.file.Paths import java.nio.file.Paths
import kotlin.io.path.readBytes
/** /**
* JSON处理接口,提供JSON字符串与Java对象之间的相互转换功能 * JSON处理接口,提供JSON字符串与Java对象之间的相互转换功能
@@ -45,6 +50,7 @@ interface JsonApi {
*/ */
inline fun <reified T> JsonApi.parse(json: String): T = parse(json, object : JsonTypeReference<T>() {}) inline fun <reified T> JsonApi.parse(json: String): T = parse(json, object : JsonTypeReference<T>() {})
/** /**
* 将JSON字节数组解析为指定泛型类型对象 * 将JSON字节数组解析为指定泛型类型对象
* *
@@ -111,7 +117,7 @@ interface JsonApi {
* @return 解析后的Map集合 * @return 解析后的Map集合
*/ */
inline fun <reified K, reified V> JsonApi.parseMap( inline fun <reified K, reified V> JsonApi.parseMap(
json: String json: String,
): MutableMap<K, V> = parseMap(json, K::class.java, V::class.java) ): MutableMap<K, V> = parseMap(json, K::class.java, V::class.java)
@@ -133,7 +139,7 @@ interface JsonApi {
*/ */
@JvmStatic @JvmStatic
inline fun <reified T : BaseJsonConverter<*, *>> JsonApi.addJsonConverter() { inline fun <reified T : BaseJsonConverter<*, *>> JsonApi.addJsonConverter() {
addJsonConverter(T::class.java.newInstance()) addJsonConverter(getJsonConverter<T>())
} }
} }
@@ -166,8 +172,6 @@ interface JsonApi {
*/ */
fun format(obj: Any): String fun format(obj: Any): String
fun formatUnicode(obj: Any): String
/** /**
* 从文件路径读取JSON并解析为指定类型对象 * 从文件路径读取JSON并解析为指定类型对象
* *
@@ -249,6 +253,7 @@ interface JsonApi {
return parseFrom(path.toFile(), type) return parseFrom(path.toFile(), type)
} }
/** /**
* 从文件读取JSON并解析为指定泛型类型对象 * 从文件读取JSON并解析为指定泛型类型对象
* *
@@ -333,7 +338,7 @@ interface JsonApi {
* @return 解析后的对象实例或默认值 * @return 解析后的对象实例或默认值
**/ **/
fun <T> parse( fun <T> parse(
json: String, type: JsonTypeReference<T>, defaultValue: T json: String, type: JsonTypeReference<T>, defaultValue: T,
): T { ): T {
return try { return try {
parse<T>(json, type) parse<T>(json, type)
@@ -354,12 +359,6 @@ interface JsonApi {
return formatPretty(obj)!!.toByteArray() return formatPretty(obj)!!.toByteArray()
} }
fun formatPrettyUnicode(obj: Any): String
fun formatPrettyUnicodeBytes(obj: Any): ByteArray {
return formatPrettyUnicode(obj)!!.toByteArray()
}
fun formatPretty(obj: Any, file: String) { fun formatPretty(obj: Any, file: String) {
formatPretty(obj, Paths.get(file)) formatPretty(obj, Paths.get(file))
} }
@@ -378,30 +377,8 @@ interface JsonApi {
stream.write(formatPrettyBytes(obj)) stream.write(formatPrettyBytes(obj))
} }
fun formatPrettyUnicode(obj: Any, file: String) {
formatPrettyUnicode(obj, Paths.get(file))
}
fun formatPrettyUnicode(obj: Any, file: Path) {
formatPrettyUnicode(obj, file.toFile())
}
fun formatPrettyUnicode(obj: Any, file: File) {
FileOutputStream(file).use { fos ->
formatPrettyUnicode(obj, fos)
}
}
fun formatPrettyUnicode(obj: Any, stream: OutputStream) {
stream.write(formatPrettyUnicodeBytes(obj))
}
fun formatBytes(obj: Any): ByteArray { fun formatBytes(obj: Any): ByteArray {
return format(obj)!!.toByteArray() return format(obj).toByteArray()
}
fun formatUnicodeBytes(obj: Any): ByteArray {
return formatUnicode(obj)!!.toByteArray()
} }
fun format(obj: Any, file: String) { fun format(obj: Any, file: String) {
@@ -422,23 +399,6 @@ interface JsonApi {
stream.write(formatPrettyBytes(obj)) stream.write(formatPrettyBytes(obj))
} }
fun formatUnicode(obj: Any, file: String) {
formatUnicode(obj, Paths.get(file))
}
fun formatUnicode(obj: Any, file: Path) {
formatUnicode(obj, file.toFile())
}
fun formatUnicode(obj: Any, file: File) {
FileOutputStream(file).use { fos ->
formatUnicode(obj, fos)
}
}
fun formatUnicode(obj: Any, stream: OutputStream) {
stream.write(formatPrettyUnicodeBytes(obj))
}
/** /**
* 将JSON字符串解析为指定元素类型的List集合 * 将JSON字符串解析为指定元素类型的List集合
@@ -463,7 +423,7 @@ interface JsonApi {
* @return 解析后的Map集合 * @return 解析后的Map集合
</V></K> */ </V></K> */
fun <K, V> parseMap( fun <K, V> parseMap(
json: String, keyType: Class<K>, valueType: Class<V> json: String, keyType: Class<K>, valueType: Class<V>,
): MutableMap<K, V> { ): MutableMap<K, V> {
val mapType: JsonTypeReference<MutableMap<K, V>> = object : JsonTypeReference<MutableMap<K, V>>() {} val mapType: JsonTypeReference<MutableMap<K, V>> = object : JsonTypeReference<MutableMap<K, V>>() {}
return parse<MutableMap<K, V>>(json, mapType) return parse<MutableMap<K, V>>(json, mapType)
@@ -524,9 +484,123 @@ interface JsonApi {
*/ */
fun updateNodeValue(json: String, path: String, newValue: Any): String 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 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 fun <D> convert(source: Any, destinationType: JsonTypeReference<D>): D
/**
* 注册自定义的 JSON 转换器
* 用于处理特定类型的自定义序列化和反序列化逻辑
*
* @param c 自定义的 JSON 转换器实例
*
* 使用示例:
* ```
* converter.addJsonConverter(DateJsonConverter())
* converter.addJsonConverter(LocalDateTimeJsonConverter())
* ```
*/
fun addJsonConverter(c: BaseJsonConverter<*, *>) 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())
}
} }
@@ -16,16 +16,16 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile TypeReference.kt * CurrentFile TypeReference.kt
* LastUpdate 2026-02-04 21:00:48 * LastUpdate 2026-02-26 14:11:35
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
package com.mingliqiye.utils.json.api.type package com.mingliqiye.utils.json.api.type
import com.mingliqiye.utils.string.join import com.mingliqiye.utils.string.join
import sun.reflect.generics.reflectiveObjects.WildcardTypeImpl
import java.lang.reflect.ParameterizedType import java.lang.reflect.ParameterizedType
import java.lang.reflect.Type import java.lang.reflect.Type
import java.lang.reflect.WildcardType
class TypeReference( class TypeReference(
val rawClass: Type, val rawClass: Type,
@@ -40,23 +40,37 @@ class TypeReference(
override fun getOwnerType(): Type? = null override fun getOwnerType(): Type? = null
override fun toString(): String = "${getRawString(rawType)}<${ override fun toString(): String = "${getRawString(rawClass)}<${
",".join(typeArguments, TypeReference::getRawString) ",".join(typeArguments) { getRawString(it) }
}>" }>"
companion object { companion object {
fun getRawString(s: Any): String { fun getRawString(type: Type): String {
if (s is Class<*>) { return when (type) {
return s.name is Class<*> -> type.name
is WildcardType -> {
val upperBounds = type.upperBounds
val lowerBounds = type.lowerBounds
when {
upperBounds.isNotEmpty() && upperBounds[0] != Any::class.java -> {
"? extends ${getRawString(upperBounds[0])}"
} }
if (s is WildcardTypeImpl) {
return getRawString(s.upperBounds[0]) lowerBounds.isNotEmpty() -> {
"? super ${getRawString(lowerBounds[0])}"
} }
if (s is ParameterizedType) {
return of(s).toString() else -> "?"
}
}
is ParameterizedType -> {
of(type).toString()
}
else -> type.typeName
} }
return s.toString()
} }
inline fun <reified T> of(): TypeReference { inline fun <reified T> of(): TypeReference {
@@ -64,13 +78,17 @@ class TypeReference(
} }
fun of(type: Type): TypeReference { fun of(type: Type): TypeReference {
if (type is Class<*>) { return when (type) {
return TypeReference(type) is Class<*> -> TypeReference(type)
is ParameterizedType -> TypeReference(type.rawType, *type.actualTypeArguments)
is WildcardType -> {
// 处理通配符类型,返回上界类型
val upperBound = type.upperBounds.firstOrNull() ?: Any::class.java
TypeReference(upperBound)
}
else -> throw IllegalStateException("无法获取类型: $type")
} }
if (type is ParameterizedType) {
return TypeReference(type.rawType, *type.actualTypeArguments)
}
throw IllegalStateException("无法获取类型: $type")
} }
} }
} }
@@ -16,7 +16,7 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile AnnotationGetter.kt * CurrentFile AnnotationGetter.kt
* LastUpdate 2026-02-06 16:57:45 * LastUpdate 2026-03-11 08:46:40
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@@ -73,6 +73,7 @@ interface AnnotationGetter {
* @param clazz 目标注解类型的Class对象。 * @param clazz 目标注解类型的Class对象。
* @return 如果annotation的类型与clazz一致,则返回annotation转换为T类型的实例;否则返回null。 * @return 如果annotation的类型与clazz一致,则返回annotation转换为T类型的实例;否则返回null。
*/ */
@Suppress("UNCHECKED_CAST")
override fun <T : Annotation> get(clazz: Class<T>): T? = override fun <T : Annotation> get(clazz: Class<T>): T? =
if (annotation.javaClass == clazz) annotation as T else null if (annotation.javaClass == clazz) annotation as T else null
} }
@@ -16,7 +16,7 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile BaseJsonConverter.kt * CurrentFile BaseJsonConverter.kt
* LastUpdate 2026-02-08 01:22:35 * LastUpdate 2026-02-26 15:59:35
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@@ -31,4 +31,4 @@ package com.mingliqiye.utils.json.converters.base
* @param F 源类型,表示需要被转换的数据类型。 * @param F 源类型,表示需要被转换的数据类型。
* @param T 目标类型,表示转换后的数据类型。 * @param T 目标类型,表示转换后的数据类型。
*/ */
interface BaseJsonConverter<F, T> : JackSonJsonConverter<F, T> interface BaseJsonConverter<F, T> : JsonConverter<F, T>
@@ -0,0 +1,62 @@
/*
* 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 JackJson3Deserializer.kt
* LastUpdate 2026-02-26 13:02:52
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.json.converters.base
import tools.jackson.core.JsonParser
import tools.jackson.core.JsonToken
import tools.jackson.databind.BeanProperty
import tools.jackson.databind.DeserializationContext
import tools.jackson.databind.ValueDeserializer
class JackJson3Deserializer<F, T>(
val property: BeanProperty? = null,
val jsonConverter: JsonConverter<F, T>
) : ValueDeserializer<F>() {
override fun deserialize(
p: JsonParser,
ctxt: DeserializationContext?
): F? {
if (p.currentToken() == JsonToken.VALUE_NULL) return null
return jsonConverter.deConvert(p.readValueAs(jsonConverter.getToClass()), object : AnnotationGetter {
override fun <T : Annotation> get(clazz: Class<T>): T? = property?.getAnnotation(clazz)
})
}
/**
* 上下文感知方法:设置当前属性信息。
*
* @param ctxt 反序列化上下文,可选参数。
* @param property 当前属性信息。
* @return 返回当前反序列化器实例。
*/
override fun createContextual(
ctxt: DeserializationContext?,
property: BeanProperty?
): JackJson3Deserializer<F, T> {
return JackJson3Deserializer(property, jsonConverter)
}
}
@@ -0,0 +1,66 @@
/*
* 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 JackJson3Serializer.kt
* LastUpdate 2026-02-26 13:04:18
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.json.converters.base
import tools.jackson.databind.BeanProperty
import tools.jackson.databind.SerializationContext
import tools.jackson.databind.ValueSerializer
import java.math.BigDecimal
import java.math.BigInteger
class JackJson3Serializer<F, T>(
val property: BeanProperty? = null,
val jsonConverter: JsonConverter<F, T>
) : ValueSerializer<F>() {
/**
* 序列化方法:将源对象转换为目标对象,并根据目标对象的类型写入 JSON。
*
* @param value 源对象,可能为 null。
* @param gen JSON 生成器,用于写入 JSON 数据。
* @param provider 序列化提供者,可选参数。
*/
override fun serialize(value: F, gen: tools.jackson.core.JsonGenerator, ctxt: SerializationContext) {
val data: T? = jsonConverter.convert(value, object : AnnotationGetter {
override fun <T : Annotation> get(clazz: Class<T>): T? = property?.getAnnotation(clazz)
})
when (data) {
null -> gen.writeNull()
is String -> gen.writeString(data)
is Long -> gen.writeNumber(data)
is Short -> gen.writeNumber(data)
is Byte -> gen.writeNumber(data.toShort())
is Int -> gen.writeNumber(data)
is BigDecimal -> gen.writeNumber(data)
is BigInteger -> gen.writeNumber(data)
is Float -> gen.writeNumber(data)
is Double -> gen.writeNumber(data)
is Boolean -> gen.writeBoolean(data)
else -> throw IllegalArgumentException("not sport data type ${data.javaClass} $data")
}
}
override fun createContextual(ctxt: SerializationContext?, property: BeanProperty?): ValueSerializer<*> {
return JackJson3Serializer(property, jsonConverter)
}
}
@@ -16,7 +16,7 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile JackJsonSerializer.kt * CurrentFile JackJsonSerializer.kt
* LastUpdate 2026-02-08 02:27:52 * LastUpdate 2026-02-26 12:55:57
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@@ -1,57 +0,0 @@
/*
* 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 JackSonJsonConverter.kt
* LastUpdate 2026-02-08 02:28:49
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.json.converters.base
import com.fasterxml.jackson.databind.ObjectMapper
import com.fasterxml.jackson.databind.module.SimpleModule
interface JackSonJsonConverter<F, T> : JsonConverter<F, T> {
companion object {
/**
* 扩展ObjectMapper,用于注册指定类型的模块。
*
* 此函数通过反射创建指定类型的实例,并调用其getJacksonModule方法来获取Jackson模块,
* 然后将该模块注册到当前ObjectMapper实例中。
*
* @param T 必须继承自BaseJsonConverter的泛型类型。
* @return 返回注册了模块后的ObjectMapper实例。
*/
inline fun <reified T : BaseJsonConverter<*, *>> ObjectMapper.addJsonConverter(): ObjectMapper =
this.registerModule(getJsonConverter<T>().getJacksonModule())
@JvmStatic
fun <T : BaseJsonConverter<*, *>> ObjectMapper.addJsonConverter(clazz: Class<T>): ObjectMapper =
this.registerModule(getJsonConverter(clazz).getJacksonModule())
}
/**
* 创建并返回一个 Jackson 模块,该模块包含自定义的序列化器和反序列化器。
*
* @return 配置了自定义序列化器和反序列化器的 SimpleModule 对象。
*/
fun getJacksonModule(): SimpleModule =
SimpleModule("${getFromClass().name}To${getToClass().name}")
.addSerializer(getFromClass(), JackJsonSerializer(null, this))
.addDeserializer(getFromClass(), JackJsonDeserializer(null, this))
}
@@ -16,7 +16,7 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile JsonConverterUtils.kt * CurrentFile JsonConverterUtils.kt
* LastUpdate 2026-02-07 22:33:09 * LastUpdate 2026-02-26 16:01:49
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@file:JvmName("JsonConverterUtils") @file:JvmName("JsonConverterUtils")
@@ -49,6 +49,7 @@ fun getClass(type: Type?): Class<*>? {
inline fun <reified T : JsonConverter<*, *>> getJsonConverter(): T = getJsonConverter(T::class.java) inline fun <reified T : JsonConverter<*, *>> getJsonConverter(): T = getJsonConverter(T::class.java)
@Suppress("UNCHECKED_CAST")
fun <T : JsonConverter<*, *>> getJsonConverter(clazz: Class<T>): T { fun <T : JsonConverter<*, *>> getJsonConverter(clazz: Class<T>): T {
try { try {
return clazz.getDeclaredMethod( return clazz.getDeclaredMethod(
@@ -59,3 +60,25 @@ fun <T : JsonConverter<*, *>> getJsonConverter(clazz: Class<T>): T {
throw e throw e
} }
} }
fun <T : BaseJsonConverter<*, *>> com.fasterxml.jackson.databind.ObjectMapper.addJsonConverter(clazz: Class<T>): com.fasterxml.jackson.databind.ObjectMapper =
this.registerModule(getJsonConverter(clazz).getJacksonModule())
@JvmName("inline_addJsonConverter")
inline fun <reified T : BaseJsonConverter<*, *>> com.fasterxml.jackson.databind.ObjectMapper.addJsonConverter(): com.fasterxml.jackson.databind.ObjectMapper =
this.registerModule(getJsonConverter(T::class.java).getJacksonModule())
/**
* 创建并返回一个 Jackson 模块,该模块包含自定义的序列化器和反序列化器。
*
* @return 配置了自定义序列化器和反序列化器的 SimpleModule 对象。
*/
fun <F, T> JsonConverter<F, T>.getJacksonModule(): com.fasterxml.jackson.databind.module.SimpleModule =
com.fasterxml.jackson.databind.module.SimpleModule("${getFromClass().name}To${getToClass().name}")
.addSerializer(getFromClass(), JackJsonSerializer(null, this))
.addDeserializer(getFromClass(), JackJsonDeserializer(null, this))
fun <F, T> JsonConverter<F, T>.getJackson3Module(): tools.jackson.databind.module.SimpleModule =
tools.jackson.databind.module.SimpleModule("${getFromClass().name}To${getToClass().name}")
.addSerializer(getFromClass(), JackJson3Serializer(null, this))
.addDeserializer(getFromClass(), JackJson3Deserializer(null, this))
@@ -0,0 +1,279 @@
/*
* 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 JsonObject.kt
* LastUpdate 2026-06-21 10:40:58
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.json.objects.base
import java.math.BigDecimal
import java.math.BigInteger
import java.util.*
/**
* JSON 元素接口,定义所有 JSON 数据类型的通用操作
*/
interface JsonItem {
/**
* 作为 JSON 对象返回
* @throws IllegalStateException 如果不是对象类型
*/
fun asObject(): JsonObject {
throw IllegalStateException("Current JSON element is ${name()} not a Object")
}
/**
* 作为 JSON 数组返回
* @throws IllegalStateException 如果不是数组类型
*/
fun asArray(): JsonArray {
throw IllegalStateException("Current JSON element is ${name()} not a Array")
}
/**
* 作为字符串返回
* @throws IllegalStateException 如果不是字符串类型
*/
fun asString(): String {
throw IllegalStateException("Current JSON element is ${name()} not a String")
}
/**
* 作为布尔值返回
* @throws IllegalStateException 如果不是布尔类型
*/
fun asBoolean(): Boolean {
throw IllegalStateException("Current JSON element is ${name()} not a Boolean")
}
/**
* 作为数字返回
* @throws IllegalStateException 如果不是数字类型
*/
fun asNumber(): JsonNumber {
throw IllegalStateException("Current JSON element is ${name()} not a Number")
}
/**
* 转换为 List 集合
* @throws IllegalStateException 如果不是数组类型
*/
fun toList(): List<JsonItem> {
val it = asArray().iteratorArray()
val list = LinkedList<JsonItem>()
it.forEach { item -> list.add(item.value) }
return list
}
/**
* 转换为 Map 集合
* @throws IllegalStateException 如果不是对象类型
*/
fun toMap(): Map<String, JsonItem> {
val it = asObject().iteratorObject()
val map = LinkedHashMap<String, JsonItem>()
it.forEach { item -> map[item.key] = item.value }
return map
}
/** 是否为 null */
fun isNull(): Boolean = false
/** 是否为布尔值 */
fun isBoolean(): Boolean = false
/** 是否为数字 */
fun isNumber(): Boolean = false
/** 是否为字符串 */
fun isString(): Boolean = false
/** 是否为对象 */
fun isObject(): Boolean = false
/** 是否为数组 */
fun isArray(): Boolean = false
/** 返回当前元素的类型名称 */
fun name(): String = "Any"
/** 根据索引获取元素(数组专用) */
fun get(index: Int): JsonItem = getIndex(index)
/** 根据字段名获取元素(对象专用) */
fun get(fieldName: String): JsonItem = getField(fieldName)
/**
* 根据索引获取元素
* @throws IllegalStateException 如果不是数组类型
*/
fun getIndex(index: Int): JsonItem {
throw IllegalStateException("Current JSON element is ${name()} not a Array")
}
/**
* 根据字段名获取元素
* @throws IllegalStateException 如果不是对象类型
*/
fun getField(name: String): JsonItem {
throw IllegalStateException("Current JSON element is ${name()} not a Object")
}
/**
* 遍历数组元素
* @param consumer 接收索引和元素的消费者函数
*/
fun forEachArray(consumer: (Int, JsonItem) -> Unit) {
iteratorArray().forEach {
consumer(it.index, it.value)
}
}
/**
* 遍历对象字段
* @param consumer 接收字段名和值的消费者函数
*/
fun forEachObject(consumer: (String, JsonItem) -> Unit) {
iteratorObject().forEach {
consumer(it.key, it.value)
}
}
/**
* 获取数组迭代器
* @throws IllegalStateException 如果不是数组类型
*/
fun iteratorArray(): Iterator<IndexedValue<JsonItem>> {
throw IllegalStateException("Current JSON element is ${name()} not a Array")
}
/**
* 获取对象迭代器
* @throws IllegalStateException 如果不是对象类型
*/
fun iteratorObject(): Iterator<Map.Entry<String, JsonItem>> {
throw IllegalStateException("Current JSON element is ${name()} not a Object")
}
}
/**
* JSON 对象抽象类
* 表示键值对形式的 JSON 对象 {}
*/
abstract class JsonObject : JsonItem {
override fun isObject(): Boolean = true
override fun name(): String = "object"
override fun asObject(): JsonObject = this
override fun toString(): String = StringBuilder().apply {
append("{")
iteratorObject().forEach {
append(it.key)
append("=")
append(it.value)
append(",")
}
deleteCharAt(length - 1)
append("}")
}.toString()
}
/**
* JSON 数组抽象类
* 表示有序的 JSON 数组 []
*/
abstract class JsonArray : JsonItem {
override fun isArray(): Boolean = true
override fun name(): String = "array"
override fun asArray() = this
override fun toString(): String = StringBuilder().apply {
append("[")
iteratorArray().forEach {
append(it.value)
append(",")
}
deleteCharAt(length - 1)
append("]")
}.toString()
}
/**
* JSON null 类型
* 表示 JSON 中的 null 值
*/
open class JsonNull : JsonItem {
override fun isNull(): Boolean = true
override fun name(): String = "null"
override fun toString(): String = "null"
}
/**
* JSON 数字类型
* 表示 JSON 中的数字,继承自 Number 以便转换为各种数值类型
* @param numberString 数字的字符串表示形式
*/
open class JsonNumber(val numberString: String) : JsonItem, Number() {
override fun isNumber(): Boolean = true
override fun name(): String = "number"
override fun asNumber(): JsonNumber = this
override fun toDouble(): Double = numberString.toDouble()
override fun toFloat(): Float = numberString.toFloat()
override fun toLong(): Long = numberString.toLong()
override fun toInt(): Int = numberString.toInt()
override fun toShort(): Short = numberString.toShort()
override fun toByte(): Byte = numberString.toByte()
/** 转换为 BigDecimal */
open fun toBigDecimal(): BigDecimal = numberString.toBigDecimal()
/** 转换为指定精度的 BigDecimal */
open fun toBigDecimal(scale: Int): BigDecimal = numberString.toBigDecimal().setScale(scale)
/** 转换为 BigInteger */
open fun toBigInteger(): BigInteger = numberString.toBigInteger()
override fun toString(): String = numberString
}
/**
* JSON 字符串类型
* @param value 字符串值
*/
open class JsonString(val value: String) : JsonItem {
override fun isString(): Boolean = true
override fun name(): String = "string"
override fun asString(): String {
return value
}
override fun toString(): String = value
}
/**
* JSON 布尔类型
* @param value 布尔值
*/
open class JsonBoolean(val value: Boolean) : JsonItem {
override fun isBoolean(): Boolean = true
override fun name(): String = "boolean"
override fun asBoolean(): Boolean {
return value
}
override fun toString(): String = value.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,7 +16,7 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile Maps.kt * CurrentFile Maps.kt
* LastUpdate 2025-09-15 08:33:24 * LastUpdate 2026-03-11 08:46:40
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@@ -40,6 +40,10 @@ fun <K, V> newHashMap(size: Int): HashMap<K, V> {
return HashMap(size) return HashMap(size)
} }
fun <K, V> newHashMap(): HashMap<K, V> {
return HashMap()
}
fun <K, V> newHashMap(vararg elements: Map.Entry<K, V>): HashMap<K, V> { fun <K, V> newHashMap(vararg elements: Map.Entry<K, V>): HashMap<K, V> {
val map = HashMap<K, V>() val map = HashMap<K, V>()
for (element in elements) { for (element in elements) {
@@ -16,7 +16,7 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile MathUtils.kt * CurrentFile MathUtils.kt
* LastUpdate 2026-02-05 10:25:32 * LastUpdate 2026-06-21 10:40:58
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@file:JvmName("MathUtils") @file:JvmName("MathUtils")
@@ -167,7 +167,7 @@ operator fun BigDecimal.div(value: BigDecimal): BigDecimal = this.divide(value)
* @return 除法运算结果 * @return 除法运算结果
*/ */
operator fun BigDecimal.div( operator fun BigDecimal.div(
value: Long value: Long,
): BigDecimal = this.divide(BigDecimal(value)) ): BigDecimal = this.divide(BigDecimal(value))
/** /**
@@ -176,7 +176,7 @@ operator fun BigDecimal.div(
* @return 除法运算结果 * @return 除法运算结果
*/ */
operator fun BigDecimal.div( operator fun BigDecimal.div(
value: Int value: Int,
): BigDecimal = this.divide(BigDecimal(value)) ): BigDecimal = this.divide(BigDecimal(value))
/** /**
@@ -185,7 +185,7 @@ operator fun BigDecimal.div(
* @return 除法运算结果 * @return 除法运算结果
*/ */
operator fun BigDecimal.div( operator fun BigDecimal.div(
value: Double value: Double,
): BigDecimal = this.divide(BigDecimal(value.toString())) ): BigDecimal = this.divide(BigDecimal(value.toString()))
/** /**
@@ -194,7 +194,7 @@ operator fun BigDecimal.div(
* @return 除法运算结果 * @return 除法运算结果
*/ */
operator fun BigDecimal.div( operator fun BigDecimal.div(
value: Float value: Float,
): BigDecimal = this.divide(BigDecimal(value.toString())) ): BigDecimal = this.divide(BigDecimal(value.toString()))
/** /**
@@ -203,7 +203,7 @@ operator fun BigDecimal.div(
* @return 除法运算结果 * @return 除法运算结果
*/ */
operator fun BigDecimal.div( operator fun BigDecimal.div(
value: BigInteger value: BigInteger,
): BigDecimal = this.divide(BigDecimal(value)) ): BigDecimal = this.divide(BigDecimal(value))
/** /**
@@ -372,3 +372,63 @@ fun Number.toBigInteger(): BigInteger = BigInteger(this.toString())
* @return 返回与当前 Number 对象等值且具有指定精度的 BigDecimal 实例。 * @return 返回与当前 Number 对象等值且具有指定精度的 BigDecimal 实例。
*/ */
fun Number.toBigDecimal(scale: Int): BigDecimal = BigDecimal(this.toString()).setScale(scale) fun Number.toBigDecimal(scale: Int): BigDecimal = BigDecimal(this.toString()).setScale(scale)
/**
* Number 与 BigDecimal 的加法运算符重载
*
* 允许任意数字类型(Int、Long、Double等)直接与 BigDecimal 进行加法运算
* 例如:val result = 100 + BigDecimal("10.5")
*
* @param value 要相加的 BigDecimal 值
* @return 相加后的 BigDecimal 结果
*
* 注意:通过 toString() 转换可能会丢失精度(如 Double 的精度问题)
*/
operator fun Number.plus(value: BigDecimal): BigDecimal = BigDecimal(this.toString()).plus(value)
/**
* Number 与 BigDecimal 的减法运算符重载
*
* 允许任意数字类型直接与 BigDecimal 进行减法运算
* 例如:val result = 100 - BigDecimal("10.5")
*
* @param value 要相减的 BigDecimal 值
* @return 相减后的 BigDecimal 结果
*/
operator fun Number.minus(value: BigDecimal): BigDecimal = BigDecimal(this.toString()).minus(value)
/**
* Number 与 BigDecimal 的乘法运算符重载
*
* 允许任意数字类型直接与 BigDecimal 进行乘法运算
* 例如:val result = 100 * BigDecimal("10.5")
*
* @param value 要相乘的 BigDecimal 值
* @return 相乘后的 BigDecimal 结果
*/
operator fun Number.times(value: BigDecimal): BigDecimal = BigDecimal(this.toString()).times(value)
/**
* Number 与 BigDecimal 的除法运算符重载
*
* 允许任意数字类型直接与 BigDecimal 进行除法运算
* 例如:val result = 100 / BigDecimal("10.5")
*
* @param value 要相除的 BigDecimal 值(除数)
* @return 相除后的 BigDecimal 结果
*
* 注意:如果除不尽会抛出 ArithmeticException,建议使用 divide() 方法指定精度
*/
operator fun Number.div(value: BigDecimal): BigDecimal = BigDecimal(this.toString()).div(value)
/**
* Number 与 BigDecimal 的取余运算符重载
*
* 允许任意数字类型直接与 BigDecimal 进行取余运算
* 例如:val result = 100 % BigDecimal("10.5")
*
* @param value 取余运算的 BigDecimal 值
* @return 取余后的 BigDecimal 结果
*/
operator fun Number.rem(value: BigDecimal): BigDecimal = BigDecimal(this.toString()).rem(value)
@@ -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 MetaData.kt * CurrentFile MetaData.kt
* LastUpdate 2025-09-20 10:45:43 * LastUpdate 2026-05-22 13:27:28
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@file:JvmName("MetaData") @file:JvmName("MetaData")
@@ -26,8 +26,10 @@ package com.mingliqiye.utils.metadata
import com.mingliqiye.utils.resource.ResourceUtils import com.mingliqiye.utils.resource.ResourceUtils
import java.util.stream.Collectors.toMap import java.util.stream.Collectors.toMap
class MetaDataResource
fun getMetaData(): Map<String, String> { fun getMetaData(): Map<String, String> {
return ResourceUtils.getStringResource("/META-INF/meta-data").split("\n").stream().map { return ResourceUtils.getResourceAsString<MetaDataResource>("/META-INF/meta-data").split("\n").stream().map {
if (it.isBlank()) { if (it.isBlank()) {
return@map null return@map null
} }
@@ -40,16 +42,6 @@ fun getMetaData(): Map<String, String> {
}.filter { it != null }.collect(toMap({ it!!.first }, { it!!.second })) }.filter { it != null }.collect(toMap({ it!!.first }, { it!!.second }))
} }
class MingliUtilsMetaData {
var buildTime: String = ""
var groupId: String = ""
var artifactId: String = ""
var version: String = ""
var buildJdkVersion: String = ""
var author: String = ""
var website: String = ""
}
val mingliUtilsMetaData: MingliUtilsMetaData by lazy { val mingliUtilsMetaData: MingliUtilsMetaData by lazy {
val metaData = getMetaData() val metaData = getMetaData()
MingliUtilsMetaData().apply { MingliUtilsMetaData().apply {
@@ -0,0 +1,33 @@
/*
* 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 MingliUtilsMetaData.kt
* LastUpdate 2026-10-12 13:32:30
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.metadata
data class MingliUtilsMetaData(
var buildTime: String = "",
var groupId: String = "",
var artifactId: String = "",
var version: String = "",
var buildJdkVersion: String = "",
var author: String = "",
var website: String = "",
)
@@ -16,7 +16,7 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile BaseMapperQuery.kt * CurrentFile BaseMapperQuery.kt
* LastUpdate 2026-02-06 13:15:11 * LastUpdate 2026-10-12 13:33:03
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@@ -36,7 +36,7 @@ import com.baomidou.mybatisplus.extension.kotlin.KtUpdateWrapper
@Deprecated( @Deprecated(
"rename to FastBaseMapper", "rename to FastBaseMapper",
replaceWith = ReplaceWith( replaceWith = ReplaceWith(
expression = "FastBaseMapper<*>", expression = "FastBaseMapper",
imports = ["com.mingliqiye.utils.mybatisplus.FastBaseMapper"] imports = ["com.mingliqiye.utils.mybatisplus.FastBaseMapper"]
), ),
level = DeprecationLevel.WARNING level = DeprecationLevel.WARNING
@@ -0,0 +1,74 @@
/*
* 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 ByteArrayCodec.kt
* LastUpdate 2026-06-27 21:43:25
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.netty
import io.netty.buffer.ByteBuf
import io.netty.channel.ChannelHandlerContext
/**
* ByteBuf 与 ByteArray 互转的编解码器
*
* 入站:将 Netty 的 ByteBuf 解码为 Kotlin 的 ByteArray
* 出站:将 Kotlin 的 ByteArray 编码为 Netty 的 ByteBuf
*
* @see NettyBaseCodec
*/
class ByteArrayCodec : NettyBaseCodec<ByteBuf, ByteArray>() {
/**
* 解码:ByteBuf → ByteArray
*
* 将 Netty 的 ByteBuf 转换为 Kotlin 的 ByteArray
*
* @param inData 输入的 ByteBuf
* @param channelHandlerContext 上下文
* @param outList 输出列表(未使用)
* @return 转换后的 ByteArray
*/
override fun decode(
inData: ByteBuf,
channelHandlerContext: ChannelHandlerContext,
outList: MutableList<Any>,
): ByteArray {
return inData.toByteArray()
}
/**
* 编码:ByteArray → ByteBuf
*
* 将 Kotlin 的 ByteArray 转换为 Netty 的 ByteBuf
*
* @param inData 输入的 ByteArray
* @param channelHandlerContext 上下文
* @param outList 输出列表(未使用)
* @return 转换后的 ByteBuf
*
*/
override fun encode(
inData: ByteArray,
channelHandlerContext: ChannelHandlerContext,
outList: MutableList<Any>,
): ByteBuf {
return inData.toByteBuf()
}
}
@@ -16,7 +16,7 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile ClientScheduleReconnect.kt * CurrentFile ClientScheduleReconnect.kt
* LastUpdate 2026-01-20 08:10:15 * LastUpdate 2026-06-21 10:40:58
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@@ -119,21 +119,20 @@ abstract class ClientScheduleReconnect {
* 停止连接时的日志记录回调 * 停止连接时的日志记录回调
*/ */
abstract fun onStoppedLog() abstract fun onStoppedLog()
abstract fun onConnectClosed() abstract fun onConnectClosed()
/** /**
* 执行连接操作 * 执行连接操作
* @return ChannelFuture 连接结果的异步操作对象 * @return ChannelFuture 连接结果的异步操作对象
*/ */
abstract fun doConnect(): ChannelFuture abstract fun doConnect(bootstrap: Bootstrap): ChannelFuture
/** /**
* 初始化引导配置 * 初始化引导配置
* @param bootstrap 要初始化的引导配置对象 * @param bootstrap 要初始化的引导配置对象
*/ */
open fun initBootstrap(bootstrap: Bootstrap) { abstract fun initBootstrap(bootstrap: Bootstrap)
}
/** /**
* 更新重连延迟配置 * 更新重连延迟配置
@@ -151,7 +150,7 @@ abstract class ClientScheduleReconnect {
* 执行连接操作,设置连接完成监听器 * 执行连接操作,设置连接完成监听器
*/ */
open fun connect() { open fun connect() {
doConnect().addListener(object : ChannelFutureListener { doConnect(bootstrap).addListener(object : ChannelFutureListener {
override fun operationComplete(future: ChannelFuture) { override fun operationComplete(future: ChannelFuture) {
if (future.isSuccess) { if (future.isSuccess) {
onConnected(future.channel()) onConnected(future.channel())
@@ -165,6 +164,7 @@ abstract class ClientScheduleReconnect {
/** /**
* 停止连接并标记为停止状态 * 停止连接并标记为停止状态
*/ */
@Deprecated("use close()", ReplaceWith("close()"))
open fun stop() { open fun stop() {
isStop = true isStop = true
disConnect() disConnect()
@@ -178,6 +178,14 @@ abstract class ClientScheduleReconnect {
channel = null channel = null
} }
/**
* 停止连接并标记为停止状态
*/
open fun close() {
isStop = true
disConnect()
}
/** /**
* 调度下一次重连操作 * 调度下一次重连操作
*/ */
@@ -0,0 +1,52 @@
/*
* 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 NamedMultiThreadIoEventLoopGroup.kt
* LastUpdate 2026-06-20 22:01:50
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.netty
import com.mingliqiye.utils.system.availableProcessors
import io.netty.channel.MultiThreadIoEventLoopGroup
import io.netty.channel.nio.NioIoHandler
import java.nio.channels.spi.SelectorProvider
import java.text.MessageFormat
/**
* 命名的NIO事件循环组,继承自NioEventLoopGroup
* 用于创建具有自定义命名规则的线程池,便于线程管理和调试
*
* @param name 线程池的名称,默认为"NioEventLoopGroup"
* @param template 线程名称的格式模板,默认为"{0}-{2}-{3}",{0} 名字 {1} 类名 {2} 线程池序号 {3} 线程池内线程的序号
* @param nThreads 线程数量,默认为核心数的2倍
* @param selectorProvider NIO 提供者
*/
open class NamedMultiThreadIoEventLoopGroup(
val template: String = "{0}-{2}-{3}",
val name: String = "NamedMultiThreadIoEventLoopGroup",
nThreads: Int = availableProcessors * 2,
selectorProvider: SelectorProvider = SelectorProvider.provider(),
) :
MultiThreadIoEventLoopGroup(
nThreads,
NamedThreadFactory(
getName = { a, b, c -> MessageFormat.format(template, name, a, b, c) }
),
NioIoHandler.newFactory(selectorProvider),
)
@@ -16,7 +16,7 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile NamedNioEventLoopGroup.kt * CurrentFile NamedNioEventLoopGroup.kt
* LastUpdate 2026-02-05 10:20:31 * LastUpdate 2026-06-20 22:01:50
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@@ -37,7 +37,7 @@ import java.text.MessageFormat
open class NamedNioEventLoopGroup( open class NamedNioEventLoopGroup(
val template: String = "{0}-{2}-{3}", val template: String = "{0}-{2}-{3}",
val name: String = "NioEventLoopGroup", val name: String = "NioEventLoopGroup",
nThreads: Int = availableProcessors * 2 nThreads: Int = availableProcessors * 2,
) : ) :
NioEventLoopGroup( NioEventLoopGroup(
nThreads, nThreads,
@@ -0,0 +1,116 @@
/*
* 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 NettyBaseCodec.kt
* LastUpdate 2026-06-27 21:50:22
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.netty
import io.netty.channel.ChannelHandlerContext
import io.netty.handler.codec.MessageToMessageCodec
/**
* 基础编解码器抽象类
*
* 同时处理入站解码(I → O)和出站编码(O → I)
* 继承自 Netty 的 MessageToMessageCodec,用于消息类型之间的转换
*
* @param I 入站消息类型(解码前的类型)
* @param O 出站消息类型(解码后的类型/编码前的类型)
*
* 使用示例:
* ```
* class StringToIntCodec : NettyBaseCodec<String, Int>() {
* override fun decode(inData: String, ctx: ChannelHandlerContext, outList: MutableList<Any>): Int {
* return inData.toInt()
* }
* override fun encode(inData: Int, ctx: ChannelHandlerContext, outList: MutableList<Any>): String {
* return inData.toString()
* }
* }
* ```
*/
abstract class NettyBaseCodec<I : Any, O : Any> : MessageToMessageCodec<I, O>() {
/**
* 解码方法(Netty 框架回调)
*
* 将入站消息 I 转换为 O,并添加到输出列表
*
* @param ctx ChannelHandler 上下文,可用于获取 Channel 等信息
* @param msg 入站消息(类型为 I)
* @param out 输出列表,解码后的消息(类型为 O)将被添加到此列表
*
* @see decode 抽象方法,由子类实现具体的解码逻辑
*/
override fun decode(ctx: ChannelHandlerContext, msg: I, out: MutableList<Any>) {
// 调用子类实现的抽象解码方法,将结果添加到输出列表
out.add(decode(msg, ctx, out))
}
/**
* 编码方法(Netty 框架回调)
*
* 将出站消息 O 转换为 I,并添加到输出列表
*
* @param ctx ChannelHandler 上下文
* @param msg 出站消息(类型为 O)
* @param out 输出列表,编码后的消息(类型为 I)将被添加到此列表
*
* @see encode 抽象方法,由子类实现具体的编码逻辑
*/
override fun encode(ctx: ChannelHandlerContext, msg: O, out: MutableList<Any>) {
// 调用子类实现的抽象编码方法,将结果添加到输出列表
out.add(encode(msg, ctx, out))
}
/**
* 抽象解码方法
*
* 子类必须实现此方法,定义具体的解码逻辑
* 将类型 I 的消息转换为类型 O
*
* @param inData 输入数据(类型 I),需要被解码
* @param channelHandlerContext ChannelHandler 上下文
* @param outList 输出列表,可用于在解码过程中添加多个消息(目前设计为单一返回值,outList 暂未使用)
* @return 解码后的数据(类型 O)
*/
abstract fun decode(
inData: I,
channelHandlerContext: ChannelHandlerContext,
outList: MutableList<Any>,
): O
/**
* 抽象编码方法
*
* 子类必须实现此方法,定义具体的编码逻辑
* 将类型 O 的消息转换为类型 I
*
* @param inData 输入数据(类型 O),需要被编码
* @param channelHandlerContext ChannelHandler 上下文
* @param outList 输出列表,可用于在编码过程中添加多个消息(目前设计为单一返回值,outList 暂未使用)
* @return 编码后的数据(类型 I)
*/
abstract fun encode(
inData: O,
channelHandlerContext: ChannelHandlerContext,
outList: MutableList<Any>,
): I
}
@@ -0,0 +1,114 @@
/*
* 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 NettyBaseDecoder.kt
* LastUpdate 2026-06-27 21:51:10
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.netty
import io.netty.channel.ChannelHandlerContext
import io.netty.handler.codec.MessageToMessageDecoder
/**
* Netty 基础解码器抽象类
*
* 用于将入站消息从类型 I 解码为类型 O
* 继承自 Netty 的 MessageToMessageDecoder,适用于消息类型之间的转换
*
* 适用场景:
* - 将一种业务对象转换为另一种业务对象
* - 将字符串解析为 JSON 对象
* - 将字节数组反序列化为 POJO
*
* @param I 输入消息类型(解码前的类型)
* @param O 输出消息类型(解码后的类型)
*
* 使用示例:
* ```
* class StringToIntDecoder : NettyBaseDecoder<String, Int>() {
* override fun decode(inData: String, ctx: ChannelHandlerContext, outList: MutableList<Any>): Int {
* return inData.toInt()
* }
* }
* ```
*
* @see io.netty.handler.codec.MessageToMessageDecoder
* @see io.netty.handler.codec.ByteToMessageDecoder
*/
abstract class NettyBaseDecoder<I : Any, O : Any> : MessageToMessageDecoder<I>() {
/**
* 解码方法(Netty 框架回调)
*
* 由 Netty 在收到入站消息时自动调用
* 将入站消息 I 转换为 O,并添加到输出列表
*
* @param ctx ChannelHandler 上下文
* - 可用于获取 Channel 信息
* - 可用于触发后续事件
* - 可用于获取 ChannelPipeline 引用
* @param msg 入站消息(类型为 I)
* - 由 Netty 从 Channel 中读取
* - 可能是 ByteBuf、String 或其他类型
* @param out 输出列表(类型为 MutableList<Any>)
* - 解码后的消息(类型为 O)将被添加到此列表
* - 列表中的消息会传递给下一个 InboundHandler
* - 可以添加多个消息,实现一对多的转换
*
* @see #decode 抽象方法,由子类实现具体的解码逻辑
*/
override fun decode(ctx: ChannelHandlerContext, msg: I, out: MutableList<Any>) {
// 调用子类实现的抽象解码方法,将结果添加到输出列表
// 子类通过抽象方法返回解码后的对象,然后添加到 out 中
out.add(decode(msg, ctx, out))
}
/**
* 抽象解码方法
*
* 子类必须实现此方法,定义从 I 到 O 的具体转换逻辑
*
* 实现注意事项:
* 1. 此方法会在 Netty 的 EventLoop 线程中执行,避免阻塞操作
* 2. 如果输入数据不完整,应该抛出异常或返回 null
* 3. 如果 outList 可以接收多个消息,可以多次调用 outList.add()
* 4. 注意管理 ByteBuf 的引用计数(如果 I 是 ByteBuf)
*
* @param inData 输入数据(类型 I),需要被解码
* - 由调用方(Netty 框架)传入
* - 不应为 null(泛型约束为 Any)
* @param channelHandlerContext ChannelHandler 上下文
* - 可用于获取 ChannelHandlerContext 相关信息
* - 可用于在解码过程中触发额外操作
* @param outList 输出列表
* - 可用于在解码过程中添加多个消息
* - 当前设计为单一返回值,outList 暂作为扩展预留
* - 如果需要在解码过程中输出多个消息,可以直接操作此列表并返回 null
* @return 解码后的数据(类型 O)
* - 不能返回 null(泛型约束为 Any)
* - 返回值会被自动添加到 outList 中
*
* @see #decode 包装方法,由框架调用
*/
abstract fun decode(
inData: I,
channelHandlerContext: ChannelHandlerContext,
outList: MutableList<Any>,
): O
}
@@ -0,0 +1,130 @@
/*
* 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 NettyBaseEncoder.kt
* LastUpdate 2026-06-27 21:51:10
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.netty
import io.netty.channel.ChannelHandlerContext
import io.netty.handler.codec.MessageToMessageEncoder
/**
* Netty 基础编码器抽象类
*
* 用于将出站消息从类型 I 编码为类型 O
* 继承自 Netty 的 MessageToMessageEncoder,适用于消息类型之间的转换
*
* 适用场景:
* - 将业务对象序列化为传输格式
* - 将 JSON 对象转换为字符串
* - 将 POJO 序列化为字节数组
*
* ⚠️ 注意:如果需要将对象编码为 ByteBuf,应使用 MessageToByteEncoder
*
* @param I 输入消息类型(编码前的类型)
* @param O 输出消息类型(编码后的类型)
*
* 使用示例:
* ```
* class IntToStringEncoder : NettyBaseEncoder<Int, String>() {
* override fun encode(inData: Int, ctx: ChannelHandlerContext, outList: MutableList<Any>): String {
* return inData.toString()
* }
* }
* ```
*
* @see io.netty.handler.codec.MessageToMessageEncoder
* @see MessageToByteEncoder
*/
abstract class NettyBaseEncoder<I : Any, O : Any> : MessageToMessageEncoder<I>() {
/**
* 编码方法(Netty 框架回调)
*
* 由 Netty 在发送出站消息时自动调用
* 将出站消息 I 编码为 O,并添加到输出列表
*
* 执行流程:
* 1. 用户调用 Channel.write(msg) 发送消息
* 2. Netty 将消息传递给 Pipeline 中的 OutboundHandler
* 3. 此方法被调用,执行编码逻辑
* 4. 编码结果添加到 out 列表
* 5. Netty 将 out 列表中的消息传递给下一个 OutboundHandler
*
* @param ctx ChannelHandler 上下文
* - 可用于获取 Channel 信息
* - 可用于触发后续写操作
* - 可用于获取 ChannelPipeline 引用
* @param msg 出站消息(类型为 I)
* - 由业务层调用 write 方法时传入
* - 可能是任意类型
* @param out 输出列表(类型为 MutableList<Any>)
* - 编码后的消息(类型为 O)将被添加到此列表
* - 列表中的消息会传递给下一个 OutboundHandler
* - 可以添加多个消息,实现一对多的转换
*
* @see #encode 抽象方法,由子类实现具体的编码逻辑
*/
override fun encode(ctx: ChannelHandlerContext, msg: I, out: MutableList<Any>) {
// 调用子类实现的抽象编码方法,将结果添加到输出列表
// 子类通过抽象方法返回编码后的对象,然后添加到 out 中
out.add(encode(msg, ctx, out))
}
/**
* 抽象编码方法
*
* 子类必须实现此方法,定义从 I 到 O 的具体转换逻辑
*
* 实现注意事项:
* 1. 此方法会在 Netty 的 EventLoop 线程中执行,避免阻塞操作
* 2. 编码后的对象应该是线程安全的(可能会被多个线程访问)
* 3. 如果 outList 可以接收多个消息,可以多次调用 outList.add()
* 4. 如果 I 是 ByteBuf,注意引用计数管理
* 5. 编码结果应该是完整的消息,不要依赖后续 handler 补充
*
* 性能建议:
* - 尽量复用对象池中的资源(如 ByteBuf)
* - 避免在编码过程中进行大量数据复制
* - 考虑使用 DirectBuffer 减少内存拷贝
*
* @param inData 输入数据(类型 I),需要被编码
* - 由调用方(业务层)传入
* - 不应为 null(泛型约束为 Any)
* @param channelHandlerContext ChannelHandler 上下文
* - 可用于获取 ChannelHandlerContext 相关信息
* - 可用于在编码过程中触发额外操作
* - 可通过 ctx.alloc() 获取 ByteBufAllocator 分配内存
* @param outList 输出列表
* - 可用于在编码过程中添加多个消息
* - 当前设计为单一返回值,outList 暂作为扩展预留
* - 如果需要在编码过程中输出多个消息,可以直接操作此列表并返回 null
* @return 编码后的数据(类型 O)
* - 不能返回 null(泛型约束为 Any)
* - 返回值会被自动添加到 outList 中
*
* @see #encode 包装方法,由框架调用
*/
abstract fun encode(
inData: I,
channelHandlerContext: ChannelHandlerContext,
outList: MutableList<Any>,
): O
}
@@ -16,7 +16,7 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile NettyUtils.kt * CurrentFile NettyUtils.kt
* LastUpdate 2026-01-31 20:50:41 * LastUpdate 2026-10-20 20:05:37
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@@ -28,9 +28,11 @@ import com.mingliqiye.utils.functions.P1Function
import io.netty.bootstrap.Bootstrap import io.netty.bootstrap.Bootstrap
import io.netty.bootstrap.ServerBootstrap import io.netty.bootstrap.ServerBootstrap
import io.netty.buffer.ByteBuf import io.netty.buffer.ByteBuf
import io.netty.buffer.ByteBufUtil
import io.netty.buffer.Unpooled import io.netty.buffer.Unpooled
import io.netty.channel.Channel import io.netty.channel.Channel
import io.netty.channel.ChannelInitializer import io.netty.channel.ChannelInitializer
import io.netty.channel.ChannelPipeline
import java.nio.ByteBuffer import java.nio.ByteBuffer
import java.nio.charset.Charset import java.nio.charset.Charset
@@ -68,9 +70,7 @@ fun ByteBuf.toByteBuffer(): ByteBuffer {
* @return ByteArray 转换后的字节数组,包含ByteBuf中所有可读的字节数据 * @return ByteArray 转换后的字节数组,包含ByteBuf中所有可读的字节数据
*/ */
fun ByteBuf.toByteArray(): ByteArray { fun ByteBuf.toByteArray(): ByteArray {
val array = ByteArray(this.readableBytes()) return ByteBufUtil.getBytes(this)
this.readBytes(array)
return array
} }
/** /**
@@ -106,6 +106,26 @@ fun ServerBootstrap.channelInitializer(funa: P1Function<Channel>): ServerBootstr
return this return this
} }
/**
* 为ServerBootstrap配置子管道初始化器
*
* 该函数用于设置ServerBootstrap的childHandler,当新的客户端连接建立时,
* 会调用提供的函数来初始化子管道
*
* @receiver ServerBootstrap 需要配置的服务器引导程序实例
* @param funa 用于初始化管道的回调函数,接收ChannelPipeline作为参数
* @return ServerBootstrap 返回当前实例以支持链式调用
*/
@JvmName("pipelineInit")
fun ServerBootstrap.pipelineInitializer(funa: P1Function<ChannelPipeline>): ServerBootstrap {
this.childHandler(object : ChannelInitializer<Channel>() {
override fun initChannel(ch: Channel) {
funa.call(ch.pipeline())
}
})
return this
}
/** /**
* 为Bootstrap配置通道初始化器 * 为Bootstrap配置通道初始化器
* *
@@ -126,6 +146,26 @@ fun Bootstrap.channelInitializer(funa: P1Function<Channel>): Bootstrap {
return this return this
} }
/**
* 为Bootstrap配置管道初始化器
*
* 该函数用于设置Bootstrap的handler,当客户端连接建立时,
* 会调用提供的函数来初始化管道
*
* @receiver Bootstrap 需要配置的客户端引导程序实例
* @param funa 用于初始化管道的回调函数,接收ChannelPipeline作为参数
* @return Bootstrap 返回当前实例以支持链式调用
*/
@JvmName("pipelineInit")
fun Bootstrap.pipelineInitializer(funa: P1Function<ChannelPipeline>): Bootstrap {
this.handler(object : ChannelInitializer<Channel>() {
override fun initChannel(ch: Channel) {
funa.call(ch.pipeline())
}
})
return this
}
/** /**
* 将字符串转换为Netty的ByteBuf对象 * 将字符串转换为Netty的ByteBuf对象
* *
@@ -248,7 +288,7 @@ fun Channel.closeSafely() {
/** /**
* 检查通道是否处于活跃状态 * 检查通道是否处于活跃状态
*/ */
val Channel.isActive: Boolean val Channel.isActived: Boolean
get() = isOpen && isActive get() = isOpen && isActive
/** /**
@@ -283,7 +323,7 @@ fun ByteBuf.releaseSafely(): Boolean {
*/ */
fun ByteBuf.tryRelease(): Boolean { fun ByteBuf.tryRelease(): Boolean {
return try { return try {
if (refCnt() > 0) release() else false refCnt() > 0 && release()
} catch (e: Exception) { } catch (e: Exception) {
false false
} }
@@ -16,7 +16,7 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile NetworkEndpoint.kt * CurrentFile NetworkEndpoint.kt
* LastUpdate 2026-02-05 10:20:31 * LastUpdate 2026-05-23 11:00:33
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@@ -24,6 +24,7 @@ package com.mingliqiye.utils.network
import java.io.Serializable import java.io.Serializable
import java.net.InetSocketAddress import java.net.InetSocketAddress
import java.net.SocketAddress
import java.nio.ByteBuffer import java.nio.ByteBuffer
/** /**
@@ -34,7 +35,7 @@ import java.nio.ByteBuffer
* @see java.net.InetSocketAddress * @see java.net.InetSocketAddress
*/ */
class NetworkEndpoint private constructor( class NetworkEndpoint private constructor(
val networkAddress: NetworkAddress, val networkPort: NetworkPort val networkAddress: NetworkAddress, val networkPort: NetworkPort,
) : Serializable, InetSocketAddress(networkAddress.toInetAddress(), networkPort.port) { ) : Serializable, InetSocketAddress(networkAddress.toInetAddress(), networkPort.port) {
@@ -47,11 +48,14 @@ class NetworkEndpoint private constructor(
* @see InetSocketAddress * @see InetSocketAddress
*/ */
@JvmStatic @JvmStatic
fun of(address: InetSocketAddress): NetworkEndpoint { fun of(address: SocketAddress): NetworkEndpoint {
if (address is InetSocketAddress) {
return NetworkEndpoint( return NetworkEndpoint(
NetworkAddress.of(address.hostString), NetworkPort(address.port) NetworkAddress.of(address.hostString), NetworkPort(address.port)
) )
} }
throw ClassCastException("${address.javaClass} cannot be cast to InetSocketAddress to NetworkEndpoint")
}
/** /**
* 根据主机名或IP字符串和端口号创建NetworkEndpoint实例。 * 根据主机名或IP字符串和端口号创建NetworkEndpoint实例。
@@ -117,6 +121,11 @@ class NetworkEndpoint private constructor(
s.take(lastColonIndex), s.substring(lastColonIndex + 1).toInt() s.take(lastColonIndex), s.substring(lastColonIndex + 1).toInt()
) )
} }
val SocketAddress.networkAddress: NetworkEndpoint
get() = of(this)
val SocketAddress.hostPortString: String
get() = networkAddress.toHostPortString()
} }
/** /**
@@ -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 OsPath.kt * CurrentFile OsPath.kt
* LastUpdate 2025-09-18 09:47:43 * LastUpdate 2026-10-20 20:05:37
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@@ -26,8 +26,7 @@ package com.mingliqiye.utils.path
import java.io.File import java.io.File
import java.net.URI import java.net.URI
import java.nio.file.Path import java.nio.file.*
import java.nio.file.Paths
import java.util.* import java.util.*
import java.util.function.Consumer import java.util.function.Consumer
@@ -40,6 +39,41 @@ class OsPath private constructor(private val path: Path) : Path by path {
return path.spliterator() return path.spliterator()
} }
override fun startsWith(other: String): Boolean {
return path.startsWith(other)
}
override fun endsWith(other: String): Boolean {
return path.endsWith(other)
}
override fun resolve(other: String): Path {
return path.resolve(other)
}
override fun resolveSibling(other: Path): Path {
return path.resolveSibling(other)
}
override fun resolveSibling(other: String): Path {
return path.resolveSibling(other)
}
override fun toFile(): File {
return path.toFile()
}
override fun register(
watcher: WatchService,
vararg events: WatchEvent.Kind<*>,
): WatchKey {
return path.register(watcher, *events)
}
override fun iterator(): MutableIterator<Path> {
return path.iterator()
}
companion object { companion object {
@JvmStatic @JvmStatic
fun of(path: String): OsPath { fun of(path: String): OsPath {
@@ -0,0 +1,207 @@
/*
* 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 ObjectPool.kt
* LastUpdate 2026-10-12 13:57:11
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.pool
import com.mingliqiye.utils.require.Require.require
import java.util.concurrent.TimeUnit
import java.util.concurrent.atomic.AtomicBoolean
import java.util.concurrent.locks.Condition
import java.util.concurrent.locks.ReentrantLock
import kotlin.concurrent.withLock
/**
* 通用对象池抽象实现。
*
* 支持最小空闲数量、最大容量、超时借用与自动回收。
* 子类只需实现 [init] 与 [destroy] 即可完成对象的创建与销毁。
*
* 线程安全:内部通过 [ReentrantLock] + [Condition] 协调借出/归还的等待与唤醒。
*
* @param T 池中管理的对象类型
* @property maxSize 池允许存在的对象总数上限(含已借出),必须大于 0
* @property minSize 池需要保持的最小空闲对象数,[borrow] 归还会在低于该值时补充
* @property initialSize 初始化时预热的对象数量,必须 >= [minSize] 且 <= [maxSize]
*/
abstract class ObjectPool<T>(
private val maxSize: Int = Int.MAX_VALUE,
private val minSize: Int = 0,
private val initialSize: Int = 1,
) : Pool<T> {
/**
* 已创建(含空闲与借出)对象的总数,用于容量控制。
* 所有读写均在 [lock] 内完成,保证与 [borrowedCount]、[pool] 一致。
*/
private var createdCount: Int = 0
/** 当前已借出、尚未归还的对象数量([lock] 保护) */
private var borrowedCount: Int = 0
/**
* 空闲对象队列。全部访问均在 [lock] 内完成,
* 因此 [ArrayDeque.size] 即为精确空闲数。
*/
private val pool = ArrayDeque<ObjectPoolData<T>>()
/** 池是否已关闭 */
private val isClosed = AtomicBoolean(false)
private val lock = ReentrantLock()
private val notEmpty: Condition = lock.newCondition()
private val notFull: Condition = lock.newCondition()
init {
require(maxSize >= minSize)
require(initialSize >= minSize)
require(initialSize <= maxSize)
require(maxSize > 0)
repeat(initialSize) {
pool.addLast(init(createdCount++))
}
}
/**
* 关闭对象池:销毁所有空闲对象,唤醒所有等待者。
* 已借出的对象在归还时会被直接销毁。
*/
override fun close() {
lock.withLock {
if (!isClosed.compareAndSet(false, true)) {
return
}
while (pool.isNotEmpty()) {
val data = pool.removeFirst()
runCatching { destroy(data) }
createdCount--
}
notEmpty.signalAll()
notFull.signalAll()
}
}
/**
* 从池中借出一个对象。
*
* 若池中有空闲对象则直接返回;否则在未达 [maxSize] 时新建;
* 达到上限时根据 [timeoutMillis] 阻塞等待归还,超时抛出 [IllegalStateException]。
*
* @param timeoutMillis 等待超时(毫秒)。<= 0 表示无限等待。
*/
override fun borrow(timeoutMillis: Long): ObjectPoolData<T> {
lock.withLock {
var remainingNanos = if (timeoutMillis > 0) TimeUnit.MILLISECONDS.toNanos(timeoutMillis) else -1L
while (true) {
if (isClosed.get()) {
throw IllegalStateException("Object pool closed")
}
// 1. 优先取空闲对象
if (pool.isNotEmpty()) {
val data = pool.removeFirst()
borrowedCount++
return data
}
// 2. 池未满则创建新对象
if (createdCount < maxSize) {
val id = createdCount++
val data = try {
init(id)
} catch (e: Throwable) {
createdCount--
throw e
}
borrowedCount++
return data
}
// 3. 池已满且无空闲,等待归还
if (remainingNanos < 0) {
notEmpty.await()
} else if (remainingNanos == 0L) {
throw IllegalStateException("Timeout waiting for object from pool")
} else {
remainingNanos = notEmpty.awaitNanos(remainingNanos)
if (remainingNanos <= 0L) {
throw IllegalStateException("Timeout waiting for object from pool")
}
}
}
}
}
/**
* 归还对象到池中。
* 若池已关闭或对象不属于当前池,则直接销毁;否则回填到空闲队列并唤醒等待者。
*/
override fun returnObject(obj: ObjectPoolData<T>) {
lock.withLock {
borrowedCount--
if (isClosed.get() || obj.objectPool !== this) {
runCatching { destroy(obj) }
createdCount--
notFull.signal()
return
}
pool.addLast(obj)
notEmpty.signal()
}
}
/**
* 当前空闲对象数量(精确值)。
* 通过短暂持锁读取,与 [activeSize]/[totalSize] 各自独立但均为调用瞬间的真实值。
*/
fun idleSize(): Int = lock.withLock { pool.size }
/** 当前已借出、尚未归还的对象数量(精确值) */
fun activeSize(): Int = lock.withLock { borrowedCount }
/** 已创建对象总数,含空闲与借出(精确值) */
fun totalSize(): Int = lock.withLock { createdCount }
/** 池是否已关闭 */
fun closed(): Boolean = isClosed.get()
/**
* 一次性读取空闲 / 借出 / 总数 的一致快照(同一把锁内)。
*
* 相比分别调用三个方法,可避免三者之间因并发导致的不自洽
* (例如 `idle + active != total`)。
*/
fun snapshot(): PoolSnapshot = lock.withLock {
PoolSnapshot(idle = pool.size, active = borrowedCount, total = createdCount, closed = isClosed.get())
}
/**
* 池状态快照。
* @property idle 空闲对象数
* @property active 已借出对象数
* @property total 已创建对象总数(= idle + active)
* @property closed 池是否已关闭
*/
data class PoolSnapshot(val idle: Int, val active: Int, val total: Int, val closed: Boolean)
}
@@ -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 ObjectPoolData.kt
* LastUpdate 2026-10-12 13:43:53
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.pool
/**
* 池对象的元数据包装。
*
* @property obj 实际对象
* @property objectPool 归属的对象池
* @property id 池内编号,默认取 [obj] 的 hashCode
* @property name 可选的名称,用于日志/调试
*/
data class ObjectPoolData<T>(
val obj: T,
val objectPool: ObjectPool<T>,
val id: Int = obj.hashCode(),
val name: String = "",
) {
/** 语法糖:归还到所属池 */
fun release() = objectPool.returnObject(this)
}
@@ -0,0 +1,73 @@
/*
* Copyright 2026 mingliqiye
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* ProjectName mingli-utils
* ModuleName mingli-utils.main
* CurrentFile Pool.kt
* LastUpdate 2026-10-12 13:43:53
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.pool
/**
* 对象池通用接口。
*/
interface Pool<T> {
/** 关闭池并释放全部资源 */
fun close()
/** 借出一个对象,[timeoutMillis] <= 0 表示无限等待 */
fun borrow(timeoutMillis: Long): ObjectPoolData<T>
/** 无限等待地借出一个对象 */
fun borrow(): ObjectPoolData<T> = borrow(0)
/** 归还对象 */
fun returnObject(obj: ObjectPoolData<T>)
/** 使用默认超时执行 [funs] */
fun use(funs: (ObjectPoolData<T>) -> Unit) = use(0, funs)
/** 创建一个新的池对象 */
fun init(id: Int): ObjectPoolData<T>
/** 销毁池对象 */
fun destroy(data: ObjectPoolData<T>)
/**
* 借出对象执行 [funs],无论是否抛出异常都会自动归还。
*/
fun use(timeoutMillis: Long, funs: (ObjectPoolData<T>) -> Unit) {
val data = borrow(timeoutMillis)
try {
funs(data)
} finally {
runCatching { returnObject(data) }
}
}
/**
* 借出对象执行 [funs] 并返回其结果,无论是否抛出异常都会自动归还。
*/
fun <R> useResult(timeoutMillis: Long = 0, funs: (ObjectPoolData<T>) -> R): R {
val data = borrow(timeoutMillis)
try {
return funs(data)
} finally {
runCatching { returnObject(data) }
}
}
}
@@ -0,0 +1,308 @@
/*
* 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 Random.kt
* LastUpdate 2026-10-20 20:05:37
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.random
import java.security.SecureRandom
import kotlin.random.Random
import kotlin.random.nextInt
import kotlin.random.nextLong
/**
* Random对象 - 提供各种随机数据生成方法
* 使用SecureRandom确保密码学安全,同时提供便捷的随机数生成接口
*/
object Random {
/**
* 安全随机数生成器 - 使用系统强随机算法
* 通过lazy委托延迟初始化,提高性能
*/
private val secureRandom: SecureRandom by lazy {
SecureRandom.getInstanceStrong()
}
/**
* 标准随机数生成器 - Kotlin标准库提供的随机数生成器
* 通过lazy委托延迟初始化
*/
private val random: Random by lazy {
Random.Default
}
/**
* 生成指定长度的随机字节数组
* @param size 要生成的字节数组长度
* @return 包含随机字节的ByteArray
*/
@JvmStatic
fun nextBytes(size: Int): ByteArray = ByteArray(size).also { secureRandom.nextBytes(it) }
/**
* 生成单个随机字节
* @return 随机字节值(0-255)
*/
@JvmStatic
fun nextByte(): Byte = nextInt(0, 256).toByte()
/**
* 生成无符号随机字节
* @return 无符号随机字节值(0-255)
*/
@JvmStatic
fun nextUByte(): UByte = nextInt(0, 256).toUByte()
/**
* 生成小于指定最大值的随机字节
* @param max 最大值(包含)
* @return 在Byte.MIN_VALUE到max范围内的随机字节
*/
@JvmStatic
fun nextByte(max: Byte): Byte = nextInt(Byte.MIN_VALUE.toInt(), max.toInt()).toByte()
/**
* 生成指定范围内的随机字节
* @param min 最小值(包含)
* @param max 最大值(包含)
* @return 在min到max范围内的随机字节
*/
@JvmStatic
fun nextByte(min: Byte, max: Byte): Byte = nextInt(min.toInt(), max.toInt() + 1).toByte()
/**
* 生成指定范围内的无符号随机字节
* @param min 最小值(包含)
* @param max 最大值(包含)
* @return 在min到max范围内的无符号随机字节
*/
@JvmStatic
fun nextByte(min: UByte, max: UByte): UByte = nextInt(min.toInt(), max.toInt() + 1).toUByte()
/**
* 生成指定IntRange范围内的随机字节
* @param range 指定的整数范围
* @return 在范围内转换为字节的随机值
*/
@JvmStatic
fun nextByte(range: IntRange): Byte = nextByte(range.first.toByte(), range.last.toByte())
/**
* 生成指定UIntRange范围内的无符号随机字节
* @param range 指定的无符号整数范围
* @return 在范围内转换为无符号字节的随机值
*/
@JvmStatic
fun nextByte(range: UIntRange): UByte = nextByte(range.first.toUByte(), range.last.toUByte())
/**
* 生成随机整数
* @return 随机整数值
*/
@JvmStatic
fun nextInt(): Int = secureRandom.nextInt()
/**
* 生成小于指定最大值的随机整数
* @param max 最大值(不包含)
* @return 0到max-1范围内的随机整数
*/
@JvmStatic
fun nextInt(max: Int): Int = secureRandom.nextInt(max)
/**
* 生成指定范围内的随机整数
* @param min 最小值(包含)
* @param max 最大值(包含)
* @return 在min到max范围内的随机整数
*/
@JvmStatic
fun nextInt(min: Int, max: Int): Int = random.nextInt(min..max)
/**
* 生成指定IntRange范围内的随机整数
* @param range 指定的整数范围
* @return 在范围内的随机整数
*/
@JvmStatic
fun nextInt(range: IntRange): Int = random.nextInt(range)
/**
* 生成随机短整数
* @return 在Short范围内的随机短整数
*/
@JvmStatic
fun nextShort(): Short = secureRandom.nextInt(Short.MIN_VALUE.toInt(), Short.MAX_VALUE.toInt()).toShort()
/**
* 生成小于指定最大值的随机短整数
* @param max 最大值(包含)
* @return 在Short.MIN_VALUE到max范围内的随机短整数
*/
@JvmStatic
fun nextShort(max: Short): Short = secureRandom.nextInt(Short.MIN_VALUE.toInt(), max.toInt()).toShort()
/**
* 生成指定范围内的随机短整数
* @param min 最小值(包含)
* @param max 最大值(包含)
* @return 在min到max范围内的随机短整数
*/
@JvmStatic
fun nextShort(min: Short, max: Short): Short = secureRandom.nextInt(min.toInt(), max.toInt()).toShort()
/**
* 生成指定IntRange范围内的随机短整数
* @param range 指定的整数范围
* @return 在范围内转换为短整数的随机值
*/
@JvmStatic
fun nextShort(range: IntRange): Short = secureRandom.nextInt(range.first, range.last).toShort()
/**
* 生成随机长整数
* @return 随机长整数值
*/
@JvmStatic
fun nextLong(): Long = secureRandom.nextLong()
/**
* 生成小于指定最大值的随机长整数
* @param max 最大值(不包含)
* @return 0到max-1范围内的随机长整数
*/
@JvmStatic
fun nextLong(max: Long): Long = secureRandom.nextLong(max)
/**
* 生成指定范围内的随机长整数
* @param min 最小值(包含)
* @param max 最大值(包含)
* @return 在min到max范围内的随机长整数
*/
@JvmStatic
fun nextLong(min: Long, max: Long): Long = random.nextLong(min..max)
/**
* 生成指定LongRange范围内的随机长整数
* @param range 指定的长整数范围
* @return 在范围内的随机长整数
*/
@JvmStatic
fun nextLong(range: LongRange): Long = random.nextLong(range)
/**
* 生成随机布尔值
* @return 随机true或false
*/
@JvmStatic
fun nextBoolean(): Boolean = secureRandom.nextBoolean()
/**
* String类型的扩展函数 - 从字符串中随机选择字符生成指定长度的新字符串
* @param length 要生成的字符串长度
* @return 由原字符串中随机字符组成的新字符串
*/
@JvmStatic
fun String.randomString(length: Int): String = String(CharArray(length) {
this[nextInt(indices)]
})
/**
* 生成包含数字和字母的随机字符串
* @param length 要生成的字符串长度
* @return 包含0-9、a-z、A-Z字符的随机字符串
*/
@JvmStatic
fun randomString(length: Int): String =
"0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ".randomString(length)
/**
* Array类型的扩展函数 - 从数组中随机选择一个元素
* @param T 数组元素类型
* @return 数组中的随机元素
*/
@JvmStatic
fun <T> Array<T>.randomItem(): T = this[nextInt(indices)]
/**
* ByteArray类型的扩展函数 - 从字节数组中随机选择一个元素
* @return 字节数组中的随机字节
*/
@JvmStatic
fun ByteArray.randomItem(): Byte = this[nextInt(indices)]
/**
* IntArray类型的扩展函数 - 从整数数组中随机选择一个元素
* @return 整数数组中的随机整数
*/
@JvmStatic
fun IntArray.randomItem(): Int = this[nextInt(indices)]
/**
* LongArray类型的扩展函数 - 从长整数数组中随机选择一个元素
* @return 长整数数组中的随机长整数
*/
@JvmStatic
fun LongArray.randomItem(): Long = this[nextInt(indices)]
/**
* FloatArray类型的扩展函数 - 从浮点数数组中随机选择一个元素
* @return 浮点数数组中的随机浮点数
*/
@JvmStatic
fun FloatArray.randomItem(): Float = this[nextInt(indices)]
/**
* DoubleArray类型的扩展函数 - 从双精度浮点数数组中随机选择一个元素
* @return 双精度浮点数数组中的随机双精度浮点数
*/
@JvmStatic
fun DoubleArray.randomItem(): Double = this[nextInt(indices)]
/**
* BooleanArray类型的扩展函数 - 从布尔数组中随机选择一个元素
* @return 布尔数组中的随机布尔值
*/
@JvmStatic
fun BooleanArray.randomItem(): Boolean = this[nextInt(indices)]
/**
* CharArray类型的扩展函数 - 从字符数组中随机选择一个元素
* @return 字符数组中的随机字符
*/
@JvmStatic
fun CharArray.randomItem(): Char = this[nextInt(indices)]
/**
* ShortArray类型的扩展函数 - 从短整数数组中随机选择一个元素
* @return 短整数数组中的随机短整数
*/
@JvmStatic
fun ShortArray.randomItem(): Short = this[nextInt(indices)]
/**
* Collection类型的扩展函数 - 从集合中随机选择一个元素
* @param T 集合元素类型
* @return 集合中的随机元素
*/
@JvmStatic
fun <T> Collection<T>.randomItem(): T = this.elementAt(nextInt(indices))
}
@@ -1,88 +0,0 @@
/*
* 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 RandomBytes.kt
* LastUpdate 2026-01-28 10:47:13
* UpdateUser MingLiPro
*/
@file:JvmName("RandomBytes")
package com.mingliqiye.utils.random
/**
* 生成指定长度的随机字节数组
* @param length 数组长度
* @return 包含随机字节的数组
*/
fun randomBytes(length: Int): ByteArray {
val bytes = ByteArray(length)
for (i in 0..<length) {
bytes[i] = randomByte(0x00.toByte(), 0xff.toByte())
}
return bytes
}
/**
* 生成指定长度的随机字节数组
* 从给定的字节数组中随机选择字节来填充新数组
*
* @param length 要生成的随机字节数组的长度
* @param bytes 用于随机选择的源字节数组
* @return 包含随机字节的新数组
*/
fun randomBytes(length: Int, bytes: ByteArray): ByteArray {
val rbytes = ByteArray(length)
// 从源数组中随机选择字节填充到结果数组中
for (i in 0..<length) {
rbytes[i] = bytes[randomInt(i, bytes.size - 1)]
}
return rbytes
}
/**
* 生成指定范围内的随机字节
* @param from 起始字节值(包含)
* @param to 结束字节值(包含)
* @return 指定范围内的随机字节
*/
fun randomByte(from: Byte, to: Byte): Byte {
val fromInt = from.toInt() and 0xFF
val toInt = to.toInt() and 0xFF
val randomValue = randomInt(fromInt, toInt)
return (randomValue and 0xFF).toByte()
}
/**
* 生成指定范围内的随机字节(不包含边界值)
* @param from 起始字节值(不包含)
* @param to 结束字节值(不包含)
* @return 指定范围内的随机字节
*/
fun randomByteNoHave(from: Byte, to: Byte): Byte {
val fromInt = from.toInt() and 0xFF
val toInt = to.toInt() and 0xFF
val randomValue = randomIntNoHave(fromInt, toInt)
return (randomValue and 0xFF).toByte()
}
fun randomByte(size: Int): ByteArray {
val bytes = ByteArray(size)
secureRandom.nextBytes(bytes)
return bytes
}
@@ -1,67 +0,0 @@
/*
* 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 RandomInt.kt
* LastUpdate 2026-01-28 10:46:02
* UpdateUser MingLiPro
*/
@file:JvmName("RandomInt")
package com.mingliqiye.utils.random
import java.security.SecureRandom
val secureRandom: SecureRandom by lazy {
SecureRandom.getInstanceStrong()
}
fun SecureRandom.nextInt(min: Int, max: Int): Int {
return min + nextInt(max - min)
}
/**
* 生成指定范围内的随机整数
* @param min 最小值(包含)
* @param max 最大值(不包含)
* @return 随机整数
*/
fun randomIntNoHave(min: Int, max: Int): Int {
var min = min
var max = max
if (min > max) {
val t = min
min = max
max = t
}
if (min == max) {
return min
}
return secureRandom.nextInt(min, max)
}
/**
* 生成指定范围内的随机整数
* @param min 最小值(包含)
* @param max 最大值(包含)
* @return 随机整数
*/
fun randomInt(min: Int, max: Int): Int {
var max = max
return randomIntNoHave(min, ++max)
}
@@ -1,54 +0,0 @@
/*
* 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 RandomString.kt
* LastUpdate 2026-02-05 11:12:36
* UpdateUser MingLiPro
*/
@file:JvmName("RandomString")
package com.mingliqiye.utils.random
/**
* 生成指定长度和字符集的随机字符串
*
* @param length 要生成的随机字符串长度
* @param chars 用于生成随机字符串的字符集
* @return 指定长度的随机字符串
*/
fun randomString(length: Int, chars: String): String {
val charsd: Array<String?> = chars.split("".toRegex()).dropLastWhile { it.isEmpty() }.toTypedArray()
val sb = StringBuilder(length)
// 循环生成随机字符并拼接
for (i in 0..<length) {
val index = randomInt(0, charsd.size - 1)
sb.append(charsd[index])
}
return sb.toString()
}
/**
* 生成指定长度的随机字符串,使用默认字符集(数字+大小写字母)
*
* @param length 要生成的随机字符串长度
* @return 指定长度的随机字符串
*/
fun randomString(length: Int): String {
return randomString(
length, "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
)
}
@@ -0,0 +1,56 @@
/*
* 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 ReflectUtils.kt
* LastUpdate 2026-10-11 17:11:11
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.reflect
import com.mingliqiye.utils.io.SIO.ifOr
import java.lang.reflect.Method
import kotlin.reflect.KClass
import kotlin.reflect.KFunction
import kotlin.reflect.KMutableProperty
import kotlin.reflect.KProperty
import kotlin.reflect.jvm.javaMethod
object ReflectUtils {
private val walker: StackWalker = StackWalker.getInstance(StackWalker.Option.RETAIN_CLASS_REFERENCE)
inline fun <reified T : Any> T.ktClass(): KClass<T> = T::class
var <T : Any> KMutableProperty<T>.value: T
get() = this.getter.call()
set(t: T) = this.setter.call(t)
val <T : Any> KProperty<T>.javaGetter: Method
get() = this.getter.javaMethod!!
val <T : Any> KMutableProperty<T>.javaSetter: Method
get() = this.getter.javaMethod!!
val <T : Any> KFunction<T>.java: Method
get() = this.javaMethod!!
fun getStackFrame(skip: Long = 0, limit: Long = 0): List<StackWalker.StackFrame> {
return walker.walk {
it.skip(skip + 2).ifOr(limit == 0L) {
limit(limit)
}.toList()
}
}
}
@@ -1,207 +0,0 @@
/*
* Copyright 2026 mingliqiye
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* ProjectName mingli-utils
* ModuleName mingli-utils.main
* CurrentFile Require.kt
* LastUpdate 2026-02-06 08:27:44
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.require
import com.mingliqiye.utils.exception.InternalServerErrorException
import com.mingliqiye.utils.logger.MingLiLoggerFactory
import org.slf4j.Logger
import java.lang.reflect.Constructor
import kotlin.contracts.ExperimentalContracts
import kotlin.contracts.contract
/**
* 工具对象,用于提供条件检查功能。
* 支持抛出自定义异常、延迟消息构造以及日志记录等功能。
*/
class Require(val defaultException: Class<out Throwable>) {
companion object {
@JvmStatic
val RequireLayz by lazy {
Require(IllegalArgumentException::class.java)
}
@JvmStatic
val RequireHttpLayz by lazy {
Require(InternalServerErrorException::class.java)
}
@JvmStatic
var logger: Logger? = MingLiLoggerFactory.getLogger<Require>()
@JvmStatic
var isLogError = true
/**
* 检查给定条件是否为真。如果为假,则使用延迟消息构造器生成异常并抛出。
*
* @param value 需要检查的布尔值。
* @param throwable 异常类型。
* @param layzMessage 延迟消息构造器。
*/
@OptIn(ExperimentalContracts::class)
fun require(value: Boolean, throwable: Class<out Throwable>, layzMessage: RequireLayzMessageConstructor) {
contract {
returns() implies value
}
require(value, layzMessage.call(), throwable)
}
/**
* 检查给定条件是否为真。如果为假,则使用延迟异常构造器生成异常并抛出。
*
* @param value 需要检查的布尔值。
* @param layzThrowable 延迟异常构造器。
*/
@JvmStatic
@OptIn(ExperimentalContracts::class)
fun require(value: Boolean, layzThrowable: RequireLayzExceptionConstructor) {
contract {
returns() implies value
}
if (!value) throwThrowable(layzThrowable.call())
}
/**
* 检查给定条件是否为真。如果为假,则根据指定的异常类型和消息生成异常并抛出。
*
* @param value 需要检查的布尔值。
* @param message 异常消息。
* @param throwable 异常类型。
*/
@JvmStatic
@OptIn(ExperimentalContracts::class)
fun require(value: Boolean, message: String, throwable: Class<out Throwable>) {
contract {
returns() implies value
}
if (!value) throwThrowable(getExceptionConstructor(throwable).newInstance(message))
}
/**
* 抛出指定的异常,并在启用日志记录时记录错误信息。
*
* @param throwable 需要抛出的异常。
*/
@JvmStatic
fun throwThrowable(throwable: Throwable) {
if (isLogError && logger != null) logger!!.error(throwable.message, throwable)
throw throwable
}
/**
* 检查给定条件是否为真。如果为假,则根据指定的异常类型抛出异常。
*
* @param value 需要检查的布尔值。
* @param message 异常消息。
* @param T 异常类型。
*/
@OptIn(ExperimentalContracts::class)
@JvmName("__inline_Require")
inline fun <reified T : Throwable> require(value: Boolean, message: String) {
contract {
returns() implies value
}
require(value, message, T::class.java)
}
/**
* 检查给定条件是否为真。如果为假,则根据指定的异常类型和延迟消息构造器生成异常并抛出。
*
* @param value 需要检查的布尔值。
* @param layzMessage 延迟消息构造器。
* @param T 异常类型。
*/
@OptIn(ExperimentalContracts::class)
@JvmName("__inline_Require")
inline fun <reified T : Throwable> require(value: Boolean, layzMessage: RequireLayzMessageConstructor) {
contract {
returns() implies value
}
if (!value) throwThrowable(getExceptionConstructor<T>().newInstance(layzMessage.call()))
}
/**
* 获取指定异常类型的构造函数(带字符串参数)。
*
* @param T 异常类型。
* @return 异常类型的构造函数。
*/
@JvmName("__inline_GetExceptionConstructor")
inline fun <reified T : Throwable> getExceptionConstructor(): Constructor<out T> =
getExceptionConstructor(T::class.java)
/**
* 获取指定异常类型的构造函数(带字符串参数)。
*
* @param throwable 异常类型。
* @return 异常类型的构造函数。
*/
@JvmStatic
@JvmName("__GetExceptionConstructor")
fun <T : Throwable> getExceptionConstructor(throwable: Class<out T>): Constructor<out T> =
throwable.getConstructor(String::class.java)
}
/**
* 检查给定条件是否为真。如果为假,则抛出 [IllegalArgumentException] 异常。
*
* @param value 需要检查的布尔值。
*/
@OptIn(ExperimentalContracts::class)
fun require(value: Boolean) {
contract {
returns() implies value
}
require(value, "the require conditions are not met.")
}
/**
* 检查给定条件是否为真。如果为假,则使用延迟消息构造器生成 [IllegalArgumentException] 并抛出。
*
* @param value 需要检查的布尔值。
* @param layzMessage 延迟消息构造器。
*/
@OptIn(ExperimentalContracts::class)
fun requireLayzMessage(value: Boolean, layzMessage: RequireLayzMessageConstructor) {
contract {
returns() implies value
}
require(value, defaultException, layzMessage)
}
/**
* 检查给定条件是否为真。如果为假,则抛出 [IllegalArgumentException] 异常。
*
* @param value 需要检查的布尔值。
* @param message 异常消息。
*/
@OptIn(ExperimentalContracts::class)
fun require(value: Boolean, message: String) {
contract {
returns() implies value
}
if (!value) throwThrowable(getExceptionConstructor(defaultException).newInstance(message))
}
}
@@ -0,0 +1,190 @@
/*
* 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 RequireTrue.kt
* LastUpdate 2026-10-20 20:05:24
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.require
import kotlin.contracts.ExperimentalContracts
import kotlin.contracts.contract
const val DEFAULT_MESSAGE = "required fail"
class Required<T : Throwable>(private val newException: (message: String) -> T) {
@OptIn(ExperimentalContracts::class)
fun requireTrue(value: Boolean, message: String) {
contract {
returns() implies value
}
requireTrue(value) { message }
}
@OptIn(ExperimentalContracts::class)
fun requireTrue(value: Boolean) {
contract {
returns() implies value
}
requireTrue(value) { DEFAULT_MESSAGE }
}
@OptIn(ExperimentalContracts::class)
fun requireTrue(value: Boolean, lazyMessage: () -> String) {
contract {
returns() implies value
}
if (!value) {
throw newException(lazyMessage())
}
}
}
fun newRequired(): Required<IllegalArgumentException> {
return newRequired<IllegalArgumentException>()
}
fun <T : Throwable> newRequired(clazz: Class<T>): Required<T> {
return Required {
newException(clazz, it)
}
}
inline fun <reified T : Throwable> newRequired(): Required<T> {
return newRequired(T::class.java)
}
fun <T : Throwable> newException(clazz: Class<T>, msg: String): T = try {
val constructor = clazz.getConstructor(String::class.java).also {
check(!java.lang.reflect.Modifier.isAbstract(clazz.modifiers)) {
"${clazz.name} 是抽象类,无法实例化"
}
}
constructor.newInstance(msg)
} catch (e: ReflectiveOperationException) {
throw IllegalStateException("无法实例化 ${clazz.name}", e)
}
@OptIn(ExperimentalContracts::class)
fun <T : Throwable> requireTrue(value: Boolean, clazz: Class<T>, lazyMessage: () -> String) {
contract {
returns() implies value
}
if (!value) {
throw newException(clazz, lazyMessage())
}
}
@OptIn(ExperimentalContracts::class)
inline fun <reified T : Throwable> requireTrue(value: Boolean, noinline lazyMessage: () -> String) {
contract {
returns() implies value
}
requireTrue(value, T::class.java, lazyMessage)
}
@OptIn(ExperimentalContracts::class)
fun <T : Throwable> Boolean.requireTrue(clazz: Class<T>, lazyMessage: () -> String) {
contract {
returns() implies this@requireTrue
}
requireTrue(this, clazz, lazyMessage)
}
@OptIn(ExperimentalContracts::class)
fun <T : Throwable> Boolean.requireTrue(clazz: Class<T>, message: String) {
contract {
returns() implies this@requireTrue
}
requireTrue(this, clazz) {
message
}
}
@OptIn(ExperimentalContracts::class)
fun <T : Throwable> requireTrue(value: Boolean, clazz: Class<T>, message: String) {
contract {
returns() implies value
}
requireTrue(value, clazz) { message }
}
@OptIn(ExperimentalContracts::class)
inline fun <reified T : Throwable> requireTrue(value: Boolean, message: String) {
contract {
returns() implies value
}
requireTrue(value, T::class.java) { message }
}
@OptIn(ExperimentalContracts::class)
inline fun <reified T : Throwable> Boolean.requireTrue(noinline lazyMessage: () -> String) {
contract {
returns() implies this@requireTrue
}
requireTrue(this, T::class.java, lazyMessage)
}
@OptIn(ExperimentalContracts::class)
inline fun <reified T : Throwable> Boolean.requireTrue(message: String) {
contract {
returns() implies this@requireTrue
}
requireTrue(this, T::class.java, message)
}
@OptIn(ExperimentalContracts::class)
fun <T : Throwable> requireTrue(value: Boolean, clazz: Class<T>) {
contract {
returns() implies value
}
requireTrue(value, clazz) { DEFAULT_MESSAGE }
}
@OptIn(ExperimentalContracts::class)
inline fun <reified T : Throwable> requireTrue(value: Boolean) {
contract {
returns() implies value
}
requireTrue(value, T::class.java) { DEFAULT_MESSAGE }
}
@OptIn(ExperimentalContracts::class)
fun <T : Throwable> Boolean.requireTrue(clazz: Class<T>) {
contract {
returns() implies this@requireTrue
}
requireTrue(this, clazz) { DEFAULT_MESSAGE }
}
@OptIn(ExperimentalContracts::class)
inline fun <reified T : Throwable> Boolean.requireTrue() {
contract {
returns() implies this@requireTrue
}
requireTrue(this, T::class.java) { DEFAULT_MESSAGE }
}
@@ -0,0 +1,23 @@
/*
* 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 Required.kt
* LastUpdate 2026-10-20 19:58:06
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.require
@@ -16,120 +16,142 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile ResourceUtils.kt * CurrentFile ResourceUtils.kt
* LastUpdate 2026-02-05 11:09:16 * LastUpdate 2026-05-23 10:28:28
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
package com.mingliqiye.utils.resource package com.mingliqiye.utils.resource
import java.io.IOException import com.mingliqiye.utils.exception.NotFoundResourceException
import java.nio.charset.Charset
/**
* 工具类,用于从类路径中加载资源文件。
*/
object ResourceUtils { object ResourceUtils {
/** /**
* 从默认类路径中加载指定名称的资源文件,并以字节数组形式返回。 * 从类路径中读取资源文件并返回字节数组(使用 reified 类型参数)
* *
* @param resourceName 资源文件的名称(相对于类路径根目录)。 * 这是一个内联扩展函数,利用 reified 关键字在编译时获取具体类型 T 的 Class 对象
* @return 资源文件的内容作为字节数组。 *
* @throws IOException 如果资源未找到或读取失败时抛出。 * @param T 用于获取 ClassLoader 的类型参数(通常传入调用方的类)
* @param path 资源文件的路径(相对于 T 所在的包,或以 / 开头的绝对路径)
* @return 资源的字节数组
* @throws NotFoundResourceException 当资源不存在时抛出
*
* 使用示例:
* ```kotlin
* // 在当前类的包下查找 config.json
* val data = getResourceAsByteArray<MyClass>("config.json")
*
* // 使用绝对路径(从 classpath 根目录)
* val data = getResourceAsByteArray<MyClass>("/assets/config.json")
* ```
*/ */
@JvmStatic inline fun <reified T> getResourceAsByteArray(path: String): ByteArray {
@Throws(IOException::class) // 将 reified T 的 KClass 转换为 Java 的 Class 对象,传递给重载方法
fun getResource(resourceName: String): ByteArray { return getResourceAsByteArray(path, T::class.java)
return getResource(resourceName, ResourceUtils::class.java)
} }
/** /**
* 从指定类的类路径中加载指定名称的资源文件,并以字节数组形式返回。 * 从类路径中读取资源文件并返回字符串(使用 reified 类型参数)
* *
* @param resourceName 资源文件的名称(相对于类路径根目录)。 * @param T 用于获取 ClassLoader 的类型参数
* @param clazz 用于定位资源的类。 * @param resource 资源文件路径
* @return 资源文件的内容作为字节数组。 * @param charset 字符编码,默认为系统默认字符集
* @throws IOException 如果资源未找到或读取失败时抛出。 * @return 资源文件的字符串内容
* @throws NotFoundResourceException 当资源不存在时抛出
*
* 使用示例:
* ```kotlin
* // 读取文本文件,使用默认编码
* val content = getResourceAsString<MyClass>("data.txt")
*
* // 指定 UTF-8 编码
* val content = getResourceAsString<MyClass>("data.txt", Charsets.UTF_8)
* ```
*/ */
@JvmStatic inline fun <reified T> getResourceAsString(
@Throws(IOException::class) resource: String,
fun getResource(resourceName: String, clazz: Class<*>): ByteArray { charset: Charset = Charset.defaultCharset(),
return clazz.getResourceAsStream(resourceName)?.use { ): String {
it.readBytes() // 将 reified T 的 Class 对象传递给重载方法
} ?: throw IOException("Resource not found: $resourceName") return getResourceAsString(resource, charset, T::class.java)
} }
/** /**
* 从默认类路径中加载指定名称的资源文件,并以字符串形式返回。 * 从类路径中读取资源文件并返回字符串(Java 友好重载版本)
* *
* @param resourceName 资源文件的名称(相对于类路径根目录)。 * 此方法标记为 @JvmStatic,使其可以在 Java 代码中以静态方法形式调用
* @return 资源文件的内容作为字符串(使用UTF-8编码)。 *
* @throws IOException 如果资源未找到或读取失败时抛出。 * @param path 资源文件路径
* @param charset 字符编码
* @param clazz 用于获取 ClassLoader 的参考类
* @return 资源文件的字符串内容
* @throws NotFoundResourceException 当资源不存在时抛出
*
* Java 调用示例:
* ```java
* // 在 Java 中调用
* String content = YourClass.getResourceAsString("config.json", StandardCharsets.UTF_8, MyClass.class);
* ```
*/ */
@JvmStatic @JvmStatic
@Throws(IOException::class) fun getResourceAsString(path: String, charset: Charset, clazz: Class<*>): String {
fun getStringResource(resourceName: String): String { // 先读取为字节数组,再按指定字符集解码为字符串
return getStringResource(resourceName, ResourceUtils::class.java) return String(getResourceAsByteArray(path, clazz), charset)
} }
/** /**
* 从指定类的类路径中加载指定名称的资源文件,并以字符串形式返回。 * 从类路径中读取资源文件并返回字符串(使用默认字符集,Java 友好重载)
* *
* @param resourceName 资源文件的名称(相对于类路径根目录)。 * @param path 资源文件路径
* @param clazz 用于定位资源的类。 * @param clazz 用于获取 ClassLoader 的参考类
* @return 资源文件的内容作为字符串(使用UTF-8编码)。 * @return 资源文件的字符串内容
* @throws IOException 如果资源未找到或读取失败时抛出。 * @throws NotFoundResourceException 当资源不存在时抛出
*/ */
@JvmStatic @JvmStatic
@Throws(IOException::class) fun getResourceAsString(path: String, clazz: Class<*>): String {
fun getStringResource(resourceName: String, clazz: Class<*>): String { // 委托给上面的方法,使用系统默认字符集
return clazz.getResourceAsStream(resourceName)?.use { return getResourceAsString(path, Charset.defaultCharset(), clazz)
it.readBytes().toString(charset = Charsets.UTF_8)
} ?: throw IOException("Resource not found: $resourceName")
} }
/** /**
* 从调用者的类路径中加载指定名称的资源文件,并以字符串形式返回。 * 从类路径中读取资源文件并返回字节数组(核心实现方法)
* *
* @param resourceName 资源文件的名称(相对于类路径根目录)。 * 这是所有方法的核心实现,负责实际的资源查找和读取工作
* @return 资源文件的内容作为字符串(使用UTF-8编码)。 *
* @throws IOException 如果资源未找到或读取失败时抛出。 * @param path 资源文件路径
* - 如果以 "/" 开头:表示从 classpath 根目录查找
* - 如果不以 "/" 开头:表示相对于 clazz 所在包的路径
* @param clazz 参考类,用于确定相对路径的基准包
* @return 资源的完整字节数组(使用 readAllBytes() 一次性读取)
* @throws NotFoundResourceException 当资源文件不存在时抛出,错误信息会显示完整的查找路径
*
* 资源查找规则说明:
* 1. 如果 path = "config.properties" 且 clazz = com.example.MyClass
* 实际查找路径:/com/example/config.properties
*
* 2. 如果 path = "/config.properties"
* 实际查找路径:/config.properties(classpath 根目录)
*
* 异常消息示例:
* - 找不到文件时抛出:"/com/example/config.properties is not found"
*/ */
@JvmStatic @JvmStatic
@Throws(IOException::class) fun getResourceAsByteArray(path: String, clazz: Class<*>): ByteArray {
fun getStringResourceCallers(resourceName: String): String { // 尝试从类路径中获取资源的输入流
return getStringResource(resourceName, getCallerClass()) val stream = clazz.getResourceAsStream(path)
} ?: throw NotFoundResourceException(
// 构建详细的错误信息:显示实际查找的完整路径
// 如果 path 不以 "/" 开头,则拼接类的包路径(将包名中的点替换为斜杠)
(if (!path.startsWith("/"))
"/${clazz.packageName.replace(".", "/")}/$path" // 相对路径:相对于 clazz 的包
else
path // 绝对路径:直接使用原路径
) + " is not found" // 添加 " is not found" 后缀
)
/** // 读取输入流中的所有字节并返回
* 从调用者的类路径中加载指定名称的资源文件,并以字节数组形式返回。 // Kotlin 的扩展函数,等同于 Java 9+ 的 InputStream.readAllBytes()
* return stream.readAllBytes()
* @param resourceName 资源文件的名称(相对于类路径根目录)。
* @return 资源文件的内容作为字节数组。
* @throws IOException 如果资源未找到或读取失败时抛出。
*/
@JvmStatic
@Throws(IOException::class)
fun getResourceCallers(resourceName: String): ByteArray {
return getResource(resourceName, getCallerClass())
}
/**
* 获取当前调用栈中第一个非ResourceUtils类的调用者类。
*
* @return 调用者类对象;如果未找到则返回ResourceUtils类本身。
*/
private fun getCallerClass(): Class<*> {
val stackTrace = Thread.currentThread().stackTrace
for (i in 2 until stackTrace.size) {
val className = stackTrace[i].className
try {
val clazz = Class.forName(className)
if (clazz != ResourceUtils::class.java) {
return clazz
}
} catch (e: ClassNotFoundException) {
continue
}
}
return ResourceUtils::class.java
} }
} }
@@ -0,0 +1,28 @@
/*
* Copyright 2026 mingliqiye
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* ProjectName mingli-utils
* ModuleName mingli-utils.main
* CurrentFile ApplicationDestroyedRunner.kt
* LastUpdate 2026-03-10 09:04:02
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.springboot.annotation
@Target(AnnotationTarget.FUNCTION)
annotation class ApplicationDestroyedRunner(
val order: Int = Int.MIN_VALUE
)
@@ -0,0 +1,28 @@
/*
* Copyright 2026 mingliqiye
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* ProjectName mingli-utils
* ModuleName mingli-utils.main
* CurrentFile ApplicationStartedRunner.kt
* LastUpdate 2026-03-11 08:46:40
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.springboot.annotation
@Target(AnnotationTarget.FUNCTION)
annotation class ApplicationStartedRunner(
val order: Int = Int.MIN_VALUE,
)
@@ -0,0 +1,32 @@
/*
* 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 Listener.kt
* LastUpdate 2026-03-10 09:04:02
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.springboot.annotation
import org.springframework.core.annotation.AliasFor
import org.springframework.stereotype.Component
@Component
annotation class Listener(
@get:AliasFor(annotation = Component::class)
val value: String = ""
)
@@ -16,116 +16,27 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile AutoConfiguration.kt * CurrentFile AutoConfiguration.kt
* LastUpdate 2026-02-06 15:15:46 * LastUpdate 2026-03-10 09:04:30
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
package com.mingliqiye.utils.springboot.autoconfigure package com.mingliqiye.utils.springboot.autoconfigure
import com.mingliqiye.utils.i18n.I18N import org.springframework.boot.autoconfigure.AutoConfiguration
import com.mingliqiye.utils.i18n.I18N.infoTranslater
import com.mingliqiye.utils.logger.MingLiLoggerFactory
import com.mingliqiye.utils.system.computerName
import com.mingliqiye.utils.system.getPid
import com.mingliqiye.utils.system.jdkVersion
import com.mingliqiye.utils.system.userName
import com.mingliqiye.utils.time.DateTime
import com.mingliqiye.utils.time.Formatter
import org.springframework.context.annotation.ComponentScan import org.springframework.context.annotation.ComponentScan
import java.io.IOException
/** /**
* 自动配置类,用于Spring Boot应用启动时加载相关组件和打印启动横幅。 * 自动配置类,用于Spring Boot应用启动时加载相关组件和打印启动横幅。
* *
* 该类通过@ComponentScan注解扫描指定包下的Bean,并在初始化时打印包含系统信息的启动横幅。 * 该类通过@ComponentScan注解扫描指定包下的Bean,并在初始化时打印包含系统信息的启动横幅。
*/ */
@org.springframework.boot.autoconfigure.AutoConfiguration @AutoConfiguration
@ComponentScan( @ComponentScan(
"com.mingliqiye.utils.springboot.bean", "com.mingliqiye.utils.springboot.bean",
"com.mingliqiye.utils.springboot.converters" "com.mingliqiye.utils.springboot.converters",
"com.mingliqiye.utils.springboot.listener",
) )
open class AutoConfiguration { open class AutoConfiguration {
private val log = MingLiLoggerFactory.getLogger("MingliUtils-AutoConfiguration")
companion object {
/**
* 启动横幅字符串,包含艺术字体和占位符。
*/
private const val BANNER =
" | $$\\ $$\\ $$\\ $$\\ $$\\ $$$$$$$$\\ $$$$$$\\ \n" +
"| $$$\\ $$$ |$$ | $$ | $$ |\\__$$ __|$$ __$$\\ \n" +
"| $$$$\\ $$$$ |$$ | $$ | $$ | $$ | $$ / \\__| \n" +
"| $$\\$$\\$$ $$ |$$ | $$ | $$ | $$ | \\$$$$$$\\ \n" +
"| $$ \\$$$ $$ |$$ | $$ | $$ | $$ | \\____$$\\ \n" +
"| $$ |\\$ /$$ |$$ | $$ | $$ | $$ | $$\\ $$ | \n" +
"| $$ | \\_/ $$ |$$$$$$$$\\\\$$$$$$ | $$ | \\$$$$$$ \n" +
"| \\__| \\__|\\________|\\______/ \\__| \\______/ \n|\n"
/**
* 打印启动横幅,包含系统元数据(如JDK版本、进程ID、计算机名等)。
*
* 该方法从资源文件中读取元数据,并将其格式化后追加到横幅中进行输出。
* 如果读取资源失败,则仅打印默认横幅。
*/
fun printBanner() {
val bannerBuilder = StringBuilder(BANNER)
// 尝试从资源文件中读取元数据并拼接到横幅中
try {
val inputStream = AutoConfiguration::class.java.getResourceAsStream("/META-INF/meta-data") ?: return
inputStream.use { stream ->
var readlen: Int
val buffer = ByteArray(1024)
val metaData = StringBuilder()
// 逐块读取资源文件内容
while (stream.read(buffer).also { readlen = it } != -1) {
metaData.append(String(buffer, 0, readlen))
}
// 解析元数据并添加额外的系统信息
val da = metaData.toString().split("\n").toMutableList()
da.add("${I18N.getString("com.mingliqiye.utils.springboot.autoconfigure.AutoConfiguration.jdkRuntime")}=$jdkVersion")
da.add("${I18N.getString("com.mingliqiye.utils.springboot.autoconfigure.AutoConfiguration.pid")}=$getPid")
da.add("${I18N.getString("com.mingliqiye.utils.springboot.autoconfigure.AutoConfiguration.computerName")}=$computerName")
da.add("${I18N.getString("com.mingliqiye.utils.springboot.autoconfigure.AutoConfiguration.userName")}=$userName")
da.add(
"${I18N.getString("com.mingliqiye.utils.springboot.autoconfigure.AutoConfiguration.time")}=" + DateTime.now()
.format(Formatter.STANDARD_DATETIME_MILLISECOUND7, false)
)
// 格式化每条元数据并追加到横幅中
da.forEach { s: String ->
val d = s.trim { it <= ' ' }.split("=".toRegex(), 2).toTypedArray()
if (d.size >= 2) {
val content = "| -> " + I18N.getString(d[0]) + ": " + d[1]
val targetLength = 56
if (content.length < targetLength) {
bannerBuilder.append(
String.format(
"%-${targetLength}s\n",
content
)
)
} else {
bannerBuilder
.append(content, 0, targetLength)
.append("|\n")
}
}
}
}
} catch (e: IOException) {
// 捕获IO异常并打印堆栈跟踪
e.printStackTrace()
}
// 输出最终构建的横幅
println("")
println(bannerBuilder.toString().trim())
println("")
}
}
/** /**
* 初始化块,在类实例化时执行。 * 初始化块,在类实例化时执行。
@@ -133,7 +44,6 @@ open class AutoConfiguration {
* 调用printBanner方法打印启动横幅,并记录日志表示自动配置成功。 * 调用printBanner方法打印启动横幅,并记录日志表示自动配置成功。
*/ */
init { init {
printBanner() com.mingliqiye.utils.main.Main.printb()
log.infoTranslater("com.mingliqiye.utils.springboot.autoconfigure.AutoConfiguration.bean")
} }
} }
@@ -0,0 +1,52 @@
/*
* 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 Jackson3AutoConfiguration.kt
* LastUpdate 2026-10-02 16:11:12
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.springboot.autoconfigure;
import com.mingliqiye.utils.json.converters.DateTimeJsonConverter
import com.mingliqiye.utils.json.converters.UUIDJsonConverter
import com.mingliqiye.utils.json.converters.base.getJackson3Module
import com.mingliqiye.utils.logger.MingLiLoggerFactory
import org.springframework.boot.autoconfigure.AutoConfigureAfter
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean
import org.springframework.boot.jackson.autoconfigure.JsonMapperBuilderCustomizer
import org.springframework.context.annotation.Bean
@ConditionalOnClass(name = ["tools.jackson.databind.json.JsonMapper", "org.springframework.boot.jackson.autoconfigure.JacksonAutoConfiguration"])
@AutoConfigureAfter(name = ["org.springframework.boot.jackson.autoconfigure.JacksonAutoConfiguration"])
open class Jackson3AutoConfiguration {
private val logger = MingLiLoggerFactory.getLogger<Jackson3AutoConfiguration>()
@Bean
@ConditionalOnMissingBean(JsonMapperBuilderCustomizer::class)
open fun myJsonMapperCustomizer(): JsonMapperBuilderCustomizer {
return JsonMapperBuilderCustomizer { builder ->
builder
.addModule(UUIDJsonConverter.getJsonConverter().getJackson3Module())
.addModule(DateTimeJsonConverter.getJsonConverter().getJackson3Module())
}.also {
logger.info("MingliUtils Jackson3 Serializers created")
}
}
}

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