领域驱动设计（DDD）：从核心概念到 Spring Cloud 标准落地

// 传统三层架构中的 "贫血模型" 示例
// Order 只是一个数据容器——纯粹的 getter/setter，没有任何业务行为
public class Order {
    private Long id;
    private String status;
    private BigDecimal totalAmount;
    // ... 20 个 getter/setter
}

// 所有业务逻辑都堆在 Service 里
// 随着业务增长，这个类会膨胀到不可维护的程度
@Service
public class OrderService {
​
    @Autowired
    private OrderMapper orderMapper;
    @Autowired
    private InventoryMapper inventoryMapper;
    @Autowired
    private CouponMapper couponMapper;
    @Autowired
    private PaymentClient paymentClient;
    @Autowired
    private MessageClient messageClient;
​
    @Transactional
    public void pay(Long orderId) {
        Order order = orderMapper.selectById(orderId);
​
        // 业务规则 1：状态校验
        if (!"CREATED".equals(order.getStatus())) {
            throw new RuntimeException("订单状态不允许支付");
        }
​
        // 业务规则 2：库存检查
        Inventory inventory = inventoryMapper.selectBySkuId(order.getSkuId());
        if (inventory.getStock() < order.getQuantity()) {
            throw new RuntimeException("库存不足");
        }
​
        // 业务规则 3：优惠计算
        Coupon coupon = couponMapper.selectById(order.getCouponId());
        if (coupon != null && coupon.isValid()) {
            order.setTotalAmount(order.getTotalAmount().subtract(coupon.getDiscount()));
        }
​
        // 业务规则 4：调用支付
        paymentClient.charge(order.getId(), order.getTotalAmount());
​
        // 业务规则 5：更新状态
        order.setStatus("PAID");
        orderMapper.updateById(order);
​
        // 业务规则 6：发消息
        messageClient.send("order.paid", order.getId());
    }
​
    // ... 还有 createOrder(), cancelOrder(), refundOrder() 等十几个方法
    // 每个方法都是类似的 "面条式" 流程
}

// DDD 中的 "充血模型" 示例
// Order 不再是被动的数据容器，它主动执行和保护自己的业务规则
public class Order {
​
    private OrderId id;           // 使用值对象而非原始类型
    private OrderStatus status;   // 枚举，不是字符串
    private Money totalAmount;    // 值对象，封装金额计算逻辑
​
    /**
     * 订单支付：核心业务规则由 Order 自己守护
     * - 只有 CREATED 状态的订单才能进入支付流程
     * - 状态转换是原子性的，外部无法绕过校验直接改状态
     */
    public void pay() {
        if (this.status != OrderStatus.CREATED) {
            throw new OrderStatusException(
                "订单 " + id.getValue() + " 当前状态为 " + status + "，无法支付"
            );
        }
        this.status = OrderStatus.PAID;
        // 注意：这里只处理 Order 自身的状态变更
        // 调用支付网关、扣库存、发消息等 "编排" 工作不在这里
    }
​
    /**
     * 应用优惠券：金额计算规则也由 Order 自己负责
     */
    public void applyCoupon(Coupon coupon) {
        if (!coupon.isValid()) {
            throw new CouponExpiredException("优惠券已过期");
        }
        this.totalAmount = this.totalAmount.subtract(coupon.getDiscount());
    }
}

// Java 21 + DDD Entity 示例
// 注意：Entity 是纯 Java 对象，不依赖任何框架
public class Order {
​
    private final OrderId id;         // 唯一标识，创建后不可变
    private OrderStatus status;       // 状态由业务方法控制，没有 public setter
    private Money totalAmount;
    private CustomerId customerId;
    private List<OrderItem> items;
    private LocalDateTime createdAt;
​
    // 构造方法：创建订单时就执行初始业务规则
    public Order(OrderId id, CustomerId customerId, List<OrderItem> items) {
        if (items == null || items.isEmpty()) {
            throw new EmptyOrderException("订单至少包含一个商品");
        }
        this.id = id;
        this.customerId = customerId;
        this.items = List.copyOf(items); // 防御性拷贝
        this.status = OrderStatus.CREATED;
        this.totalAmount = calculateTotal(items);
        this.createdAt = LocalDateTime.now();
    }
​
    /**
     * 支付：状态转换规则由 Order 自己守护
     */
    public void pay() {
        if (this.status != OrderStatus.CREATED) {
            throw new OrderStatusException("只有待支付订单才能执行支付");
        }
        this.status = OrderStatus.PAID;
    }
​
    /**
     * 取消：已支付的订单不能直接取消，需要走退款流程
     */
    public void cancel() {
        if (this.status == OrderStatus.PAID) {
            throw new OrderStatusException("已支付订单请走退款流程");
        }
        if (this.status == OrderStatus.CANCELLED) {
            throw new OrderStatusException("订单已取消，请勿重复操作");
        }
        this.status = OrderStatus.CANCELLED;
    }
​
    // ---- 只暴露只读访问，没有 setter ----
​
    public OrderId getId() { return id; }
    public OrderStatus getStatus() { return status; }
    public Money getTotalAmount() { return totalAmount; }
​
    // 相等性基于 ID，不是属性
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Order order)) return false;
        return id.equals(order.id);
    }
