Dans les articles précédents, nous avons exploré deux méthodes différentes pour gérer le traitement des paiements dans Laravel :

• liaison de service codée en dur
• liaison contextuelle.

Bien que les deux méthodes soient efficaces, elles ont leurs limites lorsqu'il s'agit de sélectionner dynamiquement les processeurs de paiement en fonction des conditions d'exécution (par exemple, saisie utilisateur, paramètres de configuration).

Dans cette troisième et dernière partie, nous examinerons une approche plus flexible : l'utilisation du Factory Pattern. Ce modèle de conception nous permet de choisir l'implémentation appropriée de PaymentProcessorInterface en fonction du contexte (par exemple, choisir entre Stripe ou PayPal en fonction de la demande).

Implémentation du modèle d'usine

Le modèle Factory fournit une solution évolutive pour résoudre dynamiquement différentes implémentations au moment de l'exécution. Voici comment le configurer étape par étape.

Étape 1 : Créer une interface d'usine

Tout d'abord, définissons une PaymentProcessorFactoryInterface qui décrit comment résoudre différents processeurs de paiement.

Cette interface garantit que toute usine que nous créons aura une méthode getProcessor, chargée de renvoyer le processeur de paiement approprié en fonction de l'argument fourni (par exemple, « stripe » ou « paypal »).


  
  
  Étape 2 : Créer l'implémentation d'usine


Ensuite, nous mettrons en œuvre l'usine qui résout le processeur de paiement approprié en fonction des informations fournies par le fournisseur.


Cette usine sélectionne dynamiquement le processeur de paiement correct en fonction de l'entrée fournie lors de l'exécution. Dans cet exemple, nous renvoyons directement de nouvelles instances de StripePaymentProcessor et PayPalPaymentProcessor. Si nécessaire, ces classes peuvent également être résolues à partir du conteneur de services de Laravel pour une meilleure gestion.


  
  
  Étape 3 : Implémenter les processeurs Stripe et PayPal


Assurez-vous que vous disposez des classes StripePaymentProcessor et PayPalPaymentProcessor qui implémentent PaymentProcessorInterface.

Exemple : StripePaymentProcessor


Exemple : PayPalPaymentProcessor

De même, implémentez la classe PayPalPaymentProcessor, en suivant le même modèle que StripePaymentProcessor.


  
  
  Étape 4 : lier l'usine dans le conteneur de services


Pour garantir que l'usine est disponible dans toute votre application Laravel, vous devez lier PaymentProcessorFactory au conteneur de service de Laravel. Vous pouvez le faire dans AppServiceProvider.

Dans App\Providers\AppServiceProvider.php, ajoutez ce qui suit dans la méthode de registre :


public function register()
{
    $this->app->singleton(\App\Contracts\PaymentProcessorFactoryInterface::class, \App\Services\PaymentProcessorFactory::class);
}




Cette liaison indique à Laravel d'utiliser PaymentProcessorFactory chaque fois que PaymentProcessorFactoryInterface est demandée, garantissant ainsi qu'il n'y a qu'une seule instance de l'usine dans toute l'application.


  
  
  Étape 5 : Utilisation de Factory dans un contrôleur


Maintenant que l'usine est configurée, vous pouvez l'injecter dans vos contrôleurs pour sélectionner dynamiquement le processeur de paiement approprié en fonction des données d'exécution, telles que l'entrée de la requête.

Exemple : Contrôleur de paiement


paymentProcessorFactory = $paymentProcessorFactory;
    }

    public function makePayment(Request $request)
    {
        $provider = $request->input('provider'); // E.g., 'stripe' or 'paypal'
        $amount = $request->input('amount');
        $currency = $request->input('currency');
        $paymentDetails = $request->input('details');

        // Get the appropriate payment processor based on the provider
        $paymentProcessor = $this->paymentProcessorFactory->getProcessor($provider);

        // Use the selected payment processor to create a payment
        $response = $paymentProcessor->createPayment($amount, $currency, $paymentDetails);

        return response()->json($response);
    }
}




Dans ce contrôleur, nous injectons la PaymentProcessorFactoryInterface via l'injection de dépendances. Lorsqu'un paiement est demandé, nous déterminons le fournisseur de paiement (par exemple, Stripe ou PayPal) à partir de la demande, le transmettons à l'usine et résolvons dynamiquement le processeur de paiement approprié.


  
  
  Étape 6 : Gérer différents fournisseurs de paiement


Dans cette configuration, le contrôleur peut désormais gérer dynamiquement différents fournisseurs de paiement en changeant simplement le nom du fournisseur dans la demande. Cette méthode est particulièrement puissante lorsque vous devez gérer plusieurs passerelles de paiement sans dupliquer la logique ni coupler étroitement votre code à des implémentations spécifiques.


  
  
  Conclusion


L'utilisation du modèle Factory dans Laravel 11 offre une approche très flexible pour sélectionner différents processeurs de paiement au moment de l'exécution. Voici un résumé des étapes que nous avons couvertes :

• Interface et implémentation d'usine : création d'une usine qui résout dynamiquement le processeur de paiement correct en fonction d'une entrée de chaîne.
• Implémentations du processeur : garantie que les classes StripePaymentProcessor et PayPalPaymentProcessor implémentent PaymentProcessorInterface.
• Liaison du conteneur de service : relie l'usine au conteneur de service pour permettre une injection facile dans toute l'application. Sélection dynamique dans les contrôleurs : utilisation de l'usine à l'intérieur d'un contrôleur pour sélectionner et utiliser dynamiquement le processeur de paiement approprié en fonction des données d'exécution.

Principes de conception de logiciels et modèles de conception

Nous avons commencé ce didacticiel en 3 parties en utilisant un seul processeur de paiement, avec une sélection codée en dur, puis nous avons utilisé une configuration dans le code ("temps de compilation") en utilisant Laravel Service Container Binding, puis dans cette partie, nous avons continué à refactoriser avec le design principes et modèles de conception à l'esprit, ce qui nous a permis de refactoriser le code, obtenant :

• Flexibilité dynamique : le modèle d'usine permet la sélection de différents processeurs de paiement au moment de l'exécution, ce qui rend votre application plus flexible et évolutive.
• Couplage lâche : en injectant l'usine, vos contrôleurs sont faiblement couplés aux processeurs de paiement, ce qui facilite l'ajout ou le remplacement de passerelles de paiement à l'avenir.
• Maintenabilité : cette approche fournit une base de code plus propre et plus maintenable, en particulier lorsqu'il s'agit de plusieurs options de paiement.

Avec cette configuration, nous disposons désormais d'un système puissant et flexible pour gérer les paiements dans Laravel. Si nous avons besoin de prendre en charge des processeurs supplémentaires, nous pouvons facilement étendre l'usine pour prendre en charge et modifier la logique de sélection des fournisseurs et gérer différents scénarios de logique métier.