背景

在分层的代码架构中，层与层之间的对象避免不了要做很多转换、赋值等操作，这些操作重复且繁琐，于是乎催生出很多工具来优雅，高效地完成这个操作，有BeanUtils、BeanCopier、Dozer、Orika等等，本文将讲述上面几个工具的使用、性能对比及原理分析。

性能分析

其实这几个工具要做的事情很简单，而且在使用上也是类似的，所以我觉得先给大家看看性能分析的对比结果，让大家有一个大概的认识。我是使用JMH来做性能分析的，代码如下：
要复制的对象比较简单，包含了一些基本类型；有一次warmup，因为一些工具是需要“预编译”和做缓存的，这样做对比才会比较客观；分别复制1000、10000、100000个对象，这是比较常用数量级了吧。

  1. @BenchmarkMode(Mode.AverageTime)  
  2. @OutputTimeUnit(TimeUnit.MICROSECONDS)  
  3. @Fork(1)  
  4. @Warmup(iterations = 1)  
  5. @State(Scope.Benchmark)  
  6. public class BeanMapperBenchmark {  
  8.     @Param({"1000", "10000", "100000"})  
  9.     private int times;  
  11.     private int time;  
  13.     private static MapperFactory mapperFactory;  
  15.     private static Mapper mapper;  
  17.     static {  
  18.         mapperFactory = new DefaultMapperFactory.Builder().build();  
  19.         mapperFactory.classMap(SourceVO.class, TargetVO.class)  
  20.                 .byDefault()  
  21.                 .register();  
  23.         mapper = DozerBeanMapperBuilder.create()  
  24.                 .withMappingBuilder(new BeanMappingBuilder() {  
  25.                     @Override  
  26.                     protected void configure() {  
  27.                         mapping(SourceVO.class, TargetVO.class)  
  28.                                 .fields("fullName", "name")  
  29.                                 .exclude("in");  
  30.                     }  
  31.                 }).build();  
  32.     }  
  34.     public static void main(String[] args) throws Exception {  
  35.         Options options = new OptionsBuilder()  
  36.                 .include(BeanMapperBenchmark.class.getName()).measurementIterations(3)  
  37.                 .build();  
  38.         new Runner(options).run();  
  39.     }  
  41.     @Setup  
  42.     public void prepare() {  
  43.         this.time = times;  
  44.     }  
  46.     @Benchmark  
  47.     public void springBeanUtilTest(){  
  48.         SourceVO sourceVO = getSourceVO();  
  49.         for(int i = 0; i < time; i++){  
  50.             TargetVO targetVO = new TargetVO();  
  51.             BeanUtils.copyProperties(sourceVO, targetVO);  
  52.         }  
  53.     }  
  55.     @Benchmark  
  56.     public void apacheBeanUtilTest() throws Exception{  
  57.         SourceVO sourceVO = getSourceVO();  
  58.         for(int i = 0; i < time; i++){  
  59.             TargetVO targetVO = new TargetVO();  
  60.             org.apache.commons.beanutils.BeanUtils.copyProperties(targetVO, sourceVO);  
  61.         }  
  63.     }  
  65.     @Benchmark  
  66.     public void beanCopierTest(){  
  67.         SourceVO sourceVO = getSourceVO();  
  68.         for(int i = 0; i < time; i++){  
  69.             TargetVO targetVO = new TargetVO();  
  70.             BeanCopier bc = BeanCopier.create(SourceVO.class, TargetVO.class, false);  
  71.             bc.copy(sourceVO, targetVO, null);  
  72.         }  
  74.     }  
  76.     @Benchmark  
  77.     public void dozerTest(){  
  78.         SourceVO sourceVO = getSourceVO();  
  79.         for(int i = 0; i < time; i++){  
  80.             TargetVO map = mapper.map(sourceVO, TargetVO.class);  
  81.         }  
  82.     }  
  84.     @Benchmark  
  85.     public void orikaTest(){  
  86.         SourceVO sourceVO = getSourceVO();  
  87.         for(int i = 0; i < time; i++){  
  88.             MapperFacade mapper = mapperFactory.getMapperFacade();  
  89.             TargetVO map = mapper.map(sourceVO, TargetVO.class);  
  90.         }  
  91.     }  
  93.     private SourceVO getSourceVO(){  
  94.         SourceVO sourceVO = new SourceVO();  
  95.         sourceVO.setP1(1);  
  96.         sourceVO.setP2(2L);  
  97.         sourceVO.setP3(new Integer(3).byteValue());  
  98.         sourceVO.setDate1(new Date());  
  99.         sourceVO.setPattr1("1");  
  100.         sourceVO.setIn(new SourceVO.Inner(1));  
  101.         sourceVO.setFullName("alben");  
  102.         return sourceVO;  
  103.     }  
  105. }

在我macbook下运行后的结果如下：
BeanUtils、BeanCopier、Dozer、Orika 哪个性能最强？ - 图1
Score表示的是平均运行时间，单位是微秒。从执行效率来看，可以看出 beanCopier > orika > springBeanUtil > dozer > apacheBeanUtil。这样的结果跟它们各自的实现原理有很大的关系，
下面将详细每个工具的使用及实现原理。

Spring的BeanUtils

使用

这个工具可能是大家日常使用最多的，因为是Spring自带的，使用也简单：BeanUtils.copyProperties(sourceVO, targetVO);

原理

Spring BeanUtils的实现原理也比较简答，就是通过Java的Introspector获取到两个类的PropertyDescriptor，对比两个属性具有相同的名字和类型，如果是，则进行赋值（通过ReadMethod获取值，通过WriteMethod赋值），否则忽略。
为了提高性能Spring对BeanInfo和PropertyDescriptor进行了缓存。
（源码基于：org.springframework:spring-beans:4.3.9.RELEASE）

  1. /**  
  2.   * Copy the property values of the given source bean into the given target bean.  
  3.   * <p>Note: The source and target classes do not have to match or even be derived  
  4.   * from each other, as long as the properties match. Any bean properties that the  
  5.   * source bean exposes but the target bean does not will silently be ignored.  
  6.   * @param source the source bean  
  7.   * @param target the target bean  
  8.   * @param editable the class (or interface) to restrict property setting to  
  9.   * @param ignoreProperties array of property names to ignore  
  10.   * @throws BeansException if the copying failed  
  11.   * @see BeanWrapper  
  12.   */  
  13.  private static void copyProperties(Object source, Object target, Class<?> editable, String... ignoreProperties)  
  14.    throws BeansException {  
  16.   Assert.notNull(source, "Source must not be null");  
  17.   Assert.notNull(target, "Target must not be null");  
  19.   Class<?> actualEditable = target.getClass();  
  20.   if (editable != null) {  
  21.    if (!editable.isInstance(target)) {  
  22.     throw new IllegalArgumentException("Target class [" + target.getClass().getName() +  
  23.       "] not assignable to Editable class [" + editable.getName() + "]");  
  24.    }  
  25.    actualEditable = editable;  
  26.   }  
  27.     //获取target类的属性（有缓存）  
  28.   PropertyDescriptor[] targetPds = getPropertyDescriptors(actualEditable);  
  29.   List<String> ignoreList = (ignoreProperties != null ? Arrays.asList(ignoreProperties) : null);  
  31.   for (PropertyDescriptor targetPd : targetPds) {  
  32.    Method writeMethod = targetPd.getWriteMethod();  
  33.    if (writeMethod != null && (ignoreList == null || !ignoreList.contains(targetPd.getName()))) {  
  34.         //获取source类的属性（有缓存）  
  35.     PropertyDescriptor sourcePd = getPropertyDescriptor(source.getClass(), targetPd.getName());  
  36.     if (sourcePd != null) {  
  37.      Method readMethod = sourcePd.getReadMethod();  
  38.      if (readMethod != null &&  
  39.               //判断target的setter方法入参和source的getter方法返回类型是否一致  
  40.        ClassUtils.isAssignable(writeMethod.getParameterTypes()[0], readMethod.getReturnType())) {  
  41.       try {  
  42.        if (!Modifier.isPublic(readMethod.getDeclaringClass().getModifiers())) {  
  43.         readMethod.setAccessible(true);  
  44.        }  
  45.               //获取源值  
  46.        Object value = readMethod.invoke(source);  
  47.        if (!Modifier.isPublic(writeMethod.getDeclaringClass().getModifiers())) {  
  48.         writeMethod.setAccessible(true);  
  49.        }  
  50.               //赋值到target  
  51.        writeMethod.invoke(target, value);  
  52.       }  
  53.       catch (Throwable ex) {  
  54.        throw new FatalBeanException(  
  55.          "Could not copy property '" + targetPd.getName() + "' from source to target", ex);  
  56.       }  
  57.      }  
  58.     }  
  59.    }  
  60.   }  
  61.  }

