java DTO对象与PO对象的相互转换

2018-09-27 10:27:50

前言：

　　在实际开发中往往需要DTO对象与PO对象的相互转换；

　　先说说什么是VO、DTO、DO、PO对象吧，

概念：

VO（View Object）：视图对象，用于展示层，它的作用是把某个指定页面（或组件）的所有数据封装起来。

DTO（Data Transfer Object）：数据传输对象，这个概念来源于J2EE的设计模式，原来的目的是为了EJB的分布式应用提供粗粒度的数据实体，以减少分布式调用的次数，从而提高分布式调用的性能和降低网络负载，但在这里，我泛指用于展示层与服务层之间的数据传输对象。

DO（Domain Object）：领域对象，就是从现实世界中抽象出来的有形或无形的业务实体。

PO（Persistent Object）：持久化对象，它跟持久层（通常是关系型数据库）的数据结构形成一一对应的映射关系，如果持久层是关系型数据库，那么，数据表中的每个字段（或若干个）就对应PO的一个（或若干个）属性。

　　下面看个例子：

---

PO对象Student：　　　　　　　

 /**
  * @author libo
  * @date 2018年9月20日 下午8:44:33
  */
 public class Student {

     private Integer id;
     private String name;
     private Integer age;
     private String address;

     public Integer getId() {
         return id;
     }
     public void setId(Integer id) {
         this.id = id;
     }
     public String getName() {
         return name;
     }
     public void setName(String name) {
         this.name = name;
     }
     public Integer getAge() {
         return age;
     }
     public void setAge(Integer age) {
         this.age = age;
     }
     public String getAddress() {
         return address;
     }
     public void setAddress(String address) {
         this.address = address;
     }
     @Override
     public String toString() {
         return "Student [id=" + id + ", name=" + name + ", age=" + age + ", address=" + address + "]";
     }

 }

Student【PO类】

DTO对象StudentDTO：

 /**
  * @author libo
  * @date 2018年9月20日 下午8:45:56
  */
 public class StudentDTO extends Student{

     private Integer starAge;
     private Integer endAge;

     public Integer getStarAge() {
         return starAge;
     }
     public void setStarAge(Integer starAge) {
         this.starAge = starAge;
     }
     public Integer getEndAge() {
         return endAge;
     }
     public void setEndAge(Integer endAge) {
         this.endAge = endAge;
     }
     @Override
     public String toString() {
         return "StudentDTO [starAge=" + starAge + ", endAge=" + endAge + "]"+super.toString();
     }

 }

---

相信这已经知道了什么是DTO、PO对象了，现在言归正传，通过反射实现相互转换。也就是共有的属性但类型不同的相互转换。赋值给相同属性名的属性中去。

上代码：这里是可以相互转换的，第一个转第二个无论是否DTO

 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 import java.util.Arrays;
 import org.junit.Test;

 /**
  * 通过反射将Po对象转DTO对象
  *
  * @author libo
  * @date 2018年9月20日 下午6:40:07
  */
 public class PoToDTO {

     /**
      * 将po对象的属性值赋值给dto对象相同属性名的属性
      * 此方法能将第一个转第二个无论是否DTO
      * @param po 赋值的对象
      * @param dto 被赋值的对象
      * @return
      * @throws Exception
      */
     public Object poToDto(Object po, Object dto) throws Exception {
         Class poClass = po.getClass();
         Class dtoClass = dto.getClass();
         // 取得po对象的所有属性
         Field[] poFields = poClass.getDeclaredFields();
         //取父类的所有属性
         Field[] superPoFields = poClass.getSuperclass().getDeclaredFields();
         //合并数组
         poFields = (Field[]) mergeArray(poFields,superPoFields);

         // 遍历拼接dto的set方法字段表示
         for (Field f : poFields) {
             String fieldName = f.getName();
             //取得当前get，set字符串表达形式
             String dtoSetMethodName = "set" + firstToBig(fieldName);
             String poGetMethodName = "get"+firstToBig(fieldName);

             //System.out.println(fieldName + "=====" + dtoSetMethodName);
             // 取得DTO对象的set方法
             Method dtoSetMethod=null;
             try {
                 dtoSetMethod = dtoClass.getMethod(dtoSetMethodName, f.getType());
             }catch (NoSuchMethodException e) {//如果不存在此方法跳过，
                 continue;
             }
             //取得Po对象的get方法
             Method poGetMethod = poClass.getMethod(poGetMethodName, null);
             // 将po对象的属性值set到dto对象中去
             dtoSetMethod.invoke(dto, poGetMethod.invoke(po, null));
         }
         return dto;

     }

     /**
      * 合并数组
      * @param a
      * @param b
      * @return
      */
     public Object[] mergeArray(Object[] a,Object[] b) {
         Object[] c = Arrays.copyOf(a, a.length+b.length);
         System.arraycopy(b, 0, c, a.length, b.length);
         return c;
     }

     /**
      * 首字母大写
      *
      * @param fieldName
      * @return
      */
     public String firstToBig(String fieldName) {
         if (fieldName != null && fieldName != "") {
             fieldName = fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1);
         }
         return fieldName;
     }

     @Test
     public void test() {
         Student stu = new Student();
         stu.setId(1);
         stu.setName("李波");
         stu.setAge(22);
         stu.setAddress("郴州");

         StudentDTO stuDto = new StudentDTO();
         System.out.println("之前===="+stuDto);
         try {
             stuDto = (StudentDTO) poToDto(stu, stuDto);
             System.out.println("之后===="+stuDto);
         } catch (Exception e) {
             e.printStackTrace();
         }
     }

     @Test//测试将dto转po
     public void test2() {
         StudentDTO stuDTO = new StudentDTO();
         stuDTO.setId(1);
         stuDTO.setName("李波");
         stuDTO.setAge(22);
         stuDTO.setAddress("郴州");

         Student stu = new Student();
         Student ss = stuDTO;
         System.out.println("之前===="+stu);
         try {
             stu = (Student) poToDto(stuDTO, stu);
             System.out.println("之后===="+stu);
         } catch (Exception e) {
             e.printStackTrace();
         }
     }
 }