PO与DTO互转

已于 2023-12-20 20:34:35 修改
阅读量487 收藏
点赞数
分类专栏： 第三方工具 文章标签： java 笔记
于 2023-12-20 20:31:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zgcyyh/article/details/135116270
版权

DTO（Data Transfer Object）和 PO（Persistent Object）是两种不同的数据对象，它们在不同的场景下使用。
DTO 用于在不同的应用程序组件之间传输数据。它通常是轻量级的，只包含必要的字段，并且不包含任何业务逻辑。
PO  用于持久化数据到数据库。它通常是重量级的，包含所有必要的字段，并且包含业务逻辑。

1、以下是 DTO 和 PO 的比较


    1.1、用途 

        DTO: 用于在不同的应用程序组件之间传输数据 
        PO:  用于持久化数据到数据库
    

    1.2、重量 

        DTO: 轻量级 
        PO:  重量级
    

     1.3、字段 

        DTO:只包含必要的字段 
        PO: 包含所有必要的字段

    1.4、业务逻辑 

        DTO:不包含任何业务逻辑 
        PO: 包含业务逻辑 

2、分层

    在实际开发中，我们通常会使用 DTO 和 PO 来分离数据层和业务层。

    DTO 位于数据层，用于在不同的应用程序组件之间传输数据。
    PO 位于业务层，用于持久化数据到数据库。

3、PO与DTO互转示例


3.1、UserDTO

是用于在不同的应用程序组件之间传输数据的轻量级对象。

public class UserDTO {

    private String username;
    private String password;
    private String email;
    public UserDTO(){}

    public UserDTO(String username, String password, String email) {
        this.username = username;
        this.password = password;
        this.email = email;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}

3.2、UserPO  

是用于持久化数据到数据库的重量级对象。

public class UserPO {

    private Long id;
    private String username;
    private String password;
    private String email;
    public UserPO(){}

    public UserPO(Long id, String username, String password, String email) {
        this.id = id;
        this.username = username;
        this.password = password;
        this.email = email;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}

4、使用ModelMapper

4.1、在pom.xml文件中，引入ModelMapper依赖

<dependency>
	<groupId>org.modelmapper</groupId>
	<artifactId>modelmapper</artifactId>
	<version>3.1.1</version>
</dependency>

    4.2、示例

    import org.modelmapper.ModelMapper;
    public UserPO testModelMapper(){
        // 创建一个 ModelMapper 对象
        ModelMapper modelMapper = new ModelMapper();

        // 创建一个 DTO 对象
        UserDTO userDTO = new UserDTO();
        userDTO.setUsername("张三");
        userDTO.setPassword("123456");
        userDTO.setEmail("zhangsan@example.com");

        // 将 DTO 对象转换为 PO 对象
        UserPO userPO = modelMapper.map(userDTO, UserPO.class);

        return userPO;
    }

5、使用orika

5.1、在pom.xml文件中，引入orika依赖

		<dependency>
        	<groupId>ma.glasnost.orika</groupId>
         	<artifactId>orika-core</artifactId>
        	<version>1.5.4</version>
     	 </dependency>

5.2、 示例

5.2.1、OrikaUtil 工具类
import ma.glasnost.orika.MapperFactory;
import ma.glasnost.orika.metadata.ClassMapBuilder;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * @author zhongyushi
 * https://www.cnblogs.com/zys2019/p/17005798.html#_label1_2
 */
@Component
public class OrikaUtil {
    @Resource
    private MapperFactory mapperFactory;

    /**
     * 字段映射
     *
     * @param aType  源对象类型
     * @param bType  目标对象类型
     * @param fields 不同字段映射值
     * @param <A>
     * @param <B>
     */
    private <A, B> void filedMap(Class<A> aType, Class<B> bType, Map<String, String> fields) {
        ClassMapBuilder<A, B> mapBuilder = mapperFactory.classMap(aType, bType);
        if (fields != null && fields.size() > 0) {
            Set<Map.Entry<String, String>> entries = fields.entrySet();
            for (Map.Entry<String, String> entry : entries) {
                mapBuilder.field(entry.getKey(), entry.getValue());
            }
        }
        mapBuilder.byDefault().register();
    }

    /**
     * 对象的复制
     *
     * @param aType  源对象类型
     * @param bType  目标对象类型
     * @param fields 不同字段映射值
     * @param source 要复制的对象
     * @param <A>
     * @param <B>
     * @return
     */
    public <A, B> B beanCopy(Class<A> aType, Class<B> bType, Map<String, String> fields, A source) {
        filedMap(aType, bType, fields);
        B target = mapperFactory.getMapperFacade().map(source, bType);
        return target;
    }

