关于对java项目中应用分层的简单理解

一、基于springboot的逻辑分层结构

1.概念定义

（大部分来自于：https://blog.csdn.net/weixin_39781363/article/details/112028431）

1）PO：（和数据库表对应）

Persistant Object(持久对象)，基本上，PO对象中的属性就是对应着数据库中表的字段，加上一些get和set方法的组成。
例：个人信息表中分别有：id，name，age，sex，birthday
则PO对象中的属性有：id，name，age，sex，birthday

2）DO：（就是现实中的业务对象，应该是在service层使用）

Domain Object(领域对象)，就是从现实世界中抽象出来的有形或无形的业务实体。
例如：订单对象，包含流水号，交易商品，交易金额，交易时间

3）BO：（对多个PO进行组合，或者还可能包含一些对BO属性进行处理的方法，应该是在service层使用）

Business Object(业务对象)，相比于PO来说，BO的信息则是在PO信息的基础上进行扩充，也可以理解为多个PO对象的信息按照业务流程必要的拼凑在一起形成的对象。
例：个人信息表中分别有：id，name，age，sex，birthday
个人学历表中分别有：id，school，educational_background
按照个人信息表与学历表进行关联，将用户的个人信息集合在一起，可能还包含对这些BO中的信息进行处理的方法。

则BO对象中可以是两个表信息的组合：id，name，age，sex，birthday，school，educational_background

4）DTO：（service层向上返回数据）

Data Transfer Object(数据传输对象)，顾名思义，dto的作用是传递数据。但是我们按照业务流程处理得到的数据，并不是全部都要进行显示，或者并不能完全都按照当前形势进行展示，按照业务要求，还要在已有数据的基础上进行过滤删减。
例：个人信息表中分别有：id，name，age，sex，birthday
我们可能只需要用户的名字、年龄和性别来显示，像生日这样的信息就没有必要进行传输了，所以对已有的数据进行删减，只传输需要的信息。
则DTO对象中的信息为：id，name，age，sex

5）VO：（controller层向上返回数据）

Value Object(值对象)，可以理解为展示要用的数据，传递到前端页面上，直接进行展示。为了保证数据可以直接展示使用，就要对数据进行处理。
例：个人信息表中分别有：id，name，age，sex，birthday
我们需要展示的是用户的当前状态，像年龄和性别则没有必要分开显示，可以进行合并。
则vo对象中的信息为：id，name，type，birthday

6）DAO：（mapper层）

Data Access Object(数据访问对象)，存储访问数据库完成数据处理操作的方法的对象。

---

看到过较为正确的解释文章（https://www.cnblogs.com/markLogZhu/p/12736061.html）

一、各对象说明

1.1 PO(persistant object) 持久对象

* 用于表示数据库中的一条记录,没有任何行为方法；
* 遵守 Java Bean 的规范，只拥有 getter/setter 方法;
* 可以将一条记录做为一个对象处理，可以方便转化为其他对象。

1.2 DAO(Data Access Object ) 数据访问对象

* 负责持久层操作，通常和 PO 结合使用;
* 包含了各种数据库的操作方法,为业务层提供数据库的 CRUD 操作;

1.3 DO(Domain Object) 领域对象

* 从现实世界中抽象出来的有形或无形的业务实体。

1.4 BO(business object) 业务对象

* 将业务逻辑封装为一个对象，封装了对 DAO、RPC 等的调用;
* 可以包含一个或多个其他对象，如一个简历BO,包含教育经历、工作经历、社会关系等 PO/DO 对象
* 可以进行 PO/DO 与 VO/DTO 之间的转换;   

1.5 DTO（Data Transfer Object）数据传输对象

* 表示一个数据传输对象;
* 通常用于不同服务或服务不同分层之间的数据传输;
* 与 VO 概念相似，区别点在于设计理念上，主要用于 API 服务调用。    

1.6 VO(view object) 值对象

* 视图对象，用于展示层;
* 减少传输数据量大小和保护数据库结构不外泄。    

二、对象转换

2.1 DO/BO 与 PO 之间的转换

@Getter
@Setter
public class OrderPO {
    private String orderId;
    private String orderName;
    private String creator;
    private Date createTime;
    private String modifier;
    private Date modifyTime;
}

@Getter
@Setter
public class Order {
    private String orderId;
    private String orderName;
    private String creator;
    private Date createTime;
}

通过工厂模式封装转换逻辑，工厂与仓储模式往往结对出现，应用于数据的初始化和持久化两类场景。

public class OrderFactory {
    
    public OrderPO createOrderPO(Order order, UserDTO userDTO) {
        OrderPO orderPO = new OrderPO();
        orderPO.setOrderId(order.getOrderId());
        orderPO.setOrderName(order.getOrderName());
        orderPO.setCreator(order.getCreator());
        orderPO.setCreateTime(order.getCreateTime());
        orderPO.setModifier(userDTO.getUserName());
        orderPO.setModifyTime(new Date());
        return orderPO;
    }

    public Order getOrder(OrderPO orderPO) {
        Order order = new Order();
        order.setOrderId(orderPO.getOrderId());
        order.setOrderName(orderPO.getOrderName());
        order.setCreator(orderPO.getCreator());
        order.setCreateTime(orderPO.getCreateTime());
        return order;
    }

}

2.2 DO/BO 与 DTO/VO 之间的转换

@Getter
@Setter
public class OrderDTO {
    private String orderId;
    private String orderName;
    private String creator;
    private Date createTime;
}

@Getter
@Setter
public class OrderVO {
    private String orderId;
    private String orderName;
    private String creator;
    private Date createTime;
}

通过 组装类（Assembler） 负责将应用服务返回的多个 DO/BO 对象组装为前端 DTO /VO 对象，或将前端请求的 DTO 对象转换为多个 DO/BO 对象，供应用服务作为参数使用。组装类中不应有业务逻辑，主要负责格式转换、字段映射等。Assembler 往往与 DTO 同时存在。

public class OrderAssembler {

    public static OrderVO toVO(Order order) {
        OrderVO orderVO = new OrderVO();
        orderVO.setOrderId(order.getOrderId());
        orderVO.setOrderName(order.getOrderName());
        orderVO.setCreator(order.getCreator());
        orderVO.setCreateTime(order.getCreateTime());
        return orderVO;
    }

    public static OrderDTO toDTO(Order order) {
        OrderDTO orderDTO = new OrderDTO();
        orderDTO.setOrderId(order.getOrderId());
        orderDTO.setOrderName(order.getOrderName());
        orderDTO.setCreator(order.getCreator());
        orderDTO.setCreateTime(order.getCreateTime());
        return orderDTO;
    }

    public static Order toDO(OrderDTO orderDTO) {
        Order order = new Order();
        order.setOrderId(orderDTO.getOrderId());
        order.setOrderName(orderDTO.getOrderName());
        order.setCreator(orderDTO.getCreator());
        order.setCreateTime(orderDTO.getCreateTime());
        return order;
    }
    
}