战术构件：仓储、工厂、领域服务 ≠ 应用服务

// 领域层只看到这个接口——它不知道 JPA、不知道 MyBatis、不知道任何 SQL
public interface OrderRepository {

    // 放进"集合"：新建或更新整个聚合，以聚合为粒度
    void add(Order order);

    // 按身份取出整个聚合（不是取一行、不是取 DTO）
    Order orderOfId(OrderId orderId);

    // 从"集合"移出
    void remove(Order order);

    // 工厂方法风格的下一个身份——身份由领域决定，不等数据库自增
    OrderId nextIdentity();
}

// 实现放在基础设施层，领域层对它一无所知（持久化无知）
public class JpaOrderRepository implements OrderRepository {
    private final EntityManager em;
    // ...用 JPA 把整个 Order 聚合映射进出；SQL 全部锁在这一层
}

public class Order {
    private final OrderId id;
    private final BuyerId buyerId;
    private final List<OrderLine> lines;
    private Money total;
    private OrderStatus status;

    // 构造器私有：外部没有别的路造出 Order，只能走工厂
    private Order(OrderId id, BuyerId buyerId, List<OrderLine> lines, Money total) {
        this.id = id; this.buyerId = buyerId;
        this.lines = lines; this.total = total;
        this.status = OrderStatus.CREATED;
    }

    // 静态工厂：传入买家、订单项原料、已算好的定价，产出一个合法的 CREATED 订单
    public static Order place(OrderId id, BuyerId buyerId,
                              List<OrderLine> lines, Pricing pricing) {
        if (lines == null || lines.isEmpty())
            throw new IllegalArgumentException("订单项不能为空");      // 不变量①
        Money total = pricing.totalOf(lines);
        if (!total.equals(sumOf(lines)))
            throw new IllegalStateException("总额必须等于各行金额之和"); // 不变量②
        return new Order(id, buyerId, List.copyOf(lines), total);
        // 返回时：lines 非空、total 已对齐、status = CREATED —— 全部不变量成立
    }
}

// 领域服务：无状态，进出都是领域对象，名字"定价"进入统一语言
public class PricingService {

    private final CouponPolicy couponPolicy;
    private final MembershipPolicy membershipPolicy;

    public PricingService(CouponPolicy couponPolicy, MembershipPolicy membershipPolicy) {
        this.couponPolicy = couponPolicy;
        this.membershipPolicy = membershipPolicy;
    }

    // 一笔订单价 = 单价合计 + 优惠券 + 会员折扣 + 满减，横跨多个领域对象
    public Pricing priceFor(List<OrderLine> lines, Coupon coupon, MemberLevel level) {
        Money subtotal   = sumOf(lines);                       // 单价 × 数量 合计
        Money afterCoupon = couponPolicy.apply(subtotal, coupon);   // 优惠券
        Money afterMember = membershipPolicy.discount(afterCoupon, level); // 会员折扣
        Money afterThreshold = applyFullReduction(afterMember); // 满减
        return new Pricing(afterThreshold);
    }
}

@Service
public class PlaceOrderApplicationService {

    private final CartRepository cartRepository;
    private final OrderRepository orderRepository;
    private final PricingService pricingService;       // 领域服务
    private final DomainEventPublisher eventPublisher;

    // 一个事务 = 一个用例；安全/事务是应用层的横切，不是领域的事
    @Transactional
    public OrderId placeOrder(PlaceOrderCommand cmd) {
        // 1. load：把输入装配成领域对象
        Cart cart = cartRepository.cartOf(cmd.buyerId());
        List<OrderLine> lines = cart.toOrderLines();

        // 2. 委托领域服务算价（业务规则在 PricingService 里，不在这里）
        Pricing pricing = pricingService.priceFor(
                lines, cmd.coupon(), cmd.memberLevel());

        // 3. 委托工厂造聚合（不变量校验在 Order.place 里，不在这里）
        OrderId id = orderRepository.nextIdentity();
        Order order = Order.place(id, cmd.buyerId(), lines, pricing);

        // 4. 存回仓储（怎么持久化是基础设施的事）
        orderRepository.add(order);

        // 5. 发领域事件（库存上下文异步预留，见 07 章）
        eventPublisher.publish(new OrderPlaced(id, cmd.buyerId(), lines));
        return id;
    }
}

// ❌ 贫血反例：名字叫 Application Service，干的却是领域层的活
@Service
public class OrderApplicationService {

    @Transactional
    public OrderId createOrder(PlaceOrderCommand cmd) {
        Cart cart = cartRepository.cartOf(cmd.buyerId());
        List<OrderLine> lines = cart.toOrderLines();

        // ❌ 非空校验：这是订单的不变量，本该在 Order 里
        if (lines.isEmpty()) throw new IllegalArgumentException("订单项为空");

        // ❌ 金额算法：这是领域逻辑，本该在 PricingService 里
        Money total = Money.zero();
        for (OrderLine line : lines) total = total.plus(line.amount());
        total = total.minus(cmd.coupon().value());          // 优惠券规则散落在这
        if (cmd.memberLevel() == MemberLevel.VIP)            // 会员折扣硬编码在这
            total = total.times(0.95);

        // ❌ 状态机：从哪到哪能转，本该在 Order 里
        Order order = new Order();        // 半成品窗口：此刻 total/status 都还没设
        order.setBuyerId(cmd.buyerId());  // 一串 setter —— Order 沦为数据袋
        order.setLines(lines);
        order.setTotal(total);
        order.setStatus(OrderStatus.CREATED);

        orderRepository.add(order);
        return order.getId();
    }
}
// Order 这边只剩 getter/setter，没有任何行为 —— 这就是 01 章点名的贫血模型