​
    @Override
    public int hashCode() {
        return id.hashCode();
    }
​
    private Money calculateTotal(List<OrderItem> items) {
        return items.stream()
                .map(OrderItem::subtotal)
                .reduce(Money.ZERO, Money::add);
    }
}

// 值对象示例：Money（金额）
// 不可变、无 ID、相等性基于全部属性值
public record Money(BigDecimal amount, Currency currency) {
​
    public static final Money ZERO = new Money(BigDecimal.ZERO, Currency.CNY);
​
    // 紧凑构造方法：在 record 创建时执行校验
    public Money {
        if (amount == null) {
            throw new IllegalArgumentException("金额不能为空");
        }
        if (amount.scale() > 2) {
            throw new IllegalArgumentException("金额精度不能超过两位小数");
        }
        if (currency == null) {
            throw new IllegalArgumentException("币种不能为空");
        }
    }
​
    public Money add(Money other) {
        ensureSameCurrency(other);
        return new Money(this.amount.add(other.amount), this.currency);
    }
​
    public Money subtract(Money other) {
        ensureSameCurrency(other);
        BigDecimal result = this.amount.subtract(other.amount);
        if (result.compareTo(BigDecimal.ZERO) < 0) {
            throw new NegativeAmountException("计算结果为负数");
        }
        return new Money(result, this.currency);
    }
​
    private void ensureSameCurrency(Money other) {
        if (this.currency != other.currency) {
            throw new CurrencyMismatchException(
                "币种不一致: " + this.currency + " vs " + other.currency
            );
        }
    }
}

// 值对象示例：Address（地址）
public record Address(
    String province,
    String city,
    String district,
    String street,
    String zipCode
) {
    public Address {
        if (province == null || province.isBlank()) {
            throw new IllegalArgumentException("省份不能为空");
        }
        if (city == null || city.isBlank()) {
            throw new IllegalArgumentException("城市不能为空");
        }
    }
​
    public String fullAddress() {
        return province + city + district + street;
    }
}

// 聚合根设计示例：Order 管理其下的 OrderItem
public class Order {
​
    private final OrderId id;
    private OrderStatus status;
    private Money totalAmount;
    private CustomerId customerId;           // 跨聚合引用用 ID，不是对象
    private List<OrderItem> items;           // 聚合内部的子实体
    private ShippingAddress shippingAddress; // 聚合内部的值对象
​
    /**
     * 添加商品项：由聚合根统一管理，保证总金额一致性
     */
    public void addItem(OrderItem item) {
        if (this.status != OrderStatus.CREATED) {
            throw new OrderStatusException("只有待支付订单才能修改商品");
        }
        this.items.add(item);
        this.totalAmount = calculateTotal(this.items);
    }
​
    /**
     * 移除商品项：同样由聚合根统一管理
     */
    public void removeItem(ProductId productId) {
        if (this.status != OrderStatus.CREATED) {
            throw new OrderStatusException("只有待支付订单才能修改商品");
        }
        this.items.removeIf(item -> item.getProductId().equals(productId));
        if (this.items.isEmpty()) {
            throw new EmptyOrderException("订单至少包含一个商品");
        }
        this.totalAmount = calculateTotal(this.items);
    }
​
    // ... 省略其他方法
​
    private Money calculateTotal(List<OrderItem> items) {
        return items.stream()
                .map(OrderItem::subtotal)
                .reduce(Money.ZERO, Money::add);
    }
}

