Java Bean拷贝工具Orika原理解析

　　最近面试被问及对象拷贝怎样才能高效，实际上问的就是Orika或者BeanCopier的原理。由于网上对Orika原理的解析并不太多～因此本文重点讲解一下Orika的原理。(Orika是基于JavaBean规范的属性拷贝框架，所以不了解什么是JavaBean的话请先百度)

　　首先，先纠正一下一些网上的错误说法，Java反射慢，所以要使用Orika基于Javasisst效率更好，我要说明的是Orika的整个流程是需要使用到Java的反射的，只是在真正拷贝的属性的时候没有使用反射。这里先简单讲解一下Orika的执行流程：先通过内省(反射)把JavaBean的属性(getset方法等)解析出来，进而匹配目标和源的属性-->接着根据这些属性和目标/源的匹配情况基于javasisst生成一个 GeneratedMapper的代理对象(真正的执行复制的对象)并放到缓存中-->接着就基于这个对象的 mapAtoB和mapBtoA方法对属性进行复制。

　　有了上面的流程其实只需要看看GeneratedMapper这个代理对象到底是怎样的估计大家就明白了，直接贴出来。虚线上面就是复制的Orika需要复制的属性值，分别为id和productName，虚线下面就是GeneratedMapper的代理实现，可以看到实际上就是生成了一个get set的拷贝方法。看到这里大家就知道了实际上复制就是调用了GeneratedMapper.mapAtoB

CanalSyncMapper canalSyncMapper = new CanalSyncMapper();
canalSyncMapper.setId(1L);
canalSyncMapper.setProductName("你好再见");
TestProduct map = new DefaultMapperFactory.Builder().build().getMapperFacade().map(canalSyncMapper, TestProduct.class);
-------------------------------------GeneratedMapper------------------------------------------------------------------------------------

public void mapAtoB(java.lang.Object a, java.lang.Object b, ma.glasnost.orika.MappingContext mappingContext) {
   super.mapAtoB(a, b, mappingContext);
   // sourceType: CanalSyncMapper
   cn.danvid.canal_test.mapper.CanalSyncMapper source = ((cn.danvid.canal_test.mapper.CanalSyncMapper)a);
   // destinationType: TestProduct
   cn.danvid.canal_test.mapper.TestProduct destination = ((cn.danvid.canal_test.mapper.TestProduct)b);
   destination.setId(((java.lang.Long)source.getId()));
   destination.setProductName(((java.lang.String)source.getProductName()));#如果有多个字段需要复制就多个getset
   if(customMapper != null) {
      customMapper.mapAtoB(source, destination, mappingContext);
   }
}
public void mapBtoA(java.lang.Object a, java.lang.Object b, ma.glasnost.orika.MappingContext mappingContext) {
   super.mapBtoA(a, b, mappingContext);
       // sourceType: TestProduct
   cn.danvid.canal_test.mapper.TestProduct source = ((cn.danvid.canal_test.mapper.TestProduct)a);
       // destinationType: CanalSyncMapper
   cn.danvid.canal_test.mapper.CanalSyncMapper destination = ((cn.danvid.canal_test.mapper.CanalSyncMapper)b);
   destination.setId(((java.lang.Long)source.getId()));
   destination.setProductName(((java.lang.String)source.getProductName()));#如果有多个字段需要复制就多个getset
   if(customMapper != null) {
      customMapper.mapBtoA(source, destination, mappingContext);
   }
}

可以看到实际上Orika使用map的时候，目标对象我们传的是class类，但到了GeneratedMapper.mapAtoB传入的是一个对象那么实际上目标对象是先基于Java反射创建出来，然后再复制的，所以Orika也要用到反射。
    其实到这里大概原理都讲完了，如果大家有兴趣也可以接着看我把细节再讲一下。

==========================================================================================================================

大家点击MappFacade.map里面实际上源码是这样

 public <S, D> D map(final S sourceObject, final Class<D> destinationClass, final MappingContext context) {

        MappingStrategy strategy = null;
        try {
            if (destinationClass == null) {
                throw new MappingException("'destinationClass' is required");
            }
            if (sourceObject == null) {
                return null;
            }

            D result = context.getMappedObject(sourceObject, TypeFactory.valueOf(destinationClass));
            if (result == null) {
                strategy = resolveMappingStrategy(sourceObject, null, destinationClass, false, context);#1.实际上就是创建GeneratedMapper
                result = (D) strategy.map(sourceObject, null, context);                               #2.实际上调用的是这个方法
            }
            return result;

        } catch (MappingException e) {
            throw exceptionUtil.decorate(e);
        } catch (RuntimeException e) {
            if (!ExceptionUtility.originatedByOrika(e)) {
                throw e;
            }
            MappingException me = exceptionUtil.newMappingException(e);
            me.setSourceClass(sourceObject.getClass());
            me.setDestinationType(TypeFactory.valueOf(destinationClass));
            me.setMappingStrategy(strategy);
            throw me;
        }
    }

