Java 开发中的对象类型详解（VO、PO、BO、DTO、DO、Entity）

import javax.persistence.*;
import java.util.Date;

/**
 * 用户持久化对象
 * 对应数据库表 user
 */
@Entity
@Table(name = "user")
public class UserPO {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

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

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

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

    @Column(name = "create_time")
    private Date createTime;

    @Column(name = "update_time")
    private Date updateTime;

    // getter 和 setter 方法
    // ...
}

import java.math.BigDecimal;
import java.util.Date;

/**
 * 用户信息展示对象
 */
public class UserVO {

    private Long userId;
    private String username;
    private String email;
    private String phone;
    private String avatar;
    private String createTime;  // 格式化后的日期字符串
    private Integer orderCount; // 订单数量（可能来自多个表）
    private BigDecimal totalAmount; // 总消费金额（计算后的值）

    // getter 和 setter 方法
    // ...
}

import java.math.BigDecimal;
import java.util.List;

/**
 * 订单业务对象
 * 包含订单信息和订单项信息
 */
public class OrderBO {

    private Long orderId;
    private String orderNo;
    private Long userId;
    private BigDecimal totalAmount;
    private String status;
    private List<OrderItemBO> orderItems; // 订单项列表

    /**
     * 计算订单总金额
     */
    public BigDecimal calculateTotalAmount() {
        if (orderItems == null || orderItems.isEmpty()) {
            return BigDecimal.ZERO;
        }
        return orderItems.stream()
                .map(OrderItemBO::getAmount)
                .reduce(BigDecimal.ZERO, BigDecimal::add);
    }

    /**
     * 检查订单是否可以取消
     */
    public boolean canCancel() {
        return "PENDING".equals(status) || "PAID".equals(status);
    }

    // getter 和 setter 方法
    // ...
}

import javax.validation.constraints.NotBlank;
import javax.validation.constraints.Email;

/**
 * 用户注册数据传输对象
 */
public class UserRegisterDTO {

    @NotBlank(message = "用户名不能为空")
    private String username;

    @NotBlank(message = "密码不能为空")
    private String password;

    @Email(message = "邮箱格式不正确")
    private String email;

    private String phone;

    // getter 和 setter 方法
    // ...
}

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;

/**
 * 订单领域对象
 */
public class OrderDO {

    private Long orderId;
    private String orderNo;
    private CustomerDO customer;
    private List<OrderItemDO> items;
    private OrderStatus status;
    private BigDecimal totalAmount;

    /**
     * 添加订单项
     */
    public void addItem(OrderItemDO item) {
        if (items == null) {
            items = new ArrayList<>();
        }
        items.add(item);
        recalculateTotal();
    }

    /**
     * 重新计算总金额
     */
    private void recalculateTotal() {
        this.totalAmount = items.stream()
                .map(OrderItemDO::getSubTotal)
                .reduce(BigDecimal.ZERO, BigDecimal::add);
    }

    /**
     * 提交订单
     */
    public void submit() {
        if (status != OrderStatus.DRAFT) {
            throw new IllegalStateException("只有草稿状态的订单才能提交");
        }
        this.status = OrderStatus.PENDING;
    }

    // getter 和 setter 方法
    // ...
}

import javax.persistence.*;
import java.util.List;

/**
 * 用户实体
 */
@Entity
@Table(name = "user")
public class UserEntity {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false, unique = true)
    private String username;

    @OneToMany(mappedBy = "user", cascade = CascadeType.ALL)
    private List<OrderEntity> orders;

    // getter 和 setter 方法
    // ...
}

┌─────────────────────────────────────┐
│   Controller 层 (表现层)            │
│   - 接收 DTO (请求参数)              │
│   - 返回 VO (响应数据)               │
└─────────────────────────────────────┘
              ↓ ↑
┌─────────────────────────────────────┐
│   Service 层 (业务层)               │
│   - 使用 BO (业务对象)               │
│   - 处理业务逻辑                     │
└─────────────────────────────────────┘
              ↓ ↑
┌─────────────────────────────────────┐
│   DAO 层 (数据访问层)                │
│   - 使用 PO (持久化对象)             │
│   - 数据库操作                       │
└─────────────────────────────────────┘