// 领域服务示例：跨聚合的库存校验
// 注意：Domain Service 也是纯 Java，不依赖 Spring
public class InventoryCheckService {
​
    /**
     * 检查订单中所有商品的库存是否充足
     * 这个操作涉及 Order 和 Inventory 两个聚合，不适合放在任何一个实体中
     */
    public void checkInventory(Order order, List<InventoryItem> inventoryItems) {
        for (OrderItem orderItem : order.getItems()) {
            InventoryItem stock = inventoryItems.stream()
                    .filter(inv -> inv.getSkuId().equals(orderItem.getSkuId()))
                    .findFirst()
                    .orElseThrow(() -> new InventoryNotFoundException(
                        "商品 " + orderItem.getSkuId() + " 未找到库存记录"
                    ));
​
            if (stock.getAvailable() < orderItem.getQuantity()) {
                throw new InsufficientInventoryException(
                    "商品 " + orderItem.getSkuId() + " 库存不足: " +
                    "需要 " + orderItem.getQuantity() + "，可用 " + stock.getAvailable()
                );
            }
        }
    }
}

// 领域事件：描述 "已经发生的事实"
// 不可变，过去时命名
public record OrderPaidEvent(
    OrderId orderId,
    CustomerId customerId,
    Money amount,
    LocalDateTime occurredAt
) {
    public OrderPaidEvent {
        if (orderId == null) throw new IllegalArgumentException("orderId 不能为空");
        if (amount == null) throw new IllegalArgumentException("amount 不能为空");
    }
}

// 在 Entity 中生产事件
public class Order {
​
    private final List<Object> domainEvents = new ArrayList<>();
​
    public void pay() {
        if (this.status != OrderStatus.CREATED) {
            throw new OrderStatusException("只有待支付订单才能执行支付");
        }
        this.status = OrderStatus.PAID;
​
        // 记录领域事件——"我被支付了"
        // 事件的发布和处理不在这里，由 Application 层或 Infrastructure 层负责
        this.domainEvents.add(new OrderPaidEvent(
            this.id, this.customerId, this.totalAmount, LocalDateTime.now()
        ));
    }
​
    public List<Object> getDomainEvents() {
        return List.copyOf(domainEvents);
    }
​
    public void clearDomainEvents() {
        domainEvents.clear();
    }
}

// domain 层：仓储接口
// 只用领域语言描述操作，不暴露任何数据库细节
public interface OrderRepository {
​
    /**
     * 根据 ID 查找订单聚合
     * 返回 Optional 而非 null，让调用方显式处理 "不存在" 的情况
     */
    Optional<Order> findById(OrderId id);
​
    /**
     * 保存（新建或更新）一个订单聚合
     */
    void save(Order order);
​
    /**
     * 根据客户 ID 查找该客户的所有订单
     */
    List<Order> findByCustomerId(CustomerId customerId);
}

interfaces → application → domain
infrastructure → domain

domain → application          ❌
domain → interfaces           ❌
domain → infrastructure       ❌
application → interfaces      ❌
application → mapper          ❌
interfaces → mapper           ❌
interfaces → repository impl  ❌

com.example.order
└── interfaces
    ├── controller
    │   └── OrderController.java
    ├── facade
    │   └── OrderFacade.java        // 聚合多个 application service 的门面（BFF 场景）
    ├── listener
    │   └── OrderEventListener.java // MQ 消息监听入口
    ├── job
    │   └── OrderTimeoutJob.java    // 定时任务入口
    └── vo
        ├── OrderVO.java            // 返回给前端的视图对象
        └── CreateOrderRequest.java // 接收前端的请求对象

// interfaces 层示例：只做 "接-转-回"
@RestController
@RequestMapping("/api/orders")
public class OrderController {
​
    private final OrderApplicationService orderService;
    private final OrderVOAssembler voAssembler;
​
    public OrderController(OrderApplicationService orderService, OrderVOAssembler voAssembler) {
        this.orderService = orderService;
        this.voAssembler = voAssembler;
    }
​
    @PostMapping
    public Result<OrderVO> createOrder(@RequestBody @Valid CreateOrderRequest request) {
        // 1. 把 Request 转成 DTO（或直接传 Request，取决于团队约定）
        // 2. 调用 application 层
        OrderDTO dto = orderService.createOrder(request.toDTO());
        // 3. 把 DTO 转成 VO 返回
        return Result.success(voAssembler.toVO(dto));
    }
​
    @PostMapping("/{orderId}/pay")
    public Result<Void> pay(@PathVariable Long orderId) {
        orderService.payOrder(orderId);
        return Result.success();
    }
}

