@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. 檢查庫存，如果足夠則進(jìn)行鎖定；如果不夠，則拋出異常
    this.inventoryService.checkIsEnoughAndLock(createOrderCommand.getItems());

    // 2. 創(chuàng)建 Order 聚合，此處使用靜態(tài)工廠創(chuàng)建復(fù)雜的 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<>();

    // 避免外部調(diào)用
    private Order(Long userId) {
        this.userId = userId;
    }

    // 靜態(tài)工廠，封裝復(fù)雜的 Order 創(chuàng)建邏輯，并保障創(chuàng)建的 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;
    }

    // 設(shè)置狀態(tài)完成對象的初始化
    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. 對訂單項價格進(jìn)行均攤
    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) {
            // 按比例進(jìn)行均攤
            Long itemDiscount = itemAmount / totalAmount * discount;
            // 重新設(shè)置金額
            item.setPrice(item.getPrice() - itemDiscount);
            // 記錄累加金額
            allocatedDiscount += itemDiscount;
        }else {
            // 分?jǐn)傆嘞碌膬?yōu)惠金額到最后一個訂單
            Long lastItemDiscount = discount - allocatedDiscount;
            item.setPrice(item.getPrice() - lastItemDiscount);
        }
        // 更新數(shù)據(jù)庫
        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 聚合根內(nèi)方法
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) {
            // 按比例進(jìn)行均攤
            Long itemDiscount = itemAmount / totalAmount * discount;
            // 重新設(shè)置金額
            item.setPrice(item.getPrice() - itemDiscount);
            // 記錄累加金額
            allocatedDiscount += itemDiscount;
        }else {
            // 分?jǐn)傆嘞碌膬?yōu)惠金額到最后一個訂單
            Long lastItemDiscount = discount - allocatedDiscount;
            item.setPrice(item.getPrice() - lastItemDiscount);
        }
    }
}
// Order 折扣
private void discountForOrder(long discount) {
    Long newTotalPrice = getTotalPrice() - discount;
    setTotalPrice(newTotalPrice);
}