Java对象的拷贝和转换，BeanUtils拷贝和 cglib拷贝
前言
因为工作中会不可避免的使用model的值拷贝，或者DTO转实体类，或者属性值特别多的部分拷贝。还有集合的泛型类型的转换，所以利用spring的BeanUtils和cglib写了简单的工具类来供大家参考，另外注意一点就是Apache也有提供BeanUtils，但是由于我不知道的某某原因存在性能较差。当然最快的还是cglib，这不是本文所关注的重点，本文是工作中奔着实用和学习的目标去的。
测试类中也对分组进行了 java8的写法进行对比，可以对比学习一下
当然啦还有性能对比
几种copyProperties工具类性能比较：https://www.jianshu.com/p/bcbacab3b89e
CGLIB中BeanCopier源码实现：https://www.jianshu.com/p/f8b892e08d26
Java Bean Copy框架性能对比：https://yq.aliyun.com/articles/392185
正文
工具类涉及到这些jar包，
spring的 spring-beans-xxxx.RELEASE.jar
cglib的 cglib-2.2.jar
阿里巴巴的json工具 fastjson-1.2.31.jar
代码和测试类
功能包含
对象的属性的拷贝（如果是复杂类型，如属性为另一个class类，请自行进行修改进行迭代拷贝，不然该属性值会为null，同理以下也是如此，切记切记）
属性的部分拷贝，如几十上百个以上的属性只拷贝其中的百分之六七十，一个个进行set很麻烦，可以使用部分拷贝
集合的类型转换， 如 List 转换为 List 其中A、B均为 model 形式的，也就是说有getter和setter，其中要是转换成为 Map 可以使用 fastjson 转换。
List分组 java8 的写法更好。
import java.beans.PropertyDescriptor;
import java.io.IOException;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.BiConsumer;
import java.util.function.BiPredicate;
import java.util.function.Consumer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.BeanWrapper;
import org.springframework.beans.BeanWrapperImpl;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONException;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.parser.Feature;
import com.alibaba.fastjson.serializer.SerializerFeature;
import net.sf.cglib.beans.BeanCopier;
import net.sf.cglib.beans.BeanMap;
/** <p>Title: TemplateCodeUtil</p>
* <p>Description: 对象拷贝与转化 </p>
* @author houzw
* @date 2019年4月18日
*/
public class TemplateCodeUtil {
protected static final Logger logger = LoggerFactory.getLogger(TemplateCodeUtil.class);
// 使用多线程安全的Map来缓存BeanCopier，由于读操作远大于写，所以性能影响可以忽略
public static ConcurrentHashMap<String, BeanCopier> beanCopierMap = new ConcurrentHashMap<String, BeanCopier>();
/**
* 通过cglib BeanCopier形式,使用cglib拷贝，同属性同类型拷贝
*
* @param source 源转换的对象
* @param target 目标转换的对象
*/
public static void copyProperties(Object source, Object target) {
String beanKey = generateKey(source.getClass(), target.getClass());
BeanCopier copier = null;
if (beanCopierMap.containsKey(beanKey)) {
copier = beanCopierMap.get(beanKey);
} else {
copier = BeanCopier.create(source.getClass(), target.getClass(), false);
beanCopierMap.putIfAbsent(beanKey, copier);// putIfAbsent已经实现原子操作了。
}
copier.copy(source, target, null);
}
/**
* 通过cglib BeanCopier形式,使用cglib拷贝，同属性同类型拷贝
*
* @param source 源转换的对象
* @param target 目标转换的对象
* @param action 支持Lambda函数给拷贝完的对象一些自定义操作
* @return
*/
public static <O,T> T copyProperties(O source, T target, Consumer<T> action) {
String beanKey = generateKey(source.getClass(), target.getClass());
BeanCopier copier = null;
if (beanCopierMap.containsKey(beanKey)) {
copier = beanCopierMap.get(beanKey);
} else {
copier = BeanCopier.create(source.getClass(), target.getClass(), false);
beanCopierMap.putIfAbsent(beanKey, copier);// putIfAbsent已经实现原子操作了。
}
copier.copy(source, target, null);
action.accept(target);
return target;
}
private static String generateKey(Class<?> class1, Class<?> class2) {
return class1.toString() + class2.toString();
}
/**
* transalte常规反射拷贝，同名同类型拷贝,推荐使用 transTo(O o, Class<T> clazz)
* ×通过常规反射形式 DTO对象转换为实体对象。如命名不规范或其他原因导致失败。
* @param t 源转换的对象
* @param e 目标转换的对象
*
*/
public static <T, O> void transalte(T t, O e) {
Method[] tms = t.getClass().getDeclaredMethods();
Method[] tes = e.getClass().getDeclaredMethods();
for (Method m1 : tms) {
if (m1.getName().startsWith("get")) {
String mNameSubfix = m1.getName().substring(3);
String forName = "set" + mNameSubfix;
for (Method m2 : tes) {
if (m2.getName().equals(forName)) {
// 如果类型一致，或者m2的参数类型是m1的返回类型的父类或接口
boolean canContinue = m2.getParameterTypes()[0].isAssignableFrom(m1.getReturnType());
if (canContinue) {
try {
m2.invoke(e, m1.invoke(t));
break;
} catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e1) {
// log未配置会报 WARN No appenders could be found for
// logger log4j:WARN Please initialize the log4j
// system properly.
logger.debug("DTO 2 Entity转换失败");
e1.printStackTrace();
}
}
}
}
}
}
// logger.debug("转换完成");
}
/**
* 对象属性拷贝，忽略源转换对象的 null值
* @param t 源转换的对象
* @param e 目标转换的对象
*
*/
public static <T, O> void copyPropertiesIgnoreNull(T t, O e) {
final BeanWrapper bw = new BeanWrapperImpl(t);
PropertyDescriptor[] pds = bw.getPropertyDescriptors();
Set<String> emptyNames = new HashSet<String>();
for(PropertyDescriptor pd : pds) {
Object srcValue = bw.getPropertyValue(pd.getName());
if (srcValue != null) emptyNames.add(pd.getName());
}
partialCopy(t, e, emptyNames.toArray());
}
/**
* 对象属性拷贝，同属性同类型拷贝，忽略源转换对象不符合自定义规则的属性
* @param t 源转换的对象
* @param e 目标转换的对象
* @param action lambda传入的是t的属性名和属性值，返回true和e对象有该属性则拷贝该值
*/
public static <T, O> void copyPropertiesIgnoreCustom(T t, O e, BiPredicate<String, Object> action) {
final BeanWrapper bw = new BeanWrapperImpl(t);
PropertyDescriptor[] pds = bw.getPropertyDescriptors();
Set<String> emptyNames = new HashSet<String>();
for(PropertyDescriptor pd : pds) {
Object srcValue = bw.getPropertyValue(pd.getName());
// 自定义条件的成立与否，返回true则拷贝，反之不拷贝，满足同属性同类型。
if (action.test(pd.getName(), srcValue)) emptyNames.add(pd.getName());
}
partialCopy(t, e, emptyNames.toArray());
}
/** 同类型字段部分拷贝
* @param t 源数据对象
* @param e 接收对象
* @param key 要拷贝的字段名数组
*/
public static <T> void partialCopy(T t , T e, Object... key) {
BeanMap t1 = BeanMap.create(t);
BeanMap e1 = BeanMap.create(e);
int i = key.length;
while (i-- > 0) {
e1.replace(key[i], t1.get(key[i]));
}
}
/**
* 对象集合转换，两个对象的属性名字需要一样
*/
public static <T, O> List<T> transTo(List<O> fromList, Class<T> clazz) throws IllegalAccessException, InstantiationException, InvocationTargetException {
List<T> toList = new ArrayList<>();
for (O e : fromList) {
T entity = clazz.newInstance();
BeanUtils.copyProperties(e, entity);
toList.add(entity);
}
return toList;
}
/**
* 对象集合转换，两个对象的属性名字需要一样，并可自定义设置一些参数
*/
public static <T, O> List<T> transTo(List<O> fromList, Class<T> clazz, OnTransListener<T, O> onTransListener) throws IllegalAccessException, InstantiationException, InvocationTargetException {
List<T> toList = new ArrayList<>();
for (O e : fromList) {
T entity = clazz.newInstance();
BeanUtils.copyProperties(e, entity);
if (onTransListener != null) {
onTransListener.doSomeThing(entity, e);
}
toList.add(entity);
}
return toList;
}
/**
* 使用BeanUtils，对象集合转换，两个对象的属性名字需要一样，并可自定义设置一些参数
*
* @param fromList 源数据List
* @param clazz 需要转换成的clazz
* @param action 支持lambda表达式自定义设置一些参数
* @return
*/
public static <T, O> List<T> transToCustom(List<O> fromList, Class<T> clazz, BiConsumer<O, T> action) throws IllegalAccessException, InstantiationException, InvocationTargetException {
List<T> toList = new ArrayList<>();
for (O e : fromList) {
T entity = clazz.newInstance();
BeanUtils.copyProperties(e, entity);
action.accept(e, entity);
toList.add(entity);
}
return toList;
}
/**
* 使用BeanUtils，对象转换，E转为t对象
*/
public static <T, O> T transTo(O e, Class<T> clazz) throws IllegalAccessException, InstantiationException, InvocationTargetException {
T t = clazz.newInstance();
BeanUtils.copyProperties(e, t);
return t;
}
/**
* 接口常量转为指定类型的List
*/
public static <T> List<T> interfaceTransToVal(Class<?> clazz, Class<T> toClazz) throws IllegalAccessException {
List<T> list = new ArrayList<>();
Field[] fields = clazz.getDeclaredFields();
for (Field field : fields) {
T t = (T) field.get(clazz);
if (t.getClass() == toClazz) {
list.add(t);
}
}
return list;
}
/**
* json 转为对象
*/
public static <T> T jsonToObject(String jsonStr, Class<T> clazz) {
// ObjectMapper objectMapper = new ObjectMapper();
T t = null;
try {
t = JSONObject.parseObject(jsonStr, clazz);
// t = objectMapper.readValue(jsonByte, clazz);
} catch (JSONException e) {
e.printStackTrace();
}
return t;
}
/**
* json 转为Array
*/
public static <T> List<T> jsonToArray(String jsonStr, Class<T> clazz) {
if (jsonStr == null || jsonStr.length() == 0) {
return null;
} else {
// ObjectMapper objectMapper = new ObjectMapper();
List<T> arr = null;
try {
arr = JSON.parseArray(jsonStr, clazz);
// JavaType javaType = objectMapper.getTypeFactory().constructParametricType(ArrayList.class, clazz);
// arr = objectMapper.readValue(jsonStr, javaType);
} catch (JSONException e) {
e.printStackTrace();
}
return arr;
}
}
/**
* Map 转为对象，字段格式要一致
*/
public static <T> T mapTrasnToObject(Map<String, Object> map, Class<T> clazz) throws IOException {
byte[] jsonBytes = JSON.toJSONBytes(map, SerializerFeature.WriteNullStringAsEmpty);
T t = JSON.parseObject(jsonBytes, clazz,Feature.IgnoreNotMatch);
// ObjectMapper objectMapper = new ObjectMapper();
// String jsonStr = objectMapper.writeValueAsString(map);
// T t = objectMapper.readValue(jsonStr, clazz);
return t;
}
/**
* object(非基本类型和List类型)转为 Map
* 若类型不正确返回的map为EmptyMap，其不可添加元素
* @param obj
* @return
*/
@SuppressWarnings("unchecked")
public static Map<String, Object> objectTrasnToMap(Object obj) {
if (Objects.isNull(obj)) {
return Collections.EMPTY_MAP;
} else {
Map<String, Object> map = BeanMap.create(obj);
return map.size() == 1 && map.containsKey("empty") ? Collections.EMPTY_MAP : new HashMap<>(map);
}
}
/**
* 集合根据某个关键字进行分组
*/
public static <T> Map<String, List<T>> groupBy(List<T> tList, StringKey<T> stringKey) {
Map<String, List<T>> map = new HashMap<>();
for (T t : tList) {
if (map.containsKey(stringKey.key(t))) {
map.get(stringKey.key(t)).add(t);
} else {
List<T> list = new ArrayList<>();
list.add(t);
map.put(stringKey.key(t), list);
}
}
return map;
}
/**
* 把对象转为json,并输出到日志中
*/
public static void logObject(String tag, Object object) {
try { // 保留空值数据为 ""
String json = JSON.toJSONString(object, SerializerFeature.WriteNullStringAsEmpty);
// ObjectMapper objectMapper = new ObjectMapper();
// String json = objectMapper.writeValueAsString(object);
logger.info("{}{}", tag, json);
} catch (JSONException e) {
e.printStackTrace();
logger.info("exception = {}", e);
}
}
/**
* 集合分组的关键词
*/
public interface StringKey<T> {
String key(T t);
}
/**
* 编写一些额外逻辑
*/
public interface OnTransListener<T, O> {
void doSomeThing(T t, O e);
}
}
测试类需要说明一下的就是DTO的属性比实体类属性要多一点，可以自己创建修改一下。因为懒所以直接以输出的形式输出结果，并未使用Assert，请各位有强迫X的请不要介意，谢谢
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import com.alibaba.fastjson.JSON;
import com.neusoft.util.TemplateCodeUtil.OnTransListener;
import com.neusoft.util.TemplateCodeUtil.StringKey;
import kjcxpt.kjcxpthd.dto.PrincipalConditionAndMemberDTO;
import kjcxpt.kjcxpthd.entity.PrincipalCondition;
/** <p>Title: TemplateCodeUtilTest</p>
* <p>Description: 该方法为测试方法，在方法名上直接右键选择juni运行</p>
* @author houzw
* @date 2019年5月6日
*/
public class TemplateCodeUtilTest {
// 当前DTO属性多
private PrincipalConditionAndMemberDTO dto = new PrincipalConditionAndMemberDTO();
// 当前entity属性少
private PrincipalCondition entity = new PrincipalCondition();
private List<PrincipalConditionAndMemberDTO> dtoList = null;
private List<PrincipalCondition> entityList = null;
@Before
public void setUpBefore() throws Exception {
dto.setIdCard("sds"); // entity中没有该属性
dto.setDr(111); // entity中有该属性
entity.setUnitName("dto的值会覆盖此值");
dtoList = new ArrayList<PrincipalConditionAndMemberDTO>();
PrincipalConditionAndMemberDTO dtoadd = null;
int num = 0;
do {
dtoadd = new PrincipalConditionAndMemberDTO();
dtoadd.setIdCard("testList"+ num);
dtoadd.setDr(Integer.valueOf(num));
dtoList.add(dtoadd);
num++;
} while (dtoList.size() < 10);
entityList = new ArrayList<PrincipalCondition>();
PrincipalCondition entityadd = null;
do {
entityadd = new PrincipalCondition();
entityList.add(entityadd);
} while (entityList.size() < 10);
}
@After
public void tearDownAfter() throws Exception {
System.out.println("dto:" + JSON.toJSONString(dto));
System.out.println("entity:" + JSON.toJSONString(entity));
System.out.println("dtoList:" + JSON.toJSONString(dtoList));
System.out.println("entityList:" + JSON.toJSONString(entityList));
}
@Test
public void testCopyPropertiesObjectObject() {
TemplateCodeUtil.copyProperties(dto, entity);
}
@Test
public void testCopyPropertiesOTConsumerOfT() {
// 对拷贝后的对象操作,使用lambda表达式
PrincipalCondition copyProperties = TemplateCodeUtil.copyProperties(dto, entity, t -> System.out.println(t.getDr()));
System.out.println(copyProperties.getDr());
// 设置其他属性
TemplateCodeUtil.copyProperties(dto, entity, t -> {
t.setFoundYear("2019");
t.setFinishTime(new Date());
});
}
@Test
public void testTransalte() {
// 常规的利用反射的 拷贝
TemplateCodeUtil.transalte(dto, entity);
}
@Test
public void testCopyPropertiesIgnoreNull() {
TemplateCodeUtil.copyPropertiesIgnoreNull(dto, entity);
System.out.println(entity.getDr());
dto.setDr(null);
entity.setDr(111111);
TemplateCodeUtil.copyPropertiesIgnoreNull(dto, entity);
}
@Test
public void testCopyPropertiesIgnoreCustom() {
// lambda自定义 那些需要赋值，前提必须是 同名同属性，否则 返回true 也不拷贝
TemplateCodeUtil.copyPropertiesIgnoreCustom(dto, entity, (key, value) -> {
if ("dr".equals(key) && value != null) {
value = "赋值给源数据value，这该如何解释"; // 这种操作我无法解释 ^_^
return true;
}
if( "idCard".equals(key)) { // 即使返回true，entity没有该属性，所以也不会有该属性和值
return true;
}
if (value != null) { // 不为null 赋值
return true;
}else {
return false;
}
});
}
@Test
public void testPartialCopy() {
String[] names = new String[]{"dr"};
TemplateCodeUtil.partialCopy(dto, entity, names);
// 此时unitName还未被覆盖，只拷贝 dr属性
System.out.println(entity.getUnitName());
// 测试部分拷贝,拷贝dr 和 unitName
TemplateCodeUtil.partialCopy(dto, entity, "dr","unitName");
}
@Test
public void testTransToListOfEClassOfT() throws Exception {
// dto转换为entity，使用的是 beanUnits
List<PrincipalCondition> transTo = TemplateCodeUtil.transTo(dtoList, PrincipalCondition.class);
System.out.println(JSON.toJSONString(transTo));
}
@Test
public void testTransToListOfEClassOfTOnTransListenerOfTE() {
// 自定义的拷贝后的转换方法
class myOnTransListener implements OnTransListener<PrincipalCondition, PrincipalConditionAndMemberDTO> {
@Override
public void doSomeThing(PrincipalCondition en, PrincipalConditionAndMemberDTO dt) {
// 这明显和lambda的简洁度比起来有点繁杂 transToCustom
System.out.println(dt.getIdCard());
en.setDescription("ssss");
}
}
try {
entityList = TemplateCodeUtil.transTo(dtoList, PrincipalCondition.class, new myOnTransListener());
} catch (IllegalAccessException | InstantiationException | InvocationTargetException e) {
e.printStackTrace();
}
}
@Test
public void testTransToCustomListOfEClassOfTBiConsumerOfTE() throws IllegalAccessException, InstantiationException, InvocationTargetException {
entityList = TemplateCodeUtil.transToCustom(dtoList, PrincipalCondition.class, (d, e)-> {
System.out.println(d.getIdCard());
e.setDescription("ssss");
});
}
@Test
public void testTransToEClassOfT() throws IllegalAccessException, InstantiationException, InvocationTargetException {
entityList = TemplateCodeUtil.transTo(dtoList, PrincipalCondition.class);
}
@Test
public void testInterfaceTransToVal() throws IllegalAccessException {
// 接口常量这种是 反模式，用接口存常量是一种不良的习惯。所以我就懒得做示范了。没什么必要
}
@Test
public void testJsonToObject() {
}
@Test
public void testJsonToArray() {
fail("Not yet implemented");
}
@Test
public void testMapTrasnToObject() {
fail("Not yet implemented");
}
@Test
public void testGroupBy() {
class myStringKey implements StringKey<PrincipalConditionAndMemberDTO> {
@Override
public String key(PrincipalConditionAndMemberDTO t) {
// 选取dto的一个字段 idCard
return t.getIdCard();
}
}
Map<String, List<PrincipalConditionAndMemberDTO>> groupBy = TemplateCodeUtil.groupBy(dtoList, new myStringKey());
System.out.println(JSON.toJSONString(groupBy));
Map<Integer, List<PrincipalConditionAndMemberDTO>> collect = dtoList.stream().collect(Collectors.groupingBy(PrincipalConditionAndMemberDTO::getDr));
System.out.println(JSON.toJSONString(collect));
}
@Test
public void testLogObject() {
// 这个是在web环境下有slf4j的配置才行，生产环境请删除该输出语句
}
}
结束祝语
以上就这么多，祝各位玩的愉快！！
