分享公司Entity与DTO之间数据拷贝的方法

主题

　　最早以前自学java web的时候,数据库查询出来一个Entity对象(CMP对象).就直接传给前台展示了.并没有用到DTO对象,开始并没有觉得有什么不好...后来发现还是需要一些DTO对象来专门用来传值与前台展示用的.因为直接使用Entity对象有几个地方会比较麻烦:

1.Entity对象的成员域和数据库字段是对应的(比如使用hibernate).所以不能额外向里面增加字段.但是有时候前台就是需要这个字段.反之,前台要向后台传一些值,entity也没办法接受,前台Form表单不可能和数据库公用同一套对象的.

2.有时候完成1个业务需要N个entity.一个一个传给前台很麻烦.这个不是最关键的,最关键的是如果你的service第一次需求定下来的时候只需要1个entity对象做为参数,后来需求变更了,需要用到另外一个entity,这个时候如果修改service的方法签名,增加一个入参,那所有用到这个service的地方都需要修改.而且其他地方不一定有那个业务相关的entity.而方法参数为单独一个DTO的时候就没有这个问题,需要什么其他属性,直接在DTO增加成员域即可.

3.entity可能是由框架控制生命周期的,比如hibernate,如果他的某个属性是懒加载的,那万一不在session中调用的话会抛出异常,而DTO对象很干净,并不会有什么问题.你可以自己控制DTO,喜欢就存在缓存里,不喜欢也没关系.同时entity对象如果属性变化的话会有是否需要同步更新数据库的问题,而DTO与数据库并没有什么卵关系.

对象拷贝

所以DTO还是需要的.这样的话就需要entity与dto之间进行数据库的拷贝. 最简单的方法当然是自己调用setget方法..但是显然这样比较麻烦.....因为成员域多的话一个一个set起来很累....

