Java 属性映射（DozerBeanMapper）

package com.tenyears.common.utils;

import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import org.apache.commons.beanutils.BeanUtils;
import org.dozer.DozerBeanMapper;
import org.dozer.Mapper;
import org.dozer.loader.api.BeanMappingBuilder;
import org.dozer.loader.api.TypeMappingOption;
import org.dozer.loader.api.TypeMappingOptions;
import org.springframework.cglib.beans.BeanMap;

import java.lang.reflect.Field;
import java.util.*;

public class DozerMapperUtil {
    static Mapper mapper = new DozerBeanMapper();

    /**
     * 将list转换为vo的list
     * Example : List<VO> resultList=DozerMapperUtil.mapList(list, VO.class);
     * @param source
     * @param destType
     * @return
     */
    public static <T, U> List<U> mapList(final List<T> source, final Class<U> destType) {
        final List<U> dest = new ArrayList<U>();
        for (T element : source) {
            dest.add(mapper.map(element, destType));
        }
        return dest;
    }

    /**
     * 将继承自Collection(Set,List....)的转换为VO的List
     * Example : Collection<VO> planLog = DozerMapperUtil.mapCollection(Set<>, VO.class);
     * @param source
     * @param destType
     * @param <T>
     * @param <U>
     * @return
     */
    public static <T, U> Collection<U> mapCollection(final Collection<T> source, final Class<U> destType) {
        final Collection<U> dest = new ArrayList<>();
        for (T element : source) {
            dest.add(mapper.map(element, destType));
        }
        return dest;
    }

    /**
     * 转换单个vo对象,自动生成目标实例化对象
     * Example : DozerMapperUtil.map(entity,VO)
     * @param source
     * @param destType
     * @return
     */
    public static <U> U map(final Object source, final Class<U> destType) {
        return mapper.map(source, destType);
    }

    /**
     * 将source的所有属性拷贝至target,source里没有的字段,target里不覆盖
     * Example : DozerMapperUtil.map(entity,VO)
     * @param source
     * @param target
     * @return
     */
    public static <U> void map(final Object source, final U target) {
        DozerBeanMapper mapper = new DozerBeanMapper();
        mapper.addMapping(new BeanMappingBuilder() {
            @Override
            protected void configure() {
                mapping(source.getClass(), target.getClass(),
                        new TypeMappingOption[]{TypeMappingOptions.mapNull(false)});
            }

        });
        mapper.map(source, target);
    }

    /**
     * 将source的所有属性拷贝至target,source里没有的字段,target里不覆盖
     * Example : DozerMapperUtil.map(entity,VO,True)
     * @param source
     * @param target
     * @param nullCover 为true时，source中的值为null也覆盖
     * @param <U>
     */
    public static <U> void map(final Object source, final U target, boolean nullCover) {
        DozerBeanMapper mapper = new DozerBeanMapper();
        mapper.addMapping(new BeanMappingBuilder() {
            @Override
            protected void configure() {
                mapping(source.getClass(), target.getClass(),
                        new TypeMappingOption[]{TypeMappingOptions.mapNull(nullCover)});
            }

        });
        mapper.map(source, target);
    }


    /**
     * @param sourceBean *            被提取的对象bean
     * @param targetBean *            用于合并的对象bean
     * @return targetBean 合并后的对象
     * @Title: map2
     * @Description: (因为在使用map方法时遇到有字段没有复制成功 ， 所以重写了新方法 ， 经试用没问题 。)该方法是用于相同对象不同属性值的合并，如果两个相同对象中同一属性都有值，
     * 那么sourceBean中的值会覆盖tagetBean重点的值
     * @return: Object
     */
    @SuppressWarnings("unused")
    public static Object map2(Object sourceBean, Object targetBean) {
        Class sourceBeanClass = sourceBean.getClass();
        Class targetBeanClass = targetBean.getClass();

        Field[] sourceFields = sourceBeanClass.getDeclaredFields();
        Field[] targetFields = sourceBeanClass.getDeclaredFields();
        for (int i = 0; i < sourceFields.length; i++) {
            Field sourceField = sourceFields[i];
            Field targetField = targetFields[i];
            sourceField.setAccessible(true);
            targetField.setAccessible(true);
            try {
                if (!(sourceField.get(sourceBean) == null)) {
                    targetField.set(targetBean, sourceField.get(sourceBean));
                }
            } catch (IllegalArgumentException | IllegalAccessException e) {
                e.printStackTrace();
            }
        }
        return targetBean;
    }

    /**
     * 将bena转换成map
     * Example : beanToMap(vo)
     * @param bean
     * @param <T>
     * @return
     */
    public static <T> Map<String, String> beanToMap(T bean) {
        if (null == bean)
            return null;
        try {
            Map<String, String> map = BeanUtils.describe(bean);
            // 移除key=class
            map.remove("class");
            return map;
        } catch (Exception e) {
            System.out.println("JavaBean-->Map转换失败：" + e.getMessage());
            e.printStackTrace();
            return null;
        }
    }


    /**
     * 将map转换成bean
     * Example : mapToBean(map,VO.class)
     * @param map
     * @param t
     * @param <T>
     * @return
     */
    @SuppressWarnings("unchecked")
    public static <T> T mapToBean(Map map, Class<T> t) {
        try {
            T newBeanInstance = (T) t.newInstance();
            BeanUtils.populate(newBeanInstance, map);
            return newBeanInstance;
        }
        catch (Exception e) {
            System.out.println("Map-->JavaBean转换失败：" + e.getMessage());
            e.printStackTrace();
            return null;
        }

    }

    /**
     * List<bean>转换成List<Map>
     * Example : beansToMaps(List<VO>)
     * @param listbean
     * @param <T>
     * @return
     */
    public static <T> List<Map<String, String>> beansToMaps(List<T> listbean) {
        List<Map<String, String>> maps = Lists.newArrayList();
        if (listbean == null || listbean.size() == 0) {
            return null;
        }
        for (T bean : listbean) {
            if (bean != null) {
                Map<String, String> beanToMaps = beanToMap(bean);
                maps.add(beanToMaps);
            }
        }
        return maps;
    }


    /**
     * list<Map>转换成List<bean>
     * Example : mapsToBeans(List<Map>,VO.class)
     * @param listmap
     * @param t
     * @param <T>
     * @return
     */
    public static <T> List<T> mapsToBeans(List<Map> listmap, Class<T> t) {
        List<T> list = Lists.newArrayList();
        if (listmap == null || listmap.size() == 0) {
            return null;
        }
        for (Map map : listmap) {
            T t2 = mapToBean(map, t);
            list.add(t2);
        }
        return list;


    }

}