com.example.order
└── application
    ├── service
    │   └── OrderApplicationService.java
    ├── command
    │   └── CreateOrderCommand.java
    ├── query
    │   └── OrderQuery.java
    ├── dto
    │   ├── OrderDTO.java
    │   └── CreateOrderDTO.java
    └── assembler
        └── OrderAssembler.java     // MapStruct: DTO ↔ Domain

// application 层示例：编排流程，不实现业务规则
@Service
public class OrderApplicationService {
​
    private final OrderRepository orderRepository;             // domain 层接口
    private final InventoryRepository inventoryRepository;
    private final InventoryCheckService inventoryCheckService; // domain 层服务
    private final OrderAssembler assembler;                    // MapStruct
​
    public OrderApplicationService(OrderRepository orderRepository,
                                   InventoryRepository inventoryRepository,
                                   InventoryCheckService inventoryCheckService,
                                   OrderAssembler assembler) {
        this.orderRepository = orderRepository;
        this.inventoryRepository = inventoryRepository;
        this.inventoryCheckService = inventoryCheckService;
        this.assembler = assembler;
    }
​
    /**
     * 创建订单：编排流程，但业务规则由 Domain 执行
     */
    @Transactional
    public OrderDTO createOrder(CreateOrderDTO dto) {
        // 1. DTO → Domain（通过 MapStruct）
        Order order = assembler.toDomain(dto);
​
        // 2. 调用 Domain Service 做库存校验（跨聚合的业务规则）
        List<InventoryItem> inventoryItems = inventoryRepository.findBySkuIds(order.getSkuIds());
        inventoryCheckService.checkInventory(order, inventoryItems);
​
        // 3. 通过 Repository 保存聚合
        orderRepository.save(order);
​
        // 4. Domain → DTO 返回
        return assembler.toDTO(order);
    }
​
    /**
     * 支付订单
     */
    @Transactional
    public void payOrder(Long orderId) {
        // 1. 从仓储加载聚合
        Order order = orderRepository.findById(new OrderId(orderId))
                .orElseThrow(() -> new OrderNotFoundException("订单不存在: " + orderId));
​
        // 2. 调用聚合根的业务方法——业务规则由 Order 自己执行
        order.pay();
​
        // 3. 保存变更
        orderRepository.save(order);
​
        // 4. 处理领域事件（实际项目中通常由事件发布器统一处理）
        // eventPublisher.publishAll(order.getDomainEvents());
        // order.clearDomainEvents();
    }
}

com.example.order
└── domain
    ├── model
    │   ├── entity
    │   │   ├── Order.java           // 聚合根
    │   │   └── OrderItem.java       // 子实体
    │   └── valueobject
    │       ├── OrderId.java
    │       ├── OrderStatus.java
    │       └── Money.java
    ├── repository
    │   └── OrderRepository.java     // 仓储接口（只有接口）
    ├── service
    │   └── InventoryCheckService.java
    └── event
        └── OrderPaidEvent.java

// domain 层单元测试：纯 Java，无需启动 Spring
class OrderTest {
​
    @Test
    void should_pay_order_when_status_is_created() {
        Order order = new Order(
            new OrderId(1L),
            new CustomerId(100L),
            List.of(new OrderItem(new ProductId(1L), Money.of(99), 2))
        );
​
        order.pay();
​
        assertEquals(OrderStatus.PAID, order.getStatus());
    }
​
    @Test
    void should_reject_payment_when_status_is_not_created() {
        Order order = createPaidOrder();
​
        assertThrows(OrderStatusException.class, order::pay);
    }
}

com.example.order
└── infrastructure
    ├── persistence
    │   ├── mapper
    │   │   └── OrderMapper.java         // MyBatis Plus Mapper
    │   ├── entity
    │   │   └── OrderDO.java             // 数据库映射对象
    │   ├── repository
    │   │   └── OrderRepositoryImpl.java // 实现 domain 的 OrderRepository
    │   └── converter
    │       └── OrderConverter.java      // MapStruct: Domain ↔ DO
    ├── client
    │   └── UserHttpClient.java          // Spring HTTP Service Client
    ├── config
    │   └── MyBatisPlusConfig.java
    └── mq
        └── OrderEventPublisher.java

