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;
|
}
|
}
|
}
|
