我们先来看一张数据扭转的图，这个是DDD思想下各种对象转换的过程。
VO（View Object）：视图对象，用于展示层，它的作用是把某个指定页面（或组件）的所有数据封装起来。
DTO（Data Transfer Object）：数据传输对象，用于展示层与服务层之间的数据传输对象。
DO（Domain Object）：领域对象，就是从现实世界中抽象出来的有形或无形的业务实体。
PO（Persistent Object）：持久化对象，它跟持久层（通常是关系型数据库）的数据结构形成一一对应的映射关系，如果持久层是关系型数据库，那么，数据表中的每个字段（或若干个）就对应PO的一个（或若干个）属性。
VO层我们先不看，从DTO开始，我们梳理简单一个请求流程中数据会转换几次：
- 请求时用户接口层DTO转DO
- 请求时领域层DO转PO
- 返回时领域层PO转DO
- 返回是DO转DTO
我们先看下操作之前和操作之后的代码，在来详解:
public static void main(String[] args) {
//初始化对象
UserDto userDto = new UserDto();
userDto.setId(1);
userDto.setName("java圈");
////////////////////////////
//UserDto转成对象UserDo
UserDtoToUserDo userDtoToUserDo = new UserDtoToUserDo();
UserDo userDo = userDtoToUserDo.convert(userDto);
//UserDo转成对象UserPo
UserDoToUserPo userDoToUserPo = new UserDoToUserPo();
UserPo userPo = userDoToUserPo.convert(userDo);
//UserPo转成对象UserDo
UserPoToUserDo userPoToUserDo = new UserPoToUserDo();
UserDo userDo1 = userPoToUserDo.convert(userPo);
//UserDo转成对象UserDto
UserDoToUserDto userDoToUserDto = new UserDoToUserDto();
UserDto userDto1 = userDoToUserDto.convert(userDo1);
System.out.println("改造之前的结果:"+userDto1);
////////////////////////////
UserDo userDo2 = AssemblerFactory.getInstance().execute(UserDtoToUserDoAssembler.class,userDto, UserDo.class);
UserPo userPo1 = AssemblerFactory.getInstance().execute(UserDoToUserPoAssembler.class,userDo2, UserPo.class);
UserDo userDo3 = AssemblerFactory.getInstance().execute(UserPoToUserDoAssembler.class,userPo1, UserDo.class);
UserDto userDto2 = AssemblerFactory.getInstance().execute(UserDoToUserDtoAssembler.class,userDo3, UserDto.class);
System.out.println("改造之后的结果:"+userDto2);
}
这段代码用两种方式实现了上述的四个对象的转换：
第一种
- 直接通过创建对象的方式进行数据扭转，可读性较差，容易混乱；
- 创建流程较麻烦，需要创建8个对象，占用额外的内存空间
- 可扩展性较差，牵一发而动全身；
第二种
- 通过工厂模式+代码模式+单例模式设计思想去实现，符合SOLID原则；
- 基于接口做实现代理，符合低耦合的概念；
- 可读性较强，每一个转换只要一行代码，只要清楚转换类型、原始对象和目标对象
功能实现
接口定义
数据转换接口，里面有一个convert转换的方法，需要传入原始对象，和返回对象的类型，直接返回目标对象，便于代码规范化话和代码隔离。
public interface Assembler<R,T> {
public T convert(R original,Class<T> targetType);
}
工厂类定义
AssemblerFactory是一个单例工厂，通过getAssembler传入的类型，获取目标转换对象的实例，ReflectionUtils为Spring-core里面的反射方法；execute执行实现类连的转换方法，需要传入原始对象和目标对象。
public class AssemblerFactory {
private static AssemblerFactory INSTANCE = new AssemblerFactory();
private AssemblerFactory(){}
public static AssemblerFactory getInstance(){
return INSTANCE;
}
private Assembler getAssembler(Class type){
Assembler assembler = null;
try {
assembler = (Assembler) ReflectionUtils.accessibleConstructor(type, new Class[0]).newInstance(new Object[0]);
} catch (Throwable e){
e.printStackTrace();
}
return assembler;
}
public <R,T> T execute(Class type,R original,Class<T> targetType){
Assembler assembler = getAssembler(type);
T target = (T) assembler.convert(original,targetType);
return target;
}
}
转换类实现
这里提供一个样例实现，实现接口Assembler，添加返回原始对象和目标对象，实现convert业务逻辑转换，这里有可能要问，里面转换的过程是否还可以优化？可以肯定是可以的，比如用组合模式，把DTO、VO、PO里面的字段进行封装、用组合+接口的方式实现，但是做起来还是比较麻烦。这里最好是建议用get/set方法转换,不要用一些序列化工具转换，执行效率没有get/set高。
/**
* UserDo 转 UserDto
*/
public class UserDoToUserDtoAssembler implements Assembler<UserDo,UserDto>{
@Override
public UserDto convert(UserDo userDo,Class<UserDto> target){
UserDto userDto = new UserDto();
userDto.setId(userDo.getId());
userDto.setName(userDo.getName());
return userDto;
}
}
源代码：https://github.com/itrickzhang/spring-demo/tree/master/data-conversion
本文由博客一文多发平台 OpenWrite 发布！