    /**
     * 对象的复制
     *
     * @param aType  源对象类型
     * @param bType  目标对象类型
     * @param source 要复制的对象
     * @param <A>
     * @param <B>
     * @return
     */
    public <A, B> B beanCopy(Class<A> aType, Class<B> bType, A source) {
        return beanCopy(aType, bType, null, source);
    }

    /**
     * 集合的复制
     *
     * @param aType  源对象类型
     * @param bType  目标对象类型
     * @param fields 不同字段映射值
     * @param source 要复制的对象
     * @param <A>
     * @param <B>
     * @return
     */
    public <A, B> List<B> beanListCopy(Class<A> aType, Class<B> bType, Map<String, String> fields, Iterable<A> source) {
        filedMap(aType, bType, fields);
        List<B> bList = mapperFactory.getMapperFacade().mapAsList(source, bType);
        return bList;
    }

    /**
     * 集合的复制
     *
     * @param aType  源对象类型
     * @param bType  目标对象类型
     * @param source 要复制的对象
     * @param <A>
     * @param <B>
     * @return
     */
    public <A, B> List<B> beanListCopy(Class<A> aType, Class<B> bType, Iterable<A> source) {
        return beanListCopy(aType, bType, null, source);
    }
}
5.2.2、配置类
import ma.glasnost.orika.MapperFactory;
import ma.glasnost.orika.impl.DefaultMapperFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * orika
 */
@Configuration
public class MapperFactoryAutoConfig {

