Comment ajouter et implémenter des interfaces de traitement des paiements dans Laravel The Part avec liaison codée en dur

Dans cet article de blog, nous explorerons comment faire la première étape dans l'ajout et la mise en œuvre d'une interface de traitement des paiements dans une application Laravel 11. Nous allons commencer par créer une liaison codée en dur entre PaymentProcessorInterface et une implémentation spécifique, telle que StripePaymentProcessor. Cette approche est une configuration fondamentale, jetant les bases de techniques plus avancées telles que la liaison dynamique et l'utilisation d'usines, que nous aborderons dans les prochains articles.

Étape 1 : Créer le répertoire des contrats (s'il n'existe pas)

Laravel encourage une base de code propre et organisée. Lors de l’implémentation des interfaces, nous les placerons généralement dans le répertoire AppContracts.

Si le répertoire Contrats n'existe pas encore dans notre application, nous pouvons le créer en exécutant la commande suivante dans le terminal :

mkdir app/Contracts

Ce répertoire servira d'emplacement à toutes nos interfaces d'application, en les gardant séparées des implémentations concrètes.

Étape 2 : Enregistrez l'interface PaymentProcessor dans le répertoire des contrats

Maintenant que nous avons le répertoire Contracts, créons un nouveau fichier dans lequel vivra PaymentProcessorInterface. Pour ce faire, exécutez la commande suivante :

touch app/Contracts/PaymentProcessorInterface.php

Cela créera un fichier vide que nous remplirons à l'étape suivante.

Étape 3 : Définir l’interface PaymentProcessor

Dans notre fichier PaymentProcessorInterface.php nouvellement créé, définissez l'interface comme suit :

<?php

namespace App\Contracts;

interface PaymentProcessorInterface
{
    public function createPayment(float $amount, string $currency, array $paymentDetails): array;
    public function processPayment(array $paymentData): array;
    public function refundPayment(string $transactionId, float $amount): bool;
}

Cette interface agira comme un contrat, garantissant que toute classe la mettant en œuvre contiendra les méthodes nécessaires à la création, au traitement et au remboursement des paiements.

Étape 4 : Implémentation de l'interface dans une classe de service

Une fois PaymentProcessorInterface définie, l'étape suivante consiste à créer une classe qui implémente cette interface. En règle générale, nous placerons cette implémentation dans le répertoire app/Services.

Par exemple, créons une classe StripePaymentProcessor qui implémente cette interface. Nous pouvons créer le fichier en exécutant :

touch app/Services/StripePaymentProcessor.php

Ensuite, implémentez la classe comme indiqué ci-dessous :

<?php

namespace App\Services;

use App\Contracts\PaymentProcessorInterface;

class StripePaymentProcessor implements PaymentProcessorInterface
{
    public function createPayment(float $amount, string $currency, array $paymentDetails): array
    {
        // Stripe-specific payment creation logic
    }

    public function processPayment(array $paymentData): array
    {
        // Stripe-specific payment processing logic
    }

    public function refundPayment(string $transactionId, float $amount): bool
    {
        // Stripe-specific payment refund logic
    }
}

Cette classe contient désormais les méthodes nécessaires pour créer, traiter et rembourser les paiements via l'API de Stripe. Nous pouvons remplacer ou étendre cela avec d'autres processeurs de paiement selon les besoins en créant des classes supplémentaires implémentant la même interface.

Étape 5 : Liaison de l'interface dans le conteneur de services (codé en dur)

Maintenant que l'interface et son implémentation sont prêtes, nous devons indiquer à Laravel comment résoudre le PaymentProcessorInterface. Dans cette première étape, nous utiliserons une liaison codée en dur en liant explicitement l'interface à une implémentation spécifique dans le conteneur de services de Laravel.

Pour ce faire, nous pouvons modifier l'AppServiceProvider ou créer un nouveau fournisseur de services.

Dans app/Providers/AppServiceProvider.php, ajoutez le code suivant dans la méthode de registre :

public function register()
{
    $this->app->bind(
        \App\Contracts\PaymentProcessorInterface::class,
        \App\Services\StripePaymentProcessor::class
    );
}

Cette liaison indique à Laravel que chaque fois que PaymentProcessorInterface est requise, elle doit automatiquement injecter la classe StripePaymentProcessor. Bien que cette approche fonctionne, elle est limitée car elle lie une implémentation spécifique à l'interface.

Cette liaison codée en dur est un excellent point de départ, mais elle n’offre pas la flexibilité requise pour les applications plus volumineuses ou lors de la prise en charge de plusieurs processeurs de paiement. Dans la prochaine partie de cette série, nous explorerons comment réaliser une liaison dynamique à l'aide du conteneur de services et des usines de Laravel, permettant au système de sélectionner différentes implémentations au moment de l'exécution en fonction de la passerelle de paiement nécessaire :

• Liaison dynamique : permet plusieurs implémentations pour différents processeurs de paiement.
• Modèle d'usine : utilisation d'usines pour sélectionner le processeur de paiement approprié en fonction des conditions d'exécution.

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!