PHP中的领域驱动：如何设计DDD架构

// 领域层：实体
namespace Domain\Model;

class User
{
    private $id;
    private $email;
    private $password;

    public function __construct(string $email, string $password)
    {
        $this->email = $email;
        $this->password = $password;
    }

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

    public function getEmail(): string
    {
        return $this->email;
    }
}

// 领域层：领域服务
namespace Domain\Service;

use Domain\Model\User;

interface UserRepository
{
    public function findByEmail(string $email): ?User;
    public function save(User $user): void;
}

class UserService
{
    private $userRepository;

    public function __construct(UserRepository $userRepository)
    {
        $this->userRepository = $userRepository;
    }

    public function register(string $email, string $password): User
    {
        if ($this->userRepository->findByEmail($email)) {
            throw new \Exception("Email already exists");
        }

        $user = new User($email, $password);
        $this->userRepository->save($user);

        return $user;
    }
}

// 基础设施层：UserRepository的实现
namespace Infrastructure\Persistence\Doctrine;

use Domain\Model\User;
use Domain\Service\UserRepository;
use Doctrine\ORM\EntityManagerInterface;

class DoctrineUserRepository implements UserRepository
{
    private $entityManager;

    public function __construct(EntityManagerInterface $entityManager)
    {
        $this->entityManager = $entityManager;
    }

    public function findByEmail(string $email): ?User
    {
        return $this->entityManager->getRepository(User::class)->findOneBy(['email' => $email]);
    }

    public function save(User $user): void
    {
        $this->entityManager->persist($user);
        $this->entityManager->flush();
    }
}

// 应用层
namespace Application\Service;

use Domain\Service\UserService;

class RegisterUserService
{
    private $userService;

    public function __construct(UserService $userService)
    {
        $this->userService = $userService;
    }

    public function execute(string $email, string $password): void
    {
        $this->userService->register($email, $password);
    }
}

// 接口层 (例如：控制器)
namespace App\Controller;

use Application\Service\RegisterUserService;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;

class UserController
{
    private $registerUserService;

    public function __construct(RegisterUserService $registerUserService)
    {
        $this->registerUserService = $registerUserService;
    }

    public function register(Request $request): Response
    {
        $email = $request->request->get('email');
        $password = $request->request->get('password');

        try {
            $this->registerUserService->execute($email, $password);
            return new Response('User registered successfully', Response::HTTP_CREATED);
        } catch (\Exception $e) {
            return new Response($e->getMessage(), Response::HTTP_BAD_REQUEST);
        }
    }
}

// 领域事件
namespace Domain\Event;

class UserRegistered
{
    private $userId;
    private $email;

    public function __construct(int $userId, string $email)
    {
        $this->userId = $userId;
        $this->email = $email;
    }

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

    public function getEmail(): string
    {
        return $this->email;
    }
}

// 聚合根
namespace Domain\Model;

use Domain\Event\UserRegistered;

class User
{
    private $id;
    private $email;
    private $registeredAt;

    private function __construct(int $id, string $email, \DateTimeImmutable $registeredAt)
    {
        $this->id = $id;
        $this->email = $email;
        $this->registeredAt = $registeredAt;
    }

    public static function register(int $id, string $email): self
    {
        $user = new self($id, $email, new \DateTimeImmutable());
        // 应用事件
        $user->apply(new UserRegistered($id, $email));
        return $user;
    }

    public function applyUserRegistered(UserRegistered $event): void
    {
        $this->id = $event->getUserId();
        $this->email = $event->getEmail();
        $this->registeredAt = new \DateTimeImmutable();
    }

    // 用于从事件流重建聚合根
    public static function reconstituteFromHistory(array $events): self
    {
        $user = null;
        foreach ($events as $event) {
            if ($event instanceof UserRegistered) {
                if ($user === null) {
                    $user = new self($event->getUserId(), $event->getEmail(), new \DateTimeImmutable());
                }
                $user->applyUserRegistered($event);
            }
        }
        return $user;
    }

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

    public function getEmail(): string
    {
        return $this->email;
    }
}