Qu'est-ce que le motif adaptateur?

Le pattern adaptateur (Adapter Pattern) est un pattern de conception structurel qui permet à des classes avec des interfaces incompatibles de travailler ensemble. Il agit comme une enveloppe qui transforme l'interface d'une classe en une autre attendue par le client.

Applications :

• Intégration de bibliothèques tierces avec des interfaces incompatibles.
• Utilisation de classes existantes dans de nouveaux systèmes sans les modifier.
• Assurer l'interaction entre des classes développées indépendamment.

Exemple d'implémentation (adaptateur d'objet) :

Supposons qu'il existe une classe LegacyService avec une méthode oldRequest() :

class LegacyService {
    public void oldRequest() {
        // code ancien
    }
}

Et une nouvelle interface NewService avec une méthode newRequest() :

interface NewService {
    void newRequest();
}

L'adaptateur ServiceAdapter implémente NewService et contient une référence à LegacyService :

class ServiceAdapter implements NewService {
    private LegacyService legacyService;

    public ServiceAdapter(LegacyService legacyService) {
        this.legacyService = legacyService;
    }

    @Override
    public void newRequest() {
        // Transformation de l'appel de la nouvelle méthode en l'ancienne
        legacyService.oldRequest();
    }
}

Le client peut utiliser LegacyService via l'interface NewService :

NewService service = new ServiceAdapter(new LegacyService());
service.newRequest(); // Appelle oldRequest() dans LegacyService

Il existe aussi une variante — adaptateur de classe, qui utilise l'héritage multiple (si le langage le supporte) ou l'héritage de la classe à adapter et l'implémentation de l'interface cible. En Java, en raison de l'absence d'héritage multiple, cela se fait par héritage de la classe à adapter et l'implémentation de l'interface de l'adaptateur, mais cette approche est moins flexible. L'adaptateur d'objet est préféré car il permet d'adapter des sous-classes et d'éviter une liaison rigide.

Avantages :

• Permet la réutilisation de classes incompatibles.
• Encapsule les détails de la transformation d'interfaces.
• Améliore la flexibilité du système.

Inconvénients :

• Peut augmenter la complexité en ajoutant une nouvelle classe.
• La performance peut légèrement diminuer en raison d'un niveau supplémentaire d'abstraction.