PHP 领域驱动设计实战：限界上下文、聚合与六边形架构

class OrderService
{
    public function pay(int $orderId, float $amount): void
    {
        $order = Order::find($orderId);
        if ($order->status === 'paid') { throw new \RuntimeException('已支付'); }
        if (abs($order->amount - $amount) > 0.01) { throw new \RuntimeException('金额不符'); }
        if ($order->expired_at < time()) { throw new \RuntimeException('订单已过期'); }
        $order->status = 'paid';
        $order->save();
    }
}

final class Order
{
    private OrderStatus $status;

    public function pay(Money $amount, \DateTimeImmutable $now): void
    {
        if ($this->status !== OrderStatus::Pending) { throw new OrderAlreadyPaid($this->id); }
        if (!$this->amount->equals($amount)) { throw new AmountMismatch($this->amount, $amount); }
        if ($this->expiresAt < $now) { throw new OrderExpired($this->id); }
        $this->status = OrderStatus::Paid;
        $this->paidAt = $now;
        $this->record(new OrderPaid($this->id, $amount));
    }
}

final readonly class Money
{
    private function __construct(
        public int $amount,       // 以「分」为单位，避免浮点误差
        public string $currency,
    ) {}

    public static function ofCents(int $amount, string $currency = 'CNY'): self
    {
        return new self($amount, strtoupper($currency));
    }

    public function add(self $other): self
    {
        if ($this->currency !== $other->currency) {
            throw new \InvalidArgumentException('币种不一致');
        }
        return new self($this->amount + $other->amount, $this->currency);
    }
}

final class Order            // 聚合根
{
    /** @var OrderLine[] */
    private array $lines = [];

    public function addLine(Sku $sku, int $qty, Money $price): void
    {
        foreach ($this->lines as $line) {       // 不变量：同一 SKU 不重复
            if ($line->sku()->equals($sku)) {
                throw new DuplicateLine($sku);
            }
        }
        $this->lines[] = new OrderLine($sku, $qty, $price);
        $this->total = $this->total->add($price->multiply($qty));  // 根维护一致性
    }

    public function total(): Money { return $this->total; }
}

final readonly class OrderPaid
{
    public function __construct(
        public string $orderId,
        public int $amountCents,
        public \DateTimeImmutable $occurredAt,
    ) {}
}

$em->transactional(function () use ($em, $order) {
    $em->persist($order);
    foreach ($order->releaseEvents() as $event) {
        $em->persist(OutboxMessage::fromEvent($event));   // 与聚合同一事务
    }
});

interface OrderRepository          // 领域层
{
    public function nextIdentity(): OrderId;
    public function find(OrderId $id): ?Order;
    public function save(Order $order): void;
}

final class DoctrineOrderRepository implements OrderRepository   // 基础设施层
{
    public function __construct(private EntityManagerInterface $em) {}

    public function find(OrderId $id): ?Order
    {
        return $this->em->find(Order::class, $id->toString());
    }

    public function save(Order $order): void
    {
        $this->em->persist($order);
        $this->em->flush();
    }
}

   HTTP/CLI 适配器 ──▶ ┌──────────────────────────┐
                      │  应用层（用例编排）        │
   （入站端口）        │  ┌────────────────────┐  │
                      │  │ 领域层（模型与规则） │  │
                      │  └────────────────────┘  │
                      └──────────────────────────┘
                             ▲             ▲
      MySQL/Redis 适配器 ─────┘             └───── 第三方 API 适配器

final class AlipayPaymentAdapter implements PaymentGateway
{
    public function __construct(private AlipayClient $client) {}

    public function charge(OrderId $orderId, Money $amount): PaymentResult
    {
        $raw = $this->client->createTrade([
            'out_trade_no' => $orderId->toString(),
            'total_amount' => $amount->toDecimalString(),
        ]);
        return match ($raw['trade_status'] ?? '') {
            'TRADE_SUCCESS' => PaymentResult::succeeded($raw['trade_no']),
            'TRADE_CLOSED'  => PaymentResult::failed('交易关闭'),
            default         => PaymentResult::pending($raw['trade_no']),
        };
    }
}

src/
├── Domain/                       # 领域层：零框架依赖
│   └── Ordering/{Model,Event,Repository,Exception}/
├── Application/                  # 应用层：编排用例
│   └── Ordering/PayOrder/{PayOrderCommand.php,PayOrderHandler.php}
├── Infrastructure/               # 基础设施层：适配器
│   ├── Persistence/Doctrine/DoctrineOrderRepository.php
│   └── Payment/AlipayPaymentAdapter.php
└── Interface/                    # 接口层
    ├── Http/Controller/OrderController.php
    └── Console/CloseExpiredOrdersCommand.php

final class PayOrderHandler
{
    public function __construct(
        private OrderRepository $orders,
        private PaymentGateway $gateway,
        private EventDispatcherInterface $events,
    ) {}

    public function handle(PayOrderCommand $command): void
    {
        $order = $this->orders->find(OrderId::fromString($command->orderId))
            ?? throw new OrderNotFound($command->orderId);
        $result = $this->gateway->charge($order->id(), $order->total());
        if (!$result->isSucceeded()) {
            throw new PaymentFailed($result->reason());
        }

        $order->pay($order->total(), new \DateTimeImmutable());
        $this->orders->save($order);

        foreach ($order->releaseEvents() as $event) {
            $this->events->dispatch($event);
        }
    }
}