Implementierung eines DDD-Anwendungsfalls in PHP

Implementierung eines DDD-Anwendungsfalls für in PHP

Dieser Artikel untersucht ein Domain-Driven Design (DDD)-Anwendungsfallmodell in PHP und zeigt, wie Schnittstellen und domänenspezifische Klassen zur Verwaltung der Datenpersistenz verwendet werden. Wir untersuchen die Klasse TaxPersistUseCase, die einen Persistenzmanager (TaxManagerInterface) verwendet, um eine Entität vom Typ Tax zu speichern, die eine Steuer darstellt.

Dieses Modell betont die DDD-Prinzipien: Jede Komponente ist klar in Schnittstellen, konkrete Implementierungen und Ausnahmen unterteilt, wobei Best Practices bei der Abhängigkeitsinjektion und Fehlerbehandlung befolgt werden.

Struktur des TaxPersistUseCase

Die TaxPersistUseCase-Klasse verwaltet die Geschäftslogik, die mit der Beibehaltung einer Steuer verbunden ist. Es ist in mehrere Abschnitte unterteilt, um die Logik und Struktur dieses Ansatzes zu verdeutlichen.

Abhängigkeitserklärungen

namespace Domain\Application\UseCase\Order;

use Domain\Application\Entity\Order\Tax;
use Domain\Application\Gateway\Manager\Order\TaxManagerInterface;
use Domain\Application\UseCase\Order\Exception\NotFoundException;
use Domain\Application\UseCase\Order\Interfaces\TaxPersistRequestInterface;
use Domain\Application\UseCase\Order\Interfaces\TaxPersistResponseInterface;
use Domain\Exception\BadRequestException;
use Domain\Exception\FormException;
use Small\CleanApplication\Contract\UseCaseInterface;
use Small\Collection\Collection\StringCollection;
use Small\SwooleEntityManager\EntityManager\Exception\EmptyResultException;

Die TaxPersistUseCase-Klasse hängt von mehreren Schnittstellen und Ausnahmen ab, um die Steuerpersistenz zu handhaben. Hier ist eine Aufschlüsselung ihrer Rollen:

TaxManagerInterface: Schnittstelle für den Steuerpersistenzmanager.

TaxPersistRequestInterface und TaxPersistResponseInterface: Schnittstellen für die Anfrage und Antwort des Anwendungsfalls.
Ausnahmen: Verschiedene Ausnahmen wie BadRequestException, FormException und NotFoundException helfen bei der Verwaltung kontextspezifischer Fehler.

Implementierung der TaxPersistUseCase-Klasse

namespace Domain\Application\UseCase\Order;

use Domain\Application\Entity\Order\Tax;
use Domain\Application\Gateway\Manager\Order\TaxManagerInterface;
use Domain\Application\UseCase\Order\Exception\NotFoundException;
use Domain\Application\UseCase\Order\Interfaces\TaxPersistRequestInterface;
use Domain\Application\UseCase\Order\Interfaces\TaxPersistResponseInterface;
use Domain\Exception\BadRequestException;
use Domain\Exception\FormException;
use Small\CleanApplication\Contract\UseCaseInterface;
use Small\Collection\Collection\StringCollection;
use Small\SwooleEntityManager\EntityManager\Exception\EmptyResultException;

• Konstruktor und Abhängigkeitsinjektion: Der Konstruktor injiziert eine Instanz von TaxManagerInterface und delegiert die Persistenz von Tax-Objekten an diese Instanz, ohne TaxPersistUseCase an eine bestimmte Implementierung zu koppeln.
• Überprüfung des Anforderungstyps: Die Ausführungsmethode überprüft, ob das $request-Objekt das TaxPersistRequestInterface implementiert. Dadurch wird sichergestellt, dass die empfangene Anfrage dem erwarteten Vertrag entspricht, und eine Validierung auf Schnittstellenebene erfolgt.
• Beibehalten des Steuerobjekts: Wenn die Anfrage gültig ist, extrahiert der Anwendungsfall das Steuerobjekt aus $request über getTax() und ruft die applicationPersist-Methode auf TaxManagerInterface auf. Dieser Persistenzprozess ist in einem Try-Catch-Block gekapselt, um potenzielle Ausnahmen zu behandeln
• EmptyResultException: Wenn die Steuerentität nicht gefunden wird, wird diese Ausnahme abgefangen und eine NotFoundException wird ausgelöst, um den Fehler zu signalisieren.
• FormException: Wenn die Formularvalidierung fehlschlägt, wird eine FormException erfasst und Fehlermeldungen werden in einer StringCollection gespeichert.
• Dynamische Antwort über anonyme Klasse: Eine anonyme Klasse implementiert TaxPersistResponseInterface, um die Antwort des Anwendungsfalls zurückzugeben. Es enthält die Methoden getTax() und getMessages(), die den Zugriff auf die Steuereinheit bzw. alle Fehlermeldungen ermöglichen.