// infrastructure 层：仓储实现
// 这是唯一直接接触数据库的地方
@Repository
public class OrderRepositoryImpl implements OrderRepository {
​
    private final OrderMapper orderMapper;        // MyBatis Plus
    private final OrderItemMapper orderItemMapper;
    private final OrderConverter converter;        // MapStruct
​
    public OrderRepositoryImpl(OrderMapper orderMapper, OrderItemMapper orderItemMapper OrderConverter converter) {
        this.orderMapper = orderMapper;
        this.orderItemMapper = orderItemMapper;
        this.converter = converter;
    }
​
    @Override
    public Optional<Order> findById(OrderId id) {
        // 1. 用 Mapper 从数据库查询 DO
        OrderDO orderDO = orderMapper.selectById(id.getValue());
        if (orderDO == null) {
            return Optional.empty();
        }
​
        // 2. 查询关联的子实体
        List<OrderItemDO> itemDOs = orderItemMapper.selectByOrderId(id.getValue());
​
        // 3. DO → Domain Entity（通过 MapStruct）
        Order order = converter.toDomain(orderDO, itemDOs);
        return Optional.of(order);
    }
​
    @Override
    public void save(Order order) {
        // 1. Domain → DO
        OrderDO orderDO = converter.toDO(order);
        List<OrderItemDO> itemDOs = converter.toItemDOs(order.getItems());
​
        // 2. 持久化（insertOrUpdate 模式）
        orderMapper.insertOrUpdate(orderDO);
​
        // 3. 子实体：先删后插（简单策略，复杂场景可用 diff 策略）
        orderItemMapper.deleteByOrderId(order.getId().getValue());
        if (!itemDOs.isEmpty()) {
            orderItemMapper.insertBatch(itemDOs);
        }
    }
​
    @Override
    public List<Order> findByCustomerId(CustomerId customerId) {
        List<OrderDO> orderDOs = orderMapper.selectByCustomerId(customerId.getValue());
        return orderDOs.stream()
                .map(orderDO -> {
                    List<OrderItemDO> itemDOs = orderItemMapper.selectByOrderId(orderDO.getId());
                    return converter.toDomain(orderDO, itemDOs);
                })
                .toList();
    }
}

// application.assembler：DTO ↔ Domain
@Mapper(componentModel = "spring")
public interface OrderAssembler {
​
    @Mapping(target = "id", source = "orderId")
    @Mapping(target = "totalAmount", source = "order.totalAmount.amount")
    OrderDTO toDTO(Order order);
​
    @Mapping(target = "status", constant = "CREATED")
    Order toDomain(CreateOrderDTO dto);
}

// infrastructure.converter：Domain ↔ DO
@Mapper(componentModel = "spring")
public interface OrderConverter {
​
    @Mapping(target = "id", source = "orderDO.id")
    @Mapping(target = "totalAmount", expression = "java(new Money(orderDO.getTotalAmount(), Currency.CNY))")
    Order toDomain(OrderDO orderDO, List<OrderItemDO> itemDOs);
​
    @Mapping(target = "totalAmount", source = "totalAmount.amount")
    OrderDO toDO(Order order);
​
    List<OrderItemDO> toItemDOs(List<OrderItem> items);
}

// infrastructure.client：远程调用接口
// 使用 Spring HTTP Service Client（非 Feign）
@HttpExchange("/api/users")
public interface UserHttpClient {
​
    @GetExchange("/{id}")
    UserDTO getUser(@PathVariable Long id);
}

// 在 infrastructure 的 repository 实现中使用远程调用
// 例如：OrderRepositoryImpl 需要查询用户信息来填充订单的某些字段
// 或者定义一个 Anti-Corruption Layer 来转换外部模型
@Component
public class UserGatewayImpl implements UserGateway {
​
    private final UserHttpClient userHttpClient;
​
    public UserGatewayImpl(UserHttpClient userHttpClient) {
        this.userHttpClient = userHttpClient;
    }
​
    @Override
    public UserInfo getUserInfo(CustomerId customerId) {
        UserDTO dto = userHttpClient.getUser(customerId.getValue());
        // 防腐层：把外部模型转成内部领域需要的模型
        return new UserInfo(dto.getName(), dto.getPhone());
    }
}