有不少框架都支持对象间属性的拷贝.公司的方法是采用CGLIB的BeanCopier去copy对象,并且在外面稍微包装了一层.

 @SuppressWarnings("rawtypes")
 public final class ConverterUtil {

     /**
      * The Constant LOGGER.
      */
     private static final Logger LOGGER = LoggerFactory.getLogger(ConverterUtil.class);

     /**
      * The Constant CACHED_COPIER_MAP.
      */
     private static final Map<String, BeanCopier> CACHED_COPIER_MAP = new ConcurrentHashMap<String, BeanCopier>();

     /**
      * The Constant CACHED_CUSTOM_CONVERTER_MAP.
      */
     private static final Map<String, ObjectConverter> CACHED_CUSTOM_CONVERTER_MAP = new ConcurrentHashMap<String, ObjectConverter>();

     /**
      * Instantiates a new converter util.
      */
     private ConverterUtil() {
     }

     /**
      * Convert list.
      *
      * @param <T>
      *            the generic type
      * @param <F>
      *            the generic type
      * @param source
      *            the source
      * @param target
      *            the target
      * @param sourceList
      *            the source list
      * @return the list
      */
     public static <T, F> List<F> convertList(Class<T> source, Class<F> target, List<T> sourceList) {
         return convertList(source, target, sourceList, null, null);
     }

     /**
      * Convert list.
      *
      * @param <T>
      *            the generic type
      * @param <F>
      *            the generic type
      * @param source
      *            the source
      * @param target
      *            the target
      * @param sourceList
      *            the source list
      * @param converter
      *            the converter
      * @param customConverterClass
      *            the custom converter class
      * @return the list
      */
     public static <T, F> List<F> convertList(Class<T> source, Class<F> target, List<T> sourceList, Converter converter,// NOSONAR
             Class<? extends ObjectConverter> customConverterClass) {
         if (CollectionUtils.isNotEmpty(sourceList)) {
             @SuppressWarnings("unchecked")
             List<F> targetList = new ArrayList();
             for (T t : sourceList) {
                 try {
                     F f = target.newInstance();
                     targetList.add(convert(t, f, converter, customConverterClass));
                 } catch (Exception e) {
                     LOGGER.error("When copy instance" + t, e);
                 }
             }
             return targetList;
         } else {
             return null;// NOSONAR
         }

     }

     /**
      * Convert.
      *
      * @param <T>
      *            the generic type
      * @param <F>
      *            the generic type
      * @param source
      *            the source
      * @param target
      *            the target
      * @return the f
      */
     public static <T, F> F convert(T source, F target) {
         return convert(source, target, null, null);
     }

     /**
      * Convert.
      *
      * @param <T>
      *            the generic type
      * @param <F>
      *            the generic type
      * @param source
      *            the source
      * @param target
      *            the target
      * @param converter
      *            the converter
      * @param customConverterClass
      *            the custom converter class
      * @return the f
      */
     public static <T, F> F convert(T source, F target, Converter converter,
             Class<? extends ObjectConverter> customConverterClass) {
         if (source == null || target == null) {
             return null; // NOSONAR
         }
         copy(source, target, converter, customConverterClass);
         return target;
     }

     /**
      * Private methods.
      *
      * @param <T>
      *            the generic type
      * @param <F>
      *            the generic type
      * @param source
      *            the source
      * @param target
      *            the target
      * @param converter
      *            the converter
      * @param customConverterClass
      *            the custom converter class
      */

     @SuppressWarnings("unchecked")
     private static <T, F> void copy(T source, F target, Converter converter,
             Class<? extends ObjectConverter> customConverterClass) {
         BeanCopier beanCopier = getBeanCopierInstance(source, target.getClass(), converter);
         beanCopier.copy(source, target, converter);
         ObjectConverter customConverter = getCustomConverterInstance(customConverterClass);
         if (customConverter != null) {
             if (target.getClass().getName().endsWith("CMP")) {
                 customConverter.convertFromDto(source, target);
             } else if (target.getClass().getName().endsWith("DTO")) {
                 customConverter.convertToDto(source, target);
             }
         }
     }

     /**
      * Gets the bean copier instance.
      *
      * @param <T>
      *            the generic type
      * @param <F>
      *            the generic type
      * @param source
      *            the source
      * @param targetClass
      *            the target class
      * @param converter
      *            the converter
      * @return the bean copier instance
      */
     private static <T, F> BeanCopier getBeanCopierInstance(T source, Class<F> targetClass, Converter converter) {
         String key = source.getClass().getName() + "#" + targetClass.getName();
         BeanCopier beanCopier = CACHED_COPIER_MAP.get(key);
         if (beanCopier == null) {
             synchronized (CACHED_COPIER_MAP) {
                 beanCopier = CACHED_COPIER_MAP.get(key);
                 if (beanCopier == null) {
                     beanCopier = TypeAwareBeanCopier.instantiate(source.getClass(), targetClass, converter != null);
                     CACHED_COPIER_MAP.put(key, beanCopier);
                 }
             }
         }
         return beanCopier;
     }

     /**
      * Gets the custom converter instance.
      *
      * @param <T>
      *            the generic type
      * @param <F>
      *            the generic type
      * @param customConverterClass
      *            the custom converter class
      * @return the custom converter instance
      */
     private static <T, F> ObjectConverter getCustomConverterInstance(
             Class<? extends ObjectConverter> customConverterClass) {
         if (customConverterClass == null) {
             return null;// NOSONAR
         }
         String key = customConverterClass.getName();
         ObjectConverter converter = CACHED_CUSTOM_CONVERTER_MAP.get(key);
         if (converter == null) {
             synchronized (CACHED_CUSTOM_CONVERTER_MAP) {
                 try {
                     converter = (ObjectConverter) SpringContextUtil.getBean(customConverterClass);
                 } catch (BeansException e) {// NOSONAR
                     LOGGER.info(customConverterClass.getName() + " is not a component, need new instance.");// NOSONAR
                 }
                 if (converter == null) {
                     try {
                         converter = customConverterClass.newInstance();
                         CACHED_CUSTOM_CONVERTER_MAP.put(key, converter);
                     } catch (InstantiationException e) {
                         LOGGER.info(e.getMessage(), e);
                         return null;
                     } catch (IllegalAccessException e) {
                         LOGGER.info(e.getMessage(), e);
                         return null;
                     }
                 }
             }
         }
         return converter;
     }

 }

完整的代码就这么多...

convert一个list,其实就是convert了N个普通对象.

convert 1个对象,其实就是new了一个相同类型的对象,然后copy成员域.

所以核心还是copy方法

     private static <T, F> void copy(T source, F target, Converter converter,
             Class<? extends ObjectConverter> customConverterClass) {
         BeanCopier beanCopier = getBeanCopierInstance(source, target.getClass(), converter);
         beanCopier.copy(source, target, converter);
         ObjectConverter customConverter = getCustomConverterInstance(customConverterClass);
         if (customConverter != null) {
             if (target.getClass().getName().endsWith("CMP")) {
                 customConverter.convertFromDto(source, target);
             } else if (target.getClass().getName().endsWith("DTO")) {
                 customConverter.convertToDto(source, target);
             }
         }
     }

copy方法就2个步骤,第一个步骤是调用CGLIB的BeanCopier的copy方法去copy对象,然后再调用自己写的ObjectConverter接口的实现类去做额外的copy..ObjectConverter接口有2个方法,一个是convertFromDto,就是DTO -> Entity的拷贝,另外一个是convertToDto就是Entity -> Dto或者Dto -> Dto的拷贝.

小小的总结

公司的对象间拷贝方法还是比较简单的,同时也蛮好用的,毕竟大多数时候就是收集下前台表单的数据,然后Copy到要保存的entity中,或者数据库查出来Entity,拷贝到前台去展示.

一般String呀,int呀这些都能很方便的拷贝,不过如果成员是List呀,引用对象呀什么的....那就只能自己去实现ObjectConverter接口做额外copy 或者为每个引用对象再掉一次copy方法.

这点是算个小缺陷吧....不过大多数情况下这个简易的转化工具还是超级好用的.