Java 后端 / 系统课时

建模实体与值对象

建模实体与值对象

本课用订单场景区分实体和值对象,并把金额、数量和状态转换规则写进领域模型。完成后,你能依据身份、相等性和生命周期选择建模方式,避免把核心规则散落在 Controller 或 Service 中。

学习目标

  • 根据身份与相等性判断实体和值对象
  • 使用不可变值对象表达金额、数量等业务概念
  • 把创建条件和状态转换规则写入领域模型

用身份判断对象类型

实体关注“它是谁”,即使属性发生变化,只要身份标识不变,仍然是同一个对象。值对象关注“它是什么值”,两个对象只要全部组成值相同,就可以视为相等。

判断维度 实体 值对象
核心依据 稳定身份标识 全部属性值
生命周期 可持续变化 通常创建后不可变
相等判断 比较 ID 比较所有组成值
常见示例 用户、订单、账户 金额、地址、日期范围

不要仅凭“是否对应数据库表”判断类型。收货地址即使被保存为独立表,只要业务只关心地址内容,它仍然可以是值对象;订单即使暂未持久化,只要需要持续跟踪身份,它仍然是实体。

把不变量放进模型

不变量是对象在任何有效状态下都必须满足的条件,例如金额不能为负、商品数量必须大于零、空订单不能确认。规则应在构造方法或行为方法中立即检查,而不是等到持久化前统一校验。

下面的完整示例使用 record 实现不可变值对象,并用带身份和状态行为的类实现订单实体。

java
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Currency;
import java.util.List;
import java.util.Objects;
import java.util.UUID;

public class DomainModelDemo {
    public static void main(String[] args) {
        Currency cny = Currency.getInstance("CNY");
        Money priceA = new Money(new BigDecimal("19.90"), cny);
        Money priceB = new Money(new BigDecimal("19.90"), cny);

        Order order = new Order(
                UUID.fromString("00000000-0000-0000-0000-000000000001")
        );
        order.addItem(new LineItem("SKU-1", 2, priceA));
        order.confirm();

        System.out.println("moneyEquals=" + priceA.equals(priceB));
        System.out.println("orderId=" + order.id());
        System.out.println("status=" + order.status());
        System.out.println("total=" + order.total().amount());
    }

    record Money(BigDecimal amount, Currency currency) {
        Money {
            Objects.requireNonNull(amount, "amount");
            Objects.requireNonNull(currency, "currency");
            if (amount.signum() < 0) {
                throw new IllegalArgumentException("amount must not be negative");
            }
        }

        Money multiply(int quantity) {
            return new Money(amount.multiply(BigDecimal.valueOf(quantity)), currency);
        }

        Money add(Money other) {
            if (!currency.equals(other.currency)) {
                throw new IllegalArgumentException("currency must be the same");
            }
            return new Money(amount.add(other.amount), currency);
        }
    }

    record LineItem(String sku, int quantity, Money unitPrice) {
        LineItem {
            if (sku == null || sku.isBlank()) {
                throw new IllegalArgumentException("sku must not be blank");
            }
            if (quantity <= 0) {
                throw new IllegalArgumentException("quantity must be positive");
            }
            Objects.requireNonNull(unitPrice, "unitPrice");
        }

        Money total() {
            return unitPrice.multiply(quantity);
        }
    }

    enum OrderStatus {
        DRAFT, CONFIRMED
    }

    static final class Order {
        private final UUID id;
        private final List<LineItem> items = new ArrayList<>();
        private OrderStatus status = OrderStatus.DRAFT;

        Order(UUID id) {
            this.id = Objects.requireNonNull(id, "id");
        }

        UUID id() {
            return id;
        }

        OrderStatus status() {
            return status;
        }

        void addItem(LineItem item) {
            ensureDraft();
            items.add(Objects.requireNonNull(item, "item"));
        }

        void confirm() {
            ensureDraft();
            if (items.isEmpty()) {
                throw new IllegalStateException("empty order cannot be confirmed");
            }
            status = OrderStatus.CONFIRMED;
        }

        Money total() {
            Money result = items.get(0).total();
            for (int i = 1; i < items.size(); i++) {
                result = result.add(items.get(i).total());
            }
            return result;
        }

        private void ensureDraft() {
            if (status != OrderStatus.DRAFT) {
                throw new IllegalStateException("order is not draft");
            }
        }

        @Override
        public boolean equals(Object other) {
            return this == other
                    || other instanceof Order order && id.equals(order.id);
        }

        @Override
        public int hashCode() {
            return id.hashCode();
        }
    }
}

预期输出

text
moneyEquals=true
orderId=00000000-0000-0000-0000-000000000001
status=CONFIRMED
total=39.80

Money 的相等性由金额和币种共同决定,因此相同组成值自然相等。Order 的属性和状态可以变化,但相等性始终由 ID 决定。实际项目中的 ID 往往是动态值,日志或接口结果可使用 <ID> 表示。

避免贫血领域模型

贫血模型只保存字段,把所有判断都放到 Service。这样会导致规则重复、对象可被任意修改,也很难保证每个入口都执行同样的校验。

更稳妥的做法是提供表达业务意图的方法,例如 addItem、confirm、changeAddress,而不是暴露通用 setStatus。应用层负责决定何时调用这些行为,领域对象负责判断行为是否允许。

值对象应尽量不可变。修改地址、金额或日期范围时,返回新对象比逐字段修改更安全,也便于测试和并发使用。

建模时逐项核对

  • 对象是否需要一个跨时间保持稳定的身份
  • 相等性应比较 ID,还是比较全部组成值
  • 哪些条件在对象创建后必须始终成立
  • 哪些状态转换必须通过明确的业务行为完成
  • 规则是否仍散落在 Controller、Application Service 或持久化回调中

当一个规则只能依赖对象自身状态和传入参数时,优先放入实体或值对象;只有需要协调多个对象或外部能力时,才考虑领域服务或应用服务。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

建模实体与值对象

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通