Compare commits

..
Author SHA1 Message Date
minglipro 77d60b38fc refactor(autoconfigure): 重构自动配置并添加 Jackson 支持- 重新组织 AutoConfiguration 类结构,优化初始化逻辑
- 新增 JacksonAutoConfiguration 类,专门处理 Jackson 相关配置
- 更新版本号至 3.1.1
- 为 SimpleModule 设置自定义名称
- 移除冗余代码,提高代码可读性和维护性
2025-09-11 14:34:46 +08:00
minglipro 5bf5cf9c7f build(dependencies): 更新项目依赖并升级版本号
- 更新 jakarta.annotation 为 2.1.1 版本
- 移除 javax.annotation.PostConstruct,使用 jakarta.annotation.PostConstruct 替代- 将项目版本号从3.0.7 升级到 3.1.0
2025-09-11 13:54:25 +08:00
minglipro 741ced2ffc refactor(uuid): 更新 UUID 类型处理器并调整包结构
-将 UUIDBinaryTypeHandler 和 UUIDStringTypeHandler 重命名为特定数据库的实现
- 创建 mysql 和 pgsql 包以区分不同数据库的实现
- 更新版本号至 3.0.7
2025-09-11 10:00:03 +08:00
minglipro 1a9553b55d refactor(utils): 重构工具类并添加新功能
- 重构了 AutoConfiguration 类,更新了组件扫描路径
- 优化了 Collection 类中的 getOrDefault 方法,增加了对非 List 集合的支持- 添加了 DateTime 类的高精度时间处理功能
- 新增了 DateTimeToStringConverter 类,用于将 DateTime 转换为字符串
- 更新了 ForEach 类中的遍历方法,提高了代码可读性和性能
2025-09-11 09:46:03 +08:00
28 changed files with 2171 additions and 1778 deletions
+3
View File
@@ -71,6 +71,9 @@ dependencies {
implementation("org.mindrot:jbcrypt:0.4") implementation("org.mindrot:jbcrypt:0.4")
implementation("org.jetbrains:annotations:24.0.0") implementation("org.jetbrains:annotations:24.0.0")
implementation("net.java.dev.jna:jna:5.17.0") implementation("net.java.dev.jna:jna:5.17.0")
// https://mvnrepository.com/artifact/jakarta.annotation/jakarta.annotation-api
implementation("jakarta.annotation:jakarta.annotation-api:2.1.1")
} }
+1 -1
View File
@@ -22,4 +22,4 @@
JDKVERSIONS=1.8 JDKVERSIONS=1.8
GROUPSID=com.mingliqiye.utils GROUPSID=com.mingliqiye.utils
ARTIFACTID=mingli-utils ARTIFACTID=mingli-utils
VERSIONS=3.0.4 VERSIONS=3.1.1
+2 -1
View File
@@ -4,7 +4,8 @@
"scripts": { "scripts": {
"build": "gradle build-jar", "build": "gradle build-jar",
"buildw": "gradlew build-jar", "buildw": "gradlew build-jar",
"format": "prettier --write \"**/*.{js,ts,jsx,tsx,cjs,cts,mjs,mts,vue,astro,json,java}\"" "format": "prettier --write \"**/*.{js,ts,jsx,tsx,cjs,cts,mjs,mts,vue,astro,json,java}\"",
"f": "prettier --write \"**/*.{js,ts,jsx,tsx,cjs,cts,mjs,mts,vue,astro,json,java}\""
}, },
"devDependencies": { "devDependencies": {
"prettier-plugin-java": "^2.7.1", "prettier-plugin-java": "^2.7.1",
@@ -22,21 +22,12 @@
package com.mingliqiye.utils; package com.mingliqiye.utils;
import com.mingliqiye.utils.collection.Lists;
import com.mingliqiye.utils.collection.Maps;
import com.mingliqiye.utils.springboot.autoconfigure.AutoConfiguration; import com.mingliqiye.utils.springboot.autoconfigure.AutoConfiguration;
import com.mingliqiye.utils.stream.SuperStream;
import java.io.IOException; import java.io.IOException;
import java.util.List;
import java.util.Map;
public class Main { public class Main {
public static void main(String[] args) throws IOException { public static void main(String[] args) throws IOException {
AutoConfiguration.printBanner(); AutoConfiguration.printBanner();
Map<String, String> map = Maps.of("1", "2", "3", "4");
SuperStream.of(map).entryToMap();
} }
} }
@@ -41,9 +41,6 @@ import org.springframework.stereotype.Component;
@Component @Component
public class SpringBeanUtil implements ApplicationContextAware { public class SpringBeanUtil implements ApplicationContextAware {
public static final String PACKAGE_NAME =
"com.mingliqiye.utils.bean.springboot";
/** /**
* 获取applicationContext * 获取applicationContext
*/ */
@@ -22,6 +22,7 @@
package com.mingliqiye.utils.collection; package com.mingliqiye.utils.collection;
import com.mingliqiye.utils.stream.SuperStream;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Arrays; import java.util.Arrays;
import java.util.Collections; import java.util.Collections;
@@ -127,14 +128,28 @@ public class Collection {
*/ */
@Nullable @Nullable
public static <T> T getOrDefault( public static <T> T getOrDefault(
@NotNull List<T> list, @NotNull java.util.Collection<T> list,
int index, int index,
@Nullable T defaultValue @Nullable T defaultValue
) { ) {
if (index < 0 || index >= list.size()) { if (index < 0 || index >= list.size()) {
return defaultValue; return defaultValue;
} }
return list.get(index); return SuperStream.of(list).get(index);
}
/**
* 获取集合中指定索引的元素。
* 如果索引超出范围则返回null。
*
* @param list 集合
* @param index 索引
* @param <T> 元素类型
* @return 指定索引的元素,如果索引超出范围则返回null
*/
@Nullable
public static <T> T get(@NotNull java.util.Collection<T> list, int index) {
return getOrDefault(list, index, null);
} }
/** /**
@@ -26,7 +26,6 @@ import com.mingliqiye.utils.functions.P1Function;
import com.mingliqiye.utils.functions.P2Function; import com.mingliqiye.utils.functions.P2Function;
import com.mingliqiye.utils.functions.P3Function; import com.mingliqiye.utils.functions.P3Function;
import com.mingliqiye.utils.stream.SuperStream; import com.mingliqiye.utils.stream.SuperStream;
import java.util.*; import java.util.*;
import java.util.Collection; import java.util.Collection;
import java.util.concurrent.ConcurrentMap; import java.util.concurrent.ConcurrentMap;
@@ -46,431 +45,499 @@ import java.util.function.Function;
*/ */
public class ForEach { public class ForEach {
/** /**
* 对给定的集合执行指定的操作,操作包含元素值和索引。 * 对给定的集合执行指定的操作,操作包含元素值和索引。
* 根据集合类型选择最优的遍历方式以提高性能。 * 根据集合类型选择最优的遍历方式以提高性能。
* *
* @param collection 要遍历的集合,可以是 List 或其他 Collection 实现 * @param collection 要遍历的集合,可以是 List 或其他 Collection 实现
* @param action 要对每个元素执行的操作,接收元素值和索引作为参数 * @param action 要对每个元素执行的操作,接收元素值和索引作为参数
* @param <T> 集合中元素的类型 * @param <T> 集合中元素的类型
*/ */
public static <T> void forEach(Collection<T> collection, P2Function<? super T, Integer> action) { public static <T> void forEach(
// 参数校验:如果集合或操作为空,则直接返回 Collection<T> collection,
if (collection == null || action == null) { P2Function<? super T, Integer> action
return; ) {
} // 参数校验:如果集合或操作为空,则直接返回
if (collection == null || action == null) {
return;
}
// 如果集合实现了 RandomAccess 接口(如 ArrayList),使用索引访问优化性能 // 如果集合实现了 RandomAccess 接口(如 ArrayList),使用索引访问优化性能
if (collection instanceof RandomAccess && collection instanceof List) { if (collection instanceof RandomAccess && collection instanceof List) {
List<T> list = (List<T>) collection; List<T> list = (List<T>) collection;
for (int i = 0; i < list.size(); i++) { for (int i = 0; i < list.size(); i++) {
action.call(list.get(i), i); action.call(list.get(i), i);
} }
} }
// 如果是普通 List,使用迭代器遍历并手动维护索引 // 如果是普通 List,使用迭代器遍历并手动维护索引
else if (collection instanceof List) { else if (collection instanceof List) {
int index = 0; int index = 0;
Iterator<T> it = collection.iterator(); Iterator<T> it = collection.iterator();
while (it.hasNext()) { while (it.hasNext()) {
action.call(it.next(), index); action.call(it.next(), index);
index++; index++;
} }
} }
// 其他类型的集合使用增强 for 循环,并手动维护索引 // 其他类型的集合使用增强 for 循环,并手动维护索引
else { else {
int index = 0; int index = 0;
for (T element : collection) { for (T element : collection) {
action.call(element, index); action.call(element, index);
index++; index++;
} }
} }
} }
/** /**
* 对给定的集合执行指定的操作,仅处理元素值。 * 对给定的集合执行指定的操作,仅处理元素值。
* 根据集合是否实现 RandomAccess 接口选择最优的遍历方式。 * 根据集合是否实现 RandomAccess 接口选择最优的遍历方式。
* *
* @param collection 要遍历的集合 * @param collection 要遍历的集合
* @param action 要对每个元素执行的操作,只接收元素值作为参数 * @param action 要对每个元素执行的操作,只接收元素值作为参数
* @param <T> 集合中元素的类型 * @param <T> 集合中元素的类型
*/ */
public static <T> void forEach(Collection<T> collection, P1Function<? super T> action) { public static <T> void forEach(
// 参数校验:如果集合或操作为空,则直接返回 Collection<T> collection,
if (collection == null || action == null) { P1Function<? super T> action
return; ) {
} // 参数校验:如果集合或操作为空,则直接返回
if (collection == null || action == null) {
return;
}
// 如果集合实现了 RandomAccess 接口,使用索引访问提升性能 // 如果集合实现了 RandomAccess 接口,使用索引访问提升性能
if (collection instanceof RandomAccess) { if (collection instanceof RandomAccess) {
List<T> list = (List<T>) collection; List<T> list = (List<T>) collection;
for (int i = 0; i < list.size(); i++) { for (int i = 0; i < list.size(); i++) {
action.call(list.get(i)); action.call(list.get(i));
} }
} }
// 否则使用增强 for 循环进行遍历 // 否则使用增强 for 循环进行遍历
else { else {
for (T element : collection) { for (T element : collection) {
action.call(element); action.call(element);
} }
} }
} }
/** /**
* 对给定的映射执行指定的操作,操作包含键、值和索引。 * 对给定的映射执行指定的操作,操作包含键、值和索引。
* 根据映射类型选择不同的遍历策略。 * 根据映射类型选择不同的遍历策略。
* *
* @param map 要遍历的映射 * @param map 要遍历的映射
* @param action 要对每个键值对执行的操作,接收键、值和索引作为参数 * @param action 要对每个键值对执行的操作,接收键、值和索引作为参数
* @param <K> 映射中键的类型 * @param <K> 映射中键的类型
* @param <V> 映射中值的类型 * @param <V> 映射中值的类型
*/ */
public static <K, V> void forEach(Map<K, V> map, P3Function<? super K, ? super V, Integer> action) { public static <K, V> void forEach(
// 参数校验:如果映射或操作为空,则直接返回 Map<K, V> map,
if (map == null || action == null) { P3Function<? super K, ? super V, Integer> action
return; ) {
} // 参数校验:如果映射或操作为空,则直接返回
if (map == null || action == null) {
return;
}
// 遍历 TreeMap 的条目集合并传递索引 // 遍历 TreeMap 的条目集合并传递索引
if (map instanceof TreeMap) { if (map instanceof TreeMap) {
int index = 0; int index = 0;
for (Map.Entry<K, V> entry : map.entrySet()) { for (Map.Entry<K, V> entry : map.entrySet()) {
action.call(entry.getKey(), entry.getValue(), index); action.call(entry.getKey(), entry.getValue(), index);
index++; index++;
} }
} }
// 遍历 ConcurrentMap 或 LinkedHashMap 的条目集合并传递索引 // 遍历 ConcurrentMap 或 LinkedHashMap 的条目集合并传递索引
else if (map instanceof ConcurrentMap || map instanceof LinkedHashMap) { else if (map instanceof ConcurrentMap || map instanceof LinkedHashMap) {
int index = 0; int index = 0;
for (Map.Entry<K, V> entry : map.entrySet()) { for (Map.Entry<K, V> entry : map.entrySet()) {
action.call(entry.getKey(), entry.getValue(), index); action.call(entry.getKey(), entry.getValue(), index);
index++; index++;
} }
} }
// 遍历其他类型映射的条目集合并传递索引 // 遍历其他类型映射的条目集合并传递索引
else { else {
int index = 0; int index = 0;
for (Map.Entry<K, V> entry : map.entrySet()) { for (Map.Entry<K, V> entry : map.entrySet()) {
action.call(entry.getKey(), entry.getValue(), index); action.call(entry.getKey(), entry.getValue(), index);
index++; index++;
} }
} }
} }
/** /**
* 对给定的映射执行指定的操作,仅处理键和值。 * 对给定的映射执行指定的操作,仅处理键和值。
* 根据映射类型选择不同的遍历策略。 * 根据映射类型选择不同的遍历策略。
* *
* @param map 要遍历的映射 * @param map 要遍历的映射
* @param action 要对每个键值对执行的操作,接收键和值作为参数 * @param action 要对每个键值对执行的操作,接收键和值作为参数
* @param <K> 映射中键的类型 * @param <K> 映射中键的类型
* @param <V> 映射中值的类型 * @param <V> 映射中值的类型
*/ */
public static <K, V> void forEach(Map<K, V> map, P2Function<? super K, ? super V> action) { public static <K, V> void forEach(
// 参数校验:如果映射或操作为空,则直接返回 Map<K, V> map,
if (map == null || action == null) { P2Function<? super K, ? super V> action
return; ) {
} // 参数校验:如果映射或操作为空,则直接返回
if (map == null || action == null) {
return;
}
// 遍历 TreeMap 的条目集合 // 遍历 TreeMap 的条目集合
if (map instanceof TreeMap) { if (map instanceof TreeMap) {
for (Map.Entry<K, V> entry : map.entrySet()) { for (Map.Entry<K, V> entry : map.entrySet()) {
action.call(entry.getKey(), entry.getValue()); action.call(entry.getKey(), entry.getValue());
} }
} }
// 如果是 ConcurrentMap 或 LinkedHashMap,使用其内置的 forEach 方法 // 如果是 ConcurrentMap 或 LinkedHashMap,使用其内置的 forEach 方法
else if (map instanceof ConcurrentMap || map instanceof LinkedHashMap) { else if (map instanceof ConcurrentMap || map instanceof LinkedHashMap) {
forEach(map.entrySet(), (i) -> action.call(i.getKey(), i.getValue())); forEach(map.entrySet(), i -> action.call(i.getKey(), i.getValue()));
} }
// 遍历其他类型映射的条目集合 // 遍历其他类型映射的条目集合
else { else {
for (Map.Entry<K, V> entry : map.entrySet()) { for (Map.Entry<K, V> entry : map.entrySet()) {
action.call(entry.getKey(), entry.getValue()); action.call(entry.getKey(), entry.getValue());
} }
} }
} }
/** /**
* 对可变参数数组执行指定的操作,操作包含元素值和索引 * 对可变参数数组执行指定的操作,操作包含元素值和索引
* *
* @param action 要对每个元素执行的操作,接收元素值和索引作为参数 * @param action 要对每个元素执行的操作,接收元素值和索引作为参数
* @param objects 要遍历的可变参数数组 * @param objects 要遍历的可变参数数组
* @param <T> 数组中元素的类型 * @param <T> 数组中元素的类型
*/ */
public static <T> void forEach(P2Function<? super T, Integer> action, T... objects) { public static <T> void forEach(
forEach(Lists.newArrayList(objects), action); P2Function<? super T, Integer> action,
} T... objects
) {
forEach(Lists.newArrayList(objects), action);
}
/** /**
* 对数组执行指定的操作,操作包含元素值和索引 * 对数组执行指定的操作,操作包含元素值和索引
* *
* @param objects 要遍历的数组 * @param objects 要遍历的数组
* @param action 要对每个元素执行的操作,接收元素值和索引作为参数 * @param action 要对每个元素执行的操作,接收元素值和索引作为参数
* @param <T> 数组中元素的类型 * @param <T> 数组中元素的类型
*/ */
public static <T> void forEach(T[] objects, P2Function<? super T, Integer> action) { public static <T> void forEach(
forEach(action, objects); T[] objects,
} P2Function<? super T, Integer> action
) {
forEach(action, objects);
}
/** /**
* 对数组执行指定的操作,仅处理元素值 * 对数组执行指定的操作,仅处理元素值
* *
* @param objects 要遍历的数组 * @param objects 要遍历的数组
* @param action 要对每个元素执行的操作,只接收元素值作为参数 * @param action 要对每个元素执行的操作,只接收元素值作为参数
* @param <T> 数组中元素的类型 * @param <T> 数组中元素的类型
*/ */
public static <T> void forEach(T[] objects, P1Function<? super T> action) { public static <T> void forEach(T[] objects, P1Function<? super T> action) {
forEach(action, objects); forEach(action, objects);
} }
/** /**
* 对可变参数数组执行指定的操作,仅处理元素值 * 对可变参数数组执行指定的操作,仅处理元素值
* *
* @param action 要对每个元素执行的操作,只接收元素值作为参数 * @param action 要对每个元素执行的操作,只接收元素值作为参数
* @param objects 要遍历的可变参数数组 * @param objects 要遍历的可变参数数组
* @param <T> 数组中元素的类型 * @param <T> 数组中元素的类型
*/ */
public static <T> void forEach(P1Function<? super T> action, T... objects) { public static <T> void forEach(P1Function<? super T> action, T... objects) {
forEach(Lists.toList(objects), (t, i) -> action.call(t)); forEach(Lists.toList(objects), (t, i) -> action.call(t));
} }
/** /**
* 对整型数组执行指定的操作,操作包含元素值和索引 * 对整型数组执行指定的操作,操作包含元素值和索引
* *
* @param objects 要遍历的整型数组 * @param objects 要遍历的整型数组
* @param action 要对每个元素执行的操作,接收元素值和索引作为参数 * @param action 要对每个元素执行的操作,接收元素值和索引作为参数
*/ */
public static void forEach(int[] objects, P2Function<Integer, Integer> action) { public static void forEach(
forEach(action, objects); int[] objects,
} P2Function<Integer, Integer> action
) {
forEach(action, objects);
}
/** /**
* 对整型可变参数数组执行指定的操作,操作包含元素值和索引 * 对整型可变参数数组执行指定的操作,操作包含元素值和索引
* *
* @param action 要对每个元素执行的操作,接收元素值和索引作为参数 * @param action 要对每个元素执行的操作,接收元素值和索引作为参数
* @param objects 要遍历的整型可变参数数组 * @param objects 要遍历的整型可变参数数组
*/ */
private static void forEach(P2Function<Integer, Integer> action, int... objects) { private static void forEach(
forEach(objects, action); P2Function<Integer, Integer> action,
} int... objects
) {
forEach(objects, action);
}
/** /**
* 对整型可变参数数组执行指定的操作,仅处理元素值 * 对整型可变参数数组执行指定的操作,仅处理元素值
* *
* @param action 要对每个元素执行的操作,只接收元素值作为参数 * @param action 要对每个元素执行的操作,只接收元素值作为参数
* @param objects 要遍历的整型可变参数数组 * @param objects 要遍历的整型可变参数数组
*/ */
private static void forEach(P1Function<Integer> action, int... objects) { private static void forEach(P1Function<Integer> action, int... objects) {
forEach(Lists.toList(objects), action); forEach(Lists.toList(objects), action);
} }
/** /**
* 对字节数组执行指定的操作,操作包含元素值和索引 * 对字节数组执行指定的操作,操作包含元素值和索引
* *
* @param objects 要遍历的字节数组 * @param objects 要遍历的字节数组
* @param action 要对每个元素执行的操作,接收元素值和索引作为参数 * @param action 要对每个元素执行的操作,接收元素值和索引作为参数
*/ */
public static void forEach(byte[] objects, P2Function<Byte, Integer> action) { public static void forEach(
forEach(Lists.toList(objects), action); byte[] objects,
} P2Function<Byte, Integer> action
) {
forEach(Lists.toList(objects), action);
}
/** /**
* 对字节可变参数数组执行指定的操作,操作包含元素值和索引 * 对字节可变参数数组执行指定的操作,操作包含元素值和索引
* *
* @param action 要对每个元素执行的操作,接收元素值和索引作为参数 * @param action 要对每个元素执行的操作,接收元素值和索引作为参数
* @param objects 要遍历的字节可变参数数组 * @param objects 要遍历的字节可变参数数组
*/ */
private static void forEach(P2Function<Byte, Integer> action, byte... objects) { private static void forEach(
forEach(objects, action); P2Function<Byte, Integer> action,
} byte... objects
) {
forEach(objects, action);
}
/** /**
* 对字节可变参数数组执行指定的操作,仅处理元素值 * 对字节可变参数数组执行指定的操作,仅处理元素值
* *
* @param action 要对每个元素执行的操作,只接收元素值作为参数 * @param action 要对每个元素执行的操作,只接收元素值作为参数
* @param objects 要遍历的字节可变参数数组 * @param objects 要遍历的字节可变参数数组
*/ */
private static void forEach(P1Function<Byte> action, byte... objects) { private static void forEach(P1Function<Byte> action, byte... objects) {
forEach(Lists.toList(objects), action); forEach(Lists.toList(objects), action);
} }
/** /**
* 对短整型数组执行指定的操作,操作包含元素值和索引 * 对短整型数组执行指定的操作,操作包含元素值和索引
* *
* @param objects 要遍历的短整型数组 * @param objects 要遍历的短整型数组
* @param action 要对每个元素执行的操作,接收元素值和索引作为参数 * @param action 要对每个元素执行的操作,接收元素值和索引作为参数
*/ */
public static void forEach(short[] objects, P2Function<Short, Integer> action) { public static void forEach(
forEach(Lists.toList(objects), action); short[] objects,
} P2Function<Short, Integer> action
) {
forEach(Lists.toList(objects), action);
}
/** /**
* 对短整型可变参数数组执行指定的操作,操作包含元素值和索引 * 对短整型可变参数数组执行指定的操作,操作包含元素值和索引
* *
* @param action 要对每个元素执行的操作,接收元素值和索引作为参数 * @param action 要对每个元素执行的操作,接收元素值和索引作为参数
* @param objects 要遍历的短整型可变参数数组 * @param objects 要遍历的短整型可变参数数组
*/ */
private static void forEach(P2Function<Short, Integer> action, short... objects) { private static void forEach(
forEach(objects, action); P2Function<Short, Integer> action,
} short... objects
) {
forEach(objects, action);
}
/** /**
* 对短整型可变参数数组执行指定的操作,仅处理元素值 * 对短整型可变参数数组执行指定的操作,仅处理元素值
* *
* @param action 要对每个元素执行的操作,只接收元素值作为参数 * @param action 要对每个元素执行的操作,只接收元素值作为参数
* @param objects 要遍历的短整型可变参数数组 * @param objects 要遍历的短整型可变参数数组
*/ */
private static void forEach(P1Function<Short> action, short... objects) { private static void forEach(P1Function<Short> action, short... objects) {
forEach(Lists.toList(objects), action); forEach(Lists.toList(objects), action);
} }
/** /**
* 对长整型数组执行指定的操作,操作包含元素值和索引 * 对长整型数组执行指定的操作,操作包含元素值和索引
* *
* @param objects 要遍历的长整型数组 * @param objects 要遍历的长整型数组
* @param action 要对每个元素执行的操作,接收元素值和索引作为参数 * @param action 要对每个元素执行的操作,接收元素值和索引作为参数
*/ */
public static void forEach(long[] objects, P2Function<Long, Integer> action) { public static void forEach(
forEach(action, objects); long[] objects,
} P2Function<Long, Integer> action
) {
forEach(action, objects);
}
/** /**
* 对长整型可变参数数组执行指定的操作,操作包含元素值和索引 * 对长整型可变参数数组执行指定的操作,操作包含元素值和索引
* *
* @param action 要对每个元素执行的操作,接收元素值和索引作为参数 * @param action 要对每个元素执行的操作,接收元素值和索引作为参数
* @param objects 要遍历的长整型可变参数数组 * @param objects 要遍历的长整型可变参数数组
*/ */
private static void forEach(P2Function<Long, Integer> action, long... objects) { private static void forEach(
forEach(Lists.toList(objects), action); P2Function<Long, Integer> action,
} long... objects
) {
forEach(Lists.toList(objects), action);
}
/** /**
* 对长整型可变参数数组执行指定的操作,仅处理元素值 * 对长整型可变参数数组执行指定的操作,仅处理元素值
* *
* @param action 要对每个元素执行的操作,只接收元素值作为参数 * @param action 要对每个元素执行的操作,只接收元素值作为参数
* @param objects 要遍历的长整型可变参数数组 * @param objects 要遍历的长整型可变参数数组
*/ */
private static void forEach(P1Function<Long> action, long... objects) { private static void forEach(P1Function<Long> action, long... objects) {
forEach(Lists.toList(objects), action); forEach(Lists.toList(objects), action);
} }
/** /**
* 对浮点数组执行指定的操作,操作包含元素值和索引 * 对浮点数组执行指定的操作,操作包含元素值和索引
* *
* @param objects 要遍历的浮点数组 * @param objects 要遍历的浮点数组
* @param action 要对每个元素执行的操作,接收元素值和索引作为参数 * @param action 要对每个元素执行的操作,接收元素值和索引作为参数
*/ */
public static void forEach(float[] objects, P2Function<Float, Integer> action) { public static void forEach(
forEach(action, objects); float[] objects,
} P2Function<Float, Integer> action
) {
forEach(action, objects);
}
/** /**
* 对浮点可变参数数组执行指定的操作,操作包含元素值和索引 * 对浮点可变参数数组执行指定的操作,操作包含元素值和索引
* *
* @param action 要对每个元素执行的操作,接收元素值和索引作为参数 * @param action 要对每个元素执行的操作,接收元素值和索引作为参数
* @param objects 要遍历的浮点可变参数数组 * @param objects 要遍历的浮点可变参数数组
*/ */
private static void forEach(P2Function<Float, Integer> action, float... objects) { private static void forEach(
forEach(Lists.toList(objects), action); P2Function<Float, Integer> action,
} float... objects
) {
forEach(Lists.toList(objects), action);
}
/** /**
* 对浮点可变参数数组执行指定的操作,仅处理元素值 * 对浮点可变参数数组执行指定的操作,仅处理元素值
* *
* @param action 要对每个元素执行的操作,只接收元素值作为参数 * @param action 要对每个元素执行的操作,只接收元素值作为参数
* @param objects 要遍历的浮点可变参数数组 * @param objects 要遍历的浮点可变参数数组
*/ */
private static void forEach(P1Function<Float> action, float... objects) { private static void forEach(P1Function<Float> action, float... objects) {
forEach(Lists.toList(objects), action); forEach(Lists.toList(objects), action);
} }
/** /**
* 对双精度浮点数组执行指定的操作,操作包含元素值和索引 * 对双精度浮点数组执行指定的操作,操作包含元素值和索引
* *
* @param objects 要遍历的双精度浮点数组 * @param objects 要遍历的双精度浮点数组
* @param action 要对每个元素执行的操作,接收元素值和索引作为参数 * @param action 要对每个元素执行的操作,接收元素值和索引作为参数
*/ */
public static void forEach(double[] objects, P2Function<Double, Integer> action) { public static void forEach(
forEach(action, objects); double[] objects,
} P2Function<Double, Integer> action
) {
forEach(action, objects);
}
/** /**
* 对双精度浮点可变参数数组执行指定的操作,操作包含元素值和索引 * 对双精度浮点可变参数数组执行指定的操作,操作包含元素值和索引
* *
* @param action 要对每个元素执行的操作,接收元素值和索引作为参数 * @param action 要对每个元素执行的操作,接收元素值和索引作为参数
* @param objects 要遍历的双精度浮点可变参数数组 * @param objects 要遍历的双精度浮点可变参数数组
*/ */
private static void forEach(P2Function<Double, Integer> action, double... objects) { private static void forEach(
forEach(Lists.toList(objects), action); P2Function<Double, Integer> action,
} double... objects
) {
forEach(Lists.toList(objects), action);
}
/** /**
* 对双精度浮点可变参数数组执行指定的操作,仅处理元素值 * 对双精度浮点可变参数数组执行指定的操作,仅处理元素值
* *
* @param action 要对每个元素执行的操作,只接收元素值作为参数 * @param action 要对每个元素执行的操作,只接收元素值作为参数
* @param objects 要遍历的双精度浮点可变参数数组 * @param objects 要遍历的双精度浮点可变参数数组
*/ */
private static void forEach(P1Function<Double> action, double... objects) { private static void forEach(P1Function<Double> action, double... objects) {
forEach(Lists.toList(objects), action); forEach(Lists.toList(objects), action);
} }
/** /**
* 对字符数组执行指定的操作,操作包含元素值和索引 * 对字符数组执行指定的操作,操作包含元素值和索引
* *
* @param objects 要遍历的字符数组 * @param objects 要遍历的字符数组
* @param action 要对每个元素执行的操作,接收元素值和索引作为参数 * @param action 要对每个元素执行的操作,接收元素值和索引作为参数
*/ */
public static void forEach(char[] objects, P2Function<Character, Integer> action) { public static void forEach(
forEach(action, objects); char[] objects,
} P2Function<Character, Integer> action
) {
forEach(action, objects);
}
/** /**
* 对字符可变参数数组执行指定的操作,操作包含元素值和索引 * 对字符可变参数数组执行指定的操作,操作包含元素值和索引
* *
* @param action 要对每个元素执行的操作,接收元素值和索引作为参数 * @param action 要对每个元素执行的操作,接收元素值和索引作为参数
* @param objects 要遍历的字符可变参数数组 * @param objects 要遍历的字符可变参数数组
*/ */
private static void forEach(P2Function<Character, Integer> action, char... objects) { private static void forEach(
forEach(Lists.toList(objects), action); P2Function<Character, Integer> action,
} char... objects
) {
forEach(Lists.toList(objects), action);
}
/** /**
* 对字符可变参数数组执行指定的操作,仅处理元素值 * 对字符可变参数数组执行指定的操作,仅处理元素值
* *
* @param action 要对每个元素执行的操作,只接收元素值作为参数 * @param action 要对每个元素执行的操作,只接收元素值作为参数
* @param objects 要遍历的字符可变参数数组 * @param objects 要遍历的字符可变参数数组
*/ */
private static void forEach(P1Function<Character> action, char... objects) { private static void forEach(P1Function<Character> action, char... objects) {
forEach(Lists.toList(objects), action); forEach(Lists.toList(objects), action);
} }
/** /**
* 对布尔数组执行指定的操作,操作包含元素值和索引 * 对布尔数组执行指定的操作,操作包含元素值和索引
* *
* @param objects 要遍历的布尔数组 * @param objects 要遍历的布尔数组
* @param action 要对每个元素执行的操作,接收元素值和索引作为参数 * @param action 要对每个元素执行的操作,接收元素值和索引作为参数
*/ */
public static void forEach(boolean[] objects, P2Function<Character, Integer> action) { public static void forEach(
forEach(objects, action); boolean[] objects,
} P2Function<Character, Integer> action
) {
forEach(objects, action);
}
/** /**
* 对布尔可变参数数组执行指定的操作,操作包含元素值和索引 * 对布尔可变参数数组执行指定的操作,操作包含元素值和索引
* *
* @param action 要对每个元素执行的操作,接收元素值和索引作为参数 * @param action 要对每个元素执行的操作,接收元素值和索引作为参数
* @param objects 要遍历的布尔可变参数数组 * @param objects 要遍历的布尔可变参数数组
*/ */
private static void forEach(P2Function<Boolean, Integer> action, boolean... objects) { private static void forEach(
forEach(Lists.toList(objects), action); P2Function<Boolean, Integer> action,
} boolean... objects
) {
/** forEach(Lists.toList(objects), action);
* 对布尔可变参数数组执行指定的操作,仅处理元素值 }
*
* @param action 要对每个元素执行的操作,只接收元素值作为参数
* @param objects 要遍历的布尔可变参数数组
*/
private static void forEach(P1Function<Boolean> action, boolean... objects) {
forEach(Lists.toList(objects), action);
}
/**
* 对布尔可变参数数组执行指定的操作,仅处理元素值
*
* @param action 要对每个元素执行的操作,只接收元素值作为参数
* @param objects 要遍历的布尔可变参数数组
*/
private static void forEach(
P1Function<Boolean> action,
boolean... objects
) {
forEach(Lists.toList(objects), action);
}
} }
File diff suppressed because it is too large Load Diff
@@ -22,7 +22,14 @@
package com.mingliqiye.utils.collection; package com.mingliqiye.utils.collection;
import static com.mingliqiye.utils.collection.Collection.findFirst;
import com.github.f4b6a3.uuid.util.internal.RandomUtil;
import com.mingliqiye.utils.random.RandomInt;
import java.util.*; import java.util.*;
import java.util.Collection;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable; import org.jetbrains.annotations.Nullable;
@@ -299,6 +306,13 @@ public class Lists {
return ts == null ? null : new ArrayList<>(Arrays.asList(ts)); return ts == null ? null : new ArrayList<>(Arrays.asList(ts));
} }
@NotNull
public static <T> List<T> toList(Stream<T> ts) {
return ts == null
? newArrayList()
: new ArrayList<>(ts.collect(Collectors.toList()));
}
/** /**
* 将int数组转换为Integer列表 * 将int数组转换为Integer列表
* *
@@ -442,4 +456,20 @@ public class Lists {
} }
return list; return list;
} }
public <T> T getFirst(Collection<T> collectors) {
return com.mingliqiye.utils.collection.Collection.getFirst(collectors);
}
public <T> T getLast(Collection<T> collectors) {
return com.mingliqiye.utils.collection.Collection.getFirst(collectors);
}
public <T> T getAny(Collection<T> collectors) {
return com.mingliqiye.utils.collection.Collection.getOrDefault(
collectors,
RandomInt.randomInt(0, collectors.size()),
null
);
}
} }
@@ -22,27 +22,25 @@
package com.mingliqiye.utils.springboot.autoconfigure; package com.mingliqiye.utils.springboot.autoconfigure;
import com.mingliqiye.utils.bean.springboot.SpringBeanUtil;
import com.mingliqiye.utils.collection.ForEach; import com.mingliqiye.utils.collection.ForEach;
import com.mingliqiye.utils.jackson.Serializers;
import com.mingliqiye.utils.json.JacksonJsonApi;
import com.mingliqiye.utils.json.JsonApi;
import com.mingliqiye.utils.time.DateTime; import com.mingliqiye.utils.time.DateTime;
import com.mingliqiye.utils.time.Formatter; import com.mingliqiye.utils.time.Formatter;
import java.io.IOException;
import java.io.InputStream;
import javax.annotation.PostConstruct;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.context.properties.EnableConfigurationProperties; import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan; import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
@Configuration import java.io.IOException;
import java.io.InputStream;
@org.springframework.boot.autoconfigure.AutoConfiguration
@EnableConfigurationProperties(AutoConfiguration.class) @EnableConfigurationProperties(AutoConfiguration.class)
@ComponentScan({ SpringBeanUtil.PACKAGE_NAME }) @ComponentScan(
{
"com.mingliqiye.utils.bean.springboot",
"com.mingliqiye.utils.springboot.autoconfigure.converters",
}
)
public class AutoConfiguration { public class AutoConfiguration {
private static final String banner = private static final String banner =
@@ -55,11 +53,16 @@ public class AutoConfiguration {
"| $$ |\\$ /$$ |$$ | $$ | $$ | $$ | $$\\ $$ | |\n" + "| $$ |\\$ /$$ |$$ | $$ | $$ | $$ | $$\\ $$ | |\n" +
"| $$ | \\_/ $$ |$$$$$$$$\\\\$$$$$$ | $$ | \\$$$$$$ | |\n" + "| $$ | \\_/ $$ |$$$$$$$$\\\\$$$$$$ | $$ | \\$$$$$$ | |\n" +
"| \\__| \\__|\\________|\\______/ \\__| \\______/ |\n"; "| \\__| \\__|\\________|\\______/ \\__| \\______/ |\n";
private static String banner2;
private final Logger log = LoggerFactory.getLogger(AutoConfiguration.class);
private com.fasterxml.jackson.databind.ObjectMapper objectMapper;
public AutoConfiguration() {} private static String banner2;
private final Logger log = LoggerFactory.getLogger(
"MingliUtils-AutoConfiguration"
);
public AutoConfiguration() {
printBanner();
log.info("MingliUtils AutoConfiguration succeed");
}
public static void printBanner() { public static void printBanner() {
StringBuilder bannerBuilder = new StringBuilder(banner); StringBuilder bannerBuilder = new StringBuilder(banner);
@@ -106,37 +109,4 @@ public class AutoConfiguration {
"---------------------------------------------------------" "---------------------------------------------------------"
); );
} }
@PostConstruct
public void init() {
try {
Class.forName("com.fasterxml.jackson.databind.ObjectMapper");
log.info("init ObjectMapper");
objectMapper = SpringBeanUtil.getBean(
com.fasterxml.jackson.databind.ObjectMapper.class
);
Serializers.addSerializers(objectMapper);
log.info("add ObjectMapper Serializers OK");
} catch (ClassNotFoundException ignored) {
log.info(
"Jackson ObjectMapper not found in classpath. Jackson serialization features will be disabled."
);
} catch (Exception e) {
log.warn("Failed to initialize ObjectMapper", e);
}
printBanner();
}
@Bean
@ConditionalOnClass(name = "com.fasterxml.jackson.databind.ObjectMapper")
public JsonApi jsonApi() {
if (objectMapper == null) {
log.warn(
"ObjectMapper is not available, returning null for JsonApi"
);
return null;
}
log.info("Creating JacksonJsonApi bean");
return new JacksonJsonApi(objectMapper);
}
} }
@@ -0,0 +1,38 @@
package com.mingliqiye.utils.springboot.autoconfigure;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.mingliqiye.utils.jackson.Serializers;
import com.mingliqiye.utils.json.JacksonJsonApi;
import com.mingliqiye.utils.json.JsonApi;
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.context.annotation.Bean;
@AutoConfiguration
@AutoConfigureAfter(
name = {
"org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration",
}
)
@ConditionalOnClass(ObjectMapper.class)
public class JacksonAutoConfiguration {
private final Logger log = LoggerFactory.getLogger(
"MingliUtils-JacksonAutoConfiguration"
);
public JacksonAutoConfiguration() {
log.info("MingliUtils JacksonAutoConfiguration succeed");
}
@Bean
public JsonApi jsonApi(ObjectMapper objectMapper) {
log.info("Creating JacksonJsonApi bean");
Serializers.addSerializers(objectMapper);
log.info("MingliUtils Serializers created");
return new JacksonJsonApi(objectMapper);
}
}
@@ -0,0 +1,25 @@
package com.mingliqiye.utils.springboot.autoconfigure.converters;
import static com.mingliqiye.utils.time.Formatter.STANDARD_DATETIME;
import com.mingliqiye.utils.time.DateTime;
import org.jetbrains.annotations.NotNull;
import org.springframework.core.convert.converter.Converter;
import org.springframework.stereotype.Component;
/**
* spring boot DateTime到字符串转换器
*
* @author MingliPro
* @see DateTime
*
*
*/
@Component
public class DateTimeToStringConverter implements Converter<DateTime, String> {
@Override
public String convert(@NotNull DateTime source) {
return source.format(STANDARD_DATETIME);
}
}
@@ -0,0 +1,25 @@
package com.mingliqiye.utils.springboot.autoconfigure.converters;
import static com.mingliqiye.utils.time.Formatter.STANDARD_DATETIME_MILLISECOUND7;
import com.mingliqiye.utils.time.DateTime;
import org.jetbrains.annotations.NotNull;
import org.springframework.core.convert.converter.Converter;
import org.springframework.stereotype.Component;
/**
* spring boot 字符串到DateTime转换器
*
* @author MingliPro
* @see DateTime
*
*
*/
@Component
public class StringToDateTimeConverter implements Converter<String, DateTime> {
@Override
public DateTime convert(@NotNull String source) {
return DateTime.parse(source, STANDARD_DATETIME_MILLISECOUND7, true);
}
}
@@ -0,0 +1,20 @@
package com.mingliqiye.utils.springboot.autoconfigure.converters;
import com.mingliqiye.utils.uuid.UUID;
import org.jetbrains.annotations.NotNull;
import org.springframework.core.convert.converter.Converter;
import org.springframework.stereotype.Component;
/**
* spring boot 字符串到UUID转换器
* @see UUID
* @author MingliPro
*/
@Component
public class StringToUUIDConverter implements Converter<String, UUID> {
@Override
public UUID convert(@NotNull String source) {
return UUID.of(source);
}
}
@@ -0,0 +1,20 @@
package com.mingliqiye.utils.springboot.autoconfigure.converters;
import com.mingliqiye.utils.uuid.UUID;
import org.jetbrains.annotations.NotNull;
import org.springframework.core.convert.converter.Converter;
import org.springframework.stereotype.Component;
/**
* spring boot UUID到字符串转换器
* @see UUID
* @author MingliPro
*/
@Component
public class UUIDToStringConverter implements Converter<UUID, String> {
@Override
public String convert(@NotNull UUID source) {
return source.toUUIDString();
}
}
@@ -56,6 +56,7 @@ public class InputStreamUtils {
/** /**
* 将输入流读取为字符串<br> * 将输入流读取为字符串<br>
* 请在外部自行关闭输入流对象 避免资源泄露 * 请在外部自行关闭输入流对象 避免资源泄露
*
* @param inputStream 输入流对象,用于读取数据 * @param inputStream 输入流对象,用于读取数据
* @return 输入流对应的字符串内容 * @return 输入流对应的字符串内容
* @throws IOException 当读取输入流时发生IO异常 * @throws IOException 当读取输入流时发生IO异常
File diff suppressed because it is too large Load Diff
@@ -0,0 +1,9 @@
package com.mingliqiye.utils.stream.interfaces;
public interface GetIdable<T> extends Getable<T> {
T getId();
default T get() {
return getId();
}
}
@@ -0,0 +1,9 @@
package com.mingliqiye.utils.stream.interfaces;
public interface GetKeyable<T> {
T getKey();
default T get() {
return getKey();
}
}
@@ -0,0 +1,9 @@
package com.mingliqiye.utils.stream.interfaces;
public interface GetNameable<T> extends Getable<T> {
T getName();
default T get() {
return getName();
}
}
@@ -0,0 +1,5 @@
package com.mingliqiye.utils.stream.interfaces;
public interface Getable<T> {
T get();
}
@@ -22,8 +22,8 @@
package com.mingliqiye.utils.string; package com.mingliqiye.utils.string;
import com.mingliqiye.utils.functions.P1RFunction;
import com.mingliqiye.utils.collection.Lists; import com.mingliqiye.utils.collection.Lists;
import com.mingliqiye.utils.functions.P1RFunction;
import java.text.MessageFormat; import java.text.MessageFormat;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Arrays; import java.util.Arrays;
@@ -23,6 +23,7 @@
package com.mingliqiye.utils.time; package com.mingliqiye.utils.time;
import com.mingliqiye.utils.jna.time.WinKernel32; import com.mingliqiye.utils.jna.time.WinKernel32;
import com.mingliqiye.utils.system.SystemUtil;
import java.io.Serializable; import java.io.Serializable;
import java.time.Instant; import java.time.Instant;
import java.time.LocalDateTime; import java.time.LocalDateTime;
@@ -36,8 +37,10 @@ import lombok.var;
import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.NotNull;
/** /**
* 时间工具类,用于处理日期时间的转换、格式化等操作。 * 时间类,用于处理日期时间的转换、格式化等操作。
* 提供了多种静态方法来创建 DateTime 实例,并支持与 Date、LocalDateTime 等类型的互转。 * 提供了多种静态方法来创建 DateTime 实例,并支持与 Date、LocalDateTime 等类型的互转。
*<br>
* windows java 1.8 及以下 使用windows Api 获取高精度时间
* *
* @author MingLiPro * @author MingLiPro
* @see java.time * @see java.time
@@ -51,13 +54,12 @@ import org.jetbrains.annotations.NotNull;
@Setter @Setter
public final class DateTime implements Serializable { public final class DateTime implements Serializable {
private static final String version = System.getProperty("java.version");
private static final WinKernel32 WIN_KERNEL_32; private static final WinKernel32 WIN_KERNEL_32;
private static final long FILETIME_EPOCH_OFFSET = -116444736000000000L; private static final long FILETIME_EPOCH_OFFSET = -116444736000000000L;
private static final long NANOS_PER_100NS = 100; private static final long NANOS_PER_100NS = 100;
static { static {
if (version.startsWith("1.8")) { if (!SystemUtil.isJdk8Plus() && SystemUtil.isWindows()) {
WIN_KERNEL_32 = WinKernel32.load(); WIN_KERNEL_32 = WinKernel32.load();
} else { } else {
WIN_KERNEL_32 = null; WIN_KERNEL_32 = null;
@@ -118,10 +120,6 @@ public final class DateTime implements Serializable {
return new DateTime(); return new DateTime();
} }
public static void main(String[] args) {
System.out.println(DateTime.now());
}
/** /**
* 将 Date 对象转换为 DateTime 实例。 * 将 Date 对象转换为 DateTime 实例。
* *
@@ -31,6 +31,7 @@ import com.fasterxml.jackson.databind.jsontype.TypeSerializer;
import com.fasterxml.jackson.databind.module.SimpleModule; import com.fasterxml.jackson.databind.module.SimpleModule;
import com.mingliqiye.utils.time.DateTime; import com.mingliqiye.utils.time.DateTime;
import com.mingliqiye.utils.time.Formatter; import com.mingliqiye.utils.time.Formatter;
import java.io.IOException; import java.io.IOException;
/** /**
@@ -47,8 +48,8 @@ public class Jackson {
*/ */
public static void addSerializers(ObjectMapper objectMapper) { public static void addSerializers(ObjectMapper objectMapper) {
// 创建SimpleModule并添加DateTime类型的序列化器和反序列化器 // 创建SimpleModule并添加DateTime类型的序列化器和反序列化器
SimpleModule module = new SimpleModule() SimpleModule module = new SimpleModule("MingliqiyeDateTimeModule")
.addSerializer(DateTime.class, new DateTimeJsonSerializerM7()) .addSerializer(DateTime.class, new DateTimeJsonSerializer())
.addDeserializer(DateTime.class, new DateTimeJsonDeserializerM7()); .addDeserializer(DateTime.class, new DateTimeJsonDeserializerM7());
objectMapper.registerModule(module); objectMapper.registerModule(module);
} }
@@ -47,7 +47,7 @@ public class Jackson {
*/ */
public static void addSerializers(ObjectMapper objectMapper) { public static void addSerializers(ObjectMapper objectMapper) {
// 创建SimpleModule并添加UUID的序列化器和反序列化器 // 创建SimpleModule并添加UUID的序列化器和反序列化器
SimpleModule module = new SimpleModule() SimpleModule module = new SimpleModule("MingliqiyeUUIDModule")
.addSerializer(UUID.class, new UUIDJsonSerializer()) .addSerializer(UUID.class, new UUIDJsonSerializer())
.addDeserializer(UUID.class, new UUIDJsonDeserializer()); .addDeserializer(UUID.class, new UUIDJsonDeserializer());
objectMapper.registerModule(module); objectMapper.registerModule(module);
@@ -20,18 +20,20 @@
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
package com.mingliqiye.utils.uuid.typehandlers; package com.mingliqiye.utils.uuid.typehandlers.mysql;
import com.mingliqiye.utils.uuid.UUID; import com.mingliqiye.utils.uuid.UUID;
import java.sql.CallableStatement; import com.mingliqiye.utils.uuid.typehandlers.UUIDConverter;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.apache.ibatis.type.BaseTypeHandler; import org.apache.ibatis.type.BaseTypeHandler;
import org.apache.ibatis.type.JdbcType; import org.apache.ibatis.type.JdbcType;
import org.apache.ibatis.type.MappedJdbcTypes; import org.apache.ibatis.type.MappedJdbcTypes;
import org.apache.ibatis.type.MappedTypes; import org.apache.ibatis.type.MappedTypes;
import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
/** /**
* UUIDBinaryTypeHandler 类用于处理 UUID 类型与数据库 BINARY 类型之间的转换 * UUIDBinaryTypeHandler 类用于处理 UUID 类型与数据库 BINARY 类型之间的转换
* 该类继承自 BaseTypeHandler,专门处理 UUID 对象的序列化和反序列化 * 该类继承自 BaseTypeHandler,专门处理 UUID 对象的序列化和反序列化
@@ -20,18 +20,20 @@
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
package com.mingliqiye.utils.uuid.typehandlers; package com.mingliqiye.utils.uuid.typehandlers.pgsql;
import com.mingliqiye.utils.uuid.UUID; import com.mingliqiye.utils.uuid.UUID;
import java.sql.CallableStatement; import com.mingliqiye.utils.uuid.typehandlers.UUIDConverter;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.apache.ibatis.type.BaseTypeHandler; import org.apache.ibatis.type.BaseTypeHandler;
import org.apache.ibatis.type.JdbcType; import org.apache.ibatis.type.JdbcType;
import org.apache.ibatis.type.MappedJdbcTypes; import org.apache.ibatis.type.MappedJdbcTypes;
import org.apache.ibatis.type.MappedTypes; import org.apache.ibatis.type.MappedTypes;
import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
/** /**
* UUIDBinaryTypeHandler 类用于处理 UUID 类型与数据库 BINARY 类型之间的转换 * UUIDBinaryTypeHandler 类用于处理 UUID 类型与数据库 BINARY 类型之间的转换
* 该类继承自 BaseTypeHandler,专门处理 UUID 对象的序列化和反序列化 * 该类继承自 BaseTypeHandler,专门处理 UUID 对象的序列化和反序列化
@@ -21,3 +21,4 @@
# #
com.mingliqiye.utils.springboot.autoconfigure.AutoConfiguration com.mingliqiye.utils.springboot.autoconfigure.AutoConfiguration
com.mingliqiye.utils.springboot.autoconfigure.JacksonAutoConfiguration