VO、DTO、DO、PO 详解 + 举例说明

最新推荐文章于 2024-05-31 10:46:10 发布
最新推荐文章于 2024-05-31 10:46:10 发布
阅读量1k 收藏 26
点赞数 18
分类专栏： Java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cxkjntm123/article/details/138924859
版权

在软件开发中，尤其是面向对象编程和分层架构中，常常使用不同的数据对象来区分不同层次和不同职责的数据传输和处理。以下是 VO、DTO、DO、PO 的详细解释和举例说明：

1. VO（Value Object，值对象）

定义：VO 是一种不变的对象，通常用于表示某个数据的抽象，在系统中用于传递只读数据，常用于展示层。

特点：

  • 不可变性：一旦创建，值对象的状态不能改变。
  • 无唯一标识：VO 不需要有唯一标识。

举例：
假设我们有一个电商系统，需要在前端展示商品的详细信息。

public class ProductVO {
    private String name;
    private String description;
    private BigDecimal price;
    private String category;

    // 构造函数、getters 等省略

    public ProductVO(String name, String description, BigDecimal price, String category) {
        this.name = name;
        this.description = description;
        this.price = price;
        this.category = category;
    }
}

2. DTO（Data Transfer Object，数据传输对象）

定义：DTO 用于在不同层之间传输数据，通常用于服务层与控制层之间的数据传输。DTO 可以是可变的，通常包含 getter 和 setter 方法。

特点：

  • 仅用于数据传输：不包含业务逻辑。
  • 可以包含部分业务逻辑以确保数据一致性。

举例：
例如，在电商系统中，从客户端接收到创建订单的数据。

public class OrderDTO {
    private Long productId;
    private Integer quantity;
    private String customerName;
    private String shippingAddress;

    // 构造函数、getters 和 setters 省略

    public OrderDTO(Long productId, Integer quantity, String customerName, String shippingAddress) {
        this.productId = productId;
        this.quantity = quantity;
        this.customerName = customerName;
        this.shippingAddress = shippingAddress;
    }

    // Getters 和 Setters 省略
}

3. DO（Domain Object，领域对象）

定义：DO 代表领域模型中的对象，包含业务逻辑和规则，直接与数据库中的数据对应。它们在持久化层和业务层之间传递。

特点：

  • 直接映射到数据库表。
  • 包含业务逻辑。

举例：
在电商系统中，表示数据库中的订单记录。

public class OrderDO {
    private Long id;
    private Long productId;
    private Integer quantity;
    private String customerName;
    private String shippingAddress;
    private LocalDateTime orderDate;

    // 构造函数、getters 和 setters 省略

    public OrderDO(Long id, Long productId, Integer quantity, String customerName, String shippingAddress, LocalDateTime orderDate) {
        this.id = id;
        this.productId = productId;
        this.quantity = quantity;
        this.customerName = customerName;
        this.shippingAddress = shippingAddress;
        this.orderDate = orderDate;
    }

    // Getters 和 Setters 省略
}

4. PO（Persistent Object，持久对象）

定义：PO 通常是与数据库中的表结构一一对应的 Java 对象，用于持久化数据。通常使用 ORM 框架（如 Hibernate 或 MyBatis）进行映射。

特点：

  • 映射到数据库表。
  • 包含持久化相关的注解。

举例：
在电商系统中，表示数据库中的商品记录。

@Entity
@Table(name = "product")
public class ProductPO {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "name")
    private String name;

    @Column(name = "description")
    private String description;

    @Column(name = "price")
    private BigDecimal price;

    @Column(name = "category")
    private String category;

    // 构造函数、getters 和 setters 省略

    public ProductPO(String name, String description, BigDecimal price, String category) {
        this.name = name;
        this.description = description;
        this.price = price;
        this.category = category;
    }

    // Getters 和 Setters 省略
}

5. 系统举例：

