package com.common.core.utils;
|
|
import org.hibernate.Hibernate;
|
import org.springframework.beans.BeanUtils;
|
import org.springframework.beans.FatalBeanException;
|
import org.springframework.util.Assert;
|
import org.springframework.util.ReflectionUtils;
|
|
import javax.persistence.Column;
|
import javax.persistence.Id;
|
import javax.validation.constraints.NotNull;
|
import java.beans.PropertyDescriptor;
|
import java.io.PrintWriter;
|
import java.io.StringWriter;
|
import java.lang.annotation.Annotation;
|
import java.lang.reflect.Array;
|
import java.lang.reflect.Field;
|
import java.lang.reflect.InvocationTargetException;
|
import java.lang.reflect.Method;
|
import java.math.BigDecimal;
|
import java.math.BigInteger;
|
import java.util.UUID;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
/**
|
* Bean工具类.
|
*
|
* @author LuoGang
|
* @date 2019-04-13 16:53
|
*/
|
public class BeanHelper {
|
|
/**
|
* 分隔符号
|
*/
|
public static final char UNDERLINE = '_';
|
|
/**
|
* 符号.
|
*/
|
public static final String POINT = ".";
|
|
/**
|
* 系统的换行符
|
*/
|
public static final String LINE_SEPARATOR = System.getProperty("line.separator", "\n");
|
|
/**
|
* 根据class缓存其所有的PropertyDescriptor
|
*/
|
private static Map<Class<?>, PropertyDescriptor[]> propertyDescriptorsCache = new HashMap<>();
|
|
/**
|
* 得到cls定义的所有字段，不包含class
|
*
|
* @param cls Class
|
* @return cls下定义的字段
|
*/
|
public static PropertyDescriptor[] getPropertyDescriptors(Class<?> cls) {
|
PropertyDescriptor[] cache = propertyDescriptorsCache.get(cls);
|
if (cache == null) {
|
List<PropertyDescriptor> pds = new ArrayList<>();
|
PropertyDescriptor[] arr = BeanUtils.getPropertyDescriptors(cls);
|
for (PropertyDescriptor pd : arr) {
|
if ("class".equals(pd.getName())) {
|
// 不需要class这个属性
|
continue;
|
}
|
|
pds.add(pd);
|
}
|
|
cache = pds.toArray(new PropertyDescriptor[pds.size()]);
|
propertyDescriptorsCache.put(cls, cache);
|
}
|
|
return cache;
|
}
|
|
/**
|
* 得到obj对象定义的所有字段。注意obj可能是Hibernate的托管对象，要处理
|
*
|
* @param obj
|
* @return obj定义的字段
|
* @see {@link Hibernate#getClass(Object)}
|
*/
|
public static PropertyDescriptor[] getPropertyDescriptors(Object obj) {
|
Class<?> cls = Hibernate.getClass(obj);
|
return getPropertyDescriptors(cls);
|
}
|
|
/**
|
* 得到属性的类型，返回class name.
|
*
|
* @param entity 实体类
|
* @param propertyName 字段名
|
* @return
|
*/
|
public static final String getPropertyType(Object entity, String propertyName) {
|
PropertyDescriptor pd = BeanUtils.getPropertyDescriptor(Hibernate.getClass(entity), propertyName);
|
if (null != pd) {
|
return pd.getPropertyType().getName();
|
} else {
|
return null;
|
}
|
}
|
|
/**
|
* 得到属性的PropertyDescriptor
|
*
|
* @param entity 实体对象
|
* @param propertyName 字段名
|
* @return 字段的PropertyDescriptor对象
|
*/
|
public static final PropertyDescriptor getPropertyDescriptor(Object entity, String propertyName) {
|
PropertyDescriptor pd = BeanUtils.getPropertyDescriptor(Hibernate.getClass(entity), propertyName);
|
return pd;
|
}
|
|
/**
|
* 为对象entity设置value.
|
*
|
* @param entity 实体类
|
* @param propertyName 字段名
|
* @param value 值
|
*/
|
public static final void setPropertyValue(Object entity, String propertyName, Object value) {
|
if (propertyName.indexOf(POINT) > -1) {
|
String[] propertyNames = StringUtils.split(propertyName, '.');
|
for (int i = 0, l = propertyNames.length - 1; i < l; i++) {
|
entity = getPropertyValue(entity, propertyNames[i]);
|
if (entity == null) {
|
return;
|
}
|
}
|
propertyName = propertyNames[propertyNames.length - 1];
|
}
|
PropertyDescriptor pd = BeanUtils.getPropertyDescriptor(Hibernate.getClass(entity), propertyName);
|
if (pd != null) {
|
setPropertyValue(entity, pd, value);
|
}
|
}
|
|
public static final void setPropertyValue(Object entity, String propertyName, Object value,Class clazz) {
|
PropertyDescriptor pd = BeanUtils.getPropertyDescriptor(clazz, propertyName);
|
if (pd != null) {
|
setPropertyValue(entity, pd, value);
|
}
|
}
|
/**
|
* 为对象entity设置value.
|
*
|
* @param entity 实体类
|
* @param pd 要读取的属性PropertyDescriptord对象
|
* @param value 值
|
*/
|
public static final void setPropertyValue(@NotNull Object entity, @NotNull PropertyDescriptor pd, Object value) {
|
Method writeMethod = pd.getWriteMethod();
|
if (writeMethod != null) {
|
try {
|
value = BeanHelper.convert(value, pd.getPropertyType());
|
if (value == null || pd.getPropertyType().isAssignableFrom(value.getClass())) { // 必须是同样类型的才匹配,否则不处理
|
ReflectionUtils.invokeMethod(writeMethod, entity, value);
|
}
|
} catch (Exception e) {
|
throw new RuntimeException(entity.getClass() + POINT + pd.getName() + "写入值：" + value + "出现异常\n" + e.getMessage(), e);
|
}
|
}
|
}
|
|
/**
|
* 得到entity中propertyName属性的值.
|
*
|
* @param entity 实体对象
|
* @param propertyName 要读取的属性名
|
* @return 得到的值
|
*/
|
@SuppressWarnings({"rawtypes", "unchecked"})
|
public static final <T> T getPropertyValue(Object entity, String propertyName) {
|
if (entity == null) {
|
return null;
|
}
|
if (entity instanceof Map) {
|
return (T) ((Map) entity).get(propertyName);
|
}
|
|
if (propertyName.indexOf(POINT) > 0) {
|
String[] propertyNames = StringUtils.split(propertyName, '.');
|
for (String name : propertyNames) {
|
entity = getPropertyValue(entity, name);
|
}
|
return (T) entity;
|
}
|
|
PropertyDescriptor pd = BeanUtils.getPropertyDescriptor(Hibernate.getClass(entity), propertyName);
|
if (pd == null) {
|
Field field = ReflectionUtils.findField(Hibernate.getClass(entity), propertyName);
|
if (field != null) {
|
Method setAccessible = ReflectionUtils.findMethod(field.getClass(), "setAccessible", Boolean.TYPE);
|
ReflectionUtils.invokeMethod(setAccessible, field, true);
|
return (T) ReflectionUtils.getField(field, entity);
|
}
|
}
|
return getPropertyValue(entity, pd);
|
}
|
|
/**
|
* 得到entity中PropertyDescriptor属性的值.
|
*
|
* @param entity 实体对象
|
* @param pd 要读取的属性PropertyDescriptord对象
|
* @return 得到的值
|
*/
|
@SuppressWarnings("unchecked")
|
public static final <T> T getPropertyValue(Object entity, PropertyDescriptor pd) {
|
if (entity == null || pd == null || pd.getReadMethod() == null) {
|
return null;
|
}
|
Method readMethod = pd.getReadMethod();
|
try {
|
// if (!Modifier.isPublic(readMethod.getDeclaringClass().getModifiers())) {
|
// readMethod.setAccessible(true);
|
// }
|
// return (T) readMethod.invoke(entity);
|
return (T) ReflectionUtils.invokeMethod(readMethod, entity);
|
} catch (Exception e) {
|
throw new RuntimeException(e);
|
}
|
|
}
|
|
/**
|
* 得到组或Collection中下标index的值.
|
*
|
* @param array 数组或Collection
|
* @param index 下标,0开始
|
* @return 得到的值
|
*/
|
@SuppressWarnings({"rawtypes", "unchecked"})
|
public static final <T> T getValue(Object array, int index) {
|
if (array == null || index < 0) {
|
return null;
|
}
|
|
if (array instanceof Collection) { // 集合
|
if (((Collection) array).size() <= index) { // 下标越界
|
return null;
|
}
|
|
if (array instanceof List) {
|
return (T) (((List) array).get(index));
|
}
|
|
Iterator it = ((Collection) array).iterator();
|
while (index-- > 0) {
|
it.next();
|
}
|
|
return (T) it.next();
|
}
|
|
if (array.getClass().isArray()) { // 数组
|
if (Array.getLength(array) <= index) { // 下标越界
|
return null;
|
}
|
return (T) Array.get(array, index);
|
}
|
return null;
|
}
|
|
/**
|
* 新建clazz对象,并复制source中的属性
|
*
|
* @param source
|
* @param clazz
|
* @return
|
*/
|
public static <T> T copyAs(Object source, Class<T> clazz) {
|
T target = BeanUtils.instantiateClass(clazz);
|
copy(source, target);
|
return target;
|
}
|
|
/**
|
* 复制一个链表，目标链表节点类型是指定的Class
|
*
|
* @param list 源数据
|
* @param clazz 目标链表节点类型
|
* @return
|
*/
|
public static <T> List<T> copyAs(Collection<?> list, Class<T> clazz) {
|
return list.stream().map(source -> copyAs(source, clazz)).collect(Collectors.toList());
|
}
|
|
/**
|
* 对给定的source对象初始化所有保留类型的字段默认值。其中数字默认为0，boolean默认为false.
|
*
|
* @param source 要处理的对象
|
* @param ignoreProperties 不需要处理的字段
|
*/
|
public static final <T> void initPrimitiveFields(T source, String... ignoreProperties) {
|
Class<?> cls = Hibernate.getClass(source);
|
PropertyDescriptor[] targetPds = getPropertyDescriptors(cls);
|
List<String> ignoreList = (ignoreProperties != null) ? Arrays.asList(ignoreProperties) : Collections.emptyList();
|
Class<?> propertyClass;
|
for (PropertyDescriptor pd : targetPds) {
|
if (ignoreList.contains(pd.getName()) || pd.getWriteMethod() == null || getPropertyValue(source, pd) != null) {
|
continue;
|
}
|
propertyClass = pd.getPropertyType();
|
if (Boolean.class.equals(propertyClass) || Boolean.TYPE.equals(propertyClass)) {
|
// boolean类型默认为false
|
setPropertyValue(source, pd, false);
|
} else if (Number.class.isAssignableFrom(propertyClass)) {
|
// 数字类型默认为0
|
setPropertyValue(source, pd, 0);
|
}
|
}
|
}
|
|
/**
|
* 直接clone一个对象
|
*
|
* @param source 要复制的对象
|
* @param ignoreProperties 忽略的字段
|
* @return 复制的对象
|
*/
|
@SuppressWarnings("unchecked")
|
public static final <T> T copy(T source, String... ignoreProperties) {
|
Class<T> cls = Hibernate.getClass(source);
|
T obj = BeanUtils.instantiateClass(cls);
|
return BeanHelper.copy(source, obj, ignoreProperties);
|
}
|
|
/**
|
* 将source中所有不为null的值copy到target中.
|
* 与{@link BeanUtils#copyProperties(Object, Object, String...)}不同之处在于本方法不copy为null的属性
|
*
|
* @param source 要复制的源对象
|
* @param target 目标对象
|
* @param ignoreProperties 需要忽略的字段
|
* @return 返回target
|
* @see BeanUtils#copyProperties(Object, Object, String...)
|
*/
|
public static final <T> T copy(Object source, T target, String... ignoreProperties) {
|
return BeanHelper.copy(source, target, false, ignoreProperties);
|
}
|
|
/**
|
* 将source中所有不为null的Encrypt值copy到target中.(eg:copy soure.nameEncrypt to target.name)
|
* 与{@link BeanUtils#copyProperties(Object, Object, String...)}不同之处在于本方法不copy为null的属性
|
*
|
* @param source 要复制的源对象
|
* @param target 目标对象
|
* @param ignoreProperties 需要忽略的字段
|
* @return 返回target
|
* @see BeanUtils#copyProperties(Object, Object, String...)
|
*/
|
public static final <T> T copyEncrypt(Object source, T target, String... ignoreProperties) {
|
return BeanHelper.copyEncrypt(source, target, false,"Encrypt", ignoreProperties);
|
}
|
|
/**
|
* 将source中所有不为null的值copy到target中.
|
* 仅复制基础类型的数据,只对JAVA保留类型/数字/String/Date以及其数组的数据进行复制
|
* 与{@link BeanUtils#copyProperties(Object, Object, String...)}不同之处在于本方法不copy为null的属性
|
*
|
* @param source 要复制的源对象
|
* @param target 目标对象
|
* @param ignoreProperties 需要忽略的字段
|
* @return 返回target
|
* @see BeanUtils#copyProperties(Object, Object, String...)
|
*/
|
public static final <T> T copyBasic(Object source, T target, String... ignoreProperties) {
|
return BeanHelper.copy(source, target, true, ignoreProperties);
|
}
|
|
/**
|
* 判断指定的clazz是否为基础数据类型
|
*
|
* @param clazz
|
* @return
|
*/
|
public static boolean isBasicClass(Class<?> clazz) {
|
if (clazz.isArray()) {
|
clazz = clazz.getComponentType();
|
}
|
if ((clazz.isPrimitive()// JAVA的保留类型,boolean, byte, char, short, int, long, float, double.
|
|| Number.class.isAssignableFrom(clazz) // 数字
|
|| Boolean.class.isAssignableFrom(clazz) // Boolean
|
|| Character.class.isAssignableFrom(clazz) // Character
|
|| CharSequence.class.isAssignableFrom(clazz) // 字符串
|
|| Date.class.isAssignableFrom(clazz))// 日期
|
) {
|
return true;
|
}
|
return false;
|
}
|
|
/**
|
* 将source中所有不为null的值copy到target中.
|
* 与{@link BeanUtils#copyProperties(Object, Object, String...)}不同之处在于本方法不copy为null的属性
|
*
|
* @param source 要复制的源对象
|
* @param target 目标对象
|
* @param basicOnly 是否仅复制基础类型的数据,如果为true,则只对JAVA保留类型/数字/String/Date以及其数组的数据进行复制
|
* @param ignoreProperties 需要忽略的字段
|
* @return 返回target
|
* @see BeanUtils#copyProperties(Object, Object, String...)
|
*/
|
public static final <T> T copy(Object source, T target, boolean basicOnly, String... ignoreProperties) {
|
Assert.notNull(source, "Source must not be null");
|
Assert.notNull(target, "Target must not be null");
|
|
Class<?> cls = Hibernate.getClass(source);
|
Class<?> actualEditable = Hibernate.getClass(target);
|
|
PropertyDescriptor[] targetPds = getPropertyDescriptors(actualEditable);
|
List<String> ignoreList = (ignoreProperties != null) ? Arrays.asList(ignoreProperties) : null;
|
|
for (PropertyDescriptor targetPd : targetPds) {
|
if (basicOnly) {
|
Class<?> propertyType = targetPd.getPropertyType();
|
if (propertyType.isArray()) {
|
propertyType = propertyType.getComponentType();
|
}
|
if (!isBasicClass(propertyType)) {
|
// 复杂对象不处理
|
continue;
|
}
|
}
|
|
Method writeMethod = targetPd.getWriteMethod();
|
if (writeMethod != null && (ignoreList == null || (!ignoreList.contains(targetPd.getName())))) {
|
PropertyDescriptor sourcePd = BeanUtils.getPropertyDescriptor(cls, targetPd.getName());
|
if (sourcePd != null) {
|
Method readMethod = sourcePd.getReadMethod();
|
if (readMethod != null) {// && ClassUtils.isAssignable(writeMethod.getParameterTypes()[0], readMethod.getReturnType())) {
|
try {
|
// if (!Modifier.isPublic(readMethod.getDeclaringClass().getModifiers())) {
|
// readMethod.setAccessible(true);
|
// }
|
Object value = ReflectionUtils.invokeMethod(readMethod, source);
|
if (value == null) {
|
// 为null的值不处理
|
continue;
|
}
|
|
setPropertyValue(target, targetPd, value);
|
|
} catch (Throwable ex) {
|
throw new FatalBeanException("Could not copy property '" + targetPd.getName() + "' from source to target", ex);
|
}
|
}
|
}
|
}
|
}
|
|
return target;
|
}
|
|
/**
|
* 将source中所有不为null的值copy到target中.
|
* 与{@link BeanUtils#copyProperties(Object, Object, String...)}不同之处在于本方法不copy为null的属性
|
*
|
* @param source 要复制的源对象
|
* @param target 目标对象
|
* @param basicOnly 是否仅复制基础类型的数据,如果为true,则只对JAVA保留类型/数字/String/Date以及其数组的数据进行复制
|
* @param suffix 要复制的字段添加后缀
|
* @param ignoreProperties 需要忽略的字段
|
* @return 返回target
|
* @see BeanUtils#copyProperties(Object, Object, String...)
|
*/
|
public static final <T> T copyEncrypt(Object source, T target, boolean basicOnly,String suffix, String... ignoreProperties) {
|
Assert.notNull(source, "Source must not be null");
|
Assert.notNull(target, "Target must not be null");
|
|
Class<?> cls = Hibernate.getClass(source);
|
Class<?> actualEditable = Hibernate.getClass(target);
|
|
PropertyDescriptor[] targetPds = getPropertyDescriptors(actualEditable);
|
List<String> ignoreList = (ignoreProperties != null) ? Arrays.asList(ignoreProperties) : null;
|
|
for (PropertyDescriptor targetPd : targetPds) {
|
if (basicOnly) {
|
Class<?> propertyType = targetPd.getPropertyType();
|
if (propertyType.isArray()) {
|
propertyType = propertyType.getComponentType();
|
}
|
if (!isBasicClass(propertyType)) {
|
// 复杂对象不处理
|
continue;
|
}
|
}
|
|
Method writeMethod = targetPd.getWriteMethod();
|
if (writeMethod != null && (ignoreList == null || (!ignoreList.contains(targetPd.getName())))) {
|
PropertyDescriptor sourcePd = BeanUtils.getPropertyDescriptor(cls, targetPd.getName()+suffix);
|
if (sourcePd != null) {
|
Method readMethod = sourcePd.getReadMethod();
|
if (readMethod != null) {// && ClassUtils.isAssignable(writeMethod.getParameterTypes()[0], readMethod.getReturnType())) {
|
try {
|
// if (!Modifier.isPublic(readMethod.getDeclaringClass().getModifiers())) {
|
// readMethod.setAccessible(true);
|
// }
|
Object value = ReflectionUtils.invokeMethod(readMethod, source);
|
if (value == null) {
|
// 为null的值不处理
|
continue;
|
}
|
|
setPropertyValue(target, targetPd, value);
|
|
} catch (Throwable ex) {
|
throw new FatalBeanException("Could not copy property '" + targetPd.getName() + "' from source to target", ex);
|
}
|
}
|
}
|
}
|
}
|
|
return target;
|
}
|
|
/**
|
* 生成32位的uuid.没有短横线"-".
|
*
|
* @return 没有短横线的UUID
|
* @see UUID#randomUUID()
|
*/
|
public static final String uuid() {
|
return UUID.randomUUID().toString().replace("-", "");
|
}
|
|
/**
|
* 判断a是否和b相等.
|
* 如果均是空白字符,视为相等; null和空白字符视为相等; 如果a,b均为字符串,区分大小写.忽略字符串前后的空格
|
*
|
* @param a
|
* @param b
|
* @return a是否等于b
|
*/
|
public static boolean equals(Object a, Object b) {
|
if (Objects.equals(a, b)) {
|
return true;
|
}
|
if (a == null) {
|
return b instanceof String && StringUtils.isBlank((String) b);
|
}
|
if (b == null) {
|
return a instanceof String && StringUtils.isBlank((String) a);
|
}
|
|
if (a instanceof String && b instanceof String) {
|
// 两个均为字符串
|
if (StringUtils.isBlank((String) a) && StringUtils.isBlank((String) b)) {
|
return true;
|
}
|
if (((String) a).trim().equals(((String) b).trim())) {
|
return true;
|
}
|
}
|
if (a instanceof Date && b instanceof Date) {
|
return ((Date) a).getTime() == ((Date) b).getTime();
|
}
|
|
if (a instanceof Number && b instanceof Number) {
|
return new BigDecimal(a.toString()).equals(new BigDecimal(b.toString()));
|
}
|
|
if (a.getClass().equals(b.getClass())) {
|
PropertyDescriptor[] pds = getPropertyDescriptors(a.getClass());
|
for (PropertyDescriptor pd : pds) {
|
if (!equals(getPropertyValue(a, pd), getPropertyValue(b, pd))) {
|
return false;
|
}
|
}
|
return true;
|
}
|
|
return false;
|
}
|
|
/**
|
* 判断a是否和b相等.忽略字符串前后的空格
|
* 如果均是空白字符,视为相等; null和空白字符视为相等; 如果a,b均为字符串,不区分大小写.
|
*
|
* @param a
|
* @param b
|
* @return a是否等于b
|
*/
|
public static boolean equalsIgnoreCase(Object a, Object b) {
|
if (a instanceof String && b instanceof String) { // 两个均为字符串
|
if (StringUtils.isBlank((String) a) && StringUtils.isBlank((String) b)) {
|
return true;
|
}
|
if (((String) a).trim().equalsIgnoreCase(((String) b).trim())) {
|
return true;
|
}
|
} else {
|
return equals(a, b);
|
}
|
|
return false;
|
}
|
|
/**
|
* 比较数组是否相同，如果是字符串,忽略大小写和前后的空格
|
*
|
* @param a
|
* @param b
|
* @return
|
*/
|
public static boolean equalsIgnoreCase(Object[] a, Object[] b) {
|
if (a == b) {
|
return true;
|
}
|
if (a == null || b == null) {
|
return false;
|
}
|
|
int length = a.length;
|
if (b.length != length) {
|
return false;
|
}
|
|
for (int i = 0; i < length; i++) {
|
if (!equalsIgnoreCase(a[i], b[i])) {
|
return false;
|
}
|
}
|
|
return true;
|
}
|
|
/**
|
* 比较数组的前length个数据是否相同，如果是字符串,忽略大小写和前后的空格
|
*
|
* @param a
|
* @param b
|
* @return
|
*/
|
public static boolean equalsIgnoreCase(Object[] a, Object[] b, int length) {
|
if (a.length > length) {
|
a = ArrayUtils.subarray(a, 0, length);
|
}
|
if (b.length > length) {
|
b = ArrayUtils.subarray(b, 0, length);
|
}
|
return equalsIgnoreCase(a, b);
|
}
|
|
/**
|
* 输出异常的堆栈信息.
|
*
|
* @param e 异常信息
|
* @return
|
*/
|
public static String toString(Throwable e) {
|
StringWriter w = new StringWriter();
|
PrintWriter pw = new PrintWriter(w);
|
e.printStackTrace(pw);
|
return w.toString();
|
}
|
|
/**
|
* 将列名转换为按驼峰命名的属性名.
|
*
|
* @param columnName 列名
|
* @return JAVA驼峰命名规范的属性名
|
*/
|
public static String columnToProperty(String columnName) {
|
char[] chars = columnName.toLowerCase().toCharArray();
|
StringBuilder buf = new StringBuilder();
|
boolean flag = false;
|
for (int i = 0, l = chars.length; i < l; i++) {
|
char c = chars[i];
|
if (c == '_' || c == '-' || c == ' ') { // 下一个单词大写
|
flag = buf.length() > 0;
|
} else {
|
buf.append(flag ? Character.toUpperCase(c) : c);
|
flag = false;
|
}
|
}
|
return buf.toString();
|
}
|
|
/**
|
* java字段名转换为列名.单词之间用下划线_隔开.
|
*
|
* @param propertyName 属性名
|
* @return 转换后的列名
|
*/
|
public static String propertyToColumn(String propertyName) {
|
char[] chars = propertyName.toCharArray();
|
StringBuilder buf = new StringBuilder();
|
for (int i = 0, l = chars.length; i < l; i++) {
|
char c = chars[i];
|
if (Character.isUpperCase(c)) {
|
// 单词大写
|
if (buf.length() > 0) {
|
buf.append('_');
|
}
|
}
|
buf.append(c);
|
}
|
return buf.toString().toLowerCase();
|
}
|
|
/**
|
* 得到pd属性的列名.
|
*
|
* @param pd 要得到列名的属性
|
* @return 列名
|
*/
|
public static String getColumnName(PropertyDescriptor pd) {
|
Column column = pd.getReadMethod() == null ? null : pd.getReadMethod().getAnnotation(Column.class);
|
if (column == null && pd.getWriteMethod() != null) {
|
// getter方法没有@Column注解,通过setter方法读取
|
column = pd.getWriteMethod().getAnnotation(Column.class);
|
}
|
|
if (column != null && !column.name().isEmpty()) {
|
return column.name();
|
}
|
return propertyToColumn(pd.getName());
|
}
|
|
/**
|
* 将Map中的数据读取到到实体对象中.
|
*
|
* @param data Map数据.
|
* @param entity 实体对象.
|
* @return 参数entity本身.
|
*/
|
public static void readValue(Map<?, ?> data, Object entity) {
|
data.entrySet().forEach(entry -> {
|
String key = entry.getKey().toString();
|
Object value = entry.getValue();
|
if (!key.contains(String.valueOf(UNDERLINE))) {
|
Class<?> clazz = Hibernate.getClass(entity);
|
PropertyDescriptor pd = BeanUtils.getPropertyDescriptor(clazz, key);
|
if (pd != null) {
|
setPropertyValue(entity, pd, value);
|
return;
|
}
|
}
|
setPropertyValueByColumn(entity, key, value);
|
});
|
}
|
|
/**
|
* 将实体转换为map中的数据.只包含不为null的字段
|
*
|
* @param map
|
* @param entity
|
* @param <K> String 或 Object
|
*/
|
@SuppressWarnings({"unchecked"})
|
public static <K> void putValue(Map<K, Object> map, Object entity) {
|
if (entity == null) {
|
return;
|
}
|
PropertyDescriptor[] pds = getPropertyDescriptors(entity);
|
Arrays.stream(pds).forEach(pd -> {
|
// String key = pd.getName();
|
Object value = getPropertyValue(entity, pd);
|
if (value != null) {
|
map.put((K) pd.getName(), value);
|
}
|
});
|
}
|
|
/**
|
* 将实体对象转换为Map.返回的map中只包含不为null的字段
|
*
|
* @param entity
|
* @param <K> String 或 Object
|
* @return
|
*/
|
public static <K> Map<K, Object> toMap(Object entity) {
|
Map<K, Object> map = new HashMap<>();
|
putValue(map, entity);
|
return map;
|
}
|
|
/**
|
* 根据列名,将数据value写入到实体entity中.会根据列名的下划线分隔符写入到子对象中.
|
*
|
* @param entity 实体对象
|
* @param columnName SQL读取的列名
|
* @param value 要写入的数据值
|
* @return 是否有设置值.
|
*/
|
public static boolean setPropertyValueByColumn(Object entity, String columnName, Object value) {
|
columnName = StringUtils.strip(columnName, "_");
|
Class<?> clazz = Hibernate.getClass(entity);
|
String propertyName = columnToProperty(columnName);
|
PropertyDescriptor pd = BeanUtils.getPropertyDescriptor(clazz, propertyName);
|
if (pd != null) {
|
setPropertyValue(entity, pd, value);
|
return true;
|
}
|
|
// 可能是包含子对象
|
int p = columnName.indexOf("_"); // 以下划线分隔的字段名
|
String field;
|
while (p > 0) {
|
field = columnName.substring(0, p);
|
propertyName = columnToProperty(field);
|
pd = BeanUtils.getPropertyDescriptor(clazz, propertyName);
|
if (pd != null) {
|
break;
|
}
|
p = columnName.indexOf("_", p + 1);
|
}
|
if (pd == null) {
|
return false;
|
}
|
|
Object e = getPropertyValue(entity, pd);
|
boolean flag = e == null;
|
if (flag) {
|
e = BeanUtils.instantiateClass(pd.getPropertyType());
|
}
|
boolean change = setPropertyValueByColumn(e, columnName.substring(p + 1), value);
|
if (flag && change) {
|
setPropertyValue(entity, pd, e);
|
}
|
return change;
|
}
|
|
/**
|
* 将obj对象转换为指定的cls类型.如果没有转换则返回obj
|
*
|
* @param obj 要转换的数据，一般指从数据库读取的数据
|
* @param cls 要转换为的类型，一般为实体类的字段class
|
* @return
|
*/
|
public static Object convert(Object obj, Class<?> cls) {
|
if (obj == null) {
|
return null;
|
}
|
if (cls.isAssignableFrom(obj.getClass())) {
|
return obj;
|
}
|
if (String.class.equals(cls)) {
|
return obj.toString();
|
}
|
|
if (Date.class.equals(cls)) {
|
return DateUtils.parse(obj.toString());
|
}
|
if (Double.class.equals(cls) || Double.TYPE.equals(cls) || Float.class.equals(cls) || Float.TYPE.equals(cls) || Long.class.equals(cls)
|
|| Long.TYPE.equals(cls) || Integer.class.equals(cls) || Integer.TYPE.equals(cls) || Short.class.equals(cls) || Short.TYPE.equals(cls)
|
|| Byte.class.equals(cls) || Byte.TYPE.equals(cls)) {
|
// 数字类型
|
BigDecimal bd;
|
if (obj instanceof Number) {
|
bd = new BigDecimal(obj.toString());
|
} else if (obj instanceof Date) {
|
bd = new BigDecimal(((Date) obj).getTime());
|
} else {
|
bd = new BigDecimal(obj.toString());
|
}
|
|
if (Double.TYPE.equals(cls)||Double.class.equals(cls)) {
|
return bd.doubleValue();
|
}
|
|
if (Float.TYPE.equals(cls)||Float.class.equals(cls)) {
|
return bd.floatValue();
|
}
|
|
if (Long.TYPE.equals(cls)||Long.class.equals(cls)) {
|
return bd.longValue();
|
}
|
|
if (Integer.TYPE.equals(cls)||Integer.class.equals(cls)) {
|
return bd.intValue();
|
}
|
|
if (Short.TYPE.equals(cls)||Short.class.equals(cls)) {
|
return bd.shortValue();
|
}
|
|
if (Byte.TYPE.equals(cls)||Byte.class.equals(cls)) {
|
return bd.byteValue();
|
}
|
}
|
|
if (BigDecimal.class.isAssignableFrom(cls)) {
|
// 大数类型
|
if (obj instanceof Long || obj instanceof Integer || obj instanceof Short || obj instanceof Byte) {
|
return BigDecimal.valueOf(((Number) obj).longValue());
|
} else if (obj instanceof Number) {
|
return BigDecimal.valueOf(((Number) obj).doubleValue());
|
} else if (obj instanceof Date) {
|
return BigDecimal.valueOf(((Date) obj).getTime());
|
} else {
|
return new BigDecimal(obj.toString());
|
}
|
}
|
|
if (BigInteger.class.isAssignableFrom(cls)) {
|
// 大整数类型
|
if (obj instanceof Number) {
|
return BigInteger.valueOf(((Number) obj).longValue());
|
} else if (obj instanceof Date) {
|
return BigInteger.valueOf(((Date) obj).getTime());
|
} else {
|
return new BigInteger(obj.toString());
|
}
|
}
|
|
return obj;
|
}
|
|
/**
|
* 将原生数据数组转换为Object[]
|
*
|
* @param primitives boolean[]/byte[]/short[]/char[]/int[]/long[]/float[]/double[]等类型的数组
|
* @return Object[]数组
|
*/
|
public static Object[] toObject(Object primitives) {
|
if (primitives == null) {
|
return null;
|
}
|
if (!primitives.getClass().isArray()) {
|
return new Object[]{primitives};
|
}
|
// final Class<?> cls = primitives.getClass().getComponentType();
|
if (primitives instanceof boolean[]) {
|
return ArrayUtils.toObject((boolean[]) primitives);
|
}
|
if (primitives instanceof byte[]) {
|
return ArrayUtils.toObject((byte[]) primitives);
|
}
|
if (primitives instanceof short[]) {
|
return ArrayUtils.toObject((char[]) primitives);
|
}
|
if (primitives instanceof char[]) {
|
return ArrayUtils.toObject((char[]) primitives);
|
}
|
if (primitives instanceof int[]) {
|
return ArrayUtils.toObject((int[]) primitives);
|
}
|
if (primitives instanceof long[]) {
|
return ArrayUtils.toObject((long[]) primitives);
|
}
|
if (primitives instanceof float[]) {
|
return ArrayUtils.toObject((float[]) primitives);
|
}
|
if (primitives instanceof double[]) {
|
return ArrayUtils.toObject((double[]) primitives);
|
}
|
|
return (Object[]) primitives;
|
}
|
|
/**
|
* 将下划线的字段改为驼峰命名
|
*
|
* @param param
|
* @return
|
*/
|
public static String underlineToCamel(String param) {
|
if (param == null || "".equals(param.trim())) {
|
return "";
|
}
|
int len = param.length();
|
StringBuilder sb = new StringBuilder(len);
|
for (int i = 0; i < len; i++) {
|
char c = param.charAt(i);
|
if (c == UNDERLINE) {
|
if (++i < len) {
|
sb.append(Character.toUpperCase(param.charAt(i)));
|
}
|
} else {
|
sb.append(c);
|
}
|
}
|
return sb.toString();
|
}
|
|
/**
|
* 首字母转小写
|
*
|
* @param s
|
* @return
|
*/
|
public static String toLowerCaseFirstOne(String s) {
|
if (Character.isLowerCase(s.charAt(0))) {
|
return s;
|
} else {
|
return (new StringBuilder()).append(Character.toLowerCase(s.charAt(0))).append(s.substring(1)).toString();
|
}
|
}
|
|
|
/**
|
* @param name 转换前的驼峰式命名的字符串
|
* @return 转换后下划线大写方式命名的字符串
|
*/
|
public static String humpToDivide(String name, String connStr) {
|
StringBuilder result = new StringBuilder();
|
if (name != null && name.length() > 0) {
|
// 将第一个字符处理成大写
|
result.append(name.substring(0, 1).toUpperCase());
|
// 循环处理其余字符
|
for (int i = 1; i < name.length(); i++) {
|
String s = name.substring(i, i + 1);
|
// 在大写字母前添加下划线
|
if (s.equals(s.toUpperCase()) && !Character.isDigit(s.charAt(0))) {
|
result.append(connStr);
|
}
|
// 其他字符直接转成大写
|
result.append(s);
|
}
|
}
|
return result.toString().toLowerCase(Locale.ENGLISH);
|
}
|
|
/**
|
* 判断对象是否为null/empty/blan
|
*
|
* @param value
|
* @return
|
*/
|
public static boolean isBlank(Object value) {
|
if (value == null) {
|
return true;
|
}
|
if (value instanceof CharSequence) {
|
return StringUtils.isBlank((CharSequence) value);
|
}
|
if (value.getClass().isArray() && Array.getLength(value) < 1) {
|
return true;
|
}
|
if (value instanceof Collection && ((Collection<?>) value).isEmpty()) {
|
return true;
|
}
|
if (value instanceof Map && ((Map<?, ?>) value).isEmpty()) {
|
return true;
|
}
|
|
return false;
|
}
|
|
/**
|
* 判断对象是否为null/empty/blan
|
*
|
* @param value
|
* @return
|
*/
|
public static boolean isEmpty(Object value) {
|
if (value == null) {
|
return true;
|
}
|
if (value instanceof CharSequence) {
|
return StringUtils.isEmpty((CharSequence) value);
|
}
|
if (value.getClass().isArray() && Array.getLength(value) < 1) {
|
return true;
|
}
|
if (value instanceof Collection && ((Collection<?>) value).isEmpty()) {
|
return true;
|
}
|
if (value instanceof Map && ((Map<?, ?>) value).isEmpty()) {
|
return true;
|
}
|
|
return false;
|
}
|
}
|
