package com.zy.asrs.framework.common;
|
|
import com.zy.asrs.framework.annotations.CoolTranslate;
|
|
import java.lang.reflect.*;
|
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;
|
|
/**
|
* Created by vincent on 2019-06-09
|
*/
|
public class Cools {
|
|
public static boolean isEmpty(Object... objects) {
|
for (Object obj : objects){
|
if (isEmpty(obj)){
|
return true;
|
}
|
}
|
return false;
|
}
|
|
@SuppressWarnings("rawtypes")
|
public static boolean isEmpty(Object o) {
|
if (o == null) {
|
return true;
|
}
|
if (o instanceof String) {
|
if (o.toString().trim().equals("")) {
|
return true;
|
}
|
} else if (o instanceof List) {
|
if (((List) o).size() == 0) {
|
return true;
|
}
|
} else if (o instanceof Map) {
|
if (((Map) o).size() == 0) {
|
return true;
|
}
|
} else if (o instanceof Set) {
|
if (((Set) o).size() == 0) {
|
return true;
|
}
|
} else if (o instanceof Object[]) {
|
if (((Object[]) o).length == 0) {
|
return true;
|
}
|
} else if (o instanceof int[]) {
|
if (((int[]) o).length == 0) {
|
return true;
|
}
|
} else if (o instanceof long[]) {
|
if (((long[]) o).length == 0) {
|
return true;
|
}
|
}
|
return false;
|
}
|
|
public static int sqlLimitIndex(Integer pageIndex, Integer pageSize){
|
return (pageIndex - 1) * pageSize;
|
}
|
|
public static String enToken(String username, String password){
|
return AesUtils.encrypt(username, zerofill(password, 16));
|
}
|
|
public static String deTokn(String token, String password){
|
return AesUtils.decrypt(token, zerofill(password, 16));
|
}
|
|
public static String zerofill(String msg, Integer count){
|
if (msg.length() == count){
|
return msg;
|
} else if (msg.length() > count){
|
return msg.substring(0, 16);
|
} else {
|
StringBuilder msgBuilder = new StringBuilder(msg);
|
for (int i = 0; i<count-msg.length(); i++){
|
msgBuilder.append("0");
|
}
|
return msgBuilder.toString();
|
}
|
}
|
|
/**
|
* 截取字符串(默认end=true)
|
* @param str 被截字符串
|
* @param end true:最后一个字符 / false:第一个字符
|
*/
|
public static String deleteChar(String str, boolean end){
|
if (isEmpty(str)){
|
return "";
|
}
|
if (end){
|
return str.substring(0, str.length()-1);
|
} else {
|
return str.substring(1);
|
}
|
}
|
|
public static String deleteChar(String str){
|
return deleteChar(str, true);
|
}
|
|
|
/**
|
* map 转 对象
|
*/
|
public static <T> T conver(Map<? extends String, ?> map, Class<T> cls){
|
T instance = null;
|
try {
|
Constructor<T> constructor = cls.getDeclaredConstructor();
|
boolean constructorAccessible = constructor.isAccessible();
|
constructor.setAccessible(true);
|
instance = constructor.newInstance();
|
constructor.setAccessible(constructorAccessible);
|
} catch (IllegalAccessException | InstantiationException | NoSuchMethodException | InvocationTargetException e) {
|
e.printStackTrace();
|
}
|
Class<?> prototype = cls;
|
do {
|
for (Field field : prototype.getDeclaredFields()){
|
if (Modifier.isFinal(field.getModifiers())
|
|| Modifier.isStatic(field.getModifiers())
|
|| Modifier.isTransient(field.getModifiers())){
|
continue;
|
}
|
String fieldName = field.getName();
|
Object val = null;
|
if (map.containsKey(fieldName)){
|
val = map.get(fieldName);
|
}
|
if (val != null){
|
boolean fieldAccessible = field.isAccessible();
|
field.setAccessible(true);
|
Class<?> type = field.getType();
|
try {
|
Constructor<?> constructor = type.getDeclaredConstructor(String.class);
|
boolean constructorAccessible = constructor.isAccessible();
|
constructor.setAccessible(true);
|
field.set(instance, constructor.newInstance(String.valueOf(val)));
|
constructor.setAccessible(constructorAccessible);
|
} catch (IllegalAccessException
|
| InstantiationException
|
| InvocationTargetException
|
| NoSuchMethodException e) {
|
System.err.println("convert error ===> Class["+prototype+"],Field:["+fieldName+"],Type:["+type+"],Value:["+val+"]");
|
}
|
field.setAccessible(fieldAccessible);
|
}
|
}
|
prototype = prototype.getSuperclass();
|
} while (!Object.class.equals(prototype));
|
return instance;
|
}
|
|
/**
|
* 对象 转 map
|
*/
|
public static Map<String, Object> conver(Object obj){
|
Class<?> cls = obj.getClass();
|
Field[] fields = getAllFields(cls);
|
Map<String, Object> map = new HashMap<>();
|
for (Field field : fields) {
|
if (Modifier.isFinal(field.getModifiers())
|
|| Modifier.isStatic(field.getModifiers())
|
|| Modifier.isTransient(field.getModifiers())){
|
continue;
|
}
|
String key = field.getName();
|
boolean flag = field.isAccessible();
|
field.setAccessible(true);
|
Object val = null;
|
try {
|
val = field.get(obj);
|
} catch (IllegalAccessException e) {
|
e.printStackTrace();
|
}
|
field.setAccessible(flag);
|
if (val != null){
|
map.put(key, val);
|
}
|
}
|
return map;
|
}
|
|
/**
|
* 获取指定Class（及其SuperClass）的成员变量
|
*/
|
public static Field[] getAllFields(Class<?> cls){
|
return getAllFields(cls, null);
|
}
|
|
/**
|
* 递归合并基类Field
|
*/
|
private static Field[] getAllFields(Class<?> cls, Field[] params){
|
Field[] fields = (params == null) ? cls.getDeclaredFields() : params;
|
Class<?> superCls = cls.getSuperclass();
|
if (superCls == null || superCls == Object.class){
|
return fields;
|
}
|
Field[] superClsFields = superCls.getDeclaredFields();
|
fields = addAll(fields, superClsFields);
|
return getAllFields(superCls, fields);
|
}
|
|
/**
|
* 根据fieldName获取Field对象
|
*/
|
public static Field getField(Class<?> cls, String fieldName) {
|
Field[] allFields = getAllFields(cls);
|
for (Field field : allFields) {
|
if (field.getName().equals(fieldName)) {
|
return field;
|
}
|
}
|
return null;
|
}
|
|
/**
|
* 获取对象中某个Field的值
|
*/
|
public static Object getFieldValue(Object obj, Field field) {
|
if (null == field) {
|
return null;
|
} else {
|
if (obj instanceof Class) {
|
obj = null;
|
}
|
if (!field.isAccessible()) {
|
field.setAccessible(true);
|
}
|
try {
|
return field.get(obj);
|
} catch (IllegalAccessException e) {
|
throw new RuntimeException(e);
|
}
|
}
|
}
|
|
/**
|
* 数组叠加
|
*/
|
@SuppressWarnings("unchecked")
|
public static <T> T[] addAll(T[] array1, T... array2) {
|
if (array1 == null) {
|
return clone(array2);
|
} else if (array2 == null) {
|
return clone(array1);
|
} else {
|
Class<?> cls = array1.getClass().getComponentType();
|
T[] joinedArray = (T[]) Array.newInstance(cls, array1.length + array2.length);
|
System.arraycopy(array1, 0, joinedArray, 0, array1.length);
|
|
try {
|
System.arraycopy(array2, 0, joinedArray, array1.length, array2.length);
|
return joinedArray;
|
} catch (ArrayStoreException e) {
|
Class<?> type2 = array2.getClass().getComponentType();
|
if (!cls.isAssignableFrom(type2)) {
|
throw new RuntimeException("Cannot store " + type2.getName() + " in an array of " + cls.getName(), e);
|
} else {
|
throw e;
|
}
|
}
|
}
|
}
|
|
/**
|
* 克隆
|
*/
|
private static <T> T[] clone(T[] array) {
|
return array == null ? null : array.clone();
|
}
|
|
/**
|
* map操作
|
*/
|
public static CoolMap add(String key,Object value){
|
CoolMap map = new CoolMap();
|
map.put(key, value);
|
return map;
|
}
|
|
public static class CoolMap extends HashMap<String, Object>{
|
|
public CoolMap add(String key,Object value){
|
this.put(key, value);
|
return this;
|
}
|
|
public CoolMap $(String key,Object value){
|
this.put(key, value);
|
return this;
|
}
|
|
}
|
|
public static String md5(String string){
|
try{
|
MessageDigest md5 = MessageDigest.getInstance("MD5");
|
byte[] bytes = md5.digest(string.getBytes(StandardCharsets.UTF_8));
|
char[] chars = new char[bytes.length * 2];
|
for (int i = 0; i < bytes.length; i++) {
|
int b = bytes[i];
|
chars[i * 2] = hexDigits[(b & 0xF0) >> 4];
|
chars[i * 2 + 1] = hexDigits[b & 0x0F];
|
}
|
return new String(chars).toLowerCase();
|
} catch (Exception e) {
|
e.printStackTrace();
|
throw new RuntimeException("md5加密失败,str=".concat(string));
|
}
|
}
|
|
private static char[] hexDigits = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
|
|
public static Map<String, Object> translate(Object obj){
|
Class<?> cls = obj.getClass();
|
Field[] fields = getAllFields(cls);
|
Map<String, Object> map = new HashMap<>();
|
for (Field field : fields) {
|
String key = field.getName();
|
if (field.isAnnotationPresent(CoolTranslate.class)){
|
CoolTranslate annotation = field.getAnnotation(CoolTranslate.class);
|
if (!isEmpty(annotation.value())) {
|
key = annotation.value();
|
}
|
}
|
boolean flag = field.isAccessible();
|
field.setAccessible(true);
|
Object val = null;
|
try {
|
val = field.get(obj);
|
} catch (IllegalAccessException e) {
|
e.printStackTrace();
|
}
|
field.setAccessible(flag);
|
if (val != null){
|
map.put(key, val);
|
}
|
}
|
return map;
|
}
|
|
public static boolean eq(String str, String str0) {
|
if (Cools.isEmpty(str) && Cools.isEmpty(str0)) {
|
return true;
|
}
|
if (Cools.isEmpty(str) && !Cools.isEmpty(str0)) {
|
return false;
|
}
|
if (Cools.isEmpty(str0) && !Cools.isEmpty(str)) {
|
return false;
|
}
|
if (str.equals(str0)) {
|
return true;
|
}
|
return false;
|
}
|
|
}
|