下面是一个使用 Spring Boot 和 MyBatis 构建的电商系统示例，包含商品和订单功能，展示了 VO、DTO、DO、PO 在三层架构中的具体应用。

项目结构

src/main/java
└── com/example/ecommerce
    ├── EcommerceApplication.java
    ├── controller
    │   ├── ProductController.java
    │   └── OrderController.java
    ├── service
    │   ├── ProductService.java
    │   └── OrderService.java
    ├── mapper
    │   ├── ProductMapper.java
    │   └── OrderMapper.java
    ├── domain
    │   ├── ProductDO.java
    │   └── OrderDO.java
    ├── po
    │   ├── ProductPO.java
    │   └── OrderPO.java
    ├── dto
    │   └── OrderDTO.java
    └── vo
        └── ProductVO.java

1. PO（Persistent Object）

映射数据库表，用于持久化数据。

// ProductPO.java
package com.example.ecommerce.po;

public class ProductPO {
    private Long id;
    private String name;
    private String description;
    private BigDecimal price;
    private String category;

    // Constructors, getters and setters
    public ProductPO() {}

    public ProductPO(String name, String description, BigDecimal price, String category) {
        this.name = name;
        this.description = description;
        this.price = price;
        this.category = category;
    }

    // Getters and Setters
}

// OrderPO.java
package com.example.ecommerce.po;

import java.time.LocalDateTime;

public class OrderPO {
    private Long id;
    private Long productId;
    private Integer quantity;
    private String customerName;
    private String shippingAddress;
    private LocalDateTime orderDate;

    // Constructors, getters and setters
    public OrderPO() {}

    public OrderPO(Long productId, Integer quantity, String customerName, String shippingAddress, LocalDateTime orderDate) {
        this.productId = productId;
        this.quantity = quantity;
        this.customerName = customerName;
        this.shippingAddress = shippingAddress;
        this.orderDate = orderDate;
    }

    // Getters and Setters
}

2. DO（Domain Object）

包含业务逻辑。

// OrderDO.java
package com.example.ecommerce.domain;

import java.math.BigDecimal;
import java.time.LocalDateTime;

public class OrderDO {
    private Long id;
    private Long productId;
    private Integer quantity;
    private String customerName;
    private String shippingAddress;
    private LocalDateTime orderDate;

    public OrderDO(Long id, Long productId, Integer quantity, String customerName, String shippingAddress, LocalDateTime orderDate) {
        this.id = id;
        this.productId = productId;
        this.quantity = quantity;
        this.customerName = customerName;
        this.shippingAddress = shippingAddress;
        this.orderDate = orderDate;
    }

    // Getters and Setters

    // Business logic methods
    public BigDecimal calculateTotalPrice(BigDecimal productPrice) {
        return productPrice.multiply(new BigDecimal(this.quantity));
    }
}

3. DTO（Data Transfer Object）

用于表示层和业务逻辑层之间的数据传输。

// OrderDTO.java
package com.example.ecommerce.dto;

public class OrderDTO {
    private Long productId;
    private Integer quantity;
    private String customerName;
    private String shippingAddress;

    public OrderDTO(Long productId, Integer quantity, String customerName, String shippingAddress) {
        this.productId = productId;
        this.quantity = quantity;
        this.customerName = customerName;
        this.shippingAddress = shippingAddress;
    }

    // Getters and Setters
}

4. VO（Value Object）

用于表示层展示数据。

// ProductVO.java
package com.example.ecommerce.vo;

import java.math.BigDecimal;

public class ProductVO {
    private Long id;
    private String name;
    private String description;
    private BigDecimal price;
    private String category;

    public ProductVO(Long id, String name, String description, BigDecimal price, String category) {
        this.id = id;
        this.name = name;
        this.description = description;
        this.price = price;
        this.category = category;
    }

    // Getters
}

5. Mapper（MyBatis Mapper）

// ProductMapper.java
package com.example.ecommerce.mapper;

