DDD 领域驱动设计 ​

// 订单 ID 相同即同一订单，即使内容被修改
public class Order {
    private OrderId id;      // 身份标识
    private OrderStatus status; // 状态随时间变化
}

// 订单 ID 相同即同一订单，即使内容被修改
public class Order {
    private OrderId id;      // 身份标识
    private OrderStatus status; // 状态随时间变化
}

public record Money(BigDecimal amount, String currency) {
    public Money {
        if (amount == null || amount.compareTo(BigDecimal.ZERO) < 0) {
            throw new IllegalArgumentException("金额不能为负");
        }
    }
    public Money add(Money other) {
        if (!currency.equals(other.currency)) throw new IllegalArgumentException("币种不一致");
        return new Money(amount.add(other.amount), currency);
    }
}

public record Money(BigDecimal amount, String currency) {
    public Money {
        if (amount == null || amount.compareTo(BigDecimal.ZERO) < 0) {
            throw new IllegalArgumentException("金额不能为负");
        }
    }
    public Money add(Money other) {
        if (!currency.equals(other.currency)) throw new IllegalArgumentException("币种不一致");
        return new Money(amount.add(other.amount), currency);
    }
}

// 贫血：Order 只是数据袋
public class Order {
    private String status;
    private BigDecimal totalAmount;
    public String getStatus() { return status; }
    public void setStatus(String status) { this.status = status; }
    // ...getter/setter
}

// Service 承载所有规则：谁能改状态？金额怎么算？散落在方法里
@Service
public class OrderService {
    public void pay(String orderId) {
        Order order = orderMapper.findById(orderId);
        if (!"PENDING_PAY".equals(order.getStatus())) {
            throw new BizException("订单状态不允许支付");
        }
        order.setStatus("PAID"); // 若还有别处也改状态，规则就重复了
        orderMapper.update(order);
    }
}

// 贫血：Order 只是数据袋
public class Order {
    private String status;
    private BigDecimal totalAmount;
    public String getStatus() { return status; }
    public void setStatus(String status) { this.status = status; }
    // ...getter/setter
}

// Service 承载所有规则：谁能改状态？金额怎么算？散落在方法里
@Service
public class OrderService {
    public void pay(String orderId) {
        Order order = orderMapper.findById(orderId);
        if (!"PENDING_PAY".equals(order.getStatus())) {
            throw new BizException("订单状态不允许支付");
        }
        order.setStatus("PAID"); // 若还有别处也改状态，规则就重复了
        orderMapper.update(order);
    }
}

// 充血：状态机与规则在聚合根内，任何调用方都无法绕过
public class Order {
    private OrderId id;
    private OrderStatus status;
    private Money totalAmount;

    public void pay() {
        if (!status.canPay()) {
            throw new BizException("当前状态(" + status + ")不允许支付");
        }
        this.status = OrderStatus.PAID;
        // 不变量在模型内自洽
    }
}

// 充血：状态机与规则在聚合根内，任何调用方都无法绕过
public class Order {
    private OrderId id;
    private OrderStatus status;
    private Money totalAmount;

    public void pay() {
        if (!status.canPay()) {
            throw new BizException("当前状态(" + status + ")不允许支付");
        }
        this.status = OrderStatus.PAID;
        // 不变量在模型内自洽
    }
}

// 值对象：OrderId
public record OrderId(Long value) {
    public OrderId {
        if (value == null || value <= 0) throw new IllegalArgumentException("订单 ID 非法");
    }
}

// 值对象：收货地址（不可变、整体相等）
public record Address(String province, String city, String detail, String phone) {
}

// 实体：订单商品行（属于 Order 聚合，无独立对外仓储）
public class OrderItem {
    private Long productId;
    private String productName;
    private Money price;      // 快照单价（防商品后续改价影响历史订单）
    private int quantity;

    OrderItem(Long productId, String productName, Money price, int quantity) {
        if (quantity <= 0) throw new IllegalArgumentException("数量必须大于 0");
        this.productId = productId;
        this.productName = productName;
        this.price = price;
        this.quantity = quantity;
    }

    Money subtotal() {
        return price.multiply(quantity); // Money 内部实现乘数量
    }
}

// 聚合根：Order（充血模型，所有状态变更收口在方法内）
public class Order {
    private final OrderId id;
    private OrderStatus status;
    private Address address;
    private Money totalAmount;
    private final List<OrderItem> items = new ArrayList<>();
    private final List<DomainEvent> pendingEvents = new ArrayList<>();

    private Order(OrderId id, Address address, List<OrderItem> items) {
        this.id = id;
        this.address = address;
        this.status = OrderStatus.PENDING_PAY;
        this.items.addAll(items);
        this.totalAmount = items.stream()
                .map(OrderItem::subtotal)
                .reduce(new Money(BigDecimal.ZERO, "CNY"), Money::add);
    }

