refactor(kotlin): 重构 AES 工具类并优化 Base64 编解码方法

- 重构 AesUtils.kt,使用 Kotlin 标准库的 encode 和 decode 方法替代自定义实现- 删除 Java 版本的 Base64Utils 类,迁移到 Kotlin 实现
- 重命名 ByteUtil.kt 为 ByteUtils.kt,统一命名风格
- 删除 Java 版本的 CloneUtil 类和 Factory 类,使用 Kotlin 实现
- 新增 Kotlin 版本的 SpringBeanUtils 工具类重构项目,迁移到 Kotlin

- 将 Java 文件转换为 Kotlin 文件
- 更新项目结构和命名- 优化代码实现
- 添加必要的依赖
This commit is contained in:
2025-09-14 22:10:47 +08:00
parent 01bfb052d0
commit 8ef3cb5ba4
17 changed files with 527 additions and 505 deletions
+1 -3
View File
@@ -16,7 +16,7 @@
* ProjectName mingli-utils
* ModuleName mingli-utils.main
* CurrentFile Main.kt
* LastUpdate 2025-09-14 20:08:44
* LastUpdate 2025-09-14 22:05:03
* UpdateUser MingLiPro
*/
@@ -29,6 +29,4 @@ import com.mingliqiye.utils.springboot.autoconfigure.AutoConfiguration
fun main() {
AutoConfiguration.printBanner()
0..10
}
@@ -16,11 +16,11 @@
* ProjectName mingli-utils
* ModuleName mingli-utils.main
* CurrentFile SpringBeanUtils.kt
* LastUpdate 2025-09-14 20:01:26
* LastUpdate 2025-09-14 22:10:45
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.bean.annotation.springboot
package com.mingliqiye.utils.bean.springboot
import org.springframework.beans.BeansException
import org.springframework.context.ApplicationContext
@@ -0,0 +1,104 @@
/*
* Copyright 2025 mingliqiye
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* ProjectName mingli-utils
* ModuleName mingli-utils.main
* CurrentFile AutoConfiguration.kt
* LastUpdate 2025-09-14 22:09:46
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.springboot.autoconfigure
import com.mingliqiye.utils.collection.ForEach
import com.mingliqiye.utils.logger.mingLiLoggerFactory
import com.mingliqiye.utils.system.getJdkVersion
import com.mingliqiye.utils.time.DateTime
import com.mingliqiye.utils.time.Formatter
import org.springframework.context.annotation.ComponentScan
import java.io.IOException
@org.springframework.boot.autoconfigure.AutoConfiguration
@ComponentScan(
"com.mingliqiye.utils.bean.springboot",
"com.mingliqiye.utils.springboot.converters"
)
open class AutoConfiguration {
companion object {
private const val banner =
"---------------------------------------------------------\n" +
"| $$\\ $$\\ $$\\ $$\\ $$\\ $$$$$$$$\\ $$$$$$\\ |\n" +
"| $$$\\ $$$ |$$ | $$ | $$ |\\__$$ __|$$ __$$\\ |\n" +
"| $$$$\\ $$$$ |$$ | $$ | $$ | $$ | $$ / \\__| |\n" +
"| $$\\$$\\$$ $$ |$$ | $$ | $$ | $$ | \\$$$$$$\\ |\n" +
"| $$ \\$$$ $$ |$$ | $$ | $$ | $$ | \\____$$\\ |\n" +
"| $$ |\\$ /$$ |$$ | $$ | $$ | $$ | $$\\ $$ | |\n" +
"| $$ | \\_/ $$ |$$$$$$$$\\\\$$$$$$ | $$ | \\$$$$$$ | |\n" +
"| \\__| \\__|\\________|\\______/ \\__| \\______/ |\n"
private var banner2: String? = null
private val log = mingLiLoggerFactory.getLogger("MingliUtils-AutoConfiguration")
fun printBanner() {
val bannerBuilder = StringBuilder(banner)
try {
val inputStream = AutoConfiguration::class.java.getResourceAsStream("/META-INF/meta-data")
if (inputStream == null) {
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("time=" + DateTime.now().format(Formatter.STANDARD_DATETIME_MILLISECOUND7))
da.add("jdkRuntime=" + getJdkVersion())
ForEach.forEach(da) { s: String, _: Int ->
val d = s.trim { it <= ' ' }.split("=".toRegex(), 2).toTypedArray()
if (d.size >= 2) {
val content = "| " + 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) {
e.printStackTrace()
}
banner2 = bannerBuilder.toString()
println(banner2)
println("---------------------------------------------------------")
}
}
init {
printBanner()
log.info("MingliUtils AutoConfiguration succeed")
}
}
@@ -0,0 +1,91 @@
/*
* Copyright 2025 mingliqiye
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* ProjectName mingli-utils
* ModuleName mingli-utils.main
* CurrentFile GsonAutoConfiguration.kt
* LastUpdate 2025-09-14 22:06:47
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.springboot.autoconfigure
import com.google.gson.Gson
import com.google.gson.GsonBuilder
import com.mingliqiye.utils.json.GsonJsonApi
import com.mingliqiye.utils.json.JsonApi
import com.mingliqiye.utils.json.converters.DateTimeJsonConverter
import com.mingliqiye.utils.json.converters.JsonStringConverter
import com.mingliqiye.utils.json.converters.UUIDJsonStringConverter
import com.mingliqiye.utils.logger.mingLiLoggerFactory
import com.mingliqiye.utils.time.DateTime
import com.mingliqiye.utils.uuid.UUID
import org.slf4j.Logger
import org.slf4j.LoggerFactory
import org.springframework.boot.autoconfigure.AutoConfiguration
import org.springframework.boot.autoconfigure.AutoConfigureAfter
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean
import org.springframework.boot.autoconfigure.gson.GsonBuilderCustomizer
import org.springframework.context.annotation.Bean
@ConditionalOnClass(Gson::class)
@AutoConfiguration
@AutoConfigureAfter(
name = ["org.springframework.boot.autoconfigure.gson.GsonAutoConfiguration",
"com.mingliqiye.utils.springboot.autoconfigure.JacksonAutoConfiguration"]
)
open class GsonAutoConfiguration {
companion object {
private val log: Logger = LoggerFactory.getLogger("MingliUtils-GsonAutoConfiguration")
fun addTypeAdapter(gsonBuilder: GsonBuilder): GsonBuilder {
val dateTimeJsonConverter: JsonStringConverter<DateTime> = DateTimeJsonConverter()
val uuidJsonStringConverter: JsonStringConverter<UUID> = UUIDJsonStringConverter()
try {
return gsonBuilder
.registerTypeAdapter(
uuidJsonStringConverter.getTClass(),
dateTimeJsonConverter
.getGsonJsonStringConverterAdapter()
.getGsonTypeAdapter()
)
.registerTypeAdapter(
dateTimeJsonConverter.getTClass(),
dateTimeJsonConverter
.getGsonJsonStringConverterAdapter()
.getGsonTypeAdapter()
)
} finally {
log.info("MingliUtils GsonBuilder TypeAdapter add")
}
}
}
private val log: Logger = mingLiLoggerFactory.getLogger("MingliUtils-GsonAutoConfiguration")
@Bean
open fun mingliGsonCustomizer(): GsonBuilderCustomizer {
return GsonBuilderCustomizer { gsonBuilder: GsonBuilder -> addTypeAdapter(gsonBuilder) }
}
@Bean
@ConditionalOnMissingBean
open fun jsonApi(gson: Gson): JsonApi {
log.info("MingliUtils-JsonApiAutoConfiguration: GsonJsonApi bean is created.")
return GsonJsonApi(gson)
}
}
@@ -0,0 +1,76 @@
/*
* Copyright 2025 mingliqiye
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* ProjectName mingli-utils
* ModuleName mingli-utils.main
* CurrentFile JacksonAutoConfiguration.kt
* LastUpdate 2025-09-14 22:10:08
* UpdateUser MingLiPro
*/
package com.mingliqiye.utils.springboot.autoconfigure
import com.fasterxml.jackson.databind.ObjectMapper
import com.mingliqiye.utils.json.JacksonJsonApi
import com.mingliqiye.utils.json.JsonApi
import com.mingliqiye.utils.json.converters.DateTimeJsonConverter
import com.mingliqiye.utils.json.converters.UUIDJsonStringConverter
import com.mingliqiye.utils.logger.mingLiLoggerFactory
import org.slf4j.Logger
import org.slf4j.LoggerFactory
import org.springframework.boot.autoconfigure.AutoConfiguration
import org.springframework.boot.autoconfigure.AutoConfigureAfter
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Primary
@ConditionalOnClass(ObjectMapper::class)
@AutoConfiguration
@AutoConfigureAfter(org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration::class)
open class JacksonAutoConfiguration(objectMapper: ObjectMapper) {
companion object {
private val log: Logger = mingLiLoggerFactory.getLogger("MingliUtils-JacksonAutoConfiguration")
fun addModules(objectMapper: ObjectMapper): ObjectMapper {
return objectMapper
.registerModule(
DateTimeJsonConverter()
.jacksonJsonStringConverterAdapter
.getJacksonModule()
)
.registerModule(
UUIDJsonStringConverter()
.jacksonJsonStringConverterAdapter
.getJacksonModule()
)
}
}
private val log: Logger = LoggerFactory.getLogger("MingliUtils-JacksonAutoConfiguration")
init {
addModules(objectMapper)
log.info("MingliUtils Jackson Serializers created")
}
@Bean
@Primary
@ConditionalOnMissingBean
open fun jsonApi(objectMapper: ObjectMapper): JsonApi {
log.info("MingliUtils-JsonApiAutoConfiguration: JacksonJsonApi bean is created.")
return JacksonJsonApi(objectMapper)
}
}
@@ -0,0 +1,195 @@
/*
* Copyright 2025 mingliqiye
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* ProjectName mingli-utils
* ModuleName mingli-utils.main
* CurrentFile SystemUtil.kt
* LastUpdate 2025-09-14 21:56:58
* UpdateUser MingLiPro
*/
@file:JvmName("SystemUtils")
package com.mingliqiye.utils.system
import com.mingliqiye.utils.collection.Lists
import java.net.Inet4Address
import java.net.NetworkInterface
import java.net.SocketException
private val osName: String? = System.getProperties().getProperty("os.name")
/**
* 判断当前操作系统是否为Windows系统
*
* @return 如果是Windows系统返回true,否则返回false
*/
fun isWindows(): Boolean {
return osName != null && osName.startsWith("Windows")
}
/**
* 判断当前操作系统是否为Mac系统
*
* @return 如果是Mac系统返回true,否则返回false
*/
fun isMac(): Boolean {
return osName != null && osName.startsWith("Mac")
}
/**
* 判断当前操作系统是否为Unix/Linux系统
*
* @return 如果是Unix/Linux系统返回true,否则返回false
*/
fun isUnix(): Boolean {
if (osName == null) {
return false
}
return (osName.startsWith("Linux") || osName.startsWith("AIX") || osName.startsWith("SunOS") || osName.startsWith("Mac OS X") || osName.startsWith(
"FreeBSD"
))
}
/**
* 获取JDK版本号
*
* @return JDK版本号字符串
*/
fun getJdkVersion(): String {
return System.getProperty("java.specification.version")
}
/**
* 获取Java版本号的整数形式
*
* @return Java版本号的整数形式(如:8、11、17等)
*/
fun getJavaVersionAsInteger(): Int {
val version = getJdkVersion()
if (version == null || version.isEmpty()) {
throw IllegalStateException(
"Unable to determine Java version from property 'java.specification.version'"
)
}
val uversion: String = if (version.startsWith("1.")) {
if (version.length < 3) {
throw IllegalStateException(
"Invalid Java version format: $version"
)
}
version.substring(2, 3)
} else {
if (version.length < 2) {
throw IllegalStateException(
"Invalid Java version format: $version"
)
}
version.substring(0, 2)
}
return uversion.toInt()
}
/**
* 判断当前JDK版本是否大于8
*
* @return 如果JDK版本大于8返回true,否则返回false
*/
fun isJdk8Plus(): Boolean {
return getJavaVersionAsInteger() > 8
}
/**
* 获取本地IP地址数组
*
* @return 本地IP地址字符串数组
* @throws RuntimeException 当获取网络接口信息失败时抛出
*/
fun getLocalIps(): Array<String> {
return try {
val ipList: MutableList<String> = ArrayList()
val interfaces = NetworkInterface.getNetworkInterfaces()
while (interfaces.hasMoreElements()) {
val networkInterface = interfaces.nextElement()
// 跳过回环接口和虚拟接口
if (networkInterface.isLoopback || networkInterface.isVirtual || !networkInterface.isUp) {
continue
}
val addresses = networkInterface.inetAddresses
while (addresses.hasMoreElements()) {
val address = addresses.nextElement()
// 只获取IPv4地址
if (address is Inet4Address) {
ipList.add(address.hostAddress)
}
}
}
ipList.toTypedArray()
} catch (e: SocketException) {
throw RuntimeException("Failed to get local IP addresses", e)
}
}
/**
* 获取本地IP地址列表
*
* @return 本地IP地址的字符串列表
*/
fun getLocalIpsByList(): List<String> {
return Lists.newArrayList(*getLocalIps())
}
/**
* 获取本地回环地址
*
* @return 回环地址字符串,通常为"127.0.0.1"
*/
fun getLoopbackIps(): Array<String> {
val strings: MutableList<String> = ArrayList(3)
return try {
val interfaces = NetworkInterface.getNetworkInterfaces()
while (interfaces.hasMoreElements()) {
val networkInterface = interfaces.nextElement()
// 只处理回环接口
if (networkInterface.isLoopback && networkInterface.isUp) {
val addresses = networkInterface.inetAddresses
while (addresses.hasMoreElements()) {
val address = addresses.nextElement()
strings.add(address.hostAddress)
}
}
}
strings.toTypedArray()
} catch (e: SocketException) {
// 可考虑添加日志记录
arrayOf("127.0.0.1")
}
}
/**
* 获取本地回环地址IP列表
*
* @return 本地回环地址IP字符串列表的副本
*/
fun getLoopbackIpsByList(): List<String> {
// 将本地回环地址IP数组转换为列表并返回
return Lists.newArrayList(*getLoopbackIps())
}