首先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