    @Bean
    public MapperFactory getFactory(){
        return new DefaultMapperFactory.Builder().build();
    }

}
5.2.3、测试示例
import cn.example.demo.dto.UserDTO;
import cn.example.demo.dto.UserPO;
import cn.example.demo.utils.OrikaUtil;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.StopWatch;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;


@Autowired
private OrikaUtil orikaUtil;

/**
* 单个对象
* @return
*/
public UserPO orika0() {
        UserDTO userDto = new UserDTO("orika0", "123", "zhansan@qq.com");
        Map<String, String> map = new HashMap<>();
        //map.put("password", "password1");//有差异的属性名称
        UserPO userPo = orikaUtil.beanCopy(UserDTO.class, UserPO.class, map, userDto);
        System.out.println(userPo);
        return userPo;
}


/**
* 对象列表转换
* 10万条耗时 583 ms
*/
public List<UserPO> orika1() {
        Integer t = 100000;
        List<UserDTO> list = new ArrayList<>();
        for (int i = 0; i < t; i++) {
            UserDTO userDto = new UserDTO("orika" + i, "111"+ i, "orika"+ i+"@qq.com");
            list.add(userDto);
        }

        Map<String, String> map = new HashMap<>();
        //map.put("age", "userAge"); //名称不同的属性之间映射
        StopWatch watch = new StopWatch();
        watch.start("orika");
        List<UserPO> poList = orikaUtil.beanListCopy(UserDTO.class, UserPO.class, map, list);
        System.out.println(poList);
        watch.stop();
        System.out.println("orika 复制用时：" + watch.getLastTaskTimeMillis());

        return poList;
}

6、使用 dozer

6.1、在pom.xml文件中，引入dozer依赖

<dependency>
  <groupId>com.github.dozermapper</groupId>
  <artifactId>dozer-core</artifactId>
  <version>6.5.0</version>
</dependency>

6.2、示例

import cn.example.demo.dto.UserDTO;
import cn.example.demo.dto.UserPO;
import com.github.dozermapper.core.DozerBeanMapperBuilder;
import com.github.dozermapper.core.Mapper;
import org.springframework.util.StopWatch;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

//参考地址：
//https://dozermapper.github.io/user-guide.pdf
//https://www.jb51.net/article/239801.htm
//https://blog.csdn.net/weixin_33786077/article/details/94759020

public List<UserPO> dozer() {
        List<UserDTO> list = new ArrayList<>();
        for (int i = 0; i < 100000; i++) {
            UserDTO userDto = new UserDTO("dozer" + i, "111"+ i, "dozer"+ i+"@qq.com");
            list.add(userDto);
        }


        List<UserPO> poList = new ArrayList<>();
        Mapper mapper = DozerBeanMapperBuilder.buildDefault();
        StopWatch watch = new StopWatch();
        watch.start("dozer");
        list.stream().forEach(item -> {
            UserPO userPo = mapper.map(item, UserPO.class);
            poList.add(userPo);
            System.out.println("userPo：" + item.hashCode());
        });
        watch.stop();
        System.out.println("dozer复制用时：" + watch.getLastTaskTimeMillis());
   return poList;
}

7、MapStruct

参考地址：https://mapstruct.org/

8、JMapper

参考地址：https://github.com/jmapper-framework/jmapper-core

zgcyyh
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
简单说下VO、PO、DO、DTO的主要区别及应用场景
黄勇的博客
01-02 2966
  好久没有更新文章了，最近刚入职熟悉了几个项目，因此看了很多代码，发现里面有很多实体采用了VO、DO、DTO这样的名称结尾，之前大致了解过他们的含义以及他们的使用场景，今天特地整理一下记录下来。
PO DTO的简单对比
afei8080的专栏
08-22 2063
PO（Persistent Object）：持久化对象，它跟持久层（通常是关系型数据库）的数据结构形成一一对应的映射关系，如果持久层是关系型数据库，那么，数据表中的每个字段（或若干个）就对应PO的一个（或若干个）属性。 DTO（Data Transfer Object）：数据传输对象，这个概念来源于J2EE的设计模式，原来的目的是为了EJB的分布式应用提供粗粒度的数据实体，以减少分布式调用的次数，...
带你多种方法实体类转换 玩转VO,PO,DTO 之间转换
最新发布
BASK2312的博客
04-20 933
尽管 "View Object" 也是一个有效的解释，但在面向对象设计和领域驱动设计（DDD）的上下文中，VO 通常指的是 "Value Object"。是需要进行一个完整的架构的，但是我们如果是一些小项目，没有必要为了设计而设计，导致的过度设计。可以这样说，对于绝大部分的应用场景来说，DTO和VO的属性值基本是一致的，而且他们通常都是。这个的话，那么这俩个方法的copyProperties 的源和目标的参数的位置是相反的。这里的DO 就相当于是PO 是没有什么区别的，或者说是很少的。
java中的vo、dto 、dao
weixin_30808575的博客
06-21 426
VO是跟数据库里表的映射，一个表对应一个VO DAO是用VO来访问真实的表，对数据库的操作都在DAO中完成 BO是业务层，做逻辑处理的 VO ， PO ， BO ， QO, DAO ,POJO O/R Mapping 是 Object RelationalMapping （对象关系映射）的缩写。 通俗点讲，就是将对象与关系数据库绑定，用对象来表示关系数据。在 O...
浅析 VO、DTO、DO、PO的概念、区别和用处
weixin_44421461的博客
06-02 370
点击上方“Java基基”，选择“设为星标”做积极的人，而不是积极废人！源码精品专栏原创 | Java 2020超神之路，很肝~中文详细注释的开源项目RPC 框架 Dubbo 源码解析...
PO、DTO、VO、BO到底是什么用在哪一层
qq_52988841的博客
10-11 994
我们可以把教育经历对应一个 PO ，工作经历对应一个 PO ，社会关系对应一个 PO。但是，有一个服务调用只需要其中的10个属性，此时我们可以创建一个只有10个属性的DTO返回给调用者。PO仅用来展现数据，类中只包含属性和get/set方法，而不会有修改数据库的方法。把相关的数据都组合到一个对象中，减少网络调用的次数，从而提高分布式调用的性能和降低网络负载。在Dubbo类型的分布式框架中，微服务间的调用使用DTO传输数据也是非常适合的。封装的复杂对象，主要是对业务数据的封装，可能包含一个或多个其它对象。
了解PO、POJO、DTO、VO、之间区别
qq_69531342的博客
06-06 603
PO 是“Persistent Object”的缩写，意为“持久化对象”。它通常用于表示数据库中的一条记录，即一组相关的数据。PO 是由 ORM（对象关系映射）框架生成或手动创建的 Java 对象，它们通常具有与数据库中的表相同的字段和数据类型。在 Java 开发中，PO 常常被用作 DAO（数据访问对象）层的数据模型，以及和数据库交互的对象。PO 对象中的字段与数据库中的列相对应，每一行数据对应一个 PO 对象，PO 对象中的字段值就是对应列的值。
po vo dto bo to
10-22
Spring Data Jpa实现自定义repository转DTO
08-18
Spring Data Jpa 实现自定义 Repository 转 DTO Spring Data Jpa 是 Java 持久层框架，提供了基于 Java 持久性 API（JPA）的实现。它提供了许多有用的功能，例如自动生成数据库表、自动处理关系数据库、支持 JPQL ...
java实现相同属性名称及相似类型的pojo、dto、vo等互转操作
08-24
Java 实现相同属性名称及相似类型的 POJO、DTO、VO 等互转操作 Java 实现相同属性名称及相似类型的 POJO、DTO、VO 等互转操作是 Java 编程中一个常见的问题。POJO、DTO、VO 等都是 Java 中常用的类别，但是它们之间...
Dto转实体类 AutoMapper
10-11
AutoMapper工具的使用 Dto 与 实体类 的值相互转换
vo bo po dto dao区别
05-16
本人以前搞不懂这些o的区别，特意查找资料总结了一下，希望也可以帮到其他人
【DDD】VO、DTO、DO、PO理解及应⽤
qq_37301432的博客
05-07 1893
实体类的定义是为了便于各个层级之间进⾏数据交换，同时降低耦合度。 概念： VO（View Object）：视图对象，⽤于展⽰层（如Controller），它的作⽤是把某个指定页⾯（或组件）的所有数据封装起来。 DTO（Data Transfer Object）：数据传输对象，这个概念来源于J2EE的设计模式，原来的⽬的是为了EJB的分布式应⽤提供粗粒度的数 据实体，以减少分布式调⽤的次数，从⽽提⾼分布式调⽤的性能和降低⽹络负载，但在这⾥，我泛指⽤于展⽰层与服务层之间的数据传输对 象。 DO（Domai...
PO,BO,VO,DTO,POJO,DAO,Entity,JavaBean,JavaBeans的区分（附图文）
魚
08-31 1295
PO (Persistent Object) PO（（bean,entity等命名）：持久化对象，它跟持久层（通常是关系型数据库）的数据结构形成一一对应的映射关系。 如果持久层是关系型数据库，那么，数据表中的每个字段（或若干个）就对应PO的一个（或若干个）属性。 VO(value object) 值对象 （view object）视图对象 VO（View Object）：视图对象，用于展示层，它的...
PO,BO,VO,DTO区别
wozaichengduha的博客
04-20 4031
开发过程中,遇到不同的封装,有DTO,BO,VO使用的时候容易混淆,分不清楚使用场景,查阅资料弄懂了
DTO，BO, PO之间的转换可以用这个框架；java 对象转换
oqqlhh的博客
12-11 3865
http://modelmapper.org/getting-started/
深入理解VO、DTO、DO、PO的概念、区别和用处
zl325118的博客
02-26 4213
本篇文章主要讨论一下我们经常会用到的一些对象：VO、DTO、DO和PO。 由于不同的项目和开发人员有不同的命名习惯，这里我首先对上述的概念进行一个简单描述，名字只是个标识，我们重点关注其概念： 概念： VO（View Object）：视图对象，用于展示层，它的作用是把某个指定页面（或组件）的所有数据封装起来。 DTO（Data Transfer Object）：数据传输对象，这个概念...
领域驱动设计系列文章（2）——浅析VO、DTO、DO、PO的概念、区别和用处
weixin_30298497的博客
06-15 6297
领域驱动设计系列文章（2）——浅析VO、DTO、DO、PO的概念、区别和用处 上一篇文章作为一个引子，说明了领域驱动设计的优势，从本篇文章开始，笔者将会结合自己的实际经验，谈及领域驱动设计的应用。本篇文章主要讨论一下我们经常会用到的一些对象：VO、DTO、DO和PO。 由于不同的项目和开发人员有不同的命名习惯，这里我首先对上述的概念进行一个简单描述，名字只是个标识，我们重点关注其概念...
po vo dto区别
03-30
PO和DTO都是用于数据传输的对象，但是它们的应用场景和设计目的不同。 PO（Persistence Object）是持久化对象，用于表示数据库中的一行记录，通常与数据库中的表一一对应。PO对象包含数据库表中的所有字段，包括主键和外键。PO对象通常是通过ORM框架自动生成的，用于简化数据库操作。 DTO（Data Transfer Object）是数据传输对象，用于在系统内部或不同系统之间传输数据。DTO对象通常只包含部分数据字段，用于提高数据传输的效率和安全性。DTO对象通常由开发人员手动创建，根据业务需求选择需要传输的字段。 因此，PO对象主要用于数据库操作，DTO对象主要用于数据传输。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值