上面代码备注上有亮点，先讲第二点=>打断点会发现，在执行strategy.map的时候最终就是调用了GeneratedMapper.mapAtoB方法。

讲完第二点实际上我们就是关注这个 GeneratedMapper的生成过程，也就是备注的第一点 strategy = resolveMappingStrategy(sourceObject, null, destinationClass, false, context);这个方法，从下面代码可以看出来strategy会被缓存起来。

  public <S, D> MappingStrategy resolveMappingStrategy(final S sourceObject, final java.lang.reflect.Type initialSourceType,
            final java.lang.reflect.Type initialDestinationType, final boolean mapInPlace, final MappingContext context) {

        Key key = new Key(getClass(sourceObject), initialSourceType, initialDestinationType, mapInPlace);
        MappingStrategy strategy = strategyCache.get(key);

        if (strategy == null) {

          ......
        }

        /*
         * Set the resolved types on the current mapping context; this can be
         * used by downstream Mappers to determine the originally resolved types
         */
        context.setResolvedSourceType(strategy.getAType());
        context.setResolvedDestinationType(strategy.getBType());
        context.setResolvedStrategy(strategy);

        return strategy;
    }

接着我们就看看if (strategy == null)里面干了什么，如下，我们重点看备注部分

            @SuppressWarnings("unchecked")
            Type<S> sourceType = (Type<S>) (initialSourceType != null ? TypeFactory.valueOf(initialSourceType)
                    : typeOf(sourceObject));
            Type<D> destinationType = TypeFactory.valueOf(initialDestinationType);

            MappingStrategyRecorder strategyRecorder = new MappingStrategyRecorder(key, unenhanceStrategy);

            final Type<S> resolvedSourceType = normalizeSourceType(sourceObject, sourceType, destinationType);

            strategyRecorder.setResolvedSourceType(resolvedSourceType);
            strategyRecorder.setResolvedDestinationType(destinationType);

            if (!mapInPlace && canCopyByReference(destinationType, resolvedSourceType)) {
                /*
                 * We can copy by reference when destination is assignable from
                 * source and the source is immutable
                 */
                strategyRecorder.setCopyByReference(true);
            } else if (!mapInPlace && canConvert(resolvedSourceType, destinationType)) {
                strategyRecorder.setResolvedConverter(mapperFactory.getConverterFactory().getConverter(resolvedSourceType, destinationType));

            } else {
                strategyRecorder.setInstantiate(true);
                Type<? extends D> resolvedDestinationType = resolveDestinationType(context, sourceType, destinationType,
                        resolvedSourceType);

                strategyRecorder.setResolvedDestinationType(resolvedDestinationType);
                strategyRecorder.setResolvedMapper(resolveMapper(resolvedSourceType, resolvedDestinationType, context));#重点关注

if (!mapInPlace) { strategyRecorder.setResolvedObjectFactory( mapperFactory.lookupObjectFactory(resolvedDestinationType, resolvedSourceType, context)); } } strategy = strategyRecorder.playback(); if (log.isDebugEnabled()) { log.debug(strategyRecorder.describeDetails()); } MappingStrategy existing = strategyCache.putIfAbsent(key, strategy); if (existing != null) { strategy = existing; }

重点关注resolveMapper(resolvedSourceType, resolvedDestinationType, context)这个方法，里面实际调用了mapperFactory.lookupMapper(mapperKey, context)方法，如下

  public Mapper<Object, Object> lookupMapper(MapperKey mapperKey, MappingContext context) {

        Mapper<?, ?> mapper = getRegisteredMapper(mapperKey.getAType(), mapperKey.getBType(), false);
        if (internalMapperMustBeGenerated(mapper, mapperKey)) {
            mapper = null;
        }
        if (mapper == null && useAutoMapping) {
            synchronized (this) {
                mapper = getRegisteredMapper(mapperKey.getAType(), mapperKey.getBType(), false);
                boolean internalMapperMustBeGenerated = internalMapperMustBeGenerated(mapper, mapperKey);
                if (internalMapperMustBeGenerated) {
                    mapper = null;
                }
                if (mapper == null) {
                    try {

                        ...
                        ClassMapBuilder<?, ?> builder = classMap(mapperKey.getAType(), mapperKey.getBType()).byDefault(); #1.基于内省收集属性
                        for (MapperKey key : discoverUsedMappers(builder)) {
                            builder.use(key.getAType(), key.getBType());
                        }
                        final ClassMap<?, ?> classMap = builder.toClassMap();

                        buildObjectFactories(classMap, context);
                        mapper = buildMapper(classMap, true, context);                #2.根据收集的属性创建GeneratedMapper
                        initializeUsedMappers(mapper, classMap, context);
                       ...
                    } catch (MappingException e) {
                        e.setSourceType(mapperKey.getAType());
                        e.setDestinationType(mapperKey.getBType());
                        throw exceptionUtil.decorate(e);
                    }
                }
            }

        }
        return (Mapper<Object, Object>) mapper;
    }

