Implémentation d'un cas d'utilisation DDD pour en PHP

Cet article explore un modèle de cas d'utilisation de conception pilotée par domaine (DDD) en PHP, démontrant comment utiliser des interfaces et des classes spécifiques à un domaine pour gérer la persistance des données. Nous examinerons la classe TaxPersistUseCase, qui utilise un gestionnaire de persistance (TaxManagerInterface) pour enregistrer une entité de type Tax, représentant une taxe.

Ce modèle met l'accent sur les principes DDD?: chaque composant est clairement séparé en interfaces, implémentations concrètes et exceptions, suivant les meilleures pratiques en matière d'injection de dépendances et de gestion des erreurs.

Structure du TaxPersistUseCase

La classe TaxPersistUseCase gère la logique métier associée à la persistance d'une taxe. Il est divisé en plusieurs sections pour clarifier la logique et la structure de cette approche.

Déclarations de dépendance

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;

La classe TaxPersistUseCase dépend de plusieurs interfaces et exceptions pour gérer la persistance fiscale. Voici une répartition de leurs r?les?:

TaxManagerInterface : Interface pour le gestionnaire de persistance fiscale.

TaxPersistRequestInterface et TaxPersistResponseInterface : Interfaces pour la demande et la réponse du cas d'utilisation.
Exceptions?: diverses exceptions, telles que BadRequestException, FormException et NotFoundException, aident à gérer les erreurs spécifiques au contexte.

Implémentation de la classe TaxPersistUseCase

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;

• Constructeur et injection de dépendances?: Le constructeur injecte une instance de TaxManagerInterface, déléguant la persistance des objets Tax à cette instance sans coupler TaxPersistUseCase à une implémentation spécifique.
• Vérification du type de demande?: la méthode d'exécution vérifie que l'objet $request implémente TaxPersistRequestInterface. Cela garantit que la demande re?ue est conforme au contrat attendu, fournissant une validation au niveau de l'interface.
• Persistance de l'objet Tax : Si la requête est valide, le cas d'utilisation extrait l'objet Tax de $request via getTax() et appelle la méthode applicationPersist sur TaxManagerInterface. Ce processus de persistance est encapsulé dans un bloc try-catch pour gérer les exceptions potentielles
• EmptyResultException?: Si l'entité fiscale n'est pas trouvée, cette exception est interceptée et une NotFoundException est levée pour signaler l'erreur.
• FormException?: si la validation du formulaire échoue, une FormException est capturée et les messages d'erreur sont stockés dans une StringCollection.
• Réponse dynamique via une classe anonyme?: une classe anonyme implémente TaxPersistResponseInterface pour renvoyer la réponse du cas d'utilisation. Il comprend les méthodes getTax() et getMessages(), permettant respectivement d'accéder à l'entité fiscale et à tous les messages d'erreur.

Interfaces de cas d'utilisation

Les interfaces définissent les contrats que chaque composant doit respecter, favorisant le découplage et la testabilité.

Interface TaxManager

Cette interface précise les modalités de gestion des taxes, notamment la récupération et la persistance :

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() et findByName()?: Ces méthodes permettent de récupérer une taxe par identifiant ou par nom.
• applicationPersist()?: Cette méthode assure la persistance de l’entité fiscale.

TaxPersistRequestInterface

Cette interface définit la structure de la requête attendue par TaxPersistUseCase?:

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

• getTax()?: Cette méthode renvoie l'entité fiscale à conserver, permettant au cas d'utilisation d'accéder directement à l'objet de domaine concerné. TaxPersistResponseInterface
• L'interface de réponse garantit que TaxPersistUseCase renvoie une réponse conforme?:

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

• getTax()?: renvoie l'entité fiscale persistante ou null si une erreur s'est produite.
• getMessages()?: renvoie une StringCollection contenant des messages d'erreur, si des erreurs de formulaire se sont produites.

Gestion des erreurs et des exceptions

Les exceptions jouent un r?le important dans DDD en capturant les erreurs spécifiques au domaine?:

• BadRequestException?: levée si le cas d'utilisation re?oit une demande d'un type incorrect.
• NotFoundException?: levée lorsque l'entité fiscale recherchée n'est pas trouvée.
• FormException?: intercepté pour gérer les erreurs de validation, avec des messages d'erreur renvoyés dans une StringCollection.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!