    /** 工厂方法：集中创建逻辑并登记领域事件 */
    public static Order place(OrderId id, Address address, List<OrderItem> items) {
        if (items == null || items.isEmpty()) throw new IllegalArgumentException("订单不能为空");
        Order order = new Order(id, address, items);
        order.pendingEvents.add(new OrderCreatedEvent(id.value(), items.size(), order.totalAmount.amount()));
        return order;
    }

    /** 状态流转收口：外部无法绕过规则直接改状态 */
    public void pay() {
        this.status = this.status.transitToPaid();
        this.pendingEvents.add(new OrderPaidEvent(id.value()));
    }

    public void cancelByTimeout() {
        this.status = this.status.transitToClosed();
    }

    /** 事务提交后由应用层取走并发布事件 */
    public List<DomainEvent> collectEvents() {
        List<DomainEvent> events = new ArrayList<>(pendingEvents);
        pendingEvents.clear();
        return events;
    }

    public OrderId id() { return id; }
    public OrderStatus status() { return status; }
    public Money totalAmount() { return totalAmount; }
}

// 状态机收口：状态流转规则只此一份
public enum OrderStatus {
    PENDING_PAY {
        @Override OrderStatus transitToPaid() { return PAID; }
    },
    PAID {
        @Override OrderStatus transitToPaid() { throw new IllegalStateException("订单已支付，不可重复支付"); }
        @Override OrderStatus transitToClosed() { return CLOSED; } // 支付后可关闭（退款/取消发货）
    },
    CLOSED, SHIPPED;

    OrderStatus transitToPaid() { throw new IllegalStateException("当前状态不可支付"); }
    OrderStatus transitToClosed() { throw new IllegalStateException("当前状态不可关闭"); }
}

// 值对象：OrderId
public record OrderId(Long value) {
    public OrderId {
        if (value == null || value <= 0) throw new IllegalArgumentException("订单 ID 非法");
    }
}

// 值对象：收货地址（不可变、整体相等）
public record Address(String province, String city, String detail, String phone) {
}

// 实体：订单商品行（属于 Order 聚合，无独立对外仓储）
public class OrderItem {
    private Long productId;
    private String productName;
    private Money price;      // 快照单价（防商品后续改价影响历史订单）
    private int quantity;

    OrderItem(Long productId, String productName, Money price, int quantity) {
        if (quantity <= 0) throw new IllegalArgumentException("数量必须大于 0");
        this.productId = productId;
        this.productName = productName;
        this.price = price;
        this.quantity = quantity;
    }

    Money subtotal() {
        return price.multiply(quantity); // Money 内部实现乘数量
    }
}

// 聚合根：Order（充血模型，所有状态变更收口在方法内）
public class Order {
    private final OrderId id;
    private OrderStatus status;
    private Address address;
    private Money totalAmount;
    private final List<OrderItem> items = new ArrayList<>();
    private final List<DomainEvent> pendingEvents = new ArrayList<>();

    private Order(OrderId id, Address address, List<OrderItem> items) {
        this.id = id;
        this.address = address;
        this.status = OrderStatus.PENDING_PAY;
        this.items.addAll(items);
        this.totalAmount = items.stream()
                .map(OrderItem::subtotal)
                .reduce(new Money(BigDecimal.ZERO, "CNY"), Money::add);
    }

    /** 工厂方法：集中创建逻辑并登记领域事件 */
    public static Order place(OrderId id, Address address, List<OrderItem> items) {
        if (items == null || items.isEmpty()) throw new IllegalArgumentException("订单不能为空");
        Order order = new Order(id, address, items);
        order.pendingEvents.add(new OrderCreatedEvent(id.value(), items.size(), order.totalAmount.amount()));
        return order;
    }

    /** 状态流转收口：外部无法绕过规则直接改状态 */
    public void pay() {
        this.status = this.status.transitToPaid();
        this.pendingEvents.add(new OrderPaidEvent(id.value()));
    }

    public void cancelByTimeout() {
        this.status = this.status.transitToClosed();
    }

    /** 事务提交后由应用层取走并发布事件 */
    public List<DomainEvent> collectEvents() {
        List<DomainEvent> events = new ArrayList<>(pendingEvents);
        pendingEvents.clear();
        return events;
    }

    public OrderId id() { return id; }
    public OrderStatus status() { return status; }
    public Money totalAmount() { return totalAmount; }
}

// 状态机收口：状态流转规则只此一份
public enum OrderStatus {
    PENDING_PAY {
        @Override OrderStatus transitToPaid() { return PAID; }
    },
    PAID {
        @Override OrderStatus transitToPaid() { throw new IllegalStateException("订单已支付，不可重复支付"); }
        @Override OrderStatus transitToClosed() { return CLOSED; } // 支付后可关闭（退款/取消发货）
    },
    CLOSED, SHIPPED;

