分享公司DAO层数据库结果映射到对象的方法

主题

　　前面写过一篇文章,分享了公司是怎么动态封装SQL查询条件的(http://www.cnblogs.com/abcwt112/p/5874401.html).

　　里面提到数据库查询结果二维数组最后是封装到List<DTO>里的.即把数据库结果集封装成了对象集合.就像hibernate那样...那么公司是怎么做到的呢,这就是这篇文章的主题.

原理

　　类似于其他持久成框架,数据库结果要转化成对象,一定会有个映射规则.比如Mybatis里的Mapper文件用XML去描述映射规则,JPA则用注解@Column去描述规则.

　　公司也有自己的描述方法,参考了JPA,同样也是用注解的方式.有了规则,只要将数据库查询结果应用下规则即可.

规则

 @Target({ ElementType.FIELD })
 @Retention(RetentionPolicy.RUNTIME)
 @Inherited
 @Documented
 public @interface DbNameColumn {

     String fieldName() default "";

     Class<? extends Converter> converter() default Converter.class;
 }

 @Target({ ElementType.FIELD })
 @Retention(RetentionPolicy.RUNTIME)
 @Inherited
 @Documented
 public @interface DbColumn {

     int index() default -1;

     Class<? extends Converter> converter() default Converter.class;

 }

有2种规则,前面那种是通过结果集的column name(DbNameColumn.fieldName其实叫columnName似乎更好)与对象字段名做关联,下面那种规则是通过结果集的column index(DbColumn.index)与对象字段名做映射.

很明显,通过index来映射是不好的方式,因为当多个service共用一套规则的时候,如果某一个service想修改SQL在数据库结果中额外插入一列的话是做不到的,因为会影响其他映射的index.而DbColumnName这套映射规则就可以.因为这个依赖于数据库列的别名,而不是顺序.

converter是org.apache.commons.beanutils.Converter接口的实现类,这里依赖apache的包,可以自己指定Converter.虽然实际使用中没人会指定Converter.因为用公司这种NativeSQL就是为了省力,不需为了每个查询都写个Entity实体去映射数据库,而是定义一个DTO去映射N种相同列(或者部分列)查询结果的不同SQL..如果这里要自己再写个Converter的话还不如写个Entity简单.

实现规则

有了规则就只要实现这个规则就可以了

 package cn.com.servyou.framework.jpa;

 import java.lang.reflect.Field;
 import java.lang.reflect.InvocationTargetException;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;

 import org.apache.commons.beanutils.PropertyUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;

 import cn.com.servyou.framework.annotation.AnnotationUtils;
 import cn.com.servyou.framework.beans.converter.ConverterUtilsWrapper;
 import cn.com.servyou.framework.exception.SystemException;

 public final class DbColumnMapper {

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

     /**
      * Instantiates a new db column mapper.
      */
     private DbColumnMapper() {
     }

     /**
      * The list must contains the object array, which is the row. Each object in
      * the array is the column element.
      *
      * @param <T>
      *            the generic type
      * @param queryResult
      *            the query result
      * @param targetClass
      *            the target class
      * @return the list
      */
     public static <T> List<T> resultMapping(List<?> queryResult, Class<? extends T> targetClass) {

         return innerMapping(queryResult, targetClass);
     }

     /**
      * Checks if is named mapping.
      *
      * @param targetClass
      *            the target class
      * @return true, if is named mapping
      */
     public static boolean isNamedMapping(Class<?> targetClass) {

         List<Field> indexAnnotationFieldList = AnnotationUtils.getAnnotationFieldsInClass(DbColumn.class, targetClass);
         List<Field> nameAnnotationFieldList = AnnotationUtils.getAnnotationFieldsInClass(DbNameColumn.class,
                 targetClass);
         if (!indexAnnotationFieldList.isEmpty() && nameAnnotationFieldList.isEmpty()) {
             return false;
         } else if (!nameAnnotationFieldList.isEmpty() && indexAnnotationFieldList.isEmpty()) {
             return true;
         } else {
             throw new SystemException("不允许使用混合的数据库mapping", SystemException.INCONSISTENCE_EXCEPTION);
         }
     }

     /**
      * Inner mapping.
      *
      * @param <D>
      *            the generic type
      * @param queryResult
      *            the query result
      * @param targetClass
      *            the target class
      * @return the list
      */
     @SuppressWarnings("unchecked")
     private static <D> List<D> innerMapping(List<?> queryResult, Class<? extends D> targetClass) {// NOSONAR

         List<D> resultList = new ArrayList<D>();

         if (!isNamedMapping(targetClass)) {
             List<Field> annotationFieldList = AnnotationUtils.getAnnotationFieldsInClass(DbColumn.class, targetClass);
             for (Object obj : queryResult) {
                 try {// NOSONAR
                     D targetDto = targetClass.newInstance();
                     Object[] row = (Object[]) obj;
                     for (Field field : annotationFieldList) {
                         DbColumn dbColumn = field.getAnnotation(DbColumn.class);
                         if (dbColumn.converter() != null && !dbColumn.converter().isInterface()) {
                             ConverterUtilsWrapper.register(dbColumn.converter().newInstance(), field.getType());
                         }
                         try {// NOSONAR
                             if (PropertyUtils.isWriteable(targetDto, field.getName())) {
                                 if (dbColumn.index() >= 0 && dbColumn.index() < row.length) {
                                     // BUG#1865
                                     int columnIndex = field.getAnnotation(DbColumn.class).index();

                                     PropertyUtils.setProperty(targetDto, field.getName(),
                                             ConverterUtilsWrapper.convert(row[columnIndex], field.getType()));
                                 } else {
                                     throw new SystemException("类" + targetClass.getName() + "的字段" + field.getName()
                                             + "没有正确设置字段索引,应设置小于" + row.length + "的索引值", new Exception("类"
                                             + targetClass.getName() + "的字段" + field.getName() + "没有正确设置字段索引,应设置小于"
                                             + row.length + "的索引值"), SystemException.REQUEST_EXCEPTION);
                                 }
                             }

                         } catch (InvocationTargetException e) {
                             LOGGER.error("[Error!]", e);
                         } catch (NoSuchMethodException e) {
                             LOGGER.error("[Error!]", e);
                         }
                     }
                     resultList.add(targetDto);
                 } catch (InstantiationException e1) {
                     LOGGER.error("[Error!]", e1);
                 } catch (IllegalAccessException e1) {
                     LOGGER.error("[Error!]", e1);
                 }

             }
             return resultList;
         } else {
             List<Field> annotationFieldList = AnnotationUtils.getAnnotationFieldsInClass(DbNameColumn.class,
                     targetClass);
             for (Object obj : queryResult) {
                 try {// NOSONAR
                     D targetDto = targetClass.newInstance();
                     Map<String, ?> row = (Map<String, ?>) obj;
                     for (Field field : annotationFieldList) {
                         DbNameColumn dbColumn = field.getAnnotation(DbNameColumn.class);
                         if (dbColumn.converter() != null && !dbColumn.converter().isInterface()) {
                             ConverterUtilsWrapper.register(dbColumn.converter().newInstance(), field.getType());
                         }
                         try {// NOSONAR
                             if (PropertyUtils.isWriteable(targetDto, field.getName())) {
                                 String colName = dbColumn.fieldName();
                                 PropertyUtils.setProperty(targetDto, field.getName(),
                                         ConverterUtilsWrapper.convert(row.get(colName.toUpperCase()), field.getType()));
                             }
                         } catch (InvocationTargetException e) {
                             LOGGER.error("[Error!]", e);
                         } catch (NoSuchMethodException e) {
                             LOGGER.error("[Error!]", e);
                         }
                     }
                     resultList.add(targetDto);
                 } catch (InstantiationException e1) {
                     LOGGER.error("[Error!]", e1);
                 } catch (IllegalAccessException e1) {
                     LOGGER.error("[Error!]", e1);
                 }
             }
             return resultList;
         }
     }

 }

以上是完整的映射规则的实现.类很长,但是核心代码不多..总共就2条分支,一条是index来映射,一条是column name来映射,分别对应前面的2种规则.

index那种映射真的不好.所以我就分享下DbNameColumn那套映射规则.核心代码如下:

 List<Field> annotationFieldList = AnnotationUtils.getAnnotationFieldsInClass(DbNameColumn.class,
                     targetClass);
             for (Object obj : queryResult) {
                 try {// NOSONAR
                     D targetDto = targetClass.newInstance();
                     Map<String, ?> row = (Map<String, ?>) obj;
                     for (Field field : annotationFieldList) {
                         DbNameColumn dbColumn = field.getAnnotation(DbNameColumn.class);
                         if (dbColumn.converter() != null && !dbColumn.converter().isInterface()) {
                             ConverterUtilsWrapper.register(dbColumn.converter().newInstance(), field.getType());
                         }
                         try {// NOSONAR
                             if (PropertyUtils.isWriteable(targetDto, field.getName())) {
                                 String colName = dbColumn.fieldName();
                                 PropertyUtils.setProperty(targetDto, field.getName(),
                                         ConverterUtilsWrapper.convert(row.get(colName.toUpperCase()), field.getType()));
                             }
                         } catch (InvocationTargetException e) {
                             LOGGER.error("[Error!]", e);
                         } catch (NoSuchMethodException e) {
                             LOGGER.error("[Error!]", e);
                         }
                     }
                     resultList.add(targetDto);
                 } catch (InstantiationException e1) {
                     LOGGER.error("[Error!]", e1);
                 } catch (IllegalAccessException e1) {
                     LOGGER.error("[Error!]", e1);
                 }
             }

实现细节:

1.数据库查询结果是List<Map>这种形式,为什么不是List<Object[]>或者其他形似呢?这个是hibernate执行原生SQL的时候可以选择.用Map的话和DbNameColumn映射比较简单,List的话和DbColumn映射比较简单.

2.我们知道要映射的对象的class以后可以用反射生成空的对象,同样用反射得到class里标注了DbNameColumn注解的所有Field,得到这些Field上面的DbNameColumn注解里需要映射到的数据库Column name.

3.从Map里找那一行数据库记录的值,设置到对象里就行,这里用的是org.apache.commons.beanutils.PropertyUtils.

这样就可以将数据库结果映射到对象了.

思考小结

用1句话来表述实现的话就是:

通过注解描述字段与数据库结果集列名的映射关系,通过反射和PropertyUtils来实现映射.

公司的这套实现方案算是对Spring Data映射的一种补充吧..

1.当不想写很多entity(比如太多代码表或者参数表) 或者

2.为很多很多相同或相似结构结果的SQL(比如不同表查询出相同树形结果的结果)提供一个统一的映射方案

的话是一种不错的选择..

但是似乎也有一些地方是可以优化的,比如:

这里对象设值用的是apache的PropertyUtils.此外公司对象之间转化有自己定义的ConverterUtil(底层用cglib的BeanCopier实现),再或者公司框架都是基于Spring的,Spring也有自己的类型转化方法.

这里是不是可以统一呢? Spring框架源码我们不会去修改,那我们能不能把我们的实现合并到Spring的实现中呢?

比如前面转化的时候的2行代码:

ConverterUtilsWrapper.register(dbColumn.converter().newInstance(), field.getType());

ConverterUtilsWrapper.convert(row.get(colName.toUpperCase());

这是不是似曾相识?!

Spring本身已经自带了类型转化的方法,提供了很多基本类型的转化,那么我们可以使用他的...除此之外的业务相关特有的转化再添加到这个service里就可以了..

不过不管怎么说...这只是实现细节的不同.....现在的实现也是一种不错的实现...