小结

Spring BeanUtils的实现就是这么简洁，这也是它性能比较高的原因。
不过，过于简洁就失去了灵活性和可扩展性了，Spring BeanUtils的使用限制也比较明显，要求类属性的名字和类型一致，这点在使用时要注意。

Apache的BeanUtils

使用

Apache的BeanUtils和Spring的BeanUtils的使用是一样的：
BeanUtils.copyProperties(targetVO, sourceVO);

要注意，source和target的入参位置不同。

原理

Apache的BeanUtils的实现原理跟Spring的BeanUtils一样，也是主要通过Java的Introspector机制获取到类的属性来进行赋值操作，对BeanInfo和PropertyDescriptor同样有缓存，但是Apache BeanUtils加了一些不那么使用的特性（包括支持Map类型、支持自定义的DynaBean类型、支持属性名的表达式等等）在里面，使得性能相对Spring的BeanUtils来说有所下降。
（源码基于：commons-beanutils:commons-beanutils:1.9.3）

  1. public void copyProperties(final Object dest, final Object orig)  
  2.         throws IllegalAccessException, InvocationTargetException {  
  4.         if (dest == null) {  
  5.             throw new IllegalArgumentException  
  6.                     ("No destination bean specified");  
  7.         }  
  8.         if (orig == null) {  
  9.             throw new IllegalArgumentException("No origin bean specified");  
  10.         }  
  11.         if (log.isDebugEnabled()) {  
  12.             log.debug("BeanUtils.copyProperties(" + dest + ", " +  
  13.                       orig + ")");  
  14.         }  
  15.         // Apache Common自定义的DynaBean  
  16.         if (orig instanceof DynaBean) {  
  17.             final DynaProperty[] origDescriptors =  
  18.                 ((DynaBean) orig).getDynaClass().getDynaProperties();  
  19.             for (DynaProperty origDescriptor : origDescriptors) {  
  20.                 final String name = origDescriptor.getName();  
  21.                 // Need to check isReadable() for WrapDynaBean  
  22.                 // (see Jira issue# BEANUTILS-61)  
  23.                 if (getPropertyUtils().isReadable(orig, name) &&  
  24.                     getPropertyUtils().isWriteable(dest, name)) {  
  25.                     final Object value = ((DynaBean) orig).get(name);  
  26.                     copyProperty(dest, name, value);  
  27.                 }  
  28.             }  
  29.         // Map类型  
  30.         } else if (orig instanceof Map) {  
  31.             @SuppressWarnings("unchecked")  
  32.             final  
  33.             // Map properties are always of type <String, Object>  
  34.             Map<String, Object> propMap = (Map<String, Object>) orig;  
  35.             for (final Map.Entry<String, Object> entry : propMap.entrySet()) {  
  36.                 final String name = entry.getKey();  
  37.                 if (getPropertyUtils().isWriteable(dest, name)) {  
  38.                     copyProperty(dest, name, entry.getValue());  
  39.                 }  
  40.             }  
  41.         // 标准的JavaBean  
  42.         } else {  
  43.             final PropertyDescriptor[] origDescriptors =  
  44.                 //获取PropertyDescriptor  
  45.                 getPropertyUtils().getPropertyDescriptors(orig);  
  46.             for (PropertyDescriptor origDescriptor : origDescriptors) {  
  47.                 final String name = origDescriptor.getName();  
  48.                 if ("class".equals(name)) {  
  49.                     continue; // No point in trying to set an object's class  
  50.                 }  
  51.                 //是否可读和可写  
  52.                 if (getPropertyUtils().isReadable(orig, name) &&  
  53.                     getPropertyUtils().isWriteable(dest, name)) {  
  54.                     try {  
  55.                         //获取源值  
  56.                         final Object value =  
  57.                             getPropertyUtils().getSimpleProperty(orig, name);  
  58.                         //赋值操作  
  59.                         copyProperty(dest, name, value);  
  60.                     } catch (final NoSuchMethodException e) {  
  61.                         // Should not happen  
  62.                     }  
  63.                 }  
  64.             }  
  65.         }  
  67.     }

小结

Apache BeanUtils的实现跟Spring BeanUtils总体上类似，但是性能却低很多，这个可以从上面性能比较看出来。阿里的Java规范是不建议使用的。
另外，关注公众号Java核心技术，在后台回复：手册，可以获取最新阿里的 Java 开发手册。

BeanCopier

使用

BeanCopier在cglib包里，它的使用也比较简单：

  1. @Test  
  2. public void beanCopierSimpleTest() {  
  3.     SourceVO sourceVO = getSourceVO();  
  4.     log.info("source={}", GsonUtil.toJson(sourceVO));  
  5.     TargetVO targetVO = new TargetVO();  
  6.     BeanCopier bc = BeanCopier.create(SourceVO.class, TargetVO.class, false);  
  7.     bc.copy(sourceVO, targetVO, null);  
  8.     log.info("target={}", GsonUtil.toJson(targetVO));  
  9. }

只需要预先定义好要转换的source类和target类就好了，可以选择是否使用Converter，这个下面会说到。
在上面的性能测试中，BeanCopier是所有中表现最好的，那么我们分析一下它的实现原理。

原理

BeanCopier的实现原理跟BeanUtils截然不同，它不是利用反射对属性进行赋值，而是直接使用cglib来生成带有的get/set方法的class类，然后执行。由于是直接生成字节码执行，所以BeanCopier的性能接近手写
get/set。
BeanCopier.create方法

  1. public static BeanCopier create(Class source, Class target, boolean useConverter) {  
  2.     Generator gen = new Generator();  
  3.     gen.setSource(source);  
  4.     gen.setTarget(target);  
  5.     gen.setUseConverter(useConverter);  
  6.     return gen.create();  
  7. }  
  9. public BeanCopier create() {  
  10.  Object key = KEY_FACTORY.newInstance(source.getName(), target.getName(), useConverter);  
  11.  return (BeanCopier)super.create(key);  
  12. }

这里的意思是用KEY_FACTORY创建一个BeanCopier出来，然后调用create方法来生成字节码。
KEY_FACTORY其实就是用cglib通过BeanCopierKey接口生成出来的一个类

  1. private static final BeanCopierKey KEY_FACTORY =  (BeanCopierKey)KeyFactory.create(BeanCopierKey.class);  
  3. interface BeanCopierKey {  
  4.  public Object newInstance(String source, String target, boolean useConverter);  
  5. }

通过设置

  1. System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "path");

可以让cglib输出生成类的class文件，我们可以反编译看看里面的代码
下面是KEY_FACTORY的类

  1. public class BeanCopier$BeanCopierKey$$KeyFactoryByCGLIB$$f32401fd extends KeyFactory implements BeanCopierKey {  
  2.     private final String FIELD_0;  
  3.     private final String FIELD_1;  
  4.     private final boolean FIELD_2;  
  6.     public BeanCopier$BeanCopierKey$$KeyFactoryByCGLIB$$f32401fd() {  
  7.     }  
  9.     public Object newInstance(String var1, String var2, boolean var3) {  
  10.         return new BeanCopier$BeanCopierKey$$KeyFactoryByCGLIB$$f32401fd(var1, var2, var3);  
  11.     }  
  13.     public BeanCopier$BeanCopierKey$$KeyFactoryByCGLIB$$f32401fd(String var1, String var2, boolean var3) {  
  14.         this.FIELD_0 = var1;  
  15.         this.FIELD_1 = var2;  
  16.         this.FIELD_2 = var3;  
  17.     }  
  18.     //省去hashCode等方法。。。  
  19. }