refinex-order-service/
├── pom.xml
└── src/main/java/com/refinex/order
    │
    ├── interfaces                          # 用户接口层
    │   ├── controller
    │   │   └── OrderController.java
    │   ├── facade
    │   │   └── OrderFacade.java
    │   ├── listener
    │   │   └── OrderEventListener.java
    │   ├── job
    │   │   └── OrderTimeoutJob.java
    │   └── vo
    │       ├── OrderVO.java
    │       └── CreateOrderRequest.java
    │
    ├── application                         # 应用服务层
    │   ├── service
    │   │   └── OrderApplicationService.java
    │   ├── command
    │   │   └── CreateOrderCommand.java
    │   ├── query
    │   │   └── OrderQuery.java
    │   ├── dto
    │   │   ├── OrderDTO.java
    │   │   └── CreateOrderDTO.java
    │   └── assembler
    │       └── OrderAssembler.java         # MapStruct: DTO ↔ Domain
    │
    ├── domain                              # 领域层（核心）
    │   ├── model
    │   │   ├── entity
    │   │   │   ├── Order.java              # 聚合根
    │   │   │   └── OrderItem.java
    │   │   └── valueobject
    │   │       ├── OrderId.java
    │   │       ├── OrderStatus.java
    │   │       └── Money.java
    │   ├── repository
    │   │   └── OrderRepository.java        # 仓储接口
    │   ├── service
    │   │   └── InventoryCheckService.java  # 领域服务
    │   └── event
    │       └── OrderPaidEvent.java
    │
    └── infrastructure                      # 基础设施层
        ├── persistence
        │   ├── mapper
        │   │   ├── OrderMapper.java        # MyBatis Plus
        │   │   └── OrderItemMapper.java
        │   ├── entity
        │   │   ├── OrderDO.java            # 数据库映射
        │   │   └── OrderItemDO.java
        │   ├── repository
        │   │   └── OrderRepositoryImpl.java
        │   └── converter
        │       └── OrderConverter.java     # MapStruct: Domain ↔ DO
        ├── client
        │   ├── UserHttpClient.java         # HTTP Service Client
        │   └── UserGatewayImpl.java        # 防腐层实现
        ├── config
        │   └── MyBatisPlusConfig.java
        └── mq
            └── OrderEventPublisher.java

// ❌ 严重违规：domain 层出现 Spring 注解
@Service  // 不应该出现
public class Order {
​
    @Autowired  // 不应该出现
    private OrderMapper mapper;
​
    public void pay() {
        // ...
        mapper.updateById(this);  // domain 直接访问数据库
    }
}

// ❌ 违规：application 层绕过 Repository，直接用 Mapper
@Service
public class OrderApplicationService {
​
    @Autowired
    private OrderMapper orderMapper;  // 不应该直接注入 Mapper
​
    public void payOrder(Long orderId) {
        OrderDO orderDO = orderMapper.selectById(orderId);  // 直接操作 DO
        orderDO.setStatus("PAID");                          // 绕过业务规则
        orderMapper.updateById(orderDO);                    // 直接写库
    }
}

// ❌ 违规：interfaces 层包含业务逻辑
@PostMapping("/{orderId}/pay")
public Result<Void> pay(@PathVariable Long orderId) {
    OrderDTO order = orderService.getOrder(orderId);
    if (!"CREATED".equals(order.getStatus())) {       // 业务规则泄露到 Controller
        return Result.fail("订单状态不允许支付");
    }
    orderService.payOrder(orderId);
    return Result.success();
}

// ❌ 不推荐：Order 直接持有完整的 Customer 和 Product 对象
public class Order {
    private Customer customer;        // 不应该直接持有另一个聚合
    private List<Product> products;   // 不应该直接持有另一个聚合
}

// ❌ 挂着 DDD 的名，做着贫血的事
// Entity 里只有 getter/setter，所有逻辑仍然在 Service 里
public class Order {
    private Long id;
    private String status;
    // ... 只有 getter/setter，没有任何业务方法
}
​
@Service
public class OrderDomainService {
    public void pay(Order order) {
        if (!"CREATED".equals(order.getStatus())) { ... }
        order.setStatus("PAID");  // 还是外部直接改状态
    }
}