// Controller 层
@RestController
@RequestMapping("/api/users")
public class UserController {

    @Autowired
    private UserService userService;

    /**
     * 创建用户
     * 接收 DTO，返回 VO
     */
    @PostMapping
    public Result<UserVO> createUser(@RequestBody UserRegisterDTO dto) {
        UserBO userBO = userService.createUser(dto);
        UserVO userVO = convertToVO(userBO);
        return Result.success(userVO);
    }

    /**
     * 获取用户信息
     * 返回 VO（可能包含多个 PO 的数据）
     */
    @GetMapping("/{id}")
    public Result<UserVO> getUser(@PathVariable Long id) {
        UserVO userVO = userService.getUserVO(id);
        return Result.success(userVO);
    }
}

// Service 层
@Service
public class UserService {

    @Autowired
    private UserDAO userDAO;

    /**
     * 创建用户
     * DTO -> BO -> PO
     */
    public UserBO createUser(UserRegisterDTO dto) {
        // DTO 转换为 BO
        UserBO userBO = new UserBO();
        userBO.setUsername(dto.getUsername());
        userBO.setEmail(dto.getEmail());
        // ... 业务逻辑处理

        // BO 转换为 PO
        UserPO userPO = convertToPO(userBO);
        userPO.setCreateTime(new Date());

        // 保存到数据库
        userDAO.save(userPO);

        // PO 转换为 BO
        return convertToBO(userPO);
    }

    /**
     * 获取用户信息（包含订单统计）
     * 组合多个 PO 的数据
     */
    public UserVO getUserVO(Long id) {
        // 查询用户 PO
        UserPO userPO = userDAO.findById(id);

        // 查询订单统计（可能来自另一个表）
        OrderStatisticsPO statistics = orderDAO.getStatisticsByUserId(id);

        // 组合成 VO
        UserVO userVO = new UserVO();
        userVO.setUserId(userPO.getId());
        userVO.setUsername(userPO.getUsername());
        userVO.setEmail(userPO.getEmail());
        userVO.setOrderCount(statistics.getOrderCount());
        userVO.setTotalAmount(statistics.getTotalAmount());
        userVO.setCreateTime(formatDate(userPO.getCreateTime()));

        return userVO;
    }
}

// DAO 层
@Repository
public class UserDAO {

    @Autowired
    private UserMapper userMapper; // MyBatis Mapper

    public void save(UserPO userPO) {
        userMapper.insert(userPO);
    }

    public UserPO findById(Long id) {
        return userMapper.selectById(id);
    }
}

public class UserConverter {

    public static UserBO dtoToBO(UserRegisterDTO dto) {
        UserBO bo = new UserBO();
        bo.setUsername(dto.getUsername());
        bo.setEmail(dto.getEmail());
        bo.setPassword(encrypt(dto.getPassword()));
        return bo;
    }

    public static UserPO boToPO(UserBO bo) {
        UserPO po = new UserPO();
        po.setUsername(bo.getUsername());
        po.setEmail(bo.getEmail());
        po.setPassword(bo.getPassword());
        return po;
    }

    public static UserVO boToVO(UserBO bo) {
        UserVO vo = new UserVO();
        vo.setUserId(bo.getId());
        vo.setUsername(bo.getUsername());
        vo.setEmail(bo.getEmail());
        return vo;
    }
}

@Mapper(componentModel = "spring")
public interface UserMapper {

    UserBO dtoToBO(UserRegisterDTO dto);

    UserPO boToPO(UserBO bo);

    UserVO boToVO(UserBO bo);

    @Mapping(target = "createTime", expression = "java(formatDate(po.getCreateTime()))")
    UserVO poToVO(UserPO po);
}

import org.springframework.beans.BeanUtils;

public class UserConverter {

    public static UserBO dtoToBO(UserRegisterDTO dto) {
        UserBO bo = new UserBO();
        BeanUtils.copyProperties(dto, bo);
        // 处理特殊字段
        bo.setPassword(encrypt(dto.getPassword()));
        return bo;
    }
}