Patron Adaptateur

Fait partie de la section Programmation Orientée Objet du Journey PHP de Coddy — leçon 76 sur 91.

Le patron Adaptateur est un patron de conception structurel qui permet à des objets ayant des interfaces incompatibles de travailler ensemble. Il agit comme un pont entre deux interfaces, traduisant les appels d'un format à un autre.

Imaginez que vous construisez une application qui traite des paiements et que vous devez intégrer une bibliothèque de paiement tierce. La bibliothèque fonctionne parfaitement, mais son interface ne correspond pas à ce que votre code attend. Au lieu de réécrire toute votre application, vous créez un adaptateur qui fait la liaison entre les deux.

<?php
// L'interface attendue par votre application
interface PaymentProcessor {
    public function pay(float $amount): string;
}

// Bibliothèque tierce avec une interface différente
class StripeAPI {
    public function createCharge(int $cents, string $currency): string {
        return "Charged {$cents} {$currency} via Stripe";
    }
}

L'adaptateur implémente l'interface attendue tout en utilisant en interne la classe tierce :

<?php
class StripeAdapter implements PaymentProcessor {
    public function __construct(private StripeAPI $stripe) {}
    
    public function pay(float $amount): string {
        $cents = (int)($amount * 100);
        return $this->stripe->createCharge($cents, 'USD');
    }
}

$stripe = new StripeAPI();
$processor = new StripeAdapter($stripe);
echo $processor->pay(29.99);

Résultat :

Charged 2999 USD via Stripe

L'adaptateur convertit les dollars en cents et appelle la méthode appropriée. Le code de votre application ne connaît que PaymentProcessor, restant ainsi totalement ignorant des exigences spécifiques de Stripe. Si vous passez ultérieurement à un autre fournisseur de paiement, il vous suffit de créer un nouvel adaptateur sans modifier votre code existant.

Défi

Facile

Construisons un système de conversion de température en utilisant le Design Pattern Adapter. Vous disposez d'un ancien capteur de température qui fournit des lectures en Fahrenheit, mais votre application météo moderne attend toutes les températures en Celsius. Au lieu de modifier l'un ou l'autre système, vous allez créer un adaptateur qui comble l'écart.

Vous organiserez votre code sur quatre fichiers :

TemperatureSensor.php — Définissez une interface TemperatureSensor que votre application météo attend. Elle doit avoir une méthode getTemperature(): float qui retourne la température en Celsius.
LegacySensor.php — Créez une classe LegacySensor qui simule l'ancien matériel. Cette classe possède une interface différente de celle dont votre application a besoin :
- Elle prend une lecture en Fahrenheit dans son constructeur (utilisez la promotion de constructeur)
- Elle possède une méthode readFahrenheit(): float qui retourne la valeur Fahrenheit stockée
LegacySensorAdapter.php — Incluez à la fois l'interface TemperatureSensor et la classe LegacySensor. Créez une classe LegacySensorAdapter qui implémente TemperatureSensor et enveloppe un LegacySensor. Votre adaptateur doit :
- Accepter un LegacySensor dans son constructeur
- Implémenter getTemperature() en lisant la valeur Fahrenheit du capteur hérité et en la convertissant en Celsius à l'aide de la formule : (fahrenheit - 32) * 5 / 9
main.php — Incluez le fichier LegacySensorAdapter. Vous recevrez une entrée : une température en Fahrenheit.
Créez un LegacySensor avec la température d'entrée, puis enveloppez-le dans un LegacySensorAdapter. Appelez getTemperature() sur l'adaptateur et affichez le résultat arrondi à deux décimales.

Le format de sortie doit être : Temperature: [celsius]C

Ce défi démontre comment le Pattern Adapter vous permet d'intégrer des interfaces incompatibles sans modifier le code existant. Votre application météo travaille exclusivement avec l'interface TemperatureSensor, ignorant totalement que les lectures réelles proviennent d'un ancien capteur Fahrenheit.

Aide-mémoire

Le Pattern Adaptateur (Adapter Pattern) est un patron de conception structurel qui permet à des objets ayant des interfaces incompatibles de travailler ensemble en agissant comme un pont entre eux.

Structure de base

Définissez l'interface attendue par votre application :

<?php
interface PaymentProcessor {
    public function pay(float $amount): string;
}

Une classe tierce avec une interface différente :

<?php
class StripeAPI {
    public function createCharge(int $cents, string $currency): string {
        return "Charged {$cents} {$currency} via Stripe";
    }
}

Création de l'adaptateur

L'adaptateur implémente l'interface attendue tout en utilisant en interne la classe tierce :

<?php
class StripeAdapter implements PaymentProcessor {
    public function __construct(private StripeAPI $stripe) {}
    
    public function pay(float $amount): string {
        $cents = (int)($amount * 100);
        return $this->stripe->createCharge($cents, 'USD');
    }
}

Utilisation

$stripe = new StripeAPI();
$processor = new StripeAdapter($stripe);
echo $processor->pay(29.99);
// Résultat : Charged 2999 USD via Stripe

L'adaptateur effectue la traduction entre les interfaces, permettant au code de votre application de rester inchangé lors de l'intégration de bibliothèques tierces ou du changement d'implémentations.

Essayez vous-même

<?php
require_once 'LegacySensorAdapter.php';

// Lire l'entrée
$fahrenheit = floatval(trim(fgets(STDIN)));

// TODO : Créer un LegacySensor avec la température d'entrée
// TODO : L'envelopper dans un LegacySensorAdapter
// TODO : Appeler getTemperature() sur l'adaptateur
// TODO : Afficher le résultat arrondi à deux décimales
// Format de sortie : Temperature: [celsius]C

?>