    OrderStatus transitToPaid() { throw new IllegalStateException("当前状态不可支付"); }
    OrderStatus transitToClosed() { throw new IllegalStateException("当前状态不可关闭"); }
}

// 领域层：仓储接口，语义是存取聚合
public interface OrderRepository {
    OrderId nextId();          // 生成 ID 的策略由基础设施提供（如雪花）
    Order findById(OrderId id);
    void save(Order order);    // 聚合整体落库（含明细）
}

// 基础设施层：MyBatis/JPA 细节实现接口
@Repository
public class OrderRepositoryImpl implements OrderRepository {
    // 组装 OrderMapper / OrderItemMapper，实现聚合与表的双向转换
}

// 领域层：仓储接口，语义是存取聚合
public interface OrderRepository {
    OrderId nextId();          // 生成 ID 的策略由基础设施提供（如雪花）
    Order findById(OrderId id);
    void save(Order order);    // 聚合整体落库（含明细）
}

// 基础设施层：MyBatis/JPA 细节实现接口
@Repository
public class OrderRepositoryImpl implements OrderRepository {
    // 组装 OrderMapper / OrderItemMapper，实现聚合与表的双向转换
}

// 领域事件（领域层定义，纯数据，过去时命名）
public record OrderCreatedEvent(Long orderId, int itemCount, BigDecimal totalAmount) {}

// 支付成功事件：由 Order.pay() 登记，支付上下文/通知上下文订阅
public record OrderPaidEvent(Long orderId) {}

// 领域服务：协调"下单"跨聚合的步骤
public class OrderDomainService {
    // 说明：库存预占通过发布 OrderCreatedEvent 由库存上下文订阅，
    // 若强一致则在本服务内调用库存网关（防超卖见《经典系统设计案例》）
}

// 领域事件（领域层定义，纯数据，过去时命名）
public record OrderCreatedEvent(Long orderId, int itemCount, BigDecimal totalAmount) {}

// 支付成功事件：由 Order.pay() 登记，支付上下文/通知上下文订阅
public record OrderPaidEvent(Long orderId) {}

// 领域服务：协调"下单"跨聚合的步骤
public class OrderDomainService {
    // 说明：库存预占通过发布 OrderCreatedEvent 由库存上下文订阅，
    // 若强一致则在本服务内调用库存网关（防超卖见《经典系统设计案例》）
}

// 应用层：编排用例、控制事务、提交后发事件
@Service
public class OrderApplicationService {
    private final OrderRepository orderRepository;
    private final OrderEventPublisher eventPublisher; // 内部封装 MQ

    @Transactional
    public OrderId createOrder(CreateOrderCommand cmd) {
        List<OrderItem> items = cmd.toItems();          // 请求 DTO -> 领域对象（assembler）
        Order order = Order.place(orderRepository.nextId(), cmd.address(), items);
        orderRepository.save(order);                    // 本事务内落库
        // 事务提交后发布事件（Spring: TransactionSynchronization 注册 afterCommit）
        afterCommit(() -> eventPublisher.publish(order.collectEvents()));
        return order.id();
    }
}

// 接口层：只做参数接收与响应转换，不含业务规则
@RestController
public class OrderController {
    @PostMapping("/orders")
    public ResponseEntity<OrderResponse> create(@RequestBody @Valid CreateOrderRequest request) {
        OrderId orderId = orderAppService.createOrder(request.toCommand());
        return ResponseEntity.ok(new OrderResponse(orderId.value(), "下单成功"));
    }
}

// 应用层：编排用例、控制事务、提交后发事件
@Service
public class OrderApplicationService {
    private final OrderRepository orderRepository;
    private final OrderEventPublisher eventPublisher; // 内部封装 MQ

    @Transactional
    public OrderId createOrder(CreateOrderCommand cmd) {
        List<OrderItem> items = cmd.toItems();          // 请求 DTO -> 领域对象（assembler）
        Order order = Order.place(orderRepository.nextId(), cmd.address(), items);
        orderRepository.save(order);                    // 本事务内落库
        // 事务提交后发布事件（Spring: TransactionSynchronization 注册 afterCommit）
        afterCommit(() -> eventPublisher.publish(order.collectEvents()));
        return order.id();
    }
}

// 接口层：只做参数接收与响应转换，不含业务规则
@RestController
public class OrderController {
    @PostMapping("/orders")
    public ResponseEntity<OrderResponse> create(@RequestBody @Valid CreateOrderRequest request) {
        OrderId orderId = orderAppService.createOrder(request.toCommand());
        return ResponseEntity.ok(new OrderResponse(orderId.value(), "下单成功"));
    }
}