DDD 对决：事务脚本 vs. 领域模型，哪个才是业务优化的终极方案？

@Transactional
public void createOrder(CreateOrderCommand createOrderCommand) {
    // 1. 库存校验
    for (OrderItemDTO itemDTO : createOrderCommand.getItems()) {
        Integer stock = inventoryMapper.getStock(itemDTO.getProductId());
        if (stock < itemDTO.getQuantity()) {
            throw new IllegalStateException("库存不足");
        }
    }
    // 2. 锁定库存
    for (OrderItemDTO itemDTO : createOrderCommand.getItems()) {
        inventoryMapper.lockStock(itemDTO.getProductId(), itemDTO.getQuantity());
    }

    // 3. 生成订单项
    List<OrderItem> items = createOrderCommand.getItems().stream()
            .map(OrderItem::create)
            .collect(Collectors.toList());
    orderItemMapper.createOrderItems(items);

    // 4. 生成订单
    Long totalPrice = items.stream()
            .mapToLong(OrderItem::getPrice)
            .sum();

    Order order = new Order(createOrderCommand.getUserId(),  totalPrice, OrderStatus.CREATED);
    orderMapper.createOrder(order);

}

public void createOrder(CreateOrderCommand createOrderCommand) {
    // 1. 检查库存，如果足够则进行锁定；如果不够，则抛出异常
    this.inventoryService.checkIsEnoughAndLock(createOrderCommand.getItems());

    // 2. 创建 Order 聚合，此处使用静态工厂创建复杂的 Order 对象
    Order order = Order.create(createOrderCommand);

    // 3. 保存 Order 聚合, @Transactional 在OrderRepository上
    this.orderRepository.save(order);
}

public class Order {
    private Long id;
    private Long userId;
    private Long totalSellingPrice = 0L;
    private Long totalPrice = 0L;
    private OrderStatus status;
    private List<OrderItem> orderItems = new ArrayList<>();

    // 避免外部调用
    private Order(Long userId) {
        this.userId = userId;
    }

    // 静态工厂，封装复杂的 Order 创建逻辑，并保障创建的 Order 对象是有效的
    public static Order create(CreateOrderCommand createOrderCommand) {
        Order order = new Order(createOrderCommand.getUserId());
        order.addItems(createOrderCommand.getItems());
        order.init();
        return order;
    }

    // 添加 OrderItem，并计算总金额
    private void addItems(List<OrderItemDTO> items) {
        if (!CollectionUtils.isEmpty(items)){
            items.forEach(item ->{
                OrderItem orderItem = OrderItem.create(item);
                this.orderItems.add(orderItem);
                this.totalPrice += item.getPrice();
            });
        }
        this.totalPrice = totalSellingPrice;
    }

    // 设置状态完成对象的初始化
    private void init() {
        this.status = OrderStatus.CREATED;
    }
}

@Transactional
public void changeOrderPrice(Long orderId, Long newPrice) {
    // 1. 校验金额
    if (newPrice <= 0) {
        throw new IllegalArgumentException("金额必须大于0");
    }

    // 校验订单有效性
    Order order = orderMapper.getOrderById(orderId);
    if (order == null) {
        throw new IllegalArgumentException("订单不存在");
    }

    // 2. 对订单项价格进行均摊
    allocateDiscount(order, order.getTotalPrice() - newPrice);

    // 3. 修改订单价格
    order.setTotalPrice(newPrice);
    orderMapper.updateOrder(order);
}

public void allocateDiscount(Order order, Long discount) {
    if (discount == 0){
        return;
    }

    List<OrderItem> items = this.orderItemMapper.getByOrderId(order.getId());
    Long totalAmount = order.getTotalPrice();
    Long allocatedDiscount = 0L;

    for (int i = 0; i < items.size(); i++) {
        OrderItem item = items.get(i);
        Long itemAmount = item.getSellingPrice();
        if (i != items.size() - 1) {
            // 按比例进行均摊
            Long itemDiscount = itemAmount / totalAmount * discount;
            // 重新设置金额
            item.setPrice(item.getPrice() - itemDiscount);
            // 记录累加金额
            allocatedDiscount += itemDiscount;
        }else {
            // 分摊余下的优惠金额到最后一个订单
            Long lastItemDiscount = discount - allocatedDiscount;
            item.setPrice(item.getPrice() - lastItemDiscount);
        }
        // 更新数据库
        this.orderItemMapper.update(item);
    }
}

@Transactional
public void changeOrderPrice(Long orderId, Long newPrice) {
    // 1. 校验金额
    if (newPrice <= 0) {
        throw new IllegalArgumentException("金额必须大于0");
    }

    // 2. 获取订单聚合根
    Optional<Order> orderOpt = this.orderRepository.getById(orderId);

    Order order = orderOpt.orElseThrow(() -> new IllegalArgumentException("订单不存在"));

    // 3. 修改价格
    order.changePrice(newPrice);

    // 4. 保存 Order 聚合
    this.orderRepository.save(order);

}

// Order 聚合根内方法
public void changePrice(Long newPrice) {
    if (newPrice <= 0) {
        throw new IllegalArgumentException("金额必须大于0");
    }

    long discount = getTotalPrice() - newPrice;
    if (discount == 0){
        return;
    }
    // Item 均摊折扣
    discountForItem(discount);
    // Order 折扣
    discountForOrder(discount);
}

// Item 均摊
private void discountForItem(long discount) {
    Long totalAmount = getTotalPrice();
    Long allocatedDiscount = 0L;

    for (int i = 0; i < getOrderItems().size(); i++) {
        OrderItem item = getOrderItems().get(i);
        Long itemAmount = item.getSellingPrice();
        if (i != getOrderItems().size() - 1) {
            // 按比例进行均摊
            Long itemDiscount = itemAmount / totalAmount * discount;
            // 重新设置金额
            item.setPrice(item.getPrice() - itemDiscount);
            // 记录累加金额
            allocatedDiscount += itemDiscount;
        }else {
            // 分摊余下的优惠金额到最后一个订单
            Long lastItemDiscount = discount - allocatedDiscount;
            item.setPrice(item.getPrice() - lastItemDiscount);
        }
    }
}
// Order 折扣
private void discountForOrder(long discount) {
    Long newTotalPrice = getTotalPrice() - discount;
    setTotalPrice(newTotalPrice);
}