Java对象的拷贝和转换，BeanUtils拷贝和 cglib拷贝

目录

• 前言
• 正文
  • 工具类涉及到这些jar包，
  • 代码和测试类
• 结束祝语

前言

因为工作中会不可避免的使用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的配置才行，生产环境请删除该输出语句
    }

}

结束祝语

以上就这么多，祝各位玩的愉快！！