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 + "]";
    }
    
    
}

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();
        }
    }
}