import com.example.ecommerce.po.ProductPO;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;

@Mapper
public interface ProductMapper {
    @Select("SELECT * FROM product WHERE id = #{id}")
    ProductPO findById(Long id);
}

// OrderMapper.java
package com.example.ecommerce.mapper;

import com.example.ecommerce.po.OrderPO;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Insert;

@Mapper
public interface OrderMapper {
    @Insert("INSERT INTO orders (product_id, quantity, customer_name, shipping_address, order_date) " +
            "VALUES (#{productId}, #{quantity}, #{customerName}, #{shippingAddress}, #{orderDate})")
    void save(OrderPO orderPO);
}

6. Service（业务逻辑层）

// ProductService.java
package com.example.ecommerce.service;

import com.example.ecommerce.mapper.ProductMapper;
import com.example.ecommerce.vo.ProductVO;
import com.example.ecommerce.po.ProductPO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class ProductService {

    @Autowired
    private ProductMapper productMapper;

    public ProductVO getProductById(Long id) {
        ProductPO productPO = productMapper.findById(id);
        return new ProductVO(productPO.getId(), productPO.getName(), productPO.getDescription(), productPO.getPrice(), productPO.getCategory());
    }
}

// OrderService.java
package com.example.ecommerce.service;

import com.example.ecommerce.mapper.OrderMapper;
import com.example.ecommerce.domain.OrderDO;
import com.example.ecommerce.dto.OrderDTO;
import com.example.ecommerce.po.OrderPO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.time.LocalDateTime;

@Service
public class OrderService {

    @Autowired
    private OrderMapper orderMapper;

    public void createOrder(OrderDTO orderDTO) {
        OrderDO orderDO = new OrderDO(null, orderDTO.getProductId(), orderDTO.getQuantity(), orderDTO.getCustomerName(), orderDTO.getShippingAddress(), LocalDateTime.now());
        OrderPO orderPO = new OrderPO(orderDO.getProductId(), orderDO.getQuantity(), orderDO.getCustomerName(), orderDO.getShippingAddress(), orderDO.getOrderDate());
        orderMapper.save(orderPO);
    }
}

7. Controller（表示层）

// ProductController.java
package com.example.ecommerce.controller;

import com.example.ecommerce.service.ProductService;
import com.example.ecommerce.vo.ProductVO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/products")
public class ProductController {

    @Autowired
    private ProductService productService;

    @GetMapping("/{id}")
    public ResponseEntity<ProductVO> getProduct(@PathVariable Long id) {
        ProductVO productVO = productService.getProductById(id);
        return ResponseEntity.ok(productVO);
    }
}

// OrderController.java
package com.example.ecommerce.controller;

import com.example.ecommerce.dto.OrderDTO;
import com.example.ecommerce.service.OrderService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/orders")
public class OrderController {

    @Autowired
    private OrderService orderService;

    @PostMapping
    public ResponseEntity<String> createOrder(@RequestBody OrderDTO orderDTO) {
        orderService.createOrder(orderDTO);
        return ResponseEntity.ok("Order created successfully");
    }
}

8. 主应用程序类

// EcommerceApplication.java
package com.example.ecommerce;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.mybatis.spring.annotation.MapperScan;

@SpringBootApplication
@MapperScan("com.example.ecommerce.mapper")
public class EcommerceApplication {
    public static void main(String[] args) {
        SpringApplication.run(EcommerceApplication.class, args);
    }
}

结论

这个示例展示了如何使用 Spring Boot 和 MyBatis 实现一个电商系统的三层架构，分别使用 VO、DTO、DO 和 PO 来管理不同层次的数据对象。

  • PO（持久对象） 在数据访问层（DAO 层）中与数据库表进行映射和持久化。
  • DO（领域对象） 在业务逻辑层（Service 层）中包含业务逻辑。
  • DTO（数据传输对象） 用于表示层（Controller 层）和业务逻辑层（Service 层）之间的数据传输。
  • VO（值对象） 在表示层（Controller 层）中用于展示数据。

