SpringBoot2.0中使用easy-mapper进行对象的拷贝（基于easy-mapper的二次简单封装）

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/Nicolas12/article/details/82390398

首先pom中引入依赖

        <dependency>
            <groupId>com.baidu.unbiz</groupId>
            <artifactId>easy-mapper</artifactId>
            <version>1.0.4</version>
        </dependency>

定义Mapper接口

public  interface IMapper
{
   <O, T> T map(O paramO, Class<T> paramClass);

   <O, T> T map(O paramO, T paramT);

   <A, B> void register(Class<A> paramClass, Class<B> paramClass1);

   <A, B> void register(Class<A> paramClass, Class<B> paramClass1, String[] paramArrayOfString);
}

实现Mapper接口

import com.baidu.unbiz.easymapper.MapperFactory;



public class Mapper implements IMapper {
    @Override
    public <O, T> T map(O obj, Class<T> val) {
        return MapperFactory.getCopyByRefMapper().map(obj, val);
    }

    @Override
    public <O, T> T map(O var1, T var2) {
        return MapperFactory.getCopyByRefMapper().map(var1, var2);
    }

    @Override
    public <A, B> void register(Class<A> var1, Class<B> var2) {
        MapperFactory.getCopyByRefMapper().mapClass(var1, var2).register();
    }

    @Override
    public <A, B> void register(Class<A> var1, Class<B> var2, String... excludes) {
        MapperFactory.getCopyByRefMapper().mapClass(var1, var2).exclude(excludes).register();
    }

}

编写MapperUtil工具类

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


public class MapperUtil {
    private static final IMapper mapperAgent = new Mapper();
    private static final Set<String> mapCaches = new HashSet();


    public static <O, T> T mapper(O obj, Class<T> val) {
        String key = obj.getClass().getName() + "_" + val.getName();
        if (mapCaches.contains(key))
            return mapperAgent.map(obj, val);

        mapperRegister(obj.getClass(), val);
        mapCaches.add(key);
        return mapperAgent.map(obj, val);
    }


    public static <O, T> T mapperObject(O var1, T var2) {
        String key = var1.getClass().getName() + "_" + var2.getClass().getName();
        if (mapCaches.contains(key))
            return mapperAgent.map(var1, var2);

        mapperRegister(var1.getClass(), var2.getClass());
        mapCaches.add(key);
        return mapperAgent.map(var1, var2);
    }


    public static Type[] getParameterizedTypes(Object object) {
        Type superclassType = object.getClass().getGenericSuperclass();
        if (!(ParameterizedType.class.isAssignableFrom(superclassType.getClass())))
            return null;

        return ((ParameterizedType) superclassType).getActualTypeArguments();
    }

    private static void mapperRegister(Class<?> sourceClazz, Class<?> targetClazz) {
        if ((Collection.class.isAssignableFrom(sourceClazz)) || (Map.class.isAssignableFrom(sourceClazz)) || (Iterator.class.isAssignableFrom(sourceClazz))) {
            return;
        }

        Field[] fields = getClassFields(sourceClazz);
        Field[] targetFields = getClassFields(targetClazz);

        List excludes = new ArrayList();
        Map targetNames = fieldsToMap(targetFields);
        Field[] arrayOfField1 = fields;
        int i = arrayOfField1.length;
        label234:
        for (int j = 0; j < i; ++j) {
            Field field = arrayOfField1[j];
            Class clazz = field.getType();
            if (ClassUtil.isBaseDataType(clazz))
                break label234;

            String fieldName = field.getName();
            if (!(targetNames.containsKey(fieldName))) {
                break label234;
            }

            Class fieldType = field.getType();
            if ((((Collection.class.isAssignableFrom(fieldType)) || (Map.class.isAssignableFrom(fieldType)) || (Iterator.class.isAssignableFrom(fieldType)))) &&
                    (!(isEqualType(field,
                            (Field) targetNames.get
                                    (fieldName))))) {
                excludes.add(fieldName);
            }

            Class tClazz = ((Field) targetNames.get(fieldName)).getType();
            if (Objects.equals(tClazz, clazz))
                mapperAgent.register(clazz, tClazz);
            //mapperRegister(clazz, tClazz);
        }
        mapperAgent.register(sourceClazz, targetClazz, (String[]) excludes.toArray(new String[excludes.size()]));
    }



    private static HashMap<String, Field> fieldsToMap(Field[] targetFields) {
        HashMap map = new HashMap();
        Field[] arrayOfField = targetFields;
        int i = arrayOfField.length;
        for (int j = 0; j < i; ++j) {
            Field field = arrayOfField[j];
            map.put(field.getName(), field);
        }
        return map;
    }

    private static Field[] getClassFields(Class clazz) {
        if ((clazz == null) || (clazz.equals(Object.class)))
            return null;
        Field[] declaredFields = clazz.getDeclaredFields();
        Field[] afterFields = getClassFields(clazz.getSuperclass());
        if (afterFields == null) {
            return declaredFields;
        }

        return ArrayUtil.joinFields(afterFields, declaredFields);
    }

    private static boolean isEqualType(Field fieldInput, Field fieldOutput) {
        return Objects.equals(fieldInput.getGenericType(), fieldOutput.getGenericType());
    }
}

附上上面使用到的ArrayUtil工具

import java.lang.reflect.Field;
import java.util.Iterator;
import java.util.List;

public class ArrayUtil
{
  public static byte[] joinBytes(byte[] byte1, byte[] byte2)
  {
    byte[] bytes = new byte[byte1.length + byte2.length];
    System.arraycopy(byte1, 0, bytes, 0, byte1.length);
    System.arraycopy(byte2, 0, bytes, byte1.length, byte2.length);
    return bytes;
  }

  public static byte[] padRightBytes(byte[] bytes, int length) {
    byte[] newbytes = new byte[length];
    System.arraycopy(bytes, 0, newbytes, 0, bytes.length);
    return newbytes;
  }

  public static byte[] limitBytes(byte[] bytes, int skip) {
    return limitBytes(bytes, skip, bytes.length - skip);
  }

  public static byte[] limitBytes(byte[] bytes, int skip, int take) {
    byte[] newBytes = new byte[take];
    System.arraycopy(bytes, skip, newBytes, 0, take);
    return newBytes;
  }

  public static byte[] joinBytes(List<byte[]> bytesList) {
    int len = 0;
    for (Iterator localIterator = bytesList.iterator(); localIterator.hasNext(); ) { byte[] item = (byte[])localIterator.next();
      len += item.length;
    }
    return joinBytes(bytesList, len);
  }

  public static byte[] joinBytes(List<byte[]> bytesList, int length) {
    byte[] bytes = new byte[length];
    int byteLength = 0;
    for (Iterator localIterator = bytesList.iterator(); localIterator.hasNext(); ) { byte[] item = (byte[])localIterator.next();
      System.arraycopy(item, 0, bytes, byteLength, item.length);
      byteLength += item.length;
    }
    return bytes;
  }

  public static Field[] joinFields(Field[] field1, Field[] field2) {
    Field[] fields = new Field[field1.length + field2.length];
    System.arraycopy(field1, 0, fields, 0, field1.length);
    System.arraycopy(field2, 0, fields, field1.length, field2.length);
    return fields;
  }
}

附上几张工具copy对象的时间的对比图



图片来源：https://blog.csdn.net/hj7jay/article/details/52179997