Quelle est la différence entre le modèle de façade et d'adaptateur?

J'ai lu les deux définitions et elles semblent tout à fait identiques. Quelqu'un pourrait-il indiquer quelles sont leurs différences?

Merci

La page wiki de Facade Pattern contient une brève note à ce sujet.

"Un Adapter est utilisé lorsque le wrapper doit respecter une interface particulière et doit supporter un comportement polymorphe. Par contre, une façade est utilisée lorsque l'on veut une interface plus facile ou plus simple avec laquelle travailler."

J'ai entendu une analogie selon laquelle vous devriez penser à votre télécommande universelle que vous avez configurée pour fonctionner avec tous vos différents systèmes stéréo - vous appuyez sur «on» et elle allume votre décodeur câble, votre récepteur et votre téléviseur. Peut-être que c'est un cinéma maison vraiment sophistiqué et qu'il atténue les lumières et dessine aussi les nuances. C'est une façade - un bouton / une fonction qui prend en charge un ensemble d'étapes plus compliqué.

Le modèle d'adaptateur relie simplement deux interfaces incompatibles.

EDIT: Une analogie rapide pour le modèle d'adaptateur (basé sur les commentaires) pourrait être quelque chose comme un adaptateur DVI-VGA. Les cartes vidéo modernes sont souvent DVI, mais vous avez un ancien moniteur VGA. Avec un adaptateur qui se branche sur l'entrée DVI attendue de votre carte vidéo et qui possède sa propre entrée VGA, vous pourrez faire fonctionner votre ancien moniteur avec votre nouvelle carte vidéo.

Adaptateur == permettant à une cheville carrée de s'insérer dans un trou rond.

Façade == un seul panneau de contrôle pour exécuter tous les composants internes.

Honnêtement, de nombreux modèles pourraient être implémentés de la même manière par programme - la différence réside dans l'intention.

Le modèle de conception de l'adaptateur est destiné à «traduire» l'interface d'une ou plusieurs classes en une interface que le client s'attend à utiliser - l'adaptateur traduirait les appels à l'interface attendue dans l'interface réelle que les classes encapsulées utilisent.

Le modèle Facade est utilisé lorsqu'une interface plus simple est souhaitée (et encore une fois, pourrait être implémentée de la même manière en enveloppant les classes offensantes.) Vous ne diriez pas que vous utilisez une façade lorsque l'interface existante est incompatible, juste au moment où vous en avez besoin. pour le rendre plus lisible, moins mal conçu, etc.

Façade:

Points clés à retenir: (extrait de l' article journaldev de Pankaj Kumar)

1. Le modèle de façade ressemble plus à une aide pour les applications clientes
2. Le modèle de façade peut être appliqué à n'importe quel point de développement, généralement lorsque le nombre d'interfaces augmente et que le système devient complexe .
3. Les interfaces du sous-système ne connaissent pas Facade et ne doivent pas avoir de référence à l'interface Facade
4. Le modèle de façade doit être appliqué pour des types d'interfaces similaires , son but est de fournir une interface unique plutôt que plusieurs interfaces qui effectuent le même type de travail

Diagramme de classe de façade:

Adaptateur:

1. C'est un modèle structurel
2. Il est utile de travailler avec deux interfaces incompatibles
3. Cela fait fonctionner les choses après leur conception

Diagramme de classe de l'adaptateur:

Vous pouvez trouver plus de détails sur l'adaptateur dans cet article SE:

Différence entre le modèle de pont et le modèle d'adaptateur

Principales différences:

1. Facade définit une nouvelle interface, tandis que Adapter utilise une ancienne interface . L'adaptateur permet à deux interfaces existantes de fonctionner ensemble au lieu d'en définir une entièrement nouvelle
2. L'adaptateur et la façade sont tous deux des emballages; mais ce sont différents types d'emballages. L'intention de Facade est de produire une interface plus simple, et l'intention de Adapter est de concevoir une interface existante

Jetez également un œil à l' article sur la création de sources pour une meilleure compréhension.

Une façade est conçue pour organiser plusieurs services derrière une seule passerelle de service. Un adaptateur est conçu pour fournir un moyen d'utiliser une interface connue pour accéder à une interface inconnue.

Le but d'un

la façade est la simplicité

l'adaptateur est l' interopérabilité .

La façade est généralement contrastée avec l'adaptateur.

+--------------------------------------------------------------+-----------------------------------------------+
|                            Facade                            |                    Adapter                    |
+--------------------------------------------------------------+-----------------------------------------------+
| Simplifies multiple complex components with single interface | Provides differnet interface for an interface |
| Works with multiple components                               | Works with single component                   |
| Control panel is an example                                  | A power adapter is an example                 |
| High-level interface                                         | Low-level interface                           |
+--------------------------------------------------------------+-----------------------------------------------+

Comme d'habitude, il existe des similitudes entre plusieurs modèles. Mais je le verrais comme ceci:

• Une façade est utilisée pour encapsuler une couche entière, et offre des méthodes pour y accéder «commodément»
• Un adaptateur est utilisé, où vous avez deux composants qui devraient déjà fonctionner ensemble, mais ne le font pas, uniquement à cause de certaines différences "sans importance" dans l'interface.

Je vais essayer d'expliquer cela en termes clairs, sans trop de formalités.

Imaginez que vous avez des classes de domaine et que vous souhaitez interagir avec elles depuis l'interface utilisateur. Une façade peut être utilisée pour fournir des fonctions qui peuvent être appelées à partir de la couche d'interface utilisateur afin que la couche d'interface utilisateur ne connaisse aucune classe de domaine autre que la façade. Cela signifie qu'au lieu d'appeler les fonctions dans les classes de domaine, vous appelez une seule fonction depuis la façade, qui sera responsable d'appeler les fonctions nécessaires depuis les autres classes.

Un adaptateur, par contre, peut être utilisé pour intégrer d'autres composants externes qui pourraient avoir les mêmes fonctionnalités dont vous avez besoin, mais leurs fonctions ne sont pas appelées tout à fait de la même manière. Supposons que vous ayez une Carclasse dans votre domaine et que vous travaillez avec un fournisseur de voiture externe qui a également défini une classe de voiture. Dans cette classe, vous avez la fonction car.getDoors()mais le fournisseur externe a l'équivalent car.getNumDoors(). Vous ne souhaitez pas modifier la façon dont vous appelez cette fonction, vous pouvez donc utiliser une classe d'adaptateur pour encapsuler la classe Car externe afin qu'un appel à getDoors()de l'adaptateur soit délégué à getNumDoors()de la classe externe.

Le modèle d'adaptateur permet à deux interfaces, auparavant incompatibles, de fonctionner l'une avec l'autre. Dispose de 2 interfaces distinctes en jeu.

Le modèle de façade prend une interface connue, qui est de bas niveau / à grain fin, et l'enveloppe avec une interface à grain de niveau / cours supérieur. A une seule interface, qui a été simplifiée en enveloppant avec une autre.

L'adaptateur permet à deux interfaces de fonctionner ensemble.

La façade expose une seule classe à un niveau plus élevé et plus limité. Par exemple, une façade de modèle de vue peut uniquement exposer certaines propriétés en lecture seule d'une classe de niveau inférieur.

Façade

Abstruit la complexité pour fournir une interface plus simple. Disons, par exemple, qu'un système d'exploitation d'ordinateur fait abstraction de la complexité du matériel sous-jacent. Ou un langage de programmation de haut niveau (Python / JavaScript) résume la complexité par rapport à un langage de bas niveau (C).

Adaptateur

Ce sont des analogues à des adaptateurs matériels. Disons que vous voulez connecter un USB deviceà un serial port, vous aurez besoin d'un USB-serial port adapter.

Le modèle d'adaptateur relie deux interfaces incompatibles en fournissant une nouvelle interface.

Le modèle de façade simplifie un sous-système complexe (ayant plusieurs composants) avec une seule interface.

La différence entre ces deux modèles est claire, mais pas dans le domaine des modèles de conception, mais de la modélisation de domaine. Dans ce qui suit, je vais vous expliquer pourquoi.

Tout d'abord, je tiens à répéter que d'autres ont dit ici, puis j'ajouterai la note:

Une façade est une interface vers un sous-système (un système externe ou hérité) qui simplifie l'accès pour le client (nous). Facade masque l'interface de l'autre sous-système (regroupez certains appels ou masquez certaines API dont nous n'avons pas besoin), ainsi votre client accède uniquement à ce sous-système via cette façade.

D'un autre côté, un adaptateur est un wrapper autour d'un autre service ou objet. Il rend l'objet encapsulé conforme à une interface standard attendue par le client. Disons qu'il existe une méthode sur l'objet "Ledger", dont vous avez besoin pour faire un tweak (changer ses paramètres, changer son nom, etc.). Vous pouvez l'envelopper avec un adaptateur.

Maintenant, la différence n'est peut-être pas claire. C'est là que je veux évoquer la principale différence entre ces deux modèles, ne laissant aucune place à une confusion supplémentaire :

Facade ne modifie pas le modèle de domaine de l'autre sous-système, contrairement à Adapter. C'est la principale différence. Période.

C'est pourquoi vous combinez ces deux éléments lorsque vous créez une couche anticorruption . Disons que vous avez un sous-système que vous souhaitez utiliser, mais que vous ne voulez pas que son modèle de domaine embrouille votre modèle de domaine. Qu'est-ce que tu ferais? Vous créeriez une couche anticorruption. Comment? Vous créez d'abord une façade, qui simplifie l'accès à l'interface pour le sous-système, puis des adaptateurs pour les objets de domaine utilisés dans cette interface (rappelez-vous que la façade contient toujours le modèle de domaine pour l'autre sous-système), afin qu'elle soit conforme à votre modèle.

De nombreux modèles de conception peuvent être utilisés dans la modélisation de domaine. Cela est également vrai pour les modèles de conception de façade et d'adaptateur. Bien que la différence entre ces deux modèles puisse ne pas être claire dans le domaine du «modèle de conception», elle est plus claire dans le domaine de la «modélisation de domaine».

J'ai lu les deux définitions et elles semblent tout à fait identiques.

Vraiment ?

J'ai remarqué que le terme adaptateur est parfois utilisé pour décrire ce qui est en fait une stratégie , peut-être parce que le mot est plus expressif.

Par exemple, dans Zend Framework , toutes les classes Adapter sont en fait des implémentations du modèle Strategy , car elles n'enveloppent que le code natif derrière les classes, pour avoir plusieurs comportements.

Les adaptateurs sont souvent utilisés pour encapsuler du code hérité ou «ancien».

L'objectif principal du modèle de façade est de rendre la classe ou le sous-système plus facile à utiliser, tandis que l'objectif principal du modèle d' adaptateur est d'ajuster l'interface à ce que le client attend.