PHP领域驱动设计核心实践完整权威指南：十大策略与实战案例

PHP 在领域驱动设计(DDD)中的工程落地关键

先厘清几个核心认知。在PHP技术栈中推行领域驱动设计，不少开发者第一反应是“这模式对PHP是不是过于沉重”？恰恰相反。DDD的真正价值不在于复杂的分层架构图，而在于它提供了一套让代码精准映射业务语义的方法论和工具。从通用语言到限界上下文，每一条设计原则背后都有可落地的工程依据。

通用语言

通用语言的核心目标是让领域专家与开发团队使用同一套术语沟通。领域层的类命名、方法命名、变量命名必须源自业务词汇表，而非框架约定或数据库表名。

一个极易被忽视的危险信号：当代码中出现 OrderManager、OrderHelper 或 OrderService（如果“Service”一词根本不在领域词汇表中），说明实现层面的命名已经渗透到了领域语言内部。正确的做法是什么？直接采用领域专家实际使用的词汇：Order、OrderFulfillment、Shipment。

另一个关键点是，将发现的通用语言直接映射为类型约束。假设领域专家说“订阅在连续两次付款失败后变为逾期”，这句话本身就蕴含了业务规则——它应该由 Subscription::markDelinquent() 来强制执行，而不是放在 SubscriptionController 中。

值对象

值对象无需标识。两个实例若值相等即视为相同，不可变性是硬性要求——任何修改状态的操作必须返回新实例。

实现

currency->equals($other->currency)) {
            throw new InvalidArgumentException('Currency mismatch');
        }
        return new self($this->amount + $other->amount, $this->currency);
    }

    public function equals(Money $other): bool
    {
        return $this->amount === $other->amount
            && $this->currency->equals($other->currency);
    }

    public function amount(): int
    {
        return $this->amount;
    }

    public function currency(): Currency
    {
        return $this->currency;
    }
}

值对象候选清单

PHP 8.1+ 枚举

PHP 8.1 引入的后端枚举（enum Status: string），本质上就是一个值对象。对于有限状态集，直接采用枚举替代字符串常量或独立的值对象类，代码更简洁且类型安全。

实体

实体拥有跨状态变更持续存在的标识。两个具有相同 ID 的 Order 对象代表同一个订单，这与它们当前的字段值无关。

标识类型

优先使用领域生成的 UUID，而非数据库分配的自增整数 ID。原因很直接：自增 ID 强制在实体存在于内存之前进行一次数据库往返，这会破坏聚合的一致性保证。

value;
    }

    public function equals(self $other): bool
    {
        return $this->value === $other->value;
    }
}

聚合

聚合由单个聚合根组织的一组实体和值对象构成。所有外部访问必须通过聚合根进行。跨越集群内多个对象的不变式，由聚合根统一强制执行。

规则

仅通过 ID 引用其他聚合——这条规则至关重要。绝不要跨聚合边界持有直接对象引用。每次访问都加载外部聚合不仅降低性能，还会耦合边界。

status = OrderStatus::Draft;
    }

    public function addLine(ProductId $productId, int $qty, Money $unitPrice): void
    {
        $this->assertStatus(OrderStatus::Draft);
        if (count($this->lines) >= 50) {
            throw new OrderLineLimit('Max 50 lines per order');
        }
        $this->lines[] = new OrderLine($productId, $qty, $unitPrice);
    }

    public function place(): void
    {
        $this->assertStatus(OrderStatus::Draft);
        if ($this->lines === []) {
            throw new EmptyOrderException('Cannot place an empty order');
        }
        $this->status = OrderStatus::Placed;
        $this->events[] = new OrderPlaced($this->id, $this->customerId, $this->total());
    }

    public function total(): Money
    {
        return array_reduce(
            $this->lines,
            fn(Money $carry, OrderLine $line) => $carry->add($line->subtotal()),
            $this->shippingFee,
        );
    }

    public function pullEvents(): array
    {
        $events = $this->events;
        $this->events = [];
        return $events;
    }

    private function assertStatus(OrderStatus $expected): void
    {
        if ($this->status !== $expected) {
            throw new InvalidOrderOperation("Operation requires status {$expected->name}, got {$this->status->name}");
        }
    }
}

