2018-09-27 10:27:50
前言：
先说说什么是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();
}
}
}