Anwendungsfallschnittstellen

Die Schnittstellen definieren die Verträge, die jede Komponente einhalten muss, und fördern so die Entkopplung und Testbarkeit.

TaxManagerInterface

Diese Schnittstelle spezifiziert die Methoden zur Verwaltung von Steuern, einschließlich Abruf und Persistenz:

class TaxPersistUseCase implements UseCaseInterface
{

    public function __construct(
        protected TaxManagerInterface $taxManager,
    ) {}

    public function execute(mixed $request): TaxPersistResponseInterface
    {

        if (!$request instanceof TaxPersistRequestInterface) {
            throw new BadRequestException(
                self::class . ' accepts only request instance of ' . TaxPersistRequestInterface::class
            );
        }

        $tax = $request->getTax();
        $messages = new StringCollection();

        try {
            $this->taxManager->applicationPersist($tax);
        } catch (EmptyResultException $e) {
            throw new NotFoundException($e->getMessage());
        } catch (FormException $e) {
            $messages = $e->getFormMessages();
        }

        return new class($tax, $messages) implements TaxPersistResponseInterface
        {
            public function __construct(
                protected readonly Tax $tax,
                protected readonly StringCollection $messages,
            ) {}

            public function getTax(): Tax
            {
                return $this->tax;
            }

            public function getMessages(): StringCollection
            {
                return $this->messages;
            }
        };

    }

}

• findById() und findByName(): Diese Methoden ermöglichen das Abrufen einer Steuer nach ID oder Name.
• applicationPersist(): Diese Methode stellt die Persistenz der Steuereinheit sicher.

TaxPersistRequestInterface

Diese Schnittstelle definiert die Struktur der von TaxPersistUseCase erwarteten Anforderung:

interface TaxManagerInterface
{
    public function findById(int $id): Tax;
    public function findByName(string $name): Tax;
    public function applicationPersist(Tax $tax): self;
}

• getTax(): Diese Methode gibt die Steuerentität zurück, die beibehalten werden soll, sodass der Anwendungsfall direkt auf das relevante Domänenobjekt zugreifen kann. TaxPersistResponseInterface
• Die Antwortschnittstelle stellt sicher, dass TaxPersistUseCase eine konforme Antwort zurückgibt:

interface TaxPersistRequestInterface extends RequestInterface
{
    public function getTax(): Tax;
}

• getTax(): Gibt die beibehaltene Steuerentität oder null zurück, wenn ein Fehler aufgetreten ist.
• getMessages(): Gibt eine StringCollection zurück, die Fehlermeldungen enthält, wenn Formularfehler aufgetreten sind.

Fehler- und Ausnahmebehandlung

Ausnahmen spielen bei DDD eine wichtige Rolle, indem sie domänenspezifische Fehler erfassen:

• BadRequestException: Wird ausgelöst, wenn der Anwendungsfall eine Anfrage eines falschen Typs empfängt.
• NotFoundException: Wird ausgelöst, wenn die gesuchte Steuereinheit nicht gefunden wird.
• FormException: Zur Behandlung von Validierungsfehlern abgefangen, wobei Fehlermeldungen in einer StringCollection zurückgegeben werden.

Das obige ist der detaillierte Inhalt vonImplementierung eines DDD-Anwendungsfalls in PHP. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!