这种分层和对象的使用方式提高了系统的可维护性和可扩展性，使代码更清晰，职责分明。

c137范特西
关注
  • 18
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java术语（PO/POJO/VO/BO/DAO/DTO）
04-14
NULL 博文链接：https://ewf-momo.iteye.com/blog/1738853
po vo dto bo to
10-22
vo bo po dto dao区别
05-16
本人以前搞不懂这些o的区别，特意查找资料总结了一下，希望也可以帮到其他人
J2EE基础知识之DTO,VO,PO,DO等定义
08-09
J2EE基础知识之DTO,VO,PO,DO等定义J2EE基础知识之DTO,VO,PO,DO等定义J2EE基础知识之DTO,VO,PO,DO等定义
Java中 PO VO BO DTO DAO 和 POJO 关系图
03-13
Java中 PO VO BO DTO DAO 和 POJO 关系图
Java中VO，BO，PO，DO，DTO的详解
抽象的螺旋
11-08 3105
java
Java中VO,DO,DTO,POJO详解及使用说明
41981DC的博客
01-05 1万+
1.VO与DTO的概念 VO（View Object）：视图层，用于展示层，它的作用是把某个指定页面（或组件）的所有数据封装起来。 DTO（Data Transfer Object）：数据传输对象，这个概念来源于J2EE的设计模式，原来的目的时为了EJB的分布式应用提供粗粒度的数据实体，以减少分布式条用的次数，从而提高分布式调用的性能和降低网络负载，但在这里，我泛指用于展示层与服务层之间的数据传输...
PO,BO,VO,DTO和POJO
哈
11-12 2151
PO,BO,VO,DTO和POJO POJO plain ordinary java object 无规则简单java对象 一个中间对象，可以转化为PO、DTO、VO。 PO persistent object 持久对象 有时也被称为Data对象，对应数据库中的entity，可以简单认为一个PO对应数据库中的一条记录。 PO中不应该包含任何对数据库的操作。 VO value object 值对...
VO、QUERY、 BO 、DTO、 DO、POJO 详解
qq_34253002的博客
05-11 650
1.DO（Data Object）与数据库表结构对应，通过 DAO 层向上传输数据源对象。 2.DTO（Data Transfer Object）数据传输对象，Service 和 Manager 向外传输的对象。 3.BO（Business Object）业务对象。可以由 Service 层输出的封装业务逻辑的对象。 4.QUERY数据查询对象，各层接收上层的查询请求。 5.VO（View Object）显示层对象，通常是 Web 向模板渲染引擎层传输的对象。 6.POJO（Plain Ordinary J
DO、DTO、BO、AO、VO、POJO定义和转换的正确姿势
热门推荐
明明如月的技术博客
04-30 3万+
一、引言 DO、DTO、BO、AO、VO、POJO的概念看似简单，但是想区分好或者理解好也不容易，本文简单梳理一下。 通过各层POJO的使用，有助于提高代码的可读性和可维护性。 ------------------------------------------------------------------------------------------------------------...
VO(DTO)存在的必要性，以及使用工厂模式+模版模式+自省实现可拓展VO
读书就是赚钱
09-01 1万+
引子： 想起以前第一个项目的时候，使用springMvc+mybatis+restful实现一个论坛的网站，那个时候因为还不知道VO层的存在（因为一直使用MVC三层架构）。为了不想重复写get,set方法（把po的数据封装到map或者新的bean），所以直接从数据库里面读取出来的po就直接封装成json反馈到前端，很多重要的数据字段如用户密码这些都直接抛给前端，数据泄漏了出去。 后来使用
DO转换DTO
qq_34157673的博客
06-02 1327
public class BeanDtoUtils<V, E> { /** * TODO Do 转换 DTO * 同：BeanUtils.copyProperties(dtoEntity, newInstance); * * @param oldClass 原数据--Dto，Vo，entity * @param newClass 转换为--Dto，Vo，entity * @return */ publi.
DO、VO、DTO
菜鸡程序猿的博客
06-20 1306
DTO – 服务实现中的核心数据 浅析VO、DTO、DO、PO的概念、区别和用处DO、DTO和VO分层设计的好处实体类（VO，DO，DTO）的划分
java里的DTO,DO,BO,VO
weixin_51508971的博客
05-20 4924
DTO（ Data Transfer Object）：数据传输对象 DTO是来绑定表现层中的数据，与实体Entity不同，DTO是指数据在页面和业务层逻辑，比如当客户在页面提交了表单后，业务层先为这个数据构造了一个DTO对象，然后业务方法内部将DTO对象转为实体对象，然后通过这个实体对象去调用数据库的信息。从这个过程可以看出DTO对象是处理显示层和业务层的数据传递，Entity对象是处理业务层和数据库之间的数据传递。 DO（ Data Object）：领域对象 DO是从现实世界中抽象出来的有形或无形的业务实
JAVAEE之多线程进阶（2）_ CAS概念、实现原理、ABA问题及解决方案
2301_80653026的博客
05-29 1364
CAS全称Compare and swap，字面意思:”比较并交换“，它是一条 CPU 并发原语，用于判断内存中某个值是否为预期值，如果是则更改为新的值，这个过程是原子的。全称 Compare and swap, 即 “比较并交换”. 相当于通过一个原子的操作, 同时完成 “读取内存, 比较是否相等, 修改内存” 这三个步骤. 本质上需要 CPU 指令的支撑。
operator ＜=＞ (spaceship operator)
janeqi1987的专栏
05-28 877
= 与!= 操作符为了检查是否相等，现在定义== 操作符就够了。当编译器找不到表达式的匹配声明a!=b 时，编译器会重写表达式并查找!(a==b)。若这不起作用，编译器也会尝试改变操作数的顺序，所以也会尝试!(b==a):a!=b,!(b==a)因此，对于TypeA 的a 和TypeB 的b，编译器将能够识别并编译a!= b若需要的话，可以这样做• 一个独立函数operator!• 一个独立函数operator==(TypeA, TypeB)
Spring6基础笔记
质胜文则野，文胜质则史。文质彬彬，然后君子。
05-21 1195
Spring 是一款主流的 Java EE 轻量级开源框架 ，Spring 由“Spring 之父”Rod Johnson 提出并创立，其目的是用于简化 Java 企业级应用的开发难度和开发周期。Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。Spring 框架除了自己提供功能外，还提供整合其他技术和框架的能力。Spring 自诞生以来备受青睐，一直被广大开发人员作为 Java 企业级应用程序开发的首选。时至今日，Spring 俨然
Java 异常处理中try-catch块、finally子句以及自定义异常的使用
最新发布
Itmastergo的博客
05-31 486
异常是程序运行过程中出现的非正常情况。Java 使用异常类（Exception 类及其子类）来表示这些异常情况。异常处理的核心思想是将正常的程序流程与异常处理流程分离开来，使代码更加清晰和可维护。Throwable 类：所有异常和错误的基类。Error 类：表示系统级的错误，程序通常无法处理，比如内存不足（OutOfMemoryError）。Exception 类：表示程序中可以处理的异常情况。RuntimeException 类。
vo dto do po 的真实使用
03-17
vo dto do po 是一组用于在面向对象编程语言中组织和管理数据的常用设计模式。 - vo (Value Object)，值对象。表示不可变的数据，如实体的属性。 - dto (Data Transfer Object)，数据传输对象。用于在不同层之间传输数据。 - do (Domain Object)，领域对象。表示业务实体。 - po (Persistent Object)，持久化对象。表示数据库中的实体。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值