聚合大小

保持聚合小巧是铁律。如果一个聚合包含数百个子实体，通常意味着其中一些子实体应该独立为单独的聚合，仅通过 ID 引用。过大的聚合会导致更长的事务锁和更多合并冲突。

聚合边界内不变式检查清单

仓储

仓储提供类似集合的接口来访问聚合。它抽象了持久化机制——领域层定义接口，基础设施层实现接口。

find($id) ?? throw new OrderNotFound($id);
    }

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

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

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

    public function findByCustomer(CustomerId $customerId): array
    {
        return $this->em->createQuery('SELECT o FROM Order o WHERE o.customerId = :id')
            ->setParameter('id', $customerId->value())
            ->getResult();
    }
}

 */
    private array $store = [];

    public function get(OrderId $id): Order
    {
        return $this->store[$id->value()] ?? throw new OrderNotFound($id);
    }

    public function find(OrderId $id): ?Order
    {
        return $this->store[$id->value()] ?? null;
    }

    public function sa ve(Order $order): void
    {
        $this->store[$order->id()->value()] = $order;
    }

    public function delete(Order $order): void
    {
        unset($this->store[$order->id()->value()]);
    }

    public function findByCustomer(CustomerId $customerId): array
    {
        return array_values(
            array_filter(
                $this->store,
                fn(Order $o) => $o->customerId()->equals($customerId),
            )
        );
    }
}

occurredAt = new DateTimeImmutable();
    }

    public function occurredAt(): DateTimeImmutable
    {
        return $this->occurredAt;
    }
}

total();
        $discount = $this->discounts->findFor($customer->tier());
        return $discount !== null
            ? $discount->apply($base)
            : $base;
    }
}

currency);
        $order = new Order(
            new OrderId($cmd->orderId),
            new CustomerId($cmd->customerId),
            new Money($cmd->shippingFee, $currency),
        );

        foreach ($cmd->lines as $line) {
            $order->addLine(
                new ProductId($line['productId']),
                $line['qty'],
                new Money($line['unitPrice'], $currency),
            );
        }

        $order->place();

        $this->orders->sa ve($order);
        foreach ($order->pullEvents() as $event) {
            $this->events->dispatch($event);
        }
    }
}

# deptrac.yaml — prevent Billing from importing Order internals
layers:
    - name: Billing
      collectors:
          - type: namespace
            regex: ^App\Domain\Billing
    - name: Order
      collectors:
          - type: namespace
            regex: ^App\Domain\Order
ruleset:
    Billing:
        - Order # disallowed — Billing must go via ACL or events

erp->getOrder($id->value());
        if ($raw === null) {
            return null;
        }
        return $this->translate($raw);
    }

    private function translate(array $raw): Order
    {
        $currency = new Currency($raw['curr_code']);
        $order = new Order(
            new OrderId($raw['ord_uuid']),
            new CustomerId($raw['cust_ref']),
            new Money((int) ($raw['ship_fee'] * 100), $currency),
        );

        foreach ($raw['items'] as $item) {
            $order->addLine(
                new ProductId($item['sku']),
                (int) $item['qty'],
                new Money((int) ($item['unit_price'] * 100), $currency),
            );
        }

        return $order;
    }
}

src/
├── Domain/
│   ├── Order/
│   │   ├── Order.php               # aggregate root
│   │   ├── OrderId.php             # VO identity
│   │   ├── OrderLine.php           # child entity
│   │   ├── OrderStatus.php         # backed enum
│   │   ├── OrderPlaced.php         # domain event
│   │   ├── OrderRepository.php     # interface
│   │   └── Exceptions/
│   ├── Pricing/
│   │   ├── PriceCalculator.php     # domain service
│   │   └── DiscountRepository.php
│   └── Shared/
│       ├── DomainEvent.php
│       ├── Money.php
│       └── Currency.php
├── Application/
│   └── Order/
│       ├── PlaceOrderCommand.php
│       └── PlaceOrderHandler.php
└── Infrastructure/
    ├── Persistence/
    │   ├── DoctrineOrderRepository.php
    │   └── InMemoryOrderRepository.php
    └── Legacy/
        └── LegacyOrderAcl.php