Java记录类与密封类实战：构建不可变领域模型的最佳实践

三、电商订单系统领域模型实战

3.1 核心领域模型定义

// 订单状态密封类
public sealed interface OrderStatus 
    permits OrderStatus.Pending, OrderStatus.Confirmed, 
            OrderStatus.Shipped, OrderStatus.Delivered, OrderStatus.Cancelled {
    
    record Pending() implements OrderStatus {}
    record Confirmed() implements OrderStatus {}
    record Shipped(LocalDate shippedDate, String trackingNumber) implements OrderStatus {}
    record Delivered(LocalDate deliveredDate, String recipient) implements OrderStatus {}
    record Cancelled(LocalDate cancelledDate, String reason) implements OrderStatus {}
}

// 订单项记录类
public record OrderItem(
    ProductId productId,
    String productName,
    BigDecimal unitPrice,
    int quantity,
    BigDecimal discount
) {
    public OrderItem {
        if (quantity <= 0) {
            throw new IllegalArgumentException("数量必须大于0");
        }
        if (unitPrice.compareTo(BigDecimal.ZERO) < 0) {
            throw new IllegalArgumentException("单价不能为负数");
        }
    }
    
    public BigDecimal calculateLineTotal() {
        return unitPrice.multiply(BigDecimal.valueOf(quantity))
                       .subtract(discount);
    }
}

// 主订单记录类
public record Order(
    OrderId orderId,
    CustomerId customerId,
    List items,
    OrderStatus status,
    LocalDateTime createdAt,
    Address shippingAddress,
    Address billingAddress
) {
    public Order {
        Objects.requireNonNull(orderId, "订单ID不能为空");
        Objects.requireNonNull(customerId, "客户ID不能为空");
        Objects.requireNonNull(items, "订单项不能为空");
        Objects.requireNonNull(status, "订单状态不能为空");
        Objects.requireNonNull(createdAt, "创建时间不能为空");
        
        if (items.isEmpty()) {
            throw new IllegalArgumentException("订单必须包含至少一个商品");
        }
    }
    
    public BigDecimal calculateTotal() {
        return items.stream()
            .map(OrderItem::calculateLineTotal)
            .reduce(BigDecimal.ZERO, BigDecimal::add);
    }
    
    public boolean canBeCancelled() {
        return switch(status) {
            case OrderStatus.Pending pending -> true;
            case OrderStatus.Confirmed confirmed -> true;
            case OrderStatus.Shipped shipped -> false;
            case OrderStatus.Delivered delivered -> false;
            case OrderStatus.Cancelled cancelled -> false;
        };
    }
}

3.2 订单服务实现

public class OrderService {
    private final OrderRepository orderRepository;
    private final PaymentService paymentService;
    private final InventoryService inventoryService;
    
    public OrderService(OrderRepository orderRepository, 
                       PaymentService paymentService,
                       InventoryService inventoryService) {
        this.orderRepository = orderRepository;
        this.paymentService = paymentService;
        this.inventoryService = inventoryService;
    }
    
    public OrderResult createOrder(CreateOrderCommand command) {
        // 验证库存
        var inventoryResults = command.items().stream()
            .map(item -> inventoryService.checkAvailability(item.productId(), item.quantity()))
            .toList();
        
        if (inventoryResults.stream().anyMatch(result -> !result.available())) {
            var unavailableItems = inventoryResults.stream()
                .filter(result -> !result.available())
                .map(InventoryResult::productId)
                .toList();
            return OrderResult.failure("库存不足: " + unavailableItems);
        }
        
        // 创建订单
        var order = new Order(
            OrderId.generate(),
            command.customerId(),
            command.items(),
            new OrderStatus.Pending(),
            LocalDateTime.now(),
            command.shippingAddress(),
            command.billingAddress()
        );
        
        var savedOrder = orderRepository.save(order);
        return OrderResult.success(savedOrder);
    }
    
    public OrderResult processOrderPayment(OrderId orderId, PaymentMethod paymentMethod) {
        var order = orderRepository.findById(orderId)
            .orElseThrow(() -> new OrderNotFoundException(orderId));
        
        if (!(order.status() instanceof OrderStatus.Pending)) {
            return OrderResult.failure("订单状态不允许支付");
        }
        
        var paymentResult = paymentService.processPayment(paymentMethod);
        
        var updatedOrder = switch(paymentResult.status()) {
            case SUCCESS -> orderRepository.updateStatus(orderId, new OrderStatus.Confirmed());
            case PENDING -> orderRepository.updateStatus(orderId, new OrderStatus.Confirmed());
            case FAILED -> order;
        };
        
        return OrderResult.success(updatedOrder);
    }
    
    public record CreateOrderCommand(
        CustomerId customerId,
        List items,
        Address shippingAddress,
        Address billingAddress
    ) {}
    
    public record OrderResult(Order order, boolean success, String message) {
        public static OrderResult success(Order order) {
            return new OrderResult(order, true, "操作成功");
        }
        
        public static OrderResult failure(String message) {
            return new OrderResult(null, false, message);
        }
    }
}

3.3 领域事件系统

// 领域事件密封类
public sealed interface DomainEvent 
    permits OrderCreatedEvent, OrderConfirmedEvent, OrderShippedEvent, 
            OrderCancelledEvent, PaymentProcessedEvent {
    
    String eventId();
    LocalDateTime occurredOn();
}

public record OrderCreatedEvent(
    String eventId,
    OrderId orderId,
    CustomerId customerId,
    BigDecimal totalAmount,
    LocalDateTime occurredOn
) implements DomainEvent {
    public OrderCreatedEvent(Order order) {
        this(
            UUID.randomUUID().toString(),
            order.orderId(),
            order.customerId(),
            order.calculateTotal(),
            LocalDateTime.now()
        );
    }
}

public record OrderConfirmedEvent(
    String eventId,
    OrderId orderId,
    LocalDateTime confirmedAt,
    LocalDateTime occurredOn
) implements DomainEvent {
    public OrderConfirmedEvent(OrderId orderId) {
        this(
            UUID.randomUUID().toString(),
            orderId,
            LocalDateTime.now(),
            LocalDateTime.now()
        );
    }
}

// 事件处理器
public class DomainEventProcessor {
    
    public void processEvent(DomainEvent event) {
        switch(event) {
            case OrderCreatedEvent e -> handleOrderCreated(e);
            case OrderConfirmedEvent e -> handleOrderConfirmed(e);
            case OrderShippedEvent e -> handleOrderShipped(e);
            case OrderCancelledEvent e -> handleOrderCancelled(e);
            case PaymentProcessedEvent e -> handlePaymentProcessed(e);
        }
    }
    
    private void handleOrderCreated(OrderCreatedEvent event) {
        // 发送通知、更新报表等
        System.out.println("处理订单创建事件: " + event.orderId());
    }
    
    private void handleOrderConfirmed(OrderConfirmedEvent event) {
        // 库存扣减、物流准备等
        System.out.println("处理订单确认事件: " + event.orderId());
    }
}