实战：电商订单系统

DDD 领域驱动设计分层架构

DDD（Domain-Driven Design，领域驱动设计）是应对复杂业务系统的架构方法论，由 Eric Evans 在 2003 年提出。其核心思想是：软件模型应该反映业务领域，而不是技术实现。DDD 将系统分为四层，每层只依赖下层：

核心概念名词解释

系统模块划分

订单实体与状态机

Order 聚合根实现

@Entity
@Table(name = "orders")
public class Order {  // 聚合根

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(unique = true, nullable = false)
    private String orderNo;  // 业务订单号（雪花算法生成）

    private Long userId;

    @Enumerated(EnumType.STRING)
    private OrderStatus status;

    @Embedded
    private Money totalAmount;  // 值对象

    @OneToMany(cascade = CascadeType.ALL, orphanRemoval = true)
    private List<OrderItem> items = new ArrayList<>();

    @Transient
    private List<DomainEvent> domainEvents = new ArrayList<>();

    // 工厂方法：创建订单（保证不变量）
    public static Order create(Long userId, List<OrderItem> items) {
        Order order = new Order();
        order.userId = userId;
        order.orderNo = SnowflakeIdGenerator.next();
        order.status = OrderStatus.PENDING;
        order.items = items;
        order.totalAmount = calculateTotal(items);
        // 发布领域事件
        order.domainEvents.add(new OrderCreatedEvent(order.orderNo, userId));
        return order;
    }

    // 支付成功（状态转换由聚合根控制）
    public void markPaid(String paymentId) {
        if (this.status != OrderStatus.PENDING) {
            throw new BusinessException("只有待支付订单才能标记为已支付");
        }
        this.status = OrderStatus.PAID;
        this.domainEvents.add(new OrderPaidEvent(this.orderNo, paymentId));
    }

    public void cancel(String reason) {
        if (!OrderStatus.CANCELLABLE_STATUSES.contains(this.status)) {
            throw new BusinessException("当前状态不可取消");
        }
        this.status = OrderStatus.CANCELLED;
        this.domainEvents.add(new OrderCancelledEvent(this.orderNo, reason));
    }
}

下单完整链路与分布式事务

ApplicationService 实现

@Service
@RequiredArgsConstructor
public class OrderApplicationService {

    private final OrderRepository orderRepository;
    private final ProductClient productClient;
    private final InventoryClient inventoryClient;
    private final PaymentClient paymentClient;
    private final ApplicationEventPublisher eventPublisher;

    @GlobalTransactional  // Seata 全局事务
    public OrderDTO createOrder(CreateOrderCommand cmd) {
        // 1. 查询并验证商品
        List<ProductDTO> products = productClient.getProducts(cmd.getProductIds());
        validateProducts(products, cmd);

        // 2. 构建订单项
        List<OrderItem> items = buildOrderItems(products, cmd);

        // 3. 创建订单聚合根
        Order order = Order.create(cmd.getUserId(), items);
        orderRepository.save(order);

        // 4. 扣减库存（Seata 管理跨服务事务）
        inventoryClient.decreaseStock(
            items.stream().map(StockDecreaseItem::from).toList()
        );

        // 5. 创建支付单
        String paymentUrl = paymentClient.createPayment(
            order.getOrderNo(), order.getTotalAmount()
        );

        // 6. 发布领域事件（Seata 提交后才发布，避免事件先于数据）
        order.getDomainEvents().forEach(eventPublisher::publishEvent);

        return OrderDTO.from(order, paymentUrl);
    }
}

领域事件监听与最终一致性

@Component
@RequiredArgsConstructor
public class OrderEventHandler {

    private final RabbitTemplate rabbitTemplate;
    private final EmailService emailService;
    private final PointsService pointsService;

    // 订单创建后：发送确认邮件（异步，不影响主流程）
    @EventListener
    @Async
    public void onOrderCreated(OrderCreatedEvent event) {
        emailService.sendOrderConfirmation(event.getUserId(), event.getOrderNo());
    }

    // 订单支付后：通过 RabbitMQ 通知仓储系统发货
    @EventListener
    public void onOrderPaid(OrderPaidEvent event) {
        rabbitTemplate.convertAndSend(
            "order.events", "order.paid",
            new ShipmentCreationCommand(event.getOrderNo())
        );
        // 异步增加积分（最终一致性）
        pointsService.addPointsAsync(event.getUserId(), event.getAmount());
    }
}

项目完整目录结构