继续跟踪Generator.create方法，由于Generator是继承AbstractClassGenerator，这个AbstractClassGenerator是cglib用来生成字节码的一个模板类，Generator的super.create其实调用AbstractClassGenerator的create方法，最终会调用到Generator的模板方法generateClass方法，我们不去细究AbstractClassGenerator的细节，重点看generateClass。
这个是一个生成java类的方法，理解起来就好像我们平时写代码一样。

  1. public void generateClass(ClassVisitor v) {  
  2.     Type sourceType = Type.getType(source);  
  3.     Type targetType = Type.getType(target);  
  4.     ClassEmitter ce = new ClassEmitter(v);  
  5.     //开始“写”类，这里有修饰符、类名、父类等信息  
  6.     ce.begin_class(Constants.V1_2,  
  7.                    Constants.ACC_PUBLIC,  
  8.                    getClassName(),  
  9.                    BEAN_COPIER,  
  10.                    null,  
  11.                    Constants.SOURCE_FILE);  
  12.     //没有构造方法  
  13.     EmitUtils.null_constructor(ce);  
  14.     //开始“写”一个方法，方法名是copy  
  15.     CodeEmitter e = ce.begin_method(Constants.ACC_PUBLIC, COPY, null);  
  16.     //通过Introspector获取source类和target类的PropertyDescriptor  
  17.     PropertyDescriptor[] getters = ReflectUtils.getBeanGetters(source);  
  18.     PropertyDescriptor[] setters = ReflectUtils.getBeanSetters(target);  
  20.     Map names = new HashMap();  
  21.     for (int i = 0; i < getters.length; i++) {  
  22.         names.put(getters[i].getName(), getters[i]);  
  23.     }  
  24.     Local targetLocal = e.make_local();  
  25.     Local sourceLocal = e.make_local();  
  26.     if (useConverter) {  
  27.         e.load_arg(1);  
  28.         e.checkcast(targetType);  
  29.         e.store_local(targetLocal);  
  30.         e.load_arg(0);                  
  31.         e.checkcast(sourceType);  
  32.         e.store_local(sourceLocal);  
  33.     } else {  
  34.         e.load_arg(1);  
  35.         e.checkcast(targetType);  
  36.         e.load_arg(0);  
  37.         e.checkcast(sourceType);  
  38.     }  
  39.     //通过属性名来生成转换的代码  
  40.     //以setter作为遍历  
  41.     for (int i = 0; i < setters.length; i++) {  
  42.         PropertyDescriptor setter = setters[i];  
  43.         //根据setter的name获取getter  
  44.         PropertyDescriptor getter = (PropertyDescriptor)names.get(setter.getName());  
  45.         if (getter != null) {  
  46.             //获取读写方法  
  47.             MethodInfo read = ReflectUtils.getMethodInfo(getter.getReadMethod());  
  48.             MethodInfo write = ReflectUtils.getMethodInfo(setter.getWriteMethod());  
  49.             //如果用了useConverter，则进行下面的拼装代码方式  
  50.             if (useConverter) {  
  51.                 Type setterType = write.getSignature().getArgumentTypes()[0];  
  52.                 e.load_local(targetLocal);  
  53.                 e.load_arg(2);  
  54.                 e.load_local(sourceLocal);  
  55.                 e.invoke(read);  
  56.                 e.box(read.getSignature().getReturnType());  
  57.                 EmitUtils.load_class(e, setterType);  
  58.                 e.push(write.getSignature().getName());  
  59.                 e.invoke_interface(CONVERTER, CONVERT);  
  60.                 e.unbox_or_zero(setterType);  
  61.                 e.invoke(write);  
  62.               //compatible用来判断getter和setter是否类型一致  
  63.             } else if (compatible(getter, setter)) {  
  64.                 e.dup2();  
  65.                 e.invoke(read);  
  66.                 e.invoke(write);  
  67.             }  
  68.         }  
  69.     }  
  70.     e.return_value();  
  71.     e.end_method();  
  72.     ce.end_class();  
  73. }  
  75. private static boolean compatible(PropertyDescriptor getter, PropertyDescriptor setter) {  
  76.     // TODO: allow automatic widening conversions?  
  77.     return setter.getPropertyType().isAssignableFrom(getter.getPropertyType());  
  78. }
  79. 即使没有使用过cglib也能读懂生成代码的流程吧，我们看看没有使用useConverter的情况下生成的代码：
  80. public class Object$$BeanCopierByCGLIB$$d1d970c8 extends BeanCopier {  
  81.     public Object$$BeanCopierByCGLIB$$d1d970c8() {  
  82.     }  
  84.     public void copy(Object var1, Object var2, Converter var3) {  
  85.         TargetVO var10000 = (TargetVO)var2;  
  86.         SourceVO var10001 = (SourceVO)var1;  
  87.         var10000.setDate1(((SourceVO)var1).getDate1());  
  88.         var10000.setIn(var10001.getIn());  
  89.         var10000.setListData(var10001.getListData());  
  90.         var10000.setMapData(var10001.getMapData());  
  91.         var10000.setP1(var10001.getP1());  
  92.         var10000.setP2(var10001.getP2());  
  93.         var10000.setP3(var10001.getP3());  
  94.         var10000.setPattr1(var10001.getPattr1());  
  95.     }  
  96. }

在对比上面生成代码的代码是不是阔然开朗了。
再看看使用useConverter的情况：

  1. public class Object$$BeanCopierByCGLIB$$d1d970c7 extends BeanCopier {  
  2.     private static final Class CGLIB$load_class$java$2Eutil$2EDate;  
  3.     private static final Class CGLIB$load_class$beanmapper_compare$2Evo$2ESourceVO$24Inner;  
  4.     private static final Class CGLIB$load_class$java$2Eutil$2EList;  
  5.     private static final Class CGLIB$load_class$java$2Eutil$2EMap;  
  6.     private static final Class CGLIB$load_class$java$2Elang$2EInteger;  
  7.     private static final Class CGLIB$load_class$java$2Elang$2ELong;  
  8.     private static final Class CGLIB$load_class$java$2Elang$2EByte;  
  9.     private static final Class CGLIB$load_class$java$2Elang$2EString;  
  11.     public Object$$BeanCopierByCGLIB$$d1d970c7() {  
  12.     }  
  14.     public void copy(Object var1, Object var2, Converter var3) {  
  15.         TargetVO var4 = (TargetVO)var2;  
  16.         SourceVO var5 = (SourceVO)var1;  
  17.         var4.setDate1((Date)var3.convert(var5.getDate1(), CGLIB$load_class$java$2Eutil$2EDate, "setDate1"));  
  18.         var4.setIn((Inner)var3.convert(var5.getIn(), CGLIB$load_class$beanmapper_compare$2Evo$2ESourceVO$24Inner, "setIn"));  
  19.         var4.setListData((List)var3.convert(var5.getListData(), CGLIB$load_class$java$2Eutil$2EList, "setListData"));  
  20.         var4.setMapData((Map)var3.convert(var5.getMapData(), CGLIB$load_class$java$2Eutil$2EMap, "setMapData"));  
  21.         var4.setP1((Integer)var3.convert(var5.getP1(), CGLIB$load_class$java$2Elang$2EInteger, "setP1"));  
  22.         var4.setP2((Long)var3.convert(var5.getP2(), CGLIB$load_class$java$2Elang$2ELong, "setP2"));  
  23.         var4.setP3((Byte)var3.convert(var5.getP3(), CGLIB$load_class$java$2Elang$2EByte, "setP3"));  
  24.         var4.setPattr1((String)var3.convert(var5.getPattr1(), CGLIB$load_class$java$2Elang$2EString, "setPattr1"));  
  25.         var4.setSeq((Long)var3.convert(var5.getSeq(), CGLIB$load_class$java$2Elang$2ELong, "setSeq"));  
  26.     }  
  28.     static void CGLIB$STATICHOOK1() {  
  29.         CGLIB$load_class$java$2Eutil$2EDate = Class.forName("java.util.Date");  
  30.         CGLIB$load_class$beanmapper_compare$2Evo$2ESourceVO$24Inner = Class.forName("beanmapper_compare.vo.SourceVO$Inner");  
  31.         CGLIB$load_class$java$2Eutil$2EList = Class.forName("java.util.List");  
  32.         CGLIB$load_class$java$2Eutil$2EMap = Class.forName("java.util.Map");  
  33.         CGLIB$load_class$java$2Elang$2EInteger = Class.forName("java.lang.Integer");  
  34.         CGLIB$load_class$java$2Elang$2ELong = Class.forName("java.lang.Long");  
  35.         CGLIB$load_class$java$2Elang$2EByte = Class.forName("java.lang.Byte");  
  36.         CGLIB$load_class$java$2Elang$2EString = Class.forName("java.lang.String");  
  37.     }  
  39.     static {  
  40.         CGLIB$STATICHOOK1();  
  41.     }  
  42. }

