package com.moral.api.utils;
|
|
import cn.hutool.json.JSONUtil;
|
import com.alibaba.fastjson.JSONArray;
|
import com.alibaba.fastjson.JSONObject;
|
import com.fasterxml.jackson.annotation.JsonInclude;
|
import com.fasterxml.jackson.core.type.TypeReference;
|
import com.fasterxml.jackson.databind.DeserializationFeature;
|
import com.fasterxml.jackson.databind.ObjectMapper;
|
import com.fasterxml.jackson.databind.SerializationFeature;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.beans.BeanUtils;
|
import org.springframework.cglib.beans.BeanMap;
|
|
import java.beans.BeanInfo;
|
import java.beans.IntrospectionException;
|
import java.beans.Introspector;
|
import java.beans.PropertyDescriptor;
|
import java.lang.reflect.InvocationTargetException;
|
import java.lang.reflect.Method;
|
import java.math.BigDecimal;
|
import java.sql.Timestamp;
|
import java.time.LocalDate;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
import java.util.stream.Stream;
|
import java.util.stream.StreamSupport;
|
|
|
import java.util.*;
|
|
/**
|
* @ClassName BeanConverts
|
* @Description TODO
|
* @Author @lizijie
|
* @Date 2023-09-20 13:41
|
* @Version 1.0
|
*/
|
@Slf4j
|
@SuppressWarnings("unchecked")
|
public class BeanConverts {
|
private static ObjectMapper objectMapper = new ObjectMapper();
|
static{
|
|
//序列化的时候序列对象的所有属性
|
objectMapper.setSerializationInclusion(JsonInclude.Include.ALWAYS);
|
|
//反序列化的时候如果多了其他属性,不抛出异常
|
objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
|
|
//如果是空对象的时候,不抛异常
|
objectMapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
|
|
//属性为null的转换
|
objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
|
}
|
|
private BeanConverts() {
|
}
|
|
/**
|
* BeanUtils.copyProperties 增强
|
* 拷贝时，source 值为空则不拷贝
|
*
|
* @param source 源数据
|
* @param target 目标数据
|
* @param ignoreProperties 忽略属性
|
*/
|
public static void copyPropertiesIgnoreNull(Object source, Object target, String... ignoreProperties) {
|
Set<String> ignoreSet = new HashSet<>();
|
if (ignoreProperties != null) {
|
ignoreSet.addAll(Arrays.asList(ignoreProperties));
|
}
|
ignoreSet.addAll(getObjectNullFieldName(source));
|
BeanUtils.copyProperties(source, target, ignoreSet.toArray(new String[0]));
|
}
|
|
/**
|
* 获取对象字段值为null 的字段名称集合
|
*
|
* @param object 源数据
|
* @return 字段名称集合
|
*/
|
public static List<String> getObjectNullFieldName(Object object) {
|
BeanMap beanMap = BeanMap.create(object);
|
List<String> fieldNameList = new ArrayList<>();
|
for (Object key : beanMap.keySet()) {
|
if (beanMap.get(key) == null) {
|
fieldNameList.add(key.toString());
|
}
|
}
|
return fieldNameList;
|
}
|
|
/**
|
* 将对象转换为map
|
* 不转换空值字段
|
*
|
* @param obj 对象
|
* @return 键值对
|
*/
|
public static Map<String, Object> objToMapIgnoreNull(Object obj) {
|
return objToMap(obj, true);
|
}
|
|
/**
|
* 将对象转换为map
|
*
|
* @param obj 对象
|
* @return 键值对
|
*/
|
public static Map<String, Object> objToMap(Object obj) {
|
return objToMap(obj, false);
|
}
|
|
/**
|
* 将对象转换为map
|
*
|
* @param obj 对象
|
* @param ignoreNull 忽略空值字段
|
* @return 键值对
|
*/
|
private static Map<String, Object> objToMap(Object obj, boolean ignoreNull) {
|
return JSONUtil.parseObj(obj, ignoreNull);
|
}
|
|
/**
|
* entity 转换
|
*
|
* @param obj 源对象
|
* @param clazz 目标类型
|
* @param <T> 泛型
|
* @return 目标对象
|
*/
|
public static <T> T cloneShallow(Object obj, Class<T> clazz) {
|
if (obj == null) {
|
return null;
|
}
|
T t = BeanUtils.instantiateClass(clazz);
|
BeanUtils.copyProperties(obj, t);
|
return t;
|
}
|
|
/**
|
* entity 集合转换
|
*
|
* @param collection 源对象集合
|
* @param clazz 目标类型
|
* @param <T> 泛型
|
* @return 目标对象集合
|
*/
|
public static <T> List<T> cloneShallow(Collection<?> collection, Class<T> clazz) {
|
return collection.stream().map(item -> convert(item, clazz)).collect(Collectors.toList());
|
}
|
|
/**
|
* entity 转换
|
*
|
* @param obj 源对象
|
* @param clazz 目标类型
|
* @param <T> 泛型
|
* @return 目标对象
|
*/
|
public static <T> T convert(Object obj, Class<T> clazz) {
|
|
return objectMapper.convertValue(obj, clazz);
|
}
|
|
public static <T> T convert(Object obj, TypeReference<T> type) {
|
return objectMapper.convertValue(obj, type);
|
}
|
|
/**
|
* entity 转换
|
*
|
* @param optional 源对象
|
* @param clazz 目标类型
|
* @param <T> 泛型
|
* @return 目标对象
|
*/
|
public static <T> T convert(Optional<?> optional, Class<T> clazz) {
|
return optional.map(obj -> convert(obj, clazz)).orElseGet(null);
|
}
|
|
/**
|
* entity 集合转换
|
*
|
* @param collection 源对象集合
|
* @param clazz 目标类型
|
* @param <T> 泛型
|
* @return 目标对象集合
|
*/
|
public static <T> List<T> convert(Collection<?> collection, Class<T> clazz) {
|
return JSONArray.parseArray(JSONArray.toJSONString(collection), clazz);
|
}
|
|
/**
|
* entity 集合转换
|
*
|
* @param iterable 实体集合
|
* @param clazz 目标类型
|
* @param <T> 泛型
|
* @return 目标对象集合
|
*/
|
public static <T> List<T> convert(Iterable<?> iterable, Class<T> clazz) {
|
return convert(StreamSupport.stream(iterable.spliterator(), false), clazz);
|
}
|
|
/**
|
* entity 集合转换
|
*
|
* @param stream 实体集合流
|
* @param clazz 目标类型
|
* @param <T> 泛型
|
* @return 目标对象集合
|
*/
|
public static <T> List<T> convert(Stream<?> stream, Class<T> clazz) {
|
return stream.map(entity -> convert(entity, clazz)).collect(Collectors.toList());
|
}
|
|
|
/**
|
* map 转对象
|
*
|
* @param clazz 目标类型
|
* @param collection 键值对集合
|
* @param <T> 泛型
|
* @return 目标对象集合
|
*/
|
public static <T> List<T> mapToObj(Class<T> clazz, Collection<Map<String, Object>> collection) {
|
return collection.stream().map(map -> BeanConverts.mapToObj(clazz, map)).collect(Collectors.toList());
|
}
|
|
/**
|
* map 转对象
|
*
|
* @param clazz 目标类型
|
* @param map 键值对
|
* @param <T> 泛型
|
* @return 目标对象
|
*/
|
public static <T> T mapToObj(Class<T> clazz, Map<String, Object> map) {
|
T d = BeanUtils.instantiateClass(clazz);
|
BeanInfo beanInfo;
|
try {
|
beanInfo = Introspector.getBeanInfo(d.getClass());
|
} catch (IntrospectionException e) {
|
log.warn(e.getMessage(), e);
|
return null;
|
}
|
PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
|
for (PropertyDescriptor property : propertyDescriptors) {
|
Method setter = property.getWriteMethod();
|
if (setter == null) {
|
continue;
|
}
|
Object value = map.get(property.getName());
|
if (value == null) {
|
continue;
|
} else if (value instanceof Timestamp) {
|
if (property.getPropertyType().equals(LocalDate.class)) {
|
value = ((Timestamp) value).toLocalDateTime().toLocalDate();
|
} else {
|
value = ((Timestamp) value).toLocalDateTime();
|
}
|
} else if (property.getPropertyType().equals(BigDecimal.class)) {
|
value = BigDecimal.valueOf((double) value);
|
}
|
try {
|
setter.invoke(d, value);
|
} catch (Exception e) {
|
log.warn(e.getMessage(), e);
|
}
|
}
|
return d;
|
}
|
|
/**
|
* 对象集合中取出两个字段，组成map
|
*
|
* @param collection 对象集合
|
* @param keyProperty key属性值
|
* @param valueProperty value属性值
|
* @param <E> 泛型
|
* @return 属性值map
|
*/
|
public static <E> Map<String, E> propertyToMap(Collection collection, String keyProperty, String valueProperty) {
|
Map<String, E> map = new LinkedHashMap<>();
|
if (collection.isEmpty()) {
|
return map;
|
}
|
Object obj = collection.iterator().next();
|
BeanInfo beanInfo;
|
try {
|
beanInfo = Introspector.getBeanInfo(obj.getClass());
|
} catch (IntrospectionException e) {
|
log.warn(e.getMessage(), e);
|
return map;
|
}
|
PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
|
Method keyGetter = null;
|
Method valueGetter = null;
|
for (PropertyDescriptor property : propertyDescriptors) {
|
if (keyProperty.equals(property.getName()) && property.getReadMethod() != null) {
|
keyGetter = property.getReadMethod();
|
} else if (valueProperty.equals(property.getName()) && property.getReadMethod() != null) {
|
valueGetter = property.getReadMethod();
|
}
|
}
|
if (keyGetter == null || valueGetter == null) {
|
return map;
|
}
|
for (Object item : collection) {
|
try {
|
map.put(keyGetter.invoke(item).toString(), (E) valueGetter.invoke(item));
|
} catch (IllegalAccessException | InvocationTargetException e) {
|
log.warn(e.getMessage(), e);
|
}
|
}
|
return map;
|
}
|
|
/**
|
* 将对象转换为map
|
*
|
* @param obj 对象
|
* @return 键值对
|
*/
|
public static Map<String, Object> objToMapNonJson(Object obj) {
|
Map<String, Object> map = new HashMap<>(8);
|
if (obj != null) {
|
BeanMap beanMap = BeanMap.create(obj);
|
for (Object key : beanMap.keySet()) {
|
Object value = beanMap.get(key);
|
map.put(key.toString(), value);
|
}
|
}
|
return map;
|
}
|
}
|
