Adapter

Le pattern Adapter en PHP est un design pattern structurel qui permet de convertir l’interface d’une classe en une autre interface que le client attend. Il permet de faire travailler ensemble des classes incompatibles en encapsulant la logique de conversion dans un objet adaptateur. En utilisant ce pattern, on peut réduire la dépendance entre les classes et rendre notre code plus flexible et réutilisable.

Problème

Le pattern Adapter résout le problème de compatibilité entre les interfaces de classes incompatibles.

Dans certains cas, le client d’une classe ne peut pas utiliser directement une méthode de cette classe parce que l’interface de la méthode ne correspond pas à l’interface attendue par le client.

L’adaptateur permet de convertir l’interface d’une classe en une autre interface que le client attend, de sorte que le client peut utiliser la classe sans avoir à modifier son propre code. Le pattern Adapter permet donc d’adapter des classes existantes pour qu’elles puissent travailler ensemble de manière transparente, sans avoir à modifier leur code source.

Solution

Le pattern Adapter propose une solution de conception qui permet d’adapter des classes incompatibles en encapsulant la logique de conversion dans un objet adaptateur.

L’adaptateur agit comme un intermédiaire entre le client et l’objet à adapter, en convertissant l’interface de l’objet en une autre interface que le client attend. Cette approche permet de réduire la dépendance entre les classes et de rendre le code plus flexible et réutilisable.

Le pattern Adapter est donc une solution élégante pour résoudre les problèmes de compatibilité entre les interfaces de classes incompatibles.

Analogie

On peut comparer le pattern Adapter à un serveur dans un restaurant qui parle deux langues différentes. Si un client ne parle pas la même langue que le serveur, il ne pourra pas commander efficacement et cela créera des problèmes de communication.

Cependant, si le serveur est équipé d’un adaptateur, sous la forme d’un traducteur ou d’un collègue qui parle la langue du client, le client pourra commander sans problème.

De même, le pattern Adapter permet à une classe qui n’a pas la bonne interface de travailler avec une autre classe en convertissant son interface en une interface compatible, tout comme le serveur adapte sa langue pour communiquer avec le client.

Implémentation

La méthodologie d’implémentation du pattern Adapter se divise généralement en quatre étapes :

• Identifier les classes incompatibles : la première étape consiste à identifier les classes qui ont des interfaces incompatibles, mais qui doivent travailler ensemble.
• Créer l’interface cible : la deuxième étape consiste à définir l’interface que le client attend. Cette interface sera utilisée pour communiquer avec l’objet adapté.
• Implémenter l’adaptateur : la troisième étape consiste à créer une classe adaptateur qui implémente l’interface cible et qui encapsule l’objet à adapter. L’adaptateur convertit l’interface de l’objet en une interface compatible avec l’interface cible.
• Utiliser l’adaptateur : la quatrième étape consiste à utiliser l’objet adapté via l’adaptateur. Le client utilise l’interface cible pour interagir avec l’adaptateur, qui se charge de communiquer avec l’objet à adapter en utilisant son interface d’origine.

En suivant cette méthodologie, on peut implémenter le pattern Adapter de manière efficace et créer un code plus flexible et réutilisable.

Supposons que nous avons une interface « Forme » qui définit une méthode « dessiner » pour dessiner différentes formes géométriques, telles que des cercles et des carrés.

//  Notre interface Forme pour dessiner des formes
interface Forme {
    public function dessiner();
}

Nous avons une classe « Cercle » qui implémente cette interface et qui a une méthode « dessinerCercle » pour dessiner un cercle.

// Une classe Cercle qui respecte l'interface Forme
class Cercle implements Forme {
    public function dessinerCercle() {
        echo "J'ai dessiné un cercle! \n";
    }

    public function dessiner() {
        $this->dessinerCercle();
    }
}

Maintenant, nous avons une autre classe « Carre » qui a une méthode « dessinerCarre » pour dessiner un carré.

// Une interface Carre qui dessine des carrés mais ne respecte pas l'interface Forme
class Carre {
    public function dessinerCarre() {
        echo "J'ai dessiné un carré! \n";
    }
}

Le problème est que la classe « Carre » ne peut pas être utilisée directement avec la classe « Forme » car elle ne respecte pas l’interface « Forme ». C’est là que le pattern Adapter intervient.

Nous allons créer une classe « AdaptateurCarre » qui implémente l’interface « Forme » et qui utilise la méthode « dessinerCarre » de la classe « Carre » pour dessiner un carré.

class AdaptateurCarre implements Forme {
    private $carre;

    public function __construct($carre) {
        $this->carre = $carre;
    }

    public function dessiner() {
        $this->carre->dessinerCarre();
    }
}

Maintenant, nous pouvons utiliser la classe « AdaptateurCarre » avec la classe « Forme » pour dessiner un carré.

$cercle = new Cercle();
$cercle->dessiner(); // Dessine un cercle

$carre = new Carre();
$adaptateurCarre = new AdaptateurCarre($carre);
$adaptateurCarre->dessiner(); // dessine un carré

Ainsi, nous avons utilisé le pattern Adapter pour adapter une classe qui ne respecte pas une interface à une autre classe qui utilise cette interface.