小结

BeanCopier性能确实很高，但从源码可以看出BeanCopier只会拷贝名称和类型都相同的属性，而且如果一旦使用Converter，BeanCopier只使用Converter定义的规则去拷贝属性，所以在convert方法中要考虑所有的属性。

Dozer

使用

上面提到的BeanUtils和BeanCopier都是功能比较简单的，需要属性名称一样，甚至类型也要一样。但是在大多数情况下这个要求就相对苛刻了，要知道有些VO由于各种原因不能修改，有些是外部接口SDK的对象，
有些对象的命名规则不同，例如有驼峰型的，有下划线的等等，各种什么情况都有。所以我们更加需要的是更加灵活丰富的功能，甚至可以做到定制化的转换。
Dozer就提供了这些功能，有支持同名隐式映射，支持基本类型互相转换，支持显示指定映射关系，支持exclude字段，支持递归匹配映射，支持深度匹配，支持Date to String的date-formate，支持自定义转换Converter，支持一次mapping定义多处使用，支持EventListener事件监听等等。不仅如此，Dozer在使用方式上，除了支持API，还支持XML和注解，满足大家的喜好。更多的功能可以参考这里
由于其功能很丰富，不可能每个都演示，这里只是给个大概认识，更详细的功能，或者XML和注解的配置，请看官方文档。

  1. private Mapper dozerMapper;  
  3.     @Before  
  4.     public void setup(){  
  5.         dozerMapper = DozerBeanMapperBuilder.create()  
  6.                 .withMappingBuilder(new BeanMappingBuilder() {  
  7.                     @Override  
  8.                     protected void configure() {  
  9.                         mapping(SourceVO.class, TargetVO.class)  
  10.                                 .fields("fullName", "name")  
  11.                                 .exclude("in");  
  12.                     }  
  13.                 })  
  14.                 .withCustomConverter(null)  
  15.                 .withEventListener(null)  
  16.                 .build();  
  17.     }  
  19.     @Test  
  20.     public void dozerTest(){  
  21.         SourceVO sourceVO = getSourceVO();  
  22.         log.info("sourceVO={}", GsonUtil.toJson(sourceVO));  
  23.         TargetVO map = dozerMapper.map(sourceVO, TargetVO.class);  
  24.         log.info("map={}", GsonUtil.toJson(map));  
  25.     }

原理

Dozer的实现原理本质上还是用反射/Introspector那套，但是其丰富的功能，以及支持多种实现方式（API、XML、注解）使得代码看上去有点复杂，在翻阅代码时，我们大可不必理会这些类，只需要知道它们大体的作用就行了，重点关注核心流程和代码的实现。下面我们重点看看构建mapper的build方法和实现映射的map方法。
build方法很简单，它是一个初始化的动作，就是通过用户的配置来构建出一系列后面要用到的配置对象、上下文对象，或其他封装对象，我们不必深究这些对象是怎么实现的，从名字上我们大概能猜出这些对象是干嘛，负责什么就可以了。

  1. DozerBeanMapper(List<String> mappingFiles,  
  2.                 BeanContainer beanContainer,  
  3.                 DestBeanCreator destBeanCreator,  
  4.                 DestBeanBuilderCreator destBeanBuilderCreator,  
  5.                 BeanMappingGenerator beanMappingGenerator,  
  6.                 PropertyDescriptorFactory propertyDescriptorFactory,  
  7.                 List<CustomConverter> customConverters,  
  8.                 List<MappingFileData> mappingsFileData,  
  9.                 List<EventListener> eventListeners,  
  10.                 CustomFieldMapper customFieldMapper,  
  11.                 Map<String, CustomConverter> customConvertersWithId,  
  12.                 ClassMappings customMappings,  
  13.                 Configuration globalConfiguration,  
  14.                 CacheManager cacheManager) {  
  15.     this.beanContainer = beanContainer;  
  16.     this.destBeanCreator = destBeanCreator;  
  17.     this.destBeanBuilderCreator = destBeanBuilderCreator;  
  18.     this.beanMappingGenerator = beanMappingGenerator;  
  19.     this.propertyDescriptorFactory = propertyDescriptorFactory;  
  20.     this.customConverters = new ArrayList<>(customConverters);  
  21.     this.eventListeners = new ArrayList<>(eventListeners);  
  22.     this.mappingFiles = new ArrayList<>(mappingFiles);  
  23.     this.customFieldMapper = customFieldMapper;  
  24.     this.customConvertersWithId = new HashMap<>(customConvertersWithId);  
  25.     this.eventManager = new DefaultEventManager(eventListeners);  
  26.     this.customMappings = customMappings;  
  27.     this.globalConfiguration = globalConfiguration;  
  28.     this.cacheManager = cacheManager;  
  29. }

map方法是映射对象的过程，其入口是MappingProcessor的mapGeneral方法

  1. private <T> T mapGeneral(Object srcObj, final Class<T> destClass, final T destObj, final String mapId) {  
  2.     srcObj = MappingUtils.deProxy(srcObj, beanContainer);  
  4.     Class<T> destType;  
  5.     T result;  
  6.     if (destClass == null) {  
  7.         destType = (Class<T>)destObj.getClass();  
  8.         result = destObj;  
  9.     } else {  
  10.         destType = destClass;  
  11.         result = null;  
  12.     }  
  14.     ClassMap classMap = null;  
  15.     try {  
  16.         //构建ClassMap  
  17.         //ClassMap是包括src类和dest类和其他配置的一个封装  
  18.         classMap = getClassMap(srcObj.getClass(), destType, mapId);  
  20.         //注册事件  
  21.         eventManager.on(new DefaultEvent(EventTypes.MAPPING_STARTED, classMap, null, srcObj, result, null));  
  24.         //看看有没有自定义converter  
  25.         Class<?> converterClass = MappingUtils.findCustomConverter(converterByDestTypeCache, classMap.getCustomConverters(), srcObj  
  26.                 .getClass(), destType);  
  28.         if (destObj == null) {  
  29.             // If this is a nested MapperAware conversion this mapping can be already processed  
  30.             // but we can do this optimization only in case of no destObject, instead we must copy to the dest object  
  31.             Object alreadyMappedValue = mappedFields.getMappedValue(srcObj, destType, mapId);  
  32.             if (alreadyMappedValue != null) {  
  33.                 return (T)alreadyMappedValue;  
  34.             }  
  35.         }  
  36.         //优先使用自定义converter进行映射  
  37.         if (converterClass != null) {  
  38.             return (T)mapUsingCustomConverter(converterClass, srcObj.getClass(), srcObj, destType, result, null, true);  
  39.         }  
  41.         //也是对配置进行了封装  
  42.         BeanCreationDirective creationDirective =  
  43.                 new BeanCreationDirective(srcObj, classMap.getSrcClassToMap(), classMap.getDestClassToMap(), destType,  
  44.                                           classMap.getDestClassBeanFactory(), classMap.getDestClassBeanFactoryId(), classMap.getDestClassCreateMethod(),  
  45.                                           classMap.getDestClass().isSkipConstructor());  
  46.         //继续进行映射  
  47.         result = createByCreationDirectiveAndMap(creationDirective, classMap, srcObj, result, false, null);  
  48.     } catch (Throwable e) {  
  49.         MappingUtils.throwMappingException(e);  
  50.     }  
  51.     eventManager.on(new DefaultEvent(EventTypes.MAPPING_FINISHED, classMap, null, srcObj, result, null));  
  53.     return result;  
  54. }