#1.基于内省收集属性：ClassMapBuilder<?, ?> builder = classMap(mapperKey.getAType(), mapperKey.getBType()).byDefault();这个方法里面最终会调用到下面这个

protected ClassMapBuilder(Type<A> aType, Type<B> bType, MapperFactory mapperFactory, PropertyResolverStrategy propertyResolver,
            DefaultFieldMapper... defaults) {

        if (aType == null) {
            throw new MappingException("[aType] is required");
        }

        if (bType == null) {
            throw new MappingException("[bType] is required");
        }

        this.mapperFactory = mapperFactory;
        this.propertyResolver = propertyResolver;
        this.defaults = defaults;

        aProperties = propertyResolver.getProperties(aType);#这里就是使用了内省机制获取属性
        bProperties = propertyResolver.getProperties(bType);#这里就是使用了内省机制获取属性

propertiesCacheA = new LinkedHashSet<String>(); propertiesCacheB = new LinkedHashSet<String>(); this.aType = aType; this.bType = bType; this.fieldsMapping = new LinkedHashSet<FieldMap>(); this.usedMappers = new LinkedHashSet<MapperKey>(); }

最终会调用IntrospectorPropertyResolver.collectProperties 下面就是内省收集属性了。

protected void collectProperties(Class<?> type, Type<?> referenceType, Map<String, Property> properties) {

        try {
            BeanInfo beanInfo = Introspector.getBeanInfo(type);
            PropertyDescriptor[] descriptors = beanInfo.getPropertyDescriptors();

            for (final PropertyDescriptor pd : descriptors) {

                try {

                    Method readMethod = getReadMethod(pd, type);
                    if (!includeTransientFields && isTransient(readMethod)) {
                        continue;
                    }
                    Method writeMethod = getWriteMethod(pd, type, null);

                    Property property =
                            processProperty(pd.getName(), pd.getPropertyType(), readMethod, writeMethod, type, referenceType, properties);

                    postProcessProperty(property, pd, readMethod, writeMethod, type, referenceType, properties);

                } catch (final Exception e) {
                    /*
                     * Wrap with info for the property we were trying to
                     * introspect
                     */
                    throw new RuntimeException("Unexpected error while trying to resolve property " + referenceType.getCanonicalName()
                            + ", [" + pd.getName() + "]", e);
                }
            }
        } catch (IntrospectionException e) {
            throw new MappingException(e);
        }
    }

#2.根据收集的属性创建GeneratedMapper：有了属性就可以基于Javasisst创建GeneratedMapper了，如下：

可以看到mapperCode已经拼接生成了一个class的字符串(sourceBuilder)，这个字符串如下

package ma.glasnost.orika.generated;

public class Orika_TestProduct_CanalSyncMapper_Mapper30589730646840$0 extends ma.glasnost.orika.impl.GeneratedMapperBase {

    public void mapAtoB(java.lang.Object a, java.lang.Object b, ma.glasnost.orika.MappingContext mappingContext) {
    　　super.mapAtoB(a, b, mappingContext);
     　// sourceType: CanalSyncMapper
    　　cn.danvid.canal_test.mapper.CanalSyncMapper source = ((cn.danvid.canal_test.mapper.CanalSyncMapper)a);
    　　// destinationType: TestProduct
    　　cn.danvid.canal_test.mapper.TestProduct destination = ((cn.danvid.canal_test.mapper.TestProduct)b);
     　destination.setId(((java.lang.Long)source.getId()));
     　destination.setProductName(((java.lang.String)source.getProductName()));
     　if(customMapper != null) {
             customMapper.mapAtoB(source, destination, mappingContext);
      }
    }

    public void mapBtoA(java.lang.Object a, java.lang.Object b, ma.glasnost.orika.MappingContext mappingContext) {
　　　　super.mapBtoA(a, b, mappingContext);
　　　　// sourceType: TestProduct
　　　　cn.danvid.canal_test.mapper.TestProduct source = ((cn.danvid.canal_test.mapper.TestProduct)a);
　　　　// destinationType: CanalSyncMapper
　　　　cn.danvid.canal_test.mapper.CanalSyncMapper destination = ((cn.danvid.canal_test.mapper.CanalSyncMapper)b);
　　　　destination.setId(((java.lang.Long)source.getId()));
　　　　destination.setProductName(((java.lang.String)source.getProductName()));
        if(customMapper != null) {
             customMapper.mapBtoA(source, destination, mappingContext);
        }
    }
}

至此，应该明白的整个流程了把～