From 13b31b2ca2a5f8600002a042b536c9d5529842e3 Mon Sep 17 00:00:00 2001
From: Junjie <fallin.jie@qq.com>
Date: 星期一, 09 三月 2026 19:21:18 +0800
Subject: [PATCH] #
---
src/main/java/com/core/common/Cools.java | 318 +++++++++++++++++++++++++++++++++++++++++++++++++++++
1 files changed, 318 insertions(+), 0 deletions(-)
diff --git a/src/main/java/com/core/common/Cools.java b/src/main/java/com/core/common/Cools.java
new file mode 100644
index 0000000..e100bf2
--- /dev/null
+++ b/src/main/java/com/core/common/Cools.java
@@ -0,0 +1,318 @@
+package com.core.common;
+
+import com.core.annotations.CoolTranslate;
+
+import java.lang.reflect.Array;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Modifier;
+import java.nio.charset.StandardCharsets;
+import java.security.MessageDigest;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+public class Cools {
+
+ private static final char[] HEX_DIGITS = {
+ '0', '1', '2', '3', '4', '5', '6', '7',
+ '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
+ };
+
+ public static boolean isEmpty(Object... objects) {
+ for (Object object : objects) {
+ if (isEmpty(object)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ public static boolean isEmpty(Object object) {
+ if (object == null) {
+ return true;
+ }
+ if (object instanceof String) {
+ return "".equals(object.toString().trim());
+ }
+ if (object instanceof List) {
+ return ((List<?>) object).size() == 0;
+ }
+ if (object instanceof Map) {
+ return ((Map<?, ?>) object).size() == 0;
+ }
+ if (object instanceof Set) {
+ return ((Set<?>) object).size() == 0;
+ }
+ if (object instanceof Object[]) {
+ return ((Object[]) object).length == 0;
+ }
+ if (object instanceof int[]) {
+ return ((int[]) object).length == 0;
+ }
+ if (object instanceof long[]) {
+ return ((long[]) object).length == 0;
+ }
+ return false;
+ }
+
+ public static int sqlLimitIndex(Integer curr, Integer limit) {
+ return (curr.intValue() - 1) * limit.intValue();
+ }
+
+ public static String enToken(String data, String key) {
+ return AesUtils.encrypt(data, zerofill(key, Integer.valueOf(16)));
+ }
+
+ public static String deTokn(String data, String key) {
+ return AesUtils.decrypt(data, zerofill(key, Integer.valueOf(16)));
+ }
+
+ public static String zerofill(String str, Integer length) {
+ if (str.length() == length.intValue()) {
+ return str;
+ }
+ if (str.length() > length.intValue()) {
+ return str.substring(0, 16);
+ }
+ StringBuilder builder = new StringBuilder(str);
+ for (int i = 0; i < length.intValue() - str.length(); i++) {
+ builder.append("0");
+ }
+ return builder.toString();
+ }
+
+ public static String deleteChar(String str, boolean end) {
+ if (isEmpty(str)) {
+ return "";
+ }
+ if (end) {
+ return str.substring(0, str.length() - 1);
+ }
+ return str.substring(1);
+ }
+
+ public static String deleteChar(String str) {
+ return deleteChar(str, true);
+ }
+
+ public static <T> T conver(Map<? extends String, ?> map, Class<T> clazz) {
+ T target = null;
+ try {
+ Constructor<T> constructor = clazz.getDeclaredConstructor();
+ boolean accessible = constructor.isAccessible();
+ constructor.setAccessible(true);
+ target = constructor.newInstance();
+ constructor.setAccessible(accessible);
+ } catch (IllegalAccessException | InstantiationException | NoSuchMethodException | InvocationTargetException e) {
+ e.printStackTrace();
+ }
+ Class<?> current = clazz;
+ while (current != null && !Object.class.equals(current)) {
+ for (Field field : current.getDeclaredFields()) {
+ if (Modifier.isFinal(field.getModifiers())
+ || Modifier.isStatic(field.getModifiers())
+ || Modifier.isTransient(field.getModifiers())) {
+ continue;
+ }
+ String fieldName = field.getName();
+ Object val = map.containsKey(fieldName) ? map.get(fieldName) : null;
+ if (val == null) {
+ continue;
+ }
+ boolean accessible = field.isAccessible();
+ field.setAccessible(true);
+ Class<?> fieldType = field.getType();
+ try {
+ field.set(target, convertFieldValue(fieldType, val));
+ } catch (Exception ex) {
+ System.err.println("convert error ===> Class[" + current + "],Field:[" + fieldName
+ + "],Type:[" + fieldType + "],Value:[" + val + "]");
+ }
+ field.setAccessible(accessible);
+ }
+ current = current.getSuperclass();
+ }
+ return target;
+ }
+
+ private static Object convertFieldValue(Class<?> fieldType, Object val)
+ throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
+ if (fieldType.isInstance(val)) {
+ return val;
+ }
+ if (fieldType == String.class) {
+ return String.valueOf(val);
+ }
+ if (fieldType == Integer.class || fieldType == int.class) {
+ return Integer.valueOf(String.valueOf(val));
+ }
+ if (fieldType == Long.class || fieldType == long.class) {
+ return Long.valueOf(String.valueOf(val));
+ }
+ if (fieldType == Short.class || fieldType == short.class) {
+ return Short.valueOf(String.valueOf(val));
+ }
+ if (fieldType == Double.class || fieldType == double.class) {
+ return Double.valueOf(String.valueOf(val));
+ }
+ if (fieldType == Float.class || fieldType == float.class) {
+ return Float.valueOf(String.valueOf(val));
+ }
+ if (fieldType == Boolean.class || fieldType == boolean.class) {
+ return Boolean.valueOf(String.valueOf(val));
+ }
+ if (fieldType == Byte.class || fieldType == byte.class) {
+ return Byte.valueOf(String.valueOf(val));
+ }
+ if (fieldType.isEnum()) {
+ return Enum.valueOf((Class<? extends Enum>) fieldType, String.valueOf(val));
+ }
+ Constructor<?> constructor = fieldType.getDeclaredConstructor(String.class);
+ boolean constructorAccessible = constructor.isAccessible();
+ constructor.setAccessible(true);
+ Object result = constructor.newInstance(String.valueOf(val));
+ constructor.setAccessible(constructorAccessible);
+ return result;
+ }
+
+ public static Map<String, Object> conver(Object object) {
+ Field[] fields = getAllFields(object.getClass());
+ Map<String, Object> result = new HashMap<>();
+ for (Field field : fields) {
+ String fieldName = field.getName();
+ boolean accessible = field.isAccessible();
+ field.setAccessible(true);
+ Object val = null;
+ try {
+ val = field.get(object);
+ } catch (IllegalAccessException e) {
+ e.printStackTrace();
+ }
+ field.setAccessible(accessible);
+ if (val != null) {
+ result.put(fieldName, val);
+ }
+ }
+ return result;
+ }
+
+ public static Field[] getAllFields(Class<?> clazz) {
+ return getAllFields(clazz, null);
+ }
+
+ private static Field[] getAllFields(Class<?> clazz, Field[] fields) {
+ Field[] allFields = fields == null ? clazz.getDeclaredFields() : fields;
+ Class<?> superClass = clazz.getSuperclass();
+ if (superClass == null || superClass == Object.class) {
+ return allFields;
+ }
+ Field[] superFields = superClass.getDeclaredFields();
+ allFields = addAll(allFields, superFields);
+ return getAllFields(superClass, allFields);
+ }
+
+ public static <T> T[] addAll(T[] array1, T... array2) {
+ if (array1 == null) {
+ return clone(array2);
+ }
+ if (array2 == null) {
+ return clone(array1);
+ }
+ Class<?> type1 = array1.getClass().getComponentType();
+ T[] joined = (T[]) Array.newInstance(type1, array1.length + array2.length);
+ System.arraycopy(array1, 0, joined, 0, array1.length);
+ try {
+ System.arraycopy(array2, 0, joined, array1.length, array2.length);
+ return joined;
+ } catch (ArrayStoreException ex) {
+ Class<?> type2 = array2.getClass().getComponentType();
+ if (!type1.isAssignableFrom(type2)) {
+ throw new RuntimeException("Cannot store" + type2.getName() + " in an array of" + type1.getName(), ex);
+ }
+ throw ex;
+ }
+ }
+
+ private static <T> T[] clone(T[] array) {
+ return array == null ? null : (T[]) array.clone();
+ }
+
+ public static CoolMap add(String key, Object value) {
+ CoolMap map = new CoolMap();
+ map.put(key, value);
+ return map;
+ }
+
+ public static String md5(String str) {
+ try {
+ MessageDigest digest = MessageDigest.getInstance("MD5");
+ byte[] bytes = digest.digest(str.getBytes(StandardCharsets.UTF_8));
+ char[] chars = new char[bytes.length * 2];
+ for (int i = 0; i < bytes.length; i++) {
+ int val = bytes[i];
+ chars[i * 2] = HEX_DIGITS[(val & 0xF0) >> 4];
+ chars[i * 2 + 1] = HEX_DIGITS[val & 0x0F];
+ }
+ return new String(chars).toLowerCase();
+ } catch (Exception e) {
+ e.printStackTrace();
+ throw new RuntimeException("md5鍔犲瘑澶辫触,str=".concat(str));
+ }
+ }
+
+ public static Map<String, Object> translate(Object object) {
+ Field[] fields = getAllFields(object.getClass());
+ Map<String, Object> result = new HashMap<>();
+ for (Field field : fields) {
+ String fieldName = field.getName();
+ if (field.isAnnotationPresent(CoolTranslate.class)) {
+ CoolTranslate translate = field.getAnnotation(CoolTranslate.class);
+ if (!isEmpty(translate.value())) {
+ fieldName = translate.value();
+ }
+ }
+ boolean accessible = field.isAccessible();
+ field.setAccessible(true);
+ Object val = null;
+ try {
+ val = field.get(object);
+ } catch (IllegalAccessException e) {
+ e.printStackTrace();
+ }
+ field.setAccessible(accessible);
+ if (val != null) {
+ result.put(fieldName, val);
+ }
+ }
+ return result;
+ }
+
+ public static boolean eq(String left, String right) {
+ if (isEmpty(left) && isEmpty(right)) {
+ return true;
+ }
+ if (isEmpty(left) && !isEmpty(right)) {
+ return false;
+ }
+ if (isEmpty(right) && !isEmpty(left)) {
+ return false;
+ }
+ return left.equals(right);
+ }
+
+ public static class CoolMap extends HashMap<String, Object> {
+
+ public CoolMap add(String key, Object value) {
+ put(key, value);
+ return this;
+ }
+
+ public CoolMap $(String key, Object value) {
+ put(key, value);
+ return this;
+ }
+ }
+}
--
Gitblit v1.9.1