Accueil/Notions/Pattern Adapter (Wrapper)

Pattern Adapter (Wrapper)

Le pattern Adapter, aussi connu sous le nom de Wrapper, est un modèle de conception (Design Patterns) structurel en programmation. Il permet d'adapter l'interfaces (programmation) d'une classes (programmation) existante à une autre interface attendue. Ce pattern est particulièrement utile lorsque tu souhaites utiliser une classe existante mais son interface ne correspond pas à celle dont tu as besoin.

Exemple en TypeScript

Imaginons que tu aies une interfaces (programmation) LightningPort que ton iPhone utilise pour se charger, et tu veux charger ton téléphone avec un chargeur qui a une sortie USBPort. Les interfaces ne sont pas compatibles, donc directement, tu ne peux pas charger ton téléphone. Voici comment le pattern Adapter peut résoudre ce problème :

// Interface que le client utilise
interface LightningPort {
    connectLightning(): void;
}

// Service qui est déjà disponible
interface USBPort {
    connectUSB(): void;
}

// Classe concrète utilisant USB
class Charger implements USBPort {
    connectUSB() {
        console.log("Connecteur USB branché et en cours de chargement");
    }
}

// Adapter
class LightningToUSBAdapter implements LightningPort {
    private usbDevice: USBPort;

    constructor(usbDevice: USBPort) {
        this.usbDevice = usbDevice;
    }

    connectLightning() {
        console.log("Adaptateur Lightning vers USB utilisé");
        this.usbDevice.connectUSB();
    }
}

// Utilisation de l'adaptateur
let usbCharger = new Charger();
let adapter = new LightningToUSBAdapter(usbCharger);
adapter.connectLightning();  // Adaptateur Lightning vers USB utilisé, Connecteur USB branché et en cours de chargement

Explication

  1. Interfaces et Classes Concrètes : LightningPort et USBPort sont des interfaces pour des types de connexion spécifiques. Charger est une implémentation concrète de USBPort.

  2. Adapter : LightningToUSBAdapter est l'adaptateur qui implémente LightningPort, l'interface requise par le client (ton iPhone dans cet exemple). Cet adaptateur contient une référence à un objet qui implémente USBPort. Quand la méthode connectLightning est appelée sur l'adaptateur, celui-ci utilise cette référence pour appeler connectUSB sur l'objet USBPort.

  3. Utilisation : Tu crées un Charger (qui est un USBPort), puis tu passes cet objet à un nouvel LightningToUSBAdapter. Quand tu appelles connectLightning sur l'adaptateur, il délègue l'appel à connectUSB du chargeur USB.

Ce pattern te permet d'intégrer des classes qui n'auraient pas pu être utilisées ensemble autrement, en raison de différences d'interface, sans modifier leur code source. C'est un moyen élégant de réutiliser des objets existants.

Pour approfondir ta compréhension des Design Patterns|patterns de conception et des concepts avancés en programmation, voici une liste de notions intéressantes à explorer :

  1. Pattern Singleton : Un modèle qui garantit qu'une classe a une seule instance, tout en fournissant un point d'accès global à cette instance.

  2. Pattern Factory : Un modèle qui permet de créer des objets sans spécifier la classe exacte de l'objet qui sera créé.

  3. Pattern Abstract Factory : Une extension du pattern Factory qui permet de créer des familles d'objets apparentés sans préciser leur classe concrète.

  4. Pattern Builder : Sépare la construction d'un objet complexe de sa représentation, permettant ainsi le même processus de construction de servir à créer différentes représentations.

  5. Pattern Prototype : Un modèle de création d'objet basé sur la copie d'un objet existant au lieu de créer de nouveaux objets et de configurer leurs propriétés à partir de zéro.

  6. Pattern Observer : Un modèle de conception dans lequel un sujet maintient une liste d'observateurs, et les notifie automatiquement de tout changement d'état, souvent utilisé dans la programmation GUI.

  7. Pattern Stratégie (Strategy) : Permet de définir une famille d'algorithmes, encapsuler chaque un, et les rendre interchangeables. La stratégie permet à l'algorithme de varier indépendamment des clients qui l'utilisent.

  8. Pattern Command : Transforme une requête en un objet autonome qui contient toute l'information nécessaire à la requête. Cela permet de paramétrer des méthodes avec des requêtes, de mettre en file d'attente ou d'exécuter des opérations asynchrones.

  9. Pattern Decorator : Permet d'ajouter dynamiquement de nouvelles responsabilités à des objets en les enveloppant dans des objets-utilitaires.

  10. Pattern Façade : Fournit une interface unifiée vers un ensemble d'interfaces dans un sous-système. Façade définit une interface de niveau supérieur qui rend le sous-système plus facile à utiliser.

  11. Pattern Proxy : Fournit un substitut ou un placeholder pour un autre objet afin de contrôler l'accès à celui-ci, utile pour la gestion de coûts opérationnels lourds ou la sécurisation.

  12. Pattern State : Permet à un objet de modifier son comportement lorsque son état interne change, semblant ainsi changer de classe.

  13. Pattern Flyweight : Utilisé pour minimiser l'utilisation de la mémoire ou les coûts de calcul en partageant autant que possible avec des objets similaires.

  14. Pattern Composite : Compose des objets en structures d'arbre pour représenter des hiérarchies partie-tout. Permet aux clients de traiter des objets individuels et des compositions de manière uniforme.

  15. Principes SOLID : Un ensemble de cinq principes de conception orientée objet qui visent à rendre les logiciels plus compréhensibles, flexibles et maintenables.

Chacune de ces notions peut t'ouvrir à des approches plus sophistiquées et efficaces de la conception logicielle, te permettant de créer des systèmes robustes et évolutifs.