一般情况下createByCreationDirectiveAndMap方法会一直调用到mapFromFieldMap方法，而在没有自定义converter的情况下会调用mapOrRecurseObject方法。
大多数情况下字段的映射会在这个方法做一般的解析

  1. private Object mapOrRecurseObject(Object srcObj, Object srcFieldValue, Class<?> destFieldType, FieldMap fieldMap, Object destObj) {  
  2.     Class<?> srcFieldClass = srcFieldValue != null ? srcFieldValue.getClass() : fieldMap.getSrcFieldType(srcObj.getClass());  
  3.     Class<?> converterClass = MappingUtils.determineCustomConverter(fieldMap, converterByDestTypeCache, fieldMap.getClassMap()  
  4.             .getCustomConverters(), srcFieldClass, destFieldType);  
  6.     //自定义converter的处理  
  7.     if (converterClass != null) {  
  8.         return mapUsingCustomConverter(converterClass, srcFieldClass, srcFieldValue, destFieldType, destObj, fieldMap, false);  
  9.     }  
  11.     if (srcFieldValue == null) {  
  12.         return null;  
  13.     }  
  15.     String srcFieldName = fieldMap.getSrcFieldName();  
  16.     String destFieldName = fieldMap.getDestFieldName();  
  18.     if (!(DozerConstants.SELF_KEYWORD.equals(srcFieldName) && DozerConstants.SELF_KEYWORD.equals(destFieldName))) {  
  19.         Object alreadyMappedValue = mappedFields.getMappedValue(srcFieldValue, destFieldType, fieldMap.getMapId());  
  20.         if (alreadyMappedValue != null) {  
  21.             return alreadyMappedValue;  
  22.         }  
  23.     }  
  25.     //如果只是浅拷贝则直接返回（可配置）  
  26.     if (fieldMap.isCopyByReference()) {  
  27.         // just get the src and return it, no transformation.  
  28.         return srcFieldValue;  
  29.     }  
  31.     //对Map类型的处理  
  32.     boolean isSrcFieldClassSupportedMap = MappingUtils.isSupportedMap(srcFieldClass);  
  33.     boolean isDestFieldTypeSupportedMap = MappingUtils.isSupportedMap(destFieldType);  
  34.     if (isSrcFieldClassSupportedMap && isDestFieldTypeSupportedMap) {  
  35.         return mapMap(srcObj, (Map<?, ?>)srcFieldValue, fieldMap, destObj);  
  36.     }  
  37.     if (fieldMap instanceof MapFieldMap && destFieldType.equals(Object.class)) {  
  39.         destFieldType = fieldMap.getDestHintContainer() != null ? fieldMap.getDestHintContainer().getHint() : srcFieldClass;  
  40.     }  
  42.     //对基本类型的映射处理  
  43.     //PrimitiveOrWrapperConverter类支持兼容了基本类型之间的互相转换  
  44.     if (primitiveConverter.accepts(srcFieldClass) || primitiveConverter.accepts(destFieldType)) {  
  45.         // Primitive or Wrapper conversion  
  46.         if (fieldMap.getDestHintContainer() != null) {  
  47.             Class<?> destHintType = fieldMap.getDestHintType(srcFieldValue.getClass());  
  48.             // if the destType is null this means that there was more than one hint.  
  49.             // we must have already set the destType then.  
  50.             if (destHintType != null) {  
  51.                 destFieldType = destHintType;  
  52.             }  
  53.         }  
  55.         //#1841448 - if trim-strings=true, then use a trimmed src string value when converting to dest value  
  56.         Object convertSrcFieldValue = srcFieldValue;  
  57.         if (fieldMap.isTrimStrings() && srcFieldValue.getClass().equals(String.class)) {  
  58.             convertSrcFieldValue = ((String)srcFieldValue).trim();  
  59.         }  
  61.         DateFormatContainer dfContainer = new DateFormatContainer(fieldMap.getDateFormat());  
  63.         if (fieldMap instanceof MapFieldMap && !primitiveConverter.accepts(destFieldType)) {  
  65.             return primitiveConverter.convert(convertSrcFieldValue, convertSrcFieldValue.getClass(), dfContainer);  
  66.         } else {  
  67.             return primitiveConverter.convert(convertSrcFieldValue, destFieldType, dfContainer, destFieldName, destObj);  
  68.         }  
  69.     }  
  70.     //对集合类型的映射处理  
  71.     if (MappingUtils.isSupportedCollection(srcFieldClass) && (MappingUtils.isSupportedCollection(destFieldType))) {  
  72.         return mapCollection(srcObj, srcFieldValue, fieldMap, destObj);  
  73.     }  
  75.     //对枚举类型的映射处理  
  76.     if (MappingUtils.isEnumType(srcFieldClass, destFieldType)) {  
  77.         return mapEnum((Enum)srcFieldValue, (Class<Enum>)destFieldType);  
  78.     }  
  79.     if (fieldMap.getDestDeepIndexHintContainer() != null) {  
  80.         destFieldType = fieldMap.getDestDeepIndexHintContainer().getHint();  
  81.     }  
  82.     //其他复杂对象类型的处理  
  83.     return mapCustomObject(fieldMap, destObj, destFieldType, destFieldName, srcFieldValue);  
  84. }  
  86. mapCustomObject方法。其实你会发现这个方法最重要的一点就是做递归处理，无论是最后调用createByCreationDirectiveAndMap还是mapToDestObject方法。
  87. private Object mapCustomObject(FieldMap fieldMap, Object destObj, Class<?> destFieldType, String destFieldName, Object srcFieldValue) {  
  88.     srcFieldValue = MappingUtils.deProxy(srcFieldValue, beanContainer);  
  90.     // Custom java bean. Need to make sure that the destination object is not  
  91.     // already instantiated.  
  92.     Object result = null;  
  93.     // in case of iterate feature new objects are created in any case  
  94.     if (!DozerConstants.ITERATE.equals(fieldMap.getDestFieldType())) {  
  95.         result = getExistingValue(fieldMap, destObj, destFieldType);  
  96.     }  
  98.     // if the field is not null than we don't want a new instance  
  99.     if (result == null) {  
  100.         // first check to see if this plain old field map has hints to the actual  
  101.         // type.  
  102.         if (fieldMap.getDestHintContainer() != null) {  
  103.             Class<?> destHintType = fieldMap.getDestHintType(srcFieldValue.getClass());  
  104.             // if the destType is null this means that there was more than one hint.  
  105.             // we must have already set the destType then.  
  106.             if (destHintType != null) {  
  107.                 destFieldType = destHintType;  
  108.             }  
  109.         }  
  110.         // Check to see if explicit map-id has been specified for the field  
  111.         // mapping  
  112.         String mapId = fieldMap.getMapId();  
  114.         Class<?> targetClass;  
  115.         if (fieldMap.getDestHintContainer() != null && fieldMap.getDestHintContainer().getHint() != null) {  
  116.             targetClass = fieldMap.getDestHintContainer().getHint();  
  117.         } else {  
  118.             targetClass = destFieldType;  
  119.         }  
  120.         ClassMap classMap = getClassMap(srcFieldValue.getClass(), targetClass, mapId);  
  122.         BeanCreationDirective creationDirective = new BeanCreationDirective(srcFieldValue, classMap.getSrcClassToMap(), classMap.getDestClassToMap(),  
  123.                                                                             destFieldType, classMap.getDestClassBeanFactory(), classMap.getDestClassBeanFactoryId(),  
  124.                                                                             fieldMap.getDestFieldCreateMethod() != null ? fieldMap.getDestFieldCreateMethod() :  
  125.                                                                                     classMap.getDestClassCreateMethod(),  
  126.                                                                             classMap.getDestClass().isSkipConstructor(), destObj, destFieldName);  
  128.         result = createByCreationDirectiveAndMap(creationDirective, classMap, srcFieldValue, null, false, fieldMap.getMapId());  
  129.     } else {  
  130.         mapToDestObject(null, srcFieldValue, result, false, fieldMap.getMapId());  
  131.     }  
  133.     return result;  
  134. }

小结

