From 792ddf0255fd3093689f2a8bef2dad61b99280be Mon Sep 17 00:00:00 2001 From: minglipro Date: Wed, 28 Oct 2026 23:36:35 +0800 Subject: [PATCH] =?UTF-8?q?feat(mybatisplus):=20=E6=96=B0=E5=A2=9E=20FastB?= =?UTF-8?q?aseIService=20=E5=B9=B6=E5=8F=91=E5=B8=83=20mingli-utils=205.4.?= =?UTF-8?q?0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 新增 FastBaseIService 服务层便捷基类,与 FastBaseMapper 对齐常用增删改查,移除旧的 BaseMapperQuery - Jackson 自动配置改用 Jackson2ObjectMapperBuilderCustomizer Bean 注册模块,避免直接依赖 ObjectMapper - SpringBeanUtils 新增 lazyBean 延迟获取 Bean 便捷函数 - SystemUtil 新增 lineSeparator 相关常量并整理链式调用格式 - FileUtils.writeLines(charset) 修复自递归问题 - build.gradle.kts 增加 mybatis-plus-spring 编译依赖 --- build.gradle.kts | 5 +- gradle.properties | 6 +- .../com/mingliqiye/utils/file/FileUtils.kt | 6 +- .../utils/mybatisplus/BaseMapperQuery.kt | 38 - .../utils/mybatisplus/FastBaseIService.kt | 822 ++++++++++++++++++ .../utils/mybatisplus/FastBaseMapper.kt | 7 +- .../JacksonJsonAutoConfiguration.kt | 33 +- .../utils/springboot/bean/SpringBeanUtils.kt | 8 +- .../com/mingliqiye/utils/system/SystemUtil.kt | 65 +- 9 files changed, 894 insertions(+), 96 deletions(-) delete mode 100644 src/main/kotlin/com/mingliqiye/utils/mybatisplus/BaseMapperQuery.kt create mode 100644 src/main/kotlin/com/mingliqiye/utils/mybatisplus/FastBaseIService.kt diff --git a/build.gradle.kts b/build.gradle.kts index a8ee448..320d2c8 100644 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -13,10 +13,10 @@ * See the License for the specific language governing permissions and * limitations under the License. * - * ProjectName FastBaseMapper.kt + * ProjectName mingli-utils * ModuleName mingli-utils * CurrentFile build.gradle.kts - * LastUpdate 2026-10-26 23:22:18 + * LastUpdate 2026-10-28 21:50:32 * UpdateUser MingLiPro */ @@ -85,6 +85,7 @@ dependencies { 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-jsqlparser:3.5.15") + compileOnly("com.baomidou:mybatis-plus-spring:3.5.9") testImplementation("org.junit.jupiter:junit-jupiter:5.7.1") testRuntimeOnly("org.junit.platform:junit-platform-launcher") testImplementation("com.mingliqiye.logger:logger-log4j2:1.0.9") diff --git a/gradle.properties b/gradle.properties index 753f012..e85b6c4 100644 --- a/gradle.properties +++ b/gradle.properties @@ -13,13 +13,13 @@ # See the License for the specific language governing permissions and # limitations under the License. # -# ProjectName FastBaseMapper.kt +# ProjectName mingli-utils # ModuleName mingli-utils # CurrentFile gradle.properties -# LastUpdate 2026-10-27 10:34:17 +# LastUpdate 2026-10-28 23:34:13 # UpdateUser MingLiPro # JDKVERSIONS=17 GROUPSID=com.mingliqiye.utils ARTIFACTID=mingli-utils -VERSIONS=5.3.7 +VERSIONS=5.4.0 diff --git a/src/main/kotlin/com/mingliqiye/utils/file/FileUtils.kt b/src/main/kotlin/com/mingliqiye/utils/file/FileUtils.kt index f4be62d..68e2f51 100644 --- a/src/main/kotlin/com/mingliqiye/utils/file/FileUtils.kt +++ b/src/main/kotlin/com/mingliqiye/utils/file/FileUtils.kt @@ -16,7 +16,7 @@ * ProjectName mingli-utils * ModuleName mingli-utils.main * CurrentFile FileUtils.kt - * LastUpdate 2026-01-28 10:49:14 + * LastUpdate 2026-10-28 22:40:34 * UpdateUser MingLiPro */ @file:JvmName("FileUtils") @@ -627,7 +627,9 @@ fun File.writeLines(lines: List) { */ fun File.writeLines(lines: List, charset: Charset) { this.parentFile?.mkdirs() - this.writeLines(lines, charset) + for (line in lines) { + this.writeText(line + System.lineSeparator(), charset) + } } // 复制文件 diff --git a/src/main/kotlin/com/mingliqiye/utils/mybatisplus/BaseMapperQuery.kt b/src/main/kotlin/com/mingliqiye/utils/mybatisplus/BaseMapperQuery.kt deleted file mode 100644 index 319bdd9..0000000 --- a/src/main/kotlin/com/mingliqiye/utils/mybatisplus/BaseMapperQuery.kt +++ /dev/null @@ -1,38 +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 FastBaseMapper.kt - * ModuleName mingli-utils.main - * CurrentFile BaseMapperQuery.kt - * LastUpdate 2026-10-26 23:22:18 - * UpdateUser MingLiPro - */ - -package com.mingliqiye.utils.mybatisplus - - -@Deprecated( - "rename to FastBaseMapper", - replaceWith = ReplaceWith( - expression = "FastBaseMapper", - imports = ["com.mingliqiye.utils.mybatisplus.FastBaseMapper"] - ), - level = DeprecationLevel.WARNING -) -/** - * @since 4.6.1 - * 已经重命名 [FastBaseMapper] - */ -typealias BaseMapperQuery = FastBaseMapper diff --git a/src/main/kotlin/com/mingliqiye/utils/mybatisplus/FastBaseIService.kt b/src/main/kotlin/com/mingliqiye/utils/mybatisplus/FastBaseIService.kt new file mode 100644 index 0000000..ac46e60 --- /dev/null +++ b/src/main/kotlin/com/mingliqiye/utils/mybatisplus/FastBaseIService.kt @@ -0,0 +1,822 @@ +/* + * 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 FastBaseIService.kt + * LastUpdate 2026-10-28 23:26:17 + * UpdateUser MingLiPro + */ + +package com.mingliqiye.utils.mybatisplus + +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper +import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper +import com.baomidou.mybatisplus.core.toolkit.support.SFunction +import com.baomidou.mybatisplus.extension.kotlin.KtQueryChainWrapper +import com.baomidou.mybatisplus.extension.kotlin.KtQueryWrapper +import com.baomidou.mybatisplus.extension.kotlin.KtUpdateChainWrapper +import com.baomidou.mybatisplus.extension.kotlin.KtUpdateWrapper +import com.baomidou.mybatisplus.extension.plugins.pagination.Page +import com.baomidou.mybatisplus.extension.service.IService +import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl +import com.mingliqiye.utils.mybatisplus.FastBaseIService.Companion.ktQueryChainWrapper +import com.mingliqiye.utils.mybatisplus.FastBaseIService.Companion.ktQueryWrapper +import com.mingliqiye.utils.mybatisplus.FastBaseIService.Companion.ktUpdateChainWrapper +import com.mingliqiye.utils.mybatisplus.FastBaseIService.Companion.ktUpdateWrapper +import com.mingliqiye.utils.mybatisplus.FastBaseMapper.Companion.delete +import com.mingliqiye.utils.mybatisplus.FastBaseMapper.Companion.deleteByColumn +import com.mingliqiye.utils.mybatisplus.FastBaseMapper.Companion.exists +import com.mingliqiye.utils.mybatisplus.FastBaseMapper.Companion.existsByColumn +import com.mingliqiye.utils.mybatisplus.FastBaseMapper.Companion.ktQueryChain +import com.mingliqiye.utils.mybatisplus.FastBaseMapper.Companion.ktQueryChainWrapper +import com.mingliqiye.utils.mybatisplus.FastBaseMapper.Companion.ktQueryWrapper +import com.mingliqiye.utils.mybatisplus.FastBaseMapper.Companion.ktUpdateChain +import com.mingliqiye.utils.mybatisplus.FastBaseMapper.Companion.ktUpdateChainWrapper +import com.mingliqiye.utils.mybatisplus.FastBaseMapper.Companion.ktUpdateWrapper +import com.mingliqiye.utils.mybatisplus.FastBaseMapper.Companion.selectCount +import com.mingliqiye.utils.mybatisplus.FastBaseMapper.Companion.selectList +import com.mingliqiye.utils.mybatisplus.FastBaseMapper.Companion.selectListByColumn +import com.mingliqiye.utils.mybatisplus.FastBaseMapper.Companion.selectListByColumns +import com.mingliqiye.utils.mybatisplus.FastBaseMapper.Companion.selectMapByColumn +import com.mingliqiye.utils.mybatisplus.FastBaseMapper.Companion.selectOne +import com.mingliqiye.utils.mybatisplus.FastBaseMapper.Companion.selectOneByColumn +import com.mingliqiye.utils.mybatisplus.FastBaseMapper.Companion.selectPage +import com.mingliqiye.utils.mybatisplus.FastBaseMapper.Companion.update +import kotlin.reflect.KProperty1 + + +/** + * MyBatis-Plus[IService]的便捷基类,在服务层暴露与[FastBaseMapper]一致的常用查询、更新、删除方法 + * 内部统一委托给[mapper]执行,避免重复书写包装器构建代码 + * @param T 实体类型 + * @param D 基础映射器类型,必须继承自[FastBaseMapper] + */ +open class FastBaseIService> : ServiceImpl(), IService { + + /** + * 当前服务绑定的基础映射器实例,等价于[com.baomidou.mybatisplus.extension.repository.CrudRepository.getBaseMapper] + * @return D 继承自[FastBaseMapper]的映射器实例 + */ + val mapper: D + get() = getBaseMapper() + + /** + * 创建[com.baomidou.mybatisplus.core.conditions.query.QueryWrapper]实例 + * @return QueryWrapper 查询包装器实例 + */ + fun queryWrapper() = mapper.queryWrapper() + + /** + * 创建[com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper]实例 + * @return UpdateWrapper 更新包装器实例 + */ + fun updateWrapper() = mapper.updateWrapper() + + /** + * 创建[com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper]实例 + * @return LambdaQueryWrapper Lambda查询包装器实例 + */ + fun lambdaQueryWrapper() = mapper.lambdaQueryWrapper() + + /** + * 创建[com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper]实例 + * @return LambdaUpdateWrapper Lambda更新包装器实例 + */ + fun lambdaUpdateWrapper() = mapper.lambdaUpdateWrapper() + + + /** + * [queryWrapper]的简写形式 + * @return QueryWrapper 查询包装器实例 + */ + fun qw() = queryWrapper() + + /** + * [updateWrapper]的简写形式 + * @return UpdateWrapper 更新包装器实例 + */ + fun uw() = updateWrapper() + + /** + * [lambdaQueryWrapper]的简写形式 + * @return LambdaQueryWrapper Lambda查询包装器实例 + */ + fun lqw() = lambdaQueryWrapper() + + /** + * [lambdaUpdateWrapper]的简写形式 + * @return LambdaUpdateWrapper Lambda更新包装器实例 + */ + fun luw() = lambdaUpdateWrapper() + + + /** + * 按字符串列名等值条件查询记录列表 + * @param R 列值类型 + * @param column 列名(数据库字段名) + * @param value 列值,执行等值匹配 + * @return List 查询结果列表 + */ + fun selectListByColumn( + column: String, + value: R, + ) = mapper.selectListByColumn(column, value, qw()) + + /** + * 在给定[com.baomidou.mybatisplus.core.conditions.query.QueryWrapper]上追加字符串列名等值条件并查询记录列表 + * @param R 列值类型 + * @param column 列名(数据库字段名) + * @param value 列值,执行等值匹配 + * @param wrapper 承载查询条件的查询包装器 + * @return List 查询结果列表 + */ + fun selectListByColumn( + column: String, + value: R, + wrapper: QueryWrapper, + ) = mapper.selectListByColumn(column, value, wrapper) + + + /** + * 按方法引用列等值条件查询记录列表 + * @param R 列值类型 + * @param column 实体列的方法引用 + * @param value 列值,执行等值匹配 + * @return List 查询结果列表 + */ + fun selectListByColumn( + column: SFunction, + value: R, + ) = mapper.selectListByColumn(column, value, lqw()) + + /** + * 在给定[com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper]上追加方法引用列等值条件并查询记录列表 + * @param R 列值类型 + * @param column 实体列的方法引用 + * @param value 列值,执行等值匹配 + * @param wrapper 承载查询条件的Lambda查询包装器 + * @return List 查询结果列表 + */ + fun selectListByColumn( + column: SFunction, + value: R, + wrapper: LambdaQueryWrapper, + ) = mapper.selectListByColumn(column, value, wrapper) + + /** + * 按方法引用列IN条件查询记录列表,集合为空时直接返回空列表而不执行查询 + * @param R 列值类型 + * @param column 实体列的方法引用 + * @param value 列值集合,执行IN匹配 + * @return List 查询结果列表 + */ + fun selectListByColumn( + column: SFunction, + value: Collection, + ) = mapper.selectListByColumn(column, value, lqw()) + + /** + * 在给定[LambdaQueryWrapper]上追加方法引用列IN条件并查询记录列表,集合为空时直接返回空列表而不执行查询 + * @param R 列值类型 + * @param column 实体列的方法引用 + * @param value 列值集合,执行IN匹配 + * @param wrapper 承载查询条件的Lambda查询包装器 + * @return List 查询结果列表 + */ + fun selectListByColumn( + column: SFunction, + value: Collection, + wrapper: LambdaQueryWrapper = lqw(), + ) = mapper.selectListByColumn(column, value, wrapper) + + /** + * 按字符串列名IN条件查询记录列表,集合为空时直接返回空列表而不执行查询 + * @param R 列值类型 + * @param column 列名(数据库字段名) + * @param value 列值集合,执行IN匹配 + * @return List 查询结果列表 + */ + fun selectListByColumn( + column: String, + value: Collection, + ) = mapper.selectListByColumn(column, value, qw()) + + /** + * 在给定[QueryWrapper]上追加字符串列名IN条件并查询记录列表,集合为空时直接返回空列表而不执行查询 + * @param R 列值类型 + * @param column 列名(数据库字段名) + * @param value 列值集合,执行IN匹配 + * @param wrapper 承载查询条件的查询包装器 + * @return List 查询结果列表 + */ + fun selectListByColumn( + column: String, + value: Collection, + wrapper: QueryWrapper = qw(), + ) = mapper.selectListByColumn(column, value, wrapper) + + /** + * 按多个字符串列名等值条件查询记录列表,各列条件以AND连接 + * @param columns 列名与列值构成的二元组,逐项执行等值匹配 + * @return List 查询结果列表 + */ + fun selectListByColumns( + vararg columns: FastBaseMapper.StringAnyTuple2, + ) = mapper.selectListByColumns(columns = columns) + + /** + * 按多个方法引用列等值条件查询记录列表,各列条件以AND连接 + * @param columns 方法引用列与列值构成的二元组,逐项执行等值匹配 + * @return List 查询结果列表 + */ + fun selectListByColumns( + vararg columns: FastBaseMapper.SFunctionAnyTuple2, + ) = mapper.selectListByColumns(lqw(), columns = columns) + + /** + * 在给定[LambdaQueryWrapper]上追加多个方法引用列等值条件并查询记录列表,各列条件以AND连接 + * @param wrapper 承载查询条件的Lambda查询包装器 + * @param columns 方法引用列与列值构成的二元组,逐项执行等值匹配 + * @return List 查询结果列表 + */ + fun selectListByColumns( + wrapper: LambdaQueryWrapper, + vararg columns: FastBaseMapper.SFunctionAnyTuple2, + ) = mapper.selectListByColumns(wrapper = wrapper, columns = columns) + + /** + * 按字符串列名等值条件查询单条记录,结果数量不为1时返回null + * @param R 列值类型 + * @param column 列名(数据库字段名) + * @param value 列值,执行等值匹配 + * @return T? 唯一的查询结果,不存在或多于一条时返回null + */ + fun selectOneByColumn( + column: String, + value: R, + ) = mapper.selectOneByColumn(column, value, qw()) + + /** + * 在给定[QueryWrapper]上追加字符串列名等值条件并查询单条记录,结果数量不为1时返回null + * @param R 列值类型 + * @param column 列名(数据库字段名) + * @param value 列值,执行等值匹配 + * @param wrapper 承载查询条件的查询包装器 + * @return T? 唯一的查询结果,不存在或多于一条时返回null + */ + fun selectOneByColumn( + column: String, + value: R, + wrapper: QueryWrapper = qw(), + ) = mapper.selectOneByColumn( + column, value, wrapper + ) + + + /** + * 按方法引用列等值条件查询单条记录,结果数量不为1时返回null + * @param R 列值类型 + * @param column 实体列的方法引用 + * @param value 列值,执行等值匹配 + * @return T? 唯一的查询结果,不存在或多于一条时返回null + */ + fun selectOneByColumn( + column: SFunction, + value: R, + ) = selectOneByColumn( + column, value, lqw() + ) + + /** + * 在给定[LambdaQueryWrapper]上追加方法引用列等值条件并查询单条记录,结果数量不为1时返回null + * @param R 列值类型 + * @param column 实体列的方法引用 + * @param value 列值,执行等值匹配 + * @param wrapper 承载查询条件的Lambda查询包装器 + * @return T? 唯一的查询结果,不存在或多于一条时返回null + */ + fun selectOneByColumn( + column: SFunction, + value: R, + wrapper: LambdaQueryWrapper, + ) = mapper.selectOneByColumn( + column, value, wrapper + ) + + /** + * 按字符串列名等值条件判断记录是否存在 + * @param R 列值类型 + * @param column 列名(数据库字段名) + * @param value 列值,执行等值匹配 + * @return Boolean 存在符合条件的记录返回true,否则返回false + */ + fun existsByColumn( + column: String, + value: R, + ) = mapper.existsByColumn(column, value, qw()) + + /** + * 在给定[QueryWrapper]上追加字符串列名等值条件并判断记录是否存在 + * @param R 列值类型 + * @param column 列名(数据库字段名) + * @param value 列值,执行等值匹配 + * @param wrapper 承载查询条件的查询包装器 + * @return Boolean 存在符合条件的记录返回true,否则返回false + */ + fun existsByColumn( + column: String, + value: R, + wrapper: QueryWrapper = qw(), + ) = mapper.existsByColumn( + column, value, wrapper + ) + + /** + * 按方法引用列等值条件判断记录是否存在 + * @param R 列值类型 + * @param column 实体列的方法引用 + * @param value 列值,执行等值匹配 + * @return Boolean 存在符合条件的记录返回true,否则返回false + */ + fun existsByColumn( + column: SFunction, + value: R, + ) = mapper.existsByColumn(column, value, lqw()) + + /** + * 在给定[LambdaQueryWrapper]上追加方法引用列等值条件并判断记录是否存在 + * @param R 列值类型 + * @param column 实体列的方法引用 + * @param value 列值,执行等值匹配 + * @param wrapper 承载查询条件的Lambda查询包装器 + * @return Boolean 存在符合条件的记录返回true,否则返回false + */ + fun existsByColumn( + column: SFunction, + value: R, + wrapper: LambdaQueryWrapper = lqw(), + ) = mapper.existsByColumn( + column, value, wrapper + ) + + /** + * 按方法引用列IN条件查询记录并构建有序映射,集合为空时直接返回空映射而不执行查询 + * 返回的[LinkedHashMap]保持入参集合的迭代顺序,缺失的键对应的值为null + * @param R 列值类型 + * @param column 实体列的方法引用 + * @param value 列值集合,执行IN匹配 + * @return LinkedHashMap 以列值为键、实体为值的有序映射 + */ + fun selectMapByColumn( + column: SFunction, + value: Collection, + ) = mapper.selectMapByColumn(column, value, lqw()) + + + /** + * 在给定[LambdaQueryWrapper]上按方法引用列IN条件查询记录并构建有序映射,集合为空时直接返回空映射而不执行查询 + * 返回的[LinkedHashMap]保持入参集合的迭代顺序,缺失的键对应的值为null + * @param R 列值类型 + * @param column 实体列的方法引用 + * @param value 列值集合,执行IN匹配 + * @param wrapper 承载查询条件的Lambda查询包装器 + * @return LinkedHashMap 以列值为键、实体为值的有序映射 + */ + fun selectMapByColumn( + column: SFunction, + value: Collection, + wrapper: LambdaQueryWrapper = lqw(), + ) = mapper.selectMapByColumn(column, value, wrapper) + + /** + * 按字符串列名IN条件删除记录,集合为空时直接返回0而不执行删除 + * @param R 列值类型 + * @param column 列名(数据库字段名) + * @param value 列值集合,执行IN匹配 + * @return Int 被删除的行数 + */ + fun deleteByColumn( + column: String, + value: Collection, + ) = mapper.deleteByColumn(column, value, qw()) + + /** + * 在给定[QueryWrapper]上按字符串列名IN条件删除记录,集合为空时直接返回0而不执行删除 + * 注意:MyBatis-Plus对空集合的IN条件会整体跳过,若不拦截将导致全表删除 + * @param R 列值类型 + * @param column 列名(数据库字段名) + * @param value 列值集合,执行IN匹配 + * @param wrapper 承载查询条件的查询包装器 + * @return Int 被删除的行数 + */ + fun deleteByColumn( + column: String, + value: Collection, + wrapper: QueryWrapper = qw(), + ) = mapper.deleteByColumn(column, value, wrapper) + + /** + * 按方法引用列IN条件删除记录,集合为空时直接返回0而不执行删除 + * @param R 列值类型 + * @param column 实体列的方法引用 + * @param value 列值集合,执行IN匹配 + * @return Int 被删除的行数 + */ + fun deleteByColumn( + column: SFunction, + value: Collection, + ) = mapper.deleteByColumn(column, value, lqw()) + + /** + * 在给定[LambdaQueryWrapper]上按方法引用列IN条件删除记录,集合为空时直接返回0而不执行删除 + * 注意:MyBatis-Plus对空集合的IN条件会整体跳过,若不拦截将导致全表删除 + * @param R 列值类型 + * @param column 实体列的方法引用 + * @param value 列值集合,执行IN匹配 + * @param wrapper 承载查询条件的Lambda查询包装器 + * @return Int 被删除的行数 + */ + fun deleteByColumn( + column: SFunction, + value: Collection, + wrapper: LambdaQueryWrapper, + ) = mapper.deleteByColumn(column, value, wrapper) + + companion object { + + /** + * 为[FastBaseIService]绑定的实体类型创建[com.baomidou.mybatisplus.extension.kotlin.KtQueryWrapper]实例 + * @param T 实体类型,必须继承自Any,通过reified获取实际类型 + * @param MP 基础映射器类型,必须继承自[FastBaseMapper] + * @receiver FastBaseIService 快速服务实例 + * @return KtQueryWrapper Kotlin查询包装器实例,使用T类作为参数 + */ + inline fun > FastBaseIService.ktQueryWrapper(): KtQueryWrapper = + KtQueryWrapper(T::class.java) + + /** + * 为[FastBaseIService]绑定的实体类型创建[com.baomidou.mybatisplus.extension.kotlin.KtQueryChainWrapper]实例 + * @param T 实体类型,必须继承自Any,通过reified获取实际类型 + * @param MP 基础映射器类型,必须继承自[FastBaseMapper] + * @receiver FastBaseIService 快速服务实例 + * @return KtQueryChainWrapper Kotlin查询链式包装器实例,使用T类作为参数 + */ + inline fun > FastBaseIService.ktQueryChainWrapper(): KtQueryChainWrapper = + KtQueryChainWrapper(T::class.java) + + /** + * 为[FastBaseIService]绑定的实体类型创建[com.baomidou.mybatisplus.extension.kotlin.KtUpdateWrapper]实例 + * @param T 实体类型,必须继承自Any,通过reified获取实际类型 + * @param MP 基础映射器类型,必须继承自[FastBaseMapper] + * @receiver FastBaseIService 快速服务实例 + * @return KtUpdateWrapper Kotlin更新包装器实例,使用T类作为参数 + */ + inline fun > FastBaseIService.ktUpdateWrapper(): KtUpdateWrapper = + KtUpdateWrapper(T::class.java) + + /** + * 为[FastBaseIService]绑定的实体类型创建[com.baomidou.mybatisplus.extension.kotlin.KtUpdateChainWrapper]实例 + * @param T 实体类型,必须继承自Any,通过reified获取实际类型 + * @param MP 基础映射器类型,必须继承自[FastBaseMapper] + * @receiver FastBaseIService 快速服务实例 + * @return KtUpdateChainWrapper Kotlin更新链式包装器实例,使用T类作为参数 + */ + inline fun > FastBaseIService.ktUpdateChainWrapper(): KtUpdateChainWrapper = + KtUpdateChainWrapper(T::class.java) + + /** + * 创建绑定当前映射器的[KtQueryChainWrapper]实例 + * 与[ktQueryChainWrapper]不同,该链式包装器持有映射器引用,可直接调用`list`/`one`/`page`等方法执行查询 + * @param T 实体类型,必须继承自Any + * @param MP 基础映射器类型,必须继承自[FastBaseMapper] + * @receiver FastBaseIService 快速服务实例 + * @return KtQueryChainWrapper 可执行的Kotlin查询链式包装器实例 + */ + fun > FastBaseIService.ktQueryChain(): KtQueryChainWrapper = + this.mapper.ktQueryChain() + + /** + * 创建绑定当前映射器的[KtUpdateChainWrapper]实例 + * 与[ktUpdateChainWrapper]不同,该链式包装器持有映射器引用,可直接调用`update`/`remove`等方法执行操作 + * @param T 实体类型,必须继承自Any + * @param MP 基础映射器类型,必须继承自[FastBaseMapper] + * @receiver FastBaseIService 快速服务实例 + * @return KtUpdateChainWrapper 可执行的Kotlin更新链式包装器实例 + */ + fun > FastBaseIService.ktUpdateChain(): KtUpdateChainWrapper = + this.mapper.ktUpdateChain() + + /** + * [ktQueryWrapper]的简写形式 + * @param T 实体类型,必须继承自Any,通过reified获取实际类型 + * @param MP 基础映射器类型,必须继承自[FastBaseMapper] + * @receiver FastBaseIService 快速服务实例 + * @return KtQueryWrapper Kotlin查询包装器实例,使用T类作为参数 + */ + inline fun > FastBaseIService.kqw(): KtQueryWrapper = + this.mapper.ktQueryWrapper() + + /** + * [ktUpdateWrapper]的简写形式 + * @param T 实体类型,必须继承自Any,通过reified获取实际类型 + * @param MP 基础映射器类型,必须继承自[FastBaseMapper] + * @receiver FastBaseIService 快速服务实例 + * @return KtUpdateWrapper Kotlin更新包装器实例,使用T类作为参数 + */ + inline fun > FastBaseIService.kuw(): KtUpdateWrapper = + this.mapper.ktUpdateWrapper() + + /** + * [ktQueryChainWrapper]的简写形式 + * @param T 实体类型,必须继承自Any,通过reified获取实际类型 + * @param MP 基础映射器类型,必须继承自[FastBaseMapper] + * @receiver FastBaseIService 快速服务实例 + * @return KtQueryChainWrapper Kotlin查询链式包装器实例,使用T类作为参数 + */ + inline fun > FastBaseIService.kqcw(): KtQueryChainWrapper = + this.mapper.ktQueryChainWrapper() + + /** + * [ktUpdateChainWrapper]的简写形式 + * @param T 实体类型,必须继承自Any,通过reified获取实际类型 + * @param MP 基础映射器类型,必须继承自[FastBaseMapper] + * @receiver FastBaseIService 快速服务实例 + * @return KtUpdateChainWrapper Kotlin更新链式包装器实例,使用T类作为参数 + */ + inline fun > FastBaseIService.kucw(): KtUpdateChainWrapper = + this.mapper.ktUpdateChainWrapper() + + /** + * 通过Lambda构建[KtUpdateWrapper]并执行更新 + * @param T 实体类型,必须继承自Any,通过reified获取实际类型 + * @param MP 基础映射器类型,必须继承自[FastBaseMapper] + * @receiver FastBaseIService 快速服务实例 + * @param funs 更新包装器构建函数,返回构建完成的更新包装器 + * @return Int 受影响的行数 + */ + inline fun > FastBaseIService.update(funs: (wrapper: KtUpdateWrapper) -> KtUpdateWrapper) = + mapper.update(funs) + + /** + * 通过Lambda构建[KtUpdateWrapper]并携带实体执行更新 + * @param T 实体类型,必须继承自Any,通过reified获取实际类型 + * @param MP 基础映射器类型,必须继承自[FastBaseMapper] + * @receiver FastBaseIService 快速服务实例 + * @param entity 承载待更新字段值的实体对象 + * @param funs 更新包装器构建函数,返回构建完成的更新包装器 + * @return Int 受影响的行数 + */ + inline fun > FastBaseIService.update( + entity: T, + funs: (wrapper: KtUpdateWrapper) -> KtUpdateWrapper, + ) = mapper.update(entity, funs) + + /** + * 通过Lambda构建[KtQueryWrapper]并执行查询 + * @param T 实体类型,必须继承自Any,通过reified获取实际类型 + * @param MP 基础映射器类型,必须继承自[FastBaseMapper] + * @receiver FastBaseIService 快速服务实例 + * @param funs 查询包装器构建函数,返回构建完成的查询包装器 + * @return List 查询结果列表 + */ + inline fun > FastBaseIService.selectList(funs: (wrapper: KtQueryWrapper) -> KtQueryWrapper) = + mapper.selectList(funs) + + /** + * 通过Lambda构建[KtQueryWrapper]并执行分页查询 + * @param T 实体类型,必须继承自Any,通过reified获取实际类型 + * @param MP 基础映射器类型,必须继承自[FastBaseMapper] + * @receiver FastBaseIService 快速服务实例 + * @param page 分页参数对象 + * @param funs 查询包装器构建函数,返回构建完成的查询包装器 + * @return Page 分页查询结果 + */ + inline fun > FastBaseIService.selectPage( + page: Page, + funs: (wrapper: KtQueryWrapper) -> KtQueryWrapper = { it }, + ) = mapper.selectPage(page, funs) + + /** + * 通过页码与每页大小直接执行分页查询 + * @param T 实体类型,必须继承自Any,通过reified获取实际类型 + * @param MP 基础映射器类型,必须继承自[FastBaseMapper] + * @receiver FastBaseIService 快速服务实例 + * @param current 当前页码,从1开始 + * @param size 每页记录数 + * @param funs 查询包装器构建函数,返回构建完成的查询包装器 + * @return Page 分页查询结果 + */ + inline fun > FastBaseIService.selectPage( + current: Long, + size: Long, + funs: (wrapper: KtQueryWrapper) -> KtQueryWrapper = { it }, + ) = mapper.selectPage( + current, size, funs + ) + + /** + * 通过Lambda构建[KtQueryWrapper]并查询单条记录 + * 结果数量不为1时返回null,不抛出异常 + * @param T 实体类型,必须继承自Any,通过reified获取实际类型 + * @param MP 基础映射器类型,必须继承自[FastBaseMapper] + * @receiver FastBaseIService 快速服务实例 + * @param funs 查询包装器构建函数,返回构建完成的查询包装器 + * @return T? 唯一的查询结果,不存在或多于一条时返回null + */ + inline fun > FastBaseIService.selectOne(funs: (wrapper: KtQueryWrapper) -> KtQueryWrapper) = + mapper.selectOne(funs) + + /** + * 通过Lambda构建[KtQueryWrapper]并统计记录数 + * @param T 实体类型,必须继承自Any,通过reified获取实际类型 + * @param MP 基础映射器类型,必须继承自[FastBaseMapper] + * @receiver FastBaseIService 快速服务实例 + * @param funs 查询包装器构建函数,返回构建完成的查询包装器 + * @return Long 符合条件的记录总数 + */ + inline fun > FastBaseIService.selectCount(funs: (wrapper: KtQueryWrapper) -> KtQueryWrapper) = + mapper.selectCount(funs) + + /** + * 通过Lambda构建[KtQueryWrapper]并判断记录是否存在 + * @param T 实体类型,必须继承自Any,通过reified获取实际类型 + * @param MP 基础映射器类型,必须继承自[FastBaseMapper] + * @receiver FastBaseIService 快速服务实例 + * @param funs 查询包装器构建函数,返回构建完成的查询包装器 + * @return Boolean 存在符合条件的记录返回true,否则返回false + */ + inline fun > FastBaseIService.exists(funs: (wrapper: KtQueryWrapper) -> KtQueryWrapper) = + mapper.exists(funs) + + /** + * 通过Lambda构建[KtQueryWrapper]并执行删除 + * @param T 实体类型,必须继承自Any,通过reified获取实际类型 + * @param MP 基础映射器类型,必须继承自[FastBaseMapper] + * @receiver FastBaseIService 快速服务实例 + * @param funs 查询包装器构建函数,返回构建完成的查询包装器 + * @return Int 被删除的行数 + */ + inline fun > FastBaseIService.delete(funs: (wrapper: KtQueryWrapper) -> KtQueryWrapper) = + mapper.delete( + funs + ) + + /** + * 按单列等值条件查询记录列表 + * @param T 实体类型,必须继承自Any,通过reified获取实际类型 + * @param MP 基础映射器类型,必须继承自[FastBaseMapper] + * @param R 列值类型 + * @receiver FastBaseIService 快速服务实例 + * @param column 实体列属性引用 + * @param value 列值,执行等值匹配 + * @param funs 附加查询包装器构建函数,在等值条件之前应用 + * @return List 查询结果列表 + */ + inline fun , R> FastBaseIService.selectListByColumn( + column: KProperty1, + value: R, + funs: (w: KtQueryWrapper) -> KtQueryWrapper = { it }, + ) = mapper.selectListByColumn( + column, value, funs + ) + + /** + * 按单列IN条件查询记录列表,集合为空时直接返回空列表而不执行查询 + * @param T 实体类型,必须继承自Any,通过reified获取实际类型 + * @param MP 基础映射器类型,必须继承自[FastBaseMapper] + * @param R 列值类型 + * @receiver FastBaseIService 快速服务实例 + * @param column 实体列属性引用 + * @param value 列值集合,执行IN匹配 + * @param funs 附加查询包装器构建函数,在IN条件之前应用 + * @return List 查询结果列表 + */ + inline fun , R> FastBaseIService.selectListByColumn( + column: KProperty1, + value: Collection, + funs: (w: KtQueryWrapper) -> KtQueryWrapper = { it }, + ) = mapper.selectListByColumn( + column, value, funs + ) + + /** + * 按多列等值条件查询记录列表 + * @param T 实体类型,必须继承自Any,通过reified获取实际类型 + * @param MP 基础映射器类型,必须继承自[FastBaseMapper] + * @receiver FastBaseIService 快速服务实例 + * @param columns 列属性引用与列值的键值对,逐项执行等值匹配 + * @param funs 附加查询包装器构建函数,在各列等值条件之前应用 + * @return List 查询结果列表 + */ + inline fun > FastBaseIService.selectListByColumns( + vararg columns: Pair, Any?>, + funs: (w: KtQueryWrapper) -> KtQueryWrapper = { it }, + ) = mapper.selectListByColumns(columns = columns, funs) + + /** + * 按单列等值条件查询单条记录,结果数量不为1时返回null + * @param T 实体类型,必须继承自Any,通过reified获取实际类型 + * @param MP 基础映射器类型,必须继承自[FastBaseMapper] + * @param R 列值类型 + * @receiver FastBaseIService 快速服务实例 + * @param column 实体列属性引用 + * @param value 列值,执行等值匹配 + * @param funs 附加查询包装器构建函数,在等值条件之前应用 + * @return T? 唯一的查询结果,不存在或多于一条时返回null + */ + inline fun , R> FastBaseIService.selectOneByColumn( + column: KProperty1, + value: R, + funs: (w: KtQueryWrapper) -> KtQueryWrapper = { it }, + ) = mapper.selectOneByColumn( + column, value, funs + ) + + /** + * 按单列等值条件判断记录是否存在 + * @param T 实体类型,必须继承自Any,通过reified获取实际类型 + * @param MP 基础映射器类型,必须继承自[FastBaseMapper] + * @param R 列值类型 + * @receiver FastBaseIService 快速服务实例 + * @param column 实体列属性引用 + * @param value 列值,执行等值匹配 + * @param funs 附加查询包装器构建函数,在等值条件之前应用 + * @return Boolean 存在符合条件的记录返回true,否则返回false + */ + inline fun , R> FastBaseIService.existsByColumn( + column: KProperty1, + value: R, + funs: (w: KtQueryWrapper) -> KtQueryWrapper = { it }, + ) = mapper.existsByColumn( + column, value, funs + ) + + /** + * 按单列IN条件查询记录并构建有序映射,集合为空时直接返回空映射而不执行查询 + * 返回的[LinkedHashMap]保持入参集合的迭代顺序,缺失的键对应的值为null + * @param T 实体类型,必须继承自Any,通过reified获取实际类型 + * @param MP 基础映射器类型,必须继承自[FastBaseMapper] + * @param R 列值类型 + * @receiver FastBaseIService 快速服务实例 + * @param column 实体列属性引用 + * @param value 列值集合,执行IN匹配 + * @param funs 附加查询包装器构建函数,在IN条件之前应用 + * @return LinkedHashMap 以列值为键、实体为值的有序映射 + */ + inline fun , R> FastBaseIService.selectMapByColumn( + column: KProperty1, + value: Collection, + funs: (w: KtQueryWrapper) -> KtQueryWrapper = { it }, + ) = mapper.selectMapByColumn( + column, value, funs + ) + + /** + * 按单列等值条件删除记录 + * @param T 实体类型,必须继承自Any,通过reified获取实际类型 + * @param MP 基础映射器类型,必须继承自[FastBaseMapper] + * @param R 列值类型 + * @receiver FastBaseIService 快速服务实例 + * @param column 实体列属性引用 + * @param value 列值,执行等值匹配 + * @param funs 附加查询包装器构建函数,在等值条件之前应用 + * @return Int 被删除的行数 + */ + inline fun , R> FastBaseIService.deleteByColumn( + column: KProperty1, + value: R, + funs: (w: KtQueryWrapper) -> KtQueryWrapper = { it }, + ) = mapper.deleteByColumn(column, value, funs) + + /** + * 按单列IN条件删除记录,集合为空时直接返回0而不执行删除 + * 注意:MyBatis-Plus对空集合的IN条件会整体跳过,若不拦截将导致全表删除 + * @param T 实体类型,必须继承自Any,通过reified获取实际类型 + * @param MP 基础映射器类型,必须继承自[FastBaseMapper] + * @param R 列值类型 + * @receiver FastBaseIService 快速服务实例 + * @param column 实体列属性引用 + * @param value 列值集合,执行IN匹配 + * @param funs 附加查询包装器构建函数,在IN条件之前应用 + * @return Int 被删除的行数 + */ + inline fun , R> FastBaseIService.deleteByColumn( + column: KProperty1, + value: Collection, + funs: (w: KtQueryWrapper) -> KtQueryWrapper = { it }, + ) = mapper.deleteByColumn(column, value, funs) + } +} diff --git a/src/main/kotlin/com/mingliqiye/utils/mybatisplus/FastBaseMapper.kt b/src/main/kotlin/com/mingliqiye/utils/mybatisplus/FastBaseMapper.kt index 6e46d67..7c0567f 100644 --- a/src/main/kotlin/com/mingliqiye/utils/mybatisplus/FastBaseMapper.kt +++ b/src/main/kotlin/com/mingliqiye/utils/mybatisplus/FastBaseMapper.kt @@ -13,10 +13,10 @@ * See the License for the specific language governing permissions and * limitations under the License. * - * ProjectName FastBaseMapper.kt + * ProjectName mingli-utils * ModuleName mingli-utils.main * CurrentFile FastBaseMapper.kt - * LastUpdate 2026-10-27 10:23:10 + * LastUpdate 2026-10-28 22:23:47 * UpdateUser MingLiPro */ @@ -37,6 +37,7 @@ import com.mingliqiye.utils.mybatisplus.FastBaseMapper.Companion.ktQueryChainWra import com.mingliqiye.utils.mybatisplus.FastBaseMapper.Companion.ktQueryWrapper import com.mingliqiye.utils.mybatisplus.FastBaseMapper.Companion.ktUpdateChainWrapper import com.mingliqiye.utils.mybatisplus.FastBaseMapper.Companion.ktUpdateWrapper +import com.mingliqiye.utils.mybatisplus.FastBaseMapper.Companion.selectListByColumns import com.mingliqiye.utils.tuple.Tuple import kotlin.reflect.KProperty1 @@ -786,8 +787,8 @@ interface FastBaseMapper : BaseMapper { */ inline fun FastBaseMapper.existsByColumn( column: KProperty1, - funs: (w: KtQueryWrapper) -> KtQueryWrapper = { it }, value: R, + funs: (w: KtQueryWrapper) -> KtQueryWrapper = { it }, ): Boolean = exists { wrapper: KtQueryWrapper -> funs(wrapper).eq(column, value) } diff --git a/src/main/kotlin/com/mingliqiye/utils/springboot/autoconfigure/JacksonJsonAutoConfiguration.kt b/src/main/kotlin/com/mingliqiye/utils/springboot/autoconfigure/JacksonJsonAutoConfiguration.kt index e21a27d..008a816 100644 --- a/src/main/kotlin/com/mingliqiye/utils/springboot/autoconfigure/JacksonJsonAutoConfiguration.kt +++ b/src/main/kotlin/com/mingliqiye/utils/springboot/autoconfigure/JacksonJsonAutoConfiguration.kt @@ -13,23 +13,24 @@ * See the License for the specific language governing permissions and * limitations under the License. * - * ProjectName FastBaseMapper.kt + * ProjectName mingli-utils * ModuleName mingli-utils.main * CurrentFile JacksonJsonAutoConfiguration.kt - * LastUpdate 2026-10-26 23:22:18 + * LastUpdate 2026-10-28 23:30:03 * UpdateUser MingLiPro */ package com.mingliqiye.utils.springboot.autoconfigure -import com.fasterxml.jackson.databind.ObjectMapper import com.mingliqiye.utils.json.converters.DateTimeJsonConverter import com.mingliqiye.utils.json.converters.UUIDJsonConverter import com.mingliqiye.utils.json.converters.base.getJacksonModule 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.autoconfigure.jackson.Jackson2ObjectMapperBuilderCustomizer +import org.springframework.context.annotation.Bean /** * Jackson 2 的序列化模块自动配置(过渡兼容)。 @@ -60,16 +61,32 @@ import org.springframework.boot.autoconfigure.jackson.Jackson2ObjectMapperBuilde */ @ConditionalOnClass(name = ["com.fasterxml.jackson.databind.ObjectMapper", "org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration"]) @AutoConfigureAfter(name = ["org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration"]) -open class JacksonJsonAutoConfiguration(objectMapper: ObjectMapper) { +open class JacksonJsonAutoConfiguration { companion object { private val log = MingLiLoggerFactory.getLogger() } - init { - objectMapper.registerModule(DateTimeJsonConverter.getJsonConverter().getJacksonModule()) - objectMapper.registerModule(UUIDJsonConverter.getJsonConverter().getJacksonModule()) - log.info("MingliUtils JacksonModule UUID,DateTime Serializers created") + @Bean("DateTimeJsonConverterJackson2ObjectMapperBuilderCustomizer") + @ConditionalOnMissingBean(name = ["DateTimeJsonConverterJackson2ObjectMapperBuilderCustomizer"]) + fun getDateTimeJsonConverterJackson2ObjectMapperBuilderCustomizer() = Jackson2ObjectMapperBuilderCustomizer { + log.info( + "MingliUtils Jackson2 DateTime Serializers created" + ) + it.modulesToInstall { modules -> + modules.add(DateTimeJsonConverter.getJsonConverter().getJacksonModule()) + } + } + + @Bean("UUIDJsonConverterJackson2ObjectMapperBuilderCustomizer") + @ConditionalOnMissingBean(name = ["UUIDJsonConverterJackson2ObjectMapperBuilderCustomizer"]) + fun getUUIDJsonConverterJackson2ObjectMapperBuilderCustomizer() = Jackson2ObjectMapperBuilderCustomizer { + log.info( + "MingliUtils Jackson2 UUID Serializers created" + ) + it.modulesToInstall { modules -> + modules.add(UUIDJsonConverter.getJsonConverter().getJacksonModule()) + } } } diff --git a/src/main/kotlin/com/mingliqiye/utils/springboot/bean/SpringBeanUtils.kt b/src/main/kotlin/com/mingliqiye/utils/springboot/bean/SpringBeanUtils.kt index acc9483..da27278 100644 --- a/src/main/kotlin/com/mingliqiye/utils/springboot/bean/SpringBeanUtils.kt +++ b/src/main/kotlin/com/mingliqiye/utils/springboot/bean/SpringBeanUtils.kt @@ -16,7 +16,7 @@ * ProjectName mingli-utils * ModuleName mingli-utils.main * CurrentFile SpringBeanUtils.kt - * LastUpdate 2026-10-02 16:18:14 + * LastUpdate 2026-10-27 12:51:22 * UpdateUser MingLiPro */ @@ -44,6 +44,12 @@ class SpringBeanUtils : ApplicationContextAware { private var applicationContextBase: ApplicationContext? = null + inline fun lazyBean(): Lazy = lazy(::getBean) + + inline fun lazyBean(name: String): Lazy = lazy { + getBean(name, T::class.java) + } + @Throws(BeansException::class) inline fun getBean() = getBean(T::class.java) diff --git a/src/main/kotlin/com/mingliqiye/utils/system/SystemUtil.kt b/src/main/kotlin/com/mingliqiye/utils/system/SystemUtil.kt index f3e1dfc..57c855b 100644 --- a/src/main/kotlin/com/mingliqiye/utils/system/SystemUtil.kt +++ b/src/main/kotlin/com/mingliqiye/utils/system/SystemUtil.kt @@ -16,7 +16,7 @@ * ProjectName mingli-utils * ModuleName mingli-utils.main * CurrentFile SystemUtil.kt - * LastUpdate 2026-10-20 18:54:24 + * LastUpdate 2026-10-28 22:43:54 * UpdateUser MingLiPro */ @file:JvmName("SystemUtils") @@ -30,8 +30,7 @@ import com.mingliqiye.utils.random.Random.nextBytes as randomByte private val UNIX_PREFIXES = arrayOf("Linux", "AIX", "SunOS", "Mac OS X", "FreeBSD") private val HEX_UPPER: Array = Array(256) { "%02X".format(it) } -private fun Enumeration?.toList(): List = - if (this == null) emptyList() else Collections.list(this) +private fun Enumeration?.toList(): List = if (this == null) emptyList() else Collections.list(this) /** * 操作系统名称属性,延迟初始化 @@ -85,8 +84,7 @@ val javaVersionAsInteger: Int by lazy { } val normalized = if (version.startsWith("1.")) version.substring(2) else version val major = normalized.substringBefore('.').substringBefore('-') - major.toIntOrNull() - ?: throw IllegalStateException("Invalid Java version format: $version") + major.toIntOrNull() ?: throw IllegalStateException("Invalid Java version format: $version") } /** @@ -103,12 +101,8 @@ val isJdk8Plus: Boolean by lazy { */ val localIps: Array by lazy { try { - activeNetworkInterfaces() - .flatMap { it.inetAddresses.toList() } - .filterIsInstance() - .mapNotNull { it.hostAddress } - .toList() - .toTypedArray() + activeNetworkInterfaces().flatMap { it.inetAddresses.toList() }.filterIsInstance() + .mapNotNull { it.hostAddress }.toList().toTypedArray() } catch (e: SocketException) { throw RuntimeException("Failed to get local IP addresses", e) } @@ -124,13 +118,8 @@ val localIpsByList: List by lazy { localIps.toList() } */ val loopbackIps: Array by lazy { try { - NetworkInterface.getNetworkInterfaces().toList() - .asSequence() - .filter { it.isLoopback && it.isUp } - .flatMap { it.inetAddresses.toList().asSequence() } - .mapNotNull { it.hostAddress } - .toList() - .toTypedArray() + NetworkInterface.getNetworkInterfaces().toList().asSequence().filter { it.isLoopback && it.isUp } + .flatMap { it.inetAddresses.toList().asSequence() }.mapNotNull { it.hostAddress }.toList().toTypedArray() } catch (_: SocketException) { arrayOf("127.0.0.1") } @@ -160,20 +149,16 @@ val pidAsString: String by lazy { * 计算机名;获取失败返回 "unknown" */ val computerName: String by lazy { - getEnvVar("COMPUTERNAME") - ?: getEnvVar("HOSTNAME") - ?: runCatching { InetAddress.getLocalHost().hostName }.getOrNull()?.takeIf { it.isNotBlank() } - ?: "unknown" + getEnvVar("COMPUTERNAME") ?: getEnvVar("HOSTNAME") + ?: runCatching { InetAddress.getLocalHost().hostName }.getOrNull()?.takeIf { it.isNotBlank() } ?: "unknown" } /** * 当前用户名;获取失败返回 "unknown" */ val userName: String by lazy { - getEnvVar("USERNAME") - ?: getEnvVar("USER") - ?: runCatching { System.getProperty("user.name") }.getOrNull()?.takeIf { it.isNotBlank() } - ?: "unknown" + getEnvVar("USERNAME") ?: getEnvVar("USER") ?: runCatching { System.getProperty("user.name") }.getOrNull() + ?.takeIf { it.isNotBlank() } ?: "unknown" } private fun getEnvVar(name: String): String? = runCatching { @@ -187,8 +172,7 @@ private fun getEnvVar(name: String): String? = runCatching { */ val macAddressBytes: ByteArray by lazy { val found = try { - activeNetworkInterfaces() - .mapNotNull { runCatching { it.hardwareAddress }.getOrNull() } + activeNetworkInterfaces().mapNotNull { runCatching { it.hardwareAddress }.getOrNull() } .firstOrNull { it.isNotEmpty() } } catch (_: SocketException) { null @@ -215,14 +199,11 @@ val macAddressFormattedString: String by lazy { */ val allMacAddresses: Map by lazy { try { - NetworkInterface.getNetworkInterfaces().toList() - .asSequence() - .filter { !it.isLoopback && !it.isVirtual } + NetworkInterface.getNetworkInterfaces().toList().asSequence().filter { !it.isLoopback && !it.isVirtual } .mapNotNull { ni -> val mac = runCatching { ni.hardwareAddress }.getOrNull() if (mac != null && mac.isNotEmpty()) ni.name to mac else null - } - .toMap() + }.toMap() } catch (_: SocketException) { emptyMap() } @@ -243,17 +224,15 @@ val availableProcessors: Int by lazy { } private fun activeNetworkInterfaces(): Sequence = - NetworkInterface.getNetworkInterfaces().toList().asSequence() - .filter { !it.isLoopback && !it.isVirtual && it.isUp } + NetworkInterface.getNetworkInterfaces().toList().asSequence().filter { !it.isLoopback && !it.isVirtual && it.isUp } private val protocol: String by lazy { val target = ProtocolAnchor::class.java val resourceName = target.simpleName + ".class" - val resource: URL = target.getResource(resourceName) - ?: throw IllegalStateException( - "Unable to locate resource '$resourceName' for class ${target.name}" - ) + val resource: URL = target.getResource(resourceName) ?: throw IllegalStateException( + "Unable to locate resource '$resourceName' for class ${target.name}" + ) resource.protocol } @@ -282,5 +261,13 @@ val isJswarMode: Boolean get() = protocol == "jswar" /** 是否不为 JSWAR 模式 */ val isNotJswarMode: Boolean get() = protocol != "jswar" +val lineSeparator + get() = System.lineSeparator() + +const val lineSeparatorLF = "\n" + +const val lineSeparatorCR = "\r" + +const val lineSeparatorCRLF = lineSeparatorCR + lineSeparatorLF private object ProtocolAnchor