项目中频繁的数据转换我们怎么优化

太过爱你忘了你带给我的痛 2023-06-30 08:46 12阅读 0赞

我们先来看一张数据扭转的图，这个是DDD思想下各种对象转换的过程。

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

**DTO**（Data Transfer Object）：数据传输对象，用于展示层与服务层之间的数据传输对象。

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

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

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nY2hhbmdiaW4xMjM_size_16_color_FFFFFF_t_70][]

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][https_github.com_itrickzhang_spring-demo_tree_master_data-conversion]

> 本文由博客一文多发平台 [OpenWrite][] 发布！

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nY2hhbmdiaW4xMjM_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200116090617398.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nY2hhbmdiaW4xMjM=,size_16,color_FFFFFF,t_70
[https_github.com_itrickzhang_spring-demo_tree_master_data-conversion]: https://github.com/itrickzhang/spring-demo/tree/master/data-conversion
[OpenWrite]: https://openwrite.cn?from=article_bottom