Dozer功能强大，但底层还是用反射那套，所以在性能测试中它的表现一般，仅次于Apache的BeanUtils。如果不追求性能的话，可以使用。

Orika

Orika可以说是几乎集成了上述几个工具的优点，不仅具有丰富的功能，底层使用Javassist生成字节码，运行 效率很高的。

使用

Orika基本支持了Dozer支持的功能，这里我也是简单介绍一下Orika的使用，具体更详细的API可以参考User Guide。

  1. private MapperFactory mapperFactory;  
  3. @Before  
  4. public void setup() {  
  5.     mapperFactory = new DefaultMapperFactory.Builder().build();  
  6.     ConverterFactory converterFactory = mapperFactory.getConverterFactory();  
  7.     converterFactory.registerConverter(new TypeConverter());  
  8.     mapperFactory.classMap(SourceVO.class, TargetVO.class)  
  9.             .field("fullName", "name")  
  10.             .field("type", "enumType")  
  11.             .exclude("in")  
  12.             .byDefault()  
  13.             .register();  
  14. }  
  16. @Test  
  17. public void main() {  
  18.     MapperFacade mapper = mapperFactory.getMapperFacade();  
  19.     SourceVO sourceVO = getSourceVO();  
  20.     log.info("sourceVO={}", GsonUtil.toJson(sourceVO));  
  21.     TargetVO map = mapper.map(sourceVO, TargetVO.class);  
  22.     log.info("map={}", GsonUtil.toJson(map));  
  23. }

原理

在讲解实现原理时，我们先看看Orika在背后干了什么事情。
通过增加以下配置，我们可以看到Orika在做映射过程中生成mapper的源码和字节码。

  1. System.setProperty("ma.glasnost.orika.writeSourceFiles", "true");  
  2. System.setProperty("ma.glasnost.orika.writeClassFiles", "true");  
  3. System.setProperty("ma.glasnost.orika.writeSourceFilesToPath", "path");  
  4. System.setProperty("ma.glasnost.orika.writeClassFilesToPath", "path");

用上面的例子，我们看看Orika生成的java代码：

  1. package ma.glasnost.orika.generated;  
  3. public class Orika_TargetVO_SourceVO_Mapper947163525829122$0 extends ma.glasnost.orika.impl.GeneratedMapperBase {  
  5.     public void mapAtoB(java.lang.Object a, java.lang.Object b, ma.glasnost.orika.MappingContext mappingContext) {  
  8.         super.mapAtoB(a, b, mappingContext);  
  11.         // sourceType: SourceVO  
  12.         beanmapper_compare.vo.SourceVO source = ((beanmapper_compare.vo.SourceVO)a);   
  13.         // destinationType: TargetVO  
  14.         beanmapper_compare.vo.TargetVO destination = ((beanmapper_compare.vo.TargetVO)b);   
  17.         destination.setName(((java.lang.String)source.getFullName()));   
  18.         if ( !(((java.lang.Integer)source.getType()) == null)){   
  19.             destination.setEnumType(((beanmapper_compare.vo.TargetVO.EnumType)((ma.glasnost.orika.Converter)usedConverters[0]).convert(((java.lang.Integer)source.getType()), ((ma.glasnost.orika.metadata.Type)usedTypes[0]), mappingContext)));   
  20.         } else {   
  21.             destination.setEnumType(null);  
  22.         }  
  23.         if ( !(((java.util.Date)source.getDate1()) == null)){   
  24.             destination.setDate1(((java.util.Date)((ma.glasnost.orika.Converter)usedConverters[1]).convert(((java.util.Date)source.getDate1()), ((ma.glasnost.orika.metadata.Type)usedTypes[1]), mappingContext)));   
  25.         } else {   
  26.             destination.setDate1(null);  
  27.         }if ( !(((java.util.List)source.getListData()) == null)) {  
  29.             java.util.List new_listData = ((java.util.List)new java.util.ArrayList());   
  31.             new_listData.addAll(mapperFacade.mapAsList(((java.util.List)source.getListData()), ((ma.glasnost.orika.metadata.Type)usedTypes[2]), ((ma.glasnost.orika.metadata.Type)usedTypes[3]), mappingContext));   
  32.             destination.setListData(new_listData);   
  33.         } else {  
  34.             if ( !(((java.util.List)destination.getListData()) == null)) {  
  35.                 destination.setListData(null);  
  36.             };  
  37.         }if ( !(((java.util.Map)source.getMapData()) == null)){  
  39.             java.util.Map new_mapData = ((java.util.Map)new java.util.LinkedHashMap());   
  40.             for( java.util.Iterator mapData_$_iter = ((java.util.Map)source.getMapData()).entrySet().iterator(); mapData_$_iter.hasNext(); ) {   
  42.                 java.util.Map.Entry sourceMapDataEntry = ((java.util.Map.Entry)mapData_$_iter.next());   
  43.                 java.lang.Integer newMapDataKey = null;   
  44.                 java.util.List newMapDataVal = null;   
  45.                 if ( !(((java.lang.Long)sourceMapDataEntry.getKey()) == null)){   
  46.                     newMapDataKey = ((java.lang.Integer)((ma.glasnost.orika.Converter)usedConverters[2]).convert(((java.lang.Long)sourceMapDataEntry.getKey()), ((ma.glasnost.orika.metadata.Type)usedTypes[3]), mappingContext));   
  47.                 } else {   
  48.                     newMapDataKey = null;  
  49.                 }  
  50.                 if ( !(((java.util.List)sourceMapDataEntry.getValue()) == null)) {  
  52.                     java.util.List new_newMapDataVal = ((java.util.List)new java.util.ArrayList());   
  54.                     new_newMapDataVal.addAll(mapperFacade.mapAsList(((java.util.List)sourceMapDataEntry.getValue()), ((ma.glasnost.orika.metadata.Type)usedTypes[2]), ((ma.glasnost.orika.metadata.Type)usedTypes[4]), mappingContext));   
  55.                     newMapDataVal = new_newMapDataVal;   
  56.                 } else {  
  57.                     if ( !(newMapDataVal == null)) {  
  58.                         newMapDataVal = null;  
  59.                     };  
  60.                 }  
  61.                 new_mapData.put(newMapDataKey, newMapDataVal);   
  63.             }  
  64.             destination.setMapData(new_mapData);   
  65.         } else {  
  66.             destination.setMapData(null);  
  67.         }  
  68.         destination.setP1(((java.lang.Integer)source.getP1()));   
  69.         destination.setP2(((java.lang.Long)source.getP2()));   
  70.         destination.setP3(((java.lang.Byte)source.getP3()));   
  71.         destination.setPattr1(((java.lang.String)source.getPattr1()));   
  72.         if ( !(((java.lang.String)source.getSeq()) == null)){   
  73.             destination.setSeq(((java.lang.Long)((ma.glasnost.orika.Converter)usedConverters[3]).convert(((java.lang.String)source.getSeq()), ((ma.glasnost.orika.metadata.Type)usedTypes[2]), mappingContext)));   
  74.         } else {   
  75.             destination.setSeq(null);  
  76.         }  
  77.         if(customMapper != null) {   
  78.             customMapper.mapAtoB(source, destination, mappingContext);  
  79.         }  
  80.     }  
  82.     public void mapBtoA(java.lang.Object a, java.lang.Object b, ma.glasnost.orika.MappingContext mappingContext) {  
  85.         super.mapBtoA(a, b, mappingContext);  
  88.         // sourceType: TargetVO  
  89.         beanmapper_compare.vo.TargetVO source = ((beanmapper_compare.vo.TargetVO)a);   
  90.         // destinationType: SourceVO  
  91.         beanmapper_compare.vo.SourceVO destination = ((beanmapper_compare.vo.SourceVO)b);   
  94.         destination.setFullName(((java.lang.String)source.getName()));   
  95.         if ( !(((beanmapper_compare.vo.TargetVO.EnumType)source.getEnumType()) == null)){   
  96.             destination.setType(((java.lang.Integer)((ma.glasnost.orika.Converter)usedConverters[0]).convert(((beanmapper_compare.vo.TargetVO.EnumType)source.getEnumType()), ((ma.glasnost.orika.metadata.Type)usedTypes[3]), mappingContext)));   
  97.         } else {   
  98.             destination.setType(null);  
  99.         }  
  100.         if ( !(((java.util.Date)source.getDate1()) == null)){   
  101.             destination.setDate1(((java.util.Date)((ma.glasnost.orika.Converter)usedConverters[1]).convert(((java.util.Date)source.getDate1()), ((ma.glasnost.orika.metadata.Type)usedTypes[1]), mappingContext)));   
  102.         } else {   
  103.             destination.setDate1(null);  
  104.         }if ( !(((java.util.List)source.getListData()) == null)) {  
  106.             java.util.List new_listData = ((java.util.List)new java.util.ArrayList());   
  108.             new_listData.addAll(mapperFacade.mapAsList(((java.util.List)source.getListData()), ((ma.glasnost.orika.metadata.Type)usedTypes[3]), ((ma.glasnost.orika.metadata.Type)usedTypes[2]), mappingContext));   
  109.             destination.setListData(new_listData);   
  110.         } else {  
  111.             if ( !(((java.util.List)destination.getListData()) == null)) {  
  112.                 destination.setListData(null);  
  113.             };  
  114.         }if ( !(((java.util.Map)source.getMapData()) == null)){  
  116.             java.util.Map new_mapData = ((java.util.Map)new java.util.LinkedHashMap());   
  117.             for( java.util.Iterator mapData_$_iter = ((java.util.Map)source.getMapData()).entrySet().iterator(); mapData_$_iter.hasNext(); ) {   
  119.                 java.util.Map.Entry sourceMapDataEntry = ((java.util.Map.Entry)mapData_$_iter.next());   
  120.                 java.lang.Long newMapDataKey = null;   
  121.                 java.util.List newMapDataVal = null;   
  122.                 if ( !(((java.lang.Integer)sourceMapDataEntry.getKey()) == null)){   
  123.                     newMapDataKey = ((java.lang.Long)((ma.glasnost.orika.Converter)usedConverters[2]).convert(((java.lang.Integer)sourceMapDataEntry.getKey()), ((ma.glasnost.orika.metadata.Type)usedTypes[2]), mappingContext));   
  124.                 } else {   
  125.                     newMapDataKey = null;  
  126.                 }  
  127.                 if ( !(((java.util.List)sourceMapDataEntry.getValue()) == null)) {  
  129.                     java.util.List new_newMapDataVal = ((java.util.List)new java.util.ArrayList());   
  131.                     new_newMapDataVal.addAll(mapperFacade.mapAsList(((java.util.List)sourceMapDataEntry.getValue()), ((ma.glasnost.orika.metadata.Type)usedTypes[4]), ((ma.glasnost.orika.metadata.Type)usedTypes[2]), mappingContext));   
  132.                     newMapDataVal = new_newMapDataVal;   
  133.                 } else {  
  134.                     if ( !(newMapDataVal == null)) {  
  135.                         newMapDataVal = null;  
  136.                     };  
  137.                 }  
  138.                 new_mapData.put(newMapDataKey, newMapDataVal);   
  140.             }  
  141.             destination.setMapData(new_mapData);   
  142.         } else {  
  143.             destination.setMapData(null);  
  144.         }  
  145.         destination.setP1(((java.lang.Integer)source.getP1()));   
  146.         destination.setP2(((java.lang.Long)source.getP2()));   
  147.         destination.setP3(((java.lang.Byte)source.getP3()));   
  148.         destination.setPattr1(((java.lang.String)source.getPattr1()));   
  149.         if ( !(((java.lang.Long)source.getSeq()) == null)){   
  150.             destination.setSeq(((java.lang.String)((ma.glasnost.orika.Converter)usedConverters[4]).convert(((java.lang.Long)source.getSeq()), ((ma.glasnost.orika.metadata.Type)usedTypes[5]), mappingContext)));   
  151.         } else {   
  152.             destination.setSeq(null);  
  153.         }  
  154.         if(customMapper != null) {   
  155.             customMapper.mapBtoA(source, destination, mappingContext);  
  156.         }  
  157.     }  
  159. }

这个mapper类就两个方法mapAtoB和mapBtoA，从名字看猜到前者是负责src -> dest的映射，后者是负责dest -> src的映射。
好，我们们看看实现的过程。
Orika的使用跟Dozer的类似，首先通过配置生成一个MapperFactory，再用MapperFacade来作为映射的统一入口，这里MapperFactory和MapperFacade都是单例的。mapperFactory在做配置类映射时，只是注册了ClassMap，还没有真正的生成mapper的字节码，是在第一次调用getMapperFacade方法时才初始化mapper。下面看看getMapperFacade。
（源码基于 ma.glasnost.orika:orika-core:1.5.4）

  1. public MapperFacade getMapperFacade() {  
  2.     if (!isBuilt) {  
  3.         synchronized (mapperFacade) {  
  4.             if (!isBuilt) {  
  5.                 build();  
  6.             }  
  7.         }  
  8.     }  
  9.     return mapperFacade;  
  10. }
  11. 利用注册的ClassMap信息和MappingContext上下文信息来构造mapper
  12. public synchronized void build() {  
  14.     if (!isBuilding && !isBuilt) {  
  15.         isBuilding = true;  
  17.         MappingContext context = contextFactory.getContext();  
  18.         try {  
  19.             if (useBuiltinConverters) {  
  20.                 BuiltinConverters.register(converterFactory);  
  21.             }  
  22.             converterFactory.setMapperFacade(mapperFacade);  
  24.             for (Map.Entry<MapperKey, ClassMap<Object, Object>> classMapEntry : classMapRegistry.entrySet()) {  
  25.                 ClassMap<Object, Object> classMap = classMapEntry.getValue();  
  26.                 if (classMap.getUsedMappers().isEmpty()) {  
  27.                     classMapEntry.setValue(classMap.copyWithUsedMappers(discoverUsedMappers(classMap)));  
  28.                 }  
  29.             }  
  31.             buildClassMapRegistry();  
  33.             Map<ClassMap<?, ?>, GeneratedMapperBase> generatedMappers = new HashMap<ClassMap<?, ?>, GeneratedMapperBase>();  
  34.             //重点看这里  
  35.             //在使用mapperFactory配置classMap时，会存放在classMapRegistry里  
  36.             for (ClassMap<?, ?> classMap : classMapRegistry.values()) {  
  37.                 //对每个classMap生成一个mapper，重点看buildMapper方法  
  38.                 generatedMappers.put(classMap, buildMapper(classMap, false, context));  
  39.             }  
  41.             Set<Entry<ClassMap<?, ?>, GeneratedMapperBase>> generatedMapperEntries = generatedMappers.entrySet();  
  42.             for (Entry<ClassMap<?, ?>, GeneratedMapperBase> generatedMapperEntry : generatedMapperEntries) {  
  43.                 buildObjectFactories(generatedMapperEntry.getKey(), context);  
  44.                 initializeUsedMappers(generatedMapperEntry.getValue(), generatedMapperEntry.getKey(), context);  
  45.             }  
  47.         } finally {  
  48.             contextFactory.release(context);  
  49.         }  
  51.         isBuilt = true;  
  52.         isBuilding = false;  
  53.     }  
  54. }  
  56. public Set<ClassMap<Object, Object>> lookupUsedClassMap(MapperKey mapperKey) {  
  57.     Set<ClassMap<Object, Object>> usedClassMapSet = usedMapperMetadataRegistry.get(mapperKey);  
  58.     if (usedClassMapSet == null) {  
  59.         usedClassMapSet = Collections.emptySet();  
  60.     }  
  61.     return usedClassMapSet;  
  62. }
  63. 跟踪buildMapper方法
  64. private GeneratedMapperBase buildMapper(ClassMap<?, ?> classMap, boolean isAutoGenerated, MappingContext context) {  
  66.     register(classMap.getAType(), classMap.getBType(), isAutoGenerated);  
  67.     register(classMap.getBType(), classMap.getAType(), isAutoGenerated);  
  69.     final MapperKey mapperKey = new MapperKey(classMap.getAType(), classMap.getBType());  
  70.     //调用mapperGenerator的build方法生成mapper  
  71.     final GeneratedMapperBase mapper = mapperGenerator.build(classMap, context);  
  72.     mapper.setMapperFacade(mapperFacade);  
  73.     mapper.setFromAutoMapping(isAutoGenerated);  
  74.     if (classMap.getCustomizedMapper() != null) {  
  75.         final Mapper<Object, Object> customizedMapper = (Mapper<Object, Object>) classMap.getCustomizedMapper();  
  76.         mapper.setCustomMapper(customizedMapper);  
  77.     }  
  78.     mappersRegistry.remove(mapper);  
  79.     //生成的mapper存放到mappersRegistry  
  80.     mappersRegistry.add(mapper);  
  81.     classMapRegistry.put(mapperKey, (ClassMap<Object, Object>) classMap);  
  83.     return mapper;  
  84. }
  85. MapperGenerator的build方法
  86. public GeneratedMapperBase build(ClassMap<?, ?> classMap, MappingContext context) {  
  88. StringBuilder logDetails = null;  
  89. try {  
  90.     compilerStrategy.assureTypeIsAccessible(classMap.getAType().getRawType());  
  91.     compilerStrategy.assureTypeIsAccessible(classMap.getBType().getRawType());  
  93.     if (LOGGER.isDebugEnabled()) {  
  94.         logDetails = new StringBuilder();  
  95.         String srcName = TypeFactory.nameOf(classMap.getAType(), classMap.getBType());  
  96.         String dstName = TypeFactory.nameOf(classMap.getBType(), classMap.getAType());  
  97.         logDetails.append("Generating new mapper for (" + srcName + ", " + dstName + ")");  
  98.     }  
  100.     //构建用来生成源码及字节码的上下文  
  101.     final SourceCodeContext mapperCode = new SourceCodeContext(classMap.getMapperClassName(), GeneratedMapperBase.class, context,  
  102.             logDetails);  
  104.     Set<FieldMap> mappedFields = new LinkedHashSet<FieldMap>();  
  105.     //增加mapAtoB方法  
  106.     mappedFields.addAll(addMapMethod(mapperCode, true, classMap, logDetails));  
  107.     //增加mapBtoA方法  
  108.     //addMapMethod方法基本就是手写代码的过程，有兴趣的读者可以看看  
  109.     mappedFields.addAll(addMapMethod(mapperCode, false, classMap, logDetails));  
  111.     //生成一个mapper实例  
  112.     GeneratedMapperBase instance = mapperCode.getInstance();  
  113.     instance.setAType(classMap.getAType());  
  114.     instance.setBType(classMap.getBType());  
  115.     instance.setFavorsExtension(classMap.favorsExtension());  
  117.     if (logDetails != null) {  
  118.         LOGGER.debug(logDetails.toString());  
  119.         logDetails = null;  
  120.     }  
  122.     classMap = classMap.copy(mappedFields);  
  123.     context.registerMapperGeneration(classMap);  
  125.     return instance;  
  127. } catch (final Exception e) {  
  128.     if (logDetails != null) {  
  129.         logDetails.append("\n<---- ERROR occurred here");  
  130.         LOGGER.debug(logDetails.toString());  
  131.     }  
  132.     throw new MappingException(e);  
  133. }
  134. 生成mapper实例
  135. T instance = (T) compileClass().newInstance();  
  137. protected Class<?> compileClass() throws SourceCodeGenerationException {  
  138.     try {  
  139.         return compilerStrategy.compileClass(this);  
  140.     } catch (SourceCodeGenerationException e) {  
  141.         throw e;  
  142.     }  
  143. }
  144. 这里的compilerStrategy的默认是用Javassist（你也可以自定义生成字节码的策略）
  145. JavassistCompilerStrategy的compileClass方法
  146. 这基本上就是一个使用Javassist的过程，经过前面的各种铺垫（通过配置信息、上下文信息、拼装java源代码等等），终于来到这一步
  147. public Class<?> compileClass(SourceCodeContext sourceCode) throws SourceCodeGenerationException {  
  149.     StringBuilder className = new StringBuilder(sourceCode.getClassName());  
  150.     CtClass byteCodeClass = null;  
  151.     int attempts = 0;  
  152.     Random rand = RANDOM;  
  153.     while (byteCodeClass == null) {  
  154.         try {  
  155.             //创建一个类  
  156.             byteCodeClass = classPool.makeClass(className.toString());  
  157.         } catch (RuntimeException e) {  
  158.             if (attempts < 5) {  
  159.                 className.append(Integer.toHexString(rand.nextInt()));  
  160.             } else {  
  161.                 // No longer likely to be accidental name collision;  
  162.                 // propagate the error  
  163.                 throw e;  
  164.             }  
  165.         }  
  166.     }  
  168.     CtClass abstractMapperClass;  
  169.     Class<?> compiledClass;  
  171.     try {  
  172.         //把源码写到磁盘（通过上面提到的配置）  
  173.         writeSourceFile(sourceCode);  
  175.         Boolean existing = superClasses.put(sourceCode.getSuperClass(), true);  
  176.         if (existing == null || !existing) {  
  177.             classPool.insertClassPath(new ClassClassPath(sourceCode.getSuperClass()));  
  178.         }  
  180.         if (registerClassLoader(Thread.currentThread().getContextClassLoader())) {  
  181.             classPool.insertClassPath(new LoaderClassPath(Thread.currentThread().getContextClassLoader()));  
  182.         }  
  184.         abstractMapperClass = classPool.get(sourceCode.getSuperClass().getCanonicalName());  
  185.         byteCodeClass.setSuperclass(abstractMapperClass);  
  187.         //增加字段  
  188.         for (String fieldDef : sourceCode.getFields()) {  
  189.             try {  
  190.                 byteCodeClass.addField(CtField.make(fieldDef, byteCodeClass));  
  191.             } catch (CannotCompileException e) {  
  192.                 LOG.error("An exception occurred while compiling: " + fieldDef + " for " + sourceCode.getClassName(), e);  
  193.                 throw e;  
  194.             }  
  195.         }  
  197.         //增加方法，这里主要就是mapAtoB和mapBtoA方法  
  198.         //直接用源码通过Javassist往类“加”方法  
  199.         for (String methodDef : sourceCode.getMethods()) {  
  200.             try {  
  201.                 byteCodeClass.addMethod(CtNewMethod.make(methodDef, byteCodeClass));  
  202.             } catch (CannotCompileException e) {  
  203.                 LOG.error(  
  204.                         "An exception occured while compiling the following method:\n\n " + methodDef + "\n\n for "  
  205.                                 + sourceCode.getClassName() + "\n", e);  
  206.                 throw e;  
  207.             }  
  209.         }  
  210.         //生成类  
  211.         compiledClass = byteCodeClass.toClass(Thread.currentThread().getContextClassLoader(), this.getClass().getProtectionDomain());  
  213.         //字节码文件写磁盘  
  214.         writeClassFile(sourceCode, byteCodeClass);  
  216.     } catch (NotFoundException e) {  
  217.         throw new SourceCodeGenerationException(e);  
  218.     } catch (CannotCompileException e) {  
  219.         throw new SourceCodeGenerationException("Error compiling " + sourceCode.getClassName(), e);  
  220.     } catch (IOException e) {  
  221.         throw new SourceCodeGenerationException("Could not write files for " + sourceCode.getClassName(), e);  
  222.     }  
  224.     return compiledClass;  
  225. }

好，mapper类生成了，现在就看在调用MapperFacade的map方法是如何使用这个mapper类的。
其实很简单，还记得生成的mapper是放到mappersRegistry吗，跟踪代码，在resolveMappingStrategy方法根据typeA和typeB在mappersRegistry找到mapper，在调用mapper的mapAtoB或mapBtoA方法即可。

小结

总体来说，Orika是一个功能强大的而且性能很高的工具，推荐使用。

总结

通过对BeanUtils、BeanCopier、Dozer、Orika这几个工具的对比，我们得知了它们的性能以及实现原理。在使用时，我们可以根据自己的实际情况选择，推荐使用Orika。另外，关注公众号Java技术栈，在后台回复：面试，可以获取我整理的 Java 系列面试题和答案，非常齐全。

参考：https://mp.weixin.qq.com/s/cV0jOipl5wg_PLMXtE7Ygg