Qual è la differenza tra Facade e Adapter Pattern?

Ho letto entrambe le definizioni e sembrano più o meno la stessa cosa. Qualcuno potrebbe sottolineare quali sono le loro differenze?

Grazie

La pagina wiki Facade Pattern contiene una breve nota a riguardo.

"Un adattatore viene utilizzato quando il wrapper deve rispettare una particolare interfaccia e deve supportare un comportamento polimorfico. D'altra parte, una facciata viene utilizzata quando si desidera un'interfaccia più facile o più semplice con cui lavorare."

Ho sentito un'analogia secondo cui dovresti pensare al tuo telecomando universale che hai impostato per funzionare con tutti i tuoi diversi sistemi stereo: premi "on" e si accende il decoder via cavo, il ricevitore e la TV. Forse è un home theater davvero stravagante e abbassa le luci e disegna anche le ombre. Questa è una facciata: un pulsante / funzione che si occupa di una serie di passaggi più complicati.

Il pattern Adapter collega solo due interfacce incompatibili.

EDIT: Una rapida analogia per il pattern Adapter (basata sui commenti) potrebbe essere qualcosa di simile a un adattatore DVI-VGA. Le schede video moderne sono spesso DVI, ma hai un vecchio monitor VGA. Con un adattatore che si collega all'ingresso DVI previsto della scheda video e dispone del proprio ingresso VGA, sarai in grado di far funzionare il tuo vecchio monitor con la nuova scheda video.

Adattatore == per inserire un piolo quadrato in un foro rotondo.

Facade == un unico pannello di controllo per eseguire tutti i componenti interni.

Onestamente, molti modelli potrebbero essere implementati allo stesso modo a livello di codice: la differenza è nell'intento.

Il modello di progettazione dell'adattatore ha lo scopo di "tradurre" l'interfaccia di una o più classi in un'interfaccia che il client si aspetta di utilizzare: l'adattatore tradurrebbe le chiamate all'interfaccia prevista nell'effettiva interfaccia utilizzata dalle classi avvolte.

Il pattern Facade viene utilizzato quando si desidera un'interfaccia più semplice (e di nuovo, potrebbe essere implementato allo stesso modo avvolgendo le classi offensive.) Non diresti che stai utilizzando una facciata quando l'interfaccia esistente è incompatibile, proprio quando ne hai bisogno per renderlo più leggibile, meno progettato male, ecc.

Facciata:

Aspetti chiave: (dall'articolo di journaldev di Pankaj Kumar)

1. Il modello di facciata è più simile a un aiuto per le applicazioni client
2. Il modello di facciata può essere applicato in qualsiasi momento dello sviluppo, di solito quando il numero di interfacce aumenta e il sistema diventa complesso .
3. Le interfacce del sottosistema non riconoscono Facade e non dovrebbero avere alcun riferimento all'interfaccia Facade
4. Il modello di facciata dovrebbe essere applicato per tipi simili di interfacce , il suo scopo è quello di fornire una singola interfaccia piuttosto che più interfacce che svolgono il tipo simile di lavori

Diagramma di classe della facciata:

Adattatore:

1. È un modello strutturale
2. È utile lavorare con due interfacce incompatibili
3. Fa funzionare le cose dopo che sono state progettate

Diagramma di classe dell'adattatore:

Puoi trovare maggiori dettagli su Adapter in questo post SE:

Differenza tra il modello del ponte e il modello dell'adattatore

Differenze chiave:

1. Facade definisce una nuova interfaccia, mentre Adapter utilizza una vecchia interfaccia . L'adattatore fa lavorare insieme due interfacce esistenti invece di definirne una completamente nuova
2. Adapter e Facade sono entrambi wrapper; ma sono diversi tipi di wrapper. L'intento di Facade è produrre un'interfaccia più semplice e lo scopo di Adapter è progettare su un'interfaccia esistente

Dai un'occhiata anche all'articolo sulla creazione di fonti per una migliore comprensione.

Una facciata è progettata per organizzare più servizi dietro un unico gateway di servizi. Un adattatore è progettato per fornire un modo per utilizzare un'interfaccia nota per accedere a una sconosciuta.

Lo scopo di un file

la facciata è semplicità

adattatore è l' interoperabilità .

La facciata è solitamente in contrasto con l'adattatore.

+--------------------------------------------------------------+-----------------------------------------------+
|                            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                           |
+--------------------------------------------------------------+-----------------------------------------------+

Come al solito, esistono somiglianze tra diversi modelli. Ma lo vedrei così:

• Una facciata viene utilizzata per incapsulare un intero strato e offre alcuni metodi per accedervi "comodamente"
• Viene utilizzato un adattatore, in cui si hanno due componenti che dovrebbero già lavorare insieme, ma non lo fanno, solo a causa di alcune differenze "non importanti" nell'interfaccia.

Cercherò di spiegarlo con parole semplici, senza troppe formalità.

Immagina di avere alcune classi di dominio e dall'interfaccia utente desideri interagire con esse. Una facciata può essere utilizzata per fornire funzioni che possono essere chiamate dal livello dell'interfaccia utente in modo che il livello dell'interfaccia utente non sia a conoscenza di classi di dominio diverse dalla facciata. Ciò significa che invece di chiamare le funzioni nelle classi di dominio chiamate una singola funzione dalla facciata, che sarà responsabile di chiamare le funzioni necessarie dalle altre classi.

Un adattatore, d'altra parte, può essere utilizzato per integrare altri componenti esterni che potrebbero avere le stesse funzionalità di cui hai bisogno ma le loro funzioni non sono chiamate esattamente allo stesso modo. Supponi di avere una Carclasse nel tuo dominio e lavori con un fornitore di auto esterno che ha anche una classe di auto definita. In questa classe, hai la funzione car.getDoors()ma il provider esterno ha l'equivalente car.getNumDoors(). Non si desidera modificare il modo in cui si chiama questa funzione, quindi è possibile utilizzare una classe dell'adattatore per eseguire il wrapping della classe Car esterna in modo che una chiamata a getDoors()dell'adattatore sia delegata alla getNumDoors()classe esterna.

Il modello dell'adattatore consente a due interfacce precedentemente incompatibili di funzionare tra loro. Ha 2 interfacce separate in gioco.

Il modello Facade prende un'interfaccia nota, che è di basso livello / a grana fine, e la avvolge con un'interfaccia di livello / corso a grana più alta. Ha un'unica interfaccia, che è stata semplificata avvolgendola con un'altra.

L'adattatore fa lavorare insieme due interfacce.

Facade espone una singola classe a un livello più alto e più limitato. Ad esempio, una facciata del modello di visualizzazione può esporre solo determinate proprietà di sola lettura di una classe di livello inferiore.

Facciata

Riassume la complessità per fornire un'interfaccia più semplice. Supponiamo, ad esempio, che un sistema operativo per computer astrae la complessità dell'hardware sottostante. Oppure un linguaggio di programmazione di alto livello (Python / JavaScript) astrae la complessità rispetto a un linguaggio di basso livello (C).

Adattatore

È analogo a un adattatore hardware. Supponiamo che tu voglia connettere un USB devicea serial port, avrai bisogno di un file USB-serial port adapter.

Il modello dell'adattatore collega due interfacce incompatibili fornendo una nuova interfaccia.

Il modello di facciata semplifica un sottosistema complesso (con più componenti) con un'unica interfaccia.

La differenza tra questi due pattern è chiara, ma non nell'ambito dei Design Pattern, ma della Domain Modeling. Di seguito, spiegherò perché.

Per prima cosa, voglio ribadire che altri hanno detto qui, e poi aggiungerò la nota:

Una facciata è un'interfaccia a un sottosistema (un sistema esterno o legacy) che semplifica l'accesso per il cliente (noi). Facade nasconde l'interfaccia dell'altro sottosistema (aggrega alcune chiamate o nasconde alcune API che non ci servono), quindi il tuo client accede a quel sottosistema solo attraverso questa facciata.

D'altra parte, un adattatore è un wrapper attorno a un altro servizio o oggetto. Rende l'oggetto avvolto conforme a un'interfaccia standard che il client si aspetta. Diciamo che c'è un metodo sull'oggetto "Ledger", di cui hai bisogno per fare un tweak (cambiare i suoi parametri, cambiare il suo nome, ecc.). Puoi avvolgerlo con un adattatore.

Ora, ancora la differenza potrebbe non essere chiara. È qui che voglio sollevare la differenza chiave tra questi due modelli senza lasciare spazio a ulteriore confusione :

Facade non cambia il modello di dominio dell'altro sottosistema, mentre lo fa Adapter. Questa è la differenza fondamentale. Periodo.

Ecco perché combini questi due quando crei uno strato anticorruzione . Supponiamo che tu abbia un sottosistema che desideri utilizzare, ma non vuoi che il suo modello di dominio confonda il tuo modello di dominio. Cosa faresti? Creeresti uno strato anticorruzione. Come? Per prima cosa crei una facciata, che semplifica l'accesso all'interfaccia per il sottosistema, quindi gli adattatori per gli oggetti di dominio utilizzati in quell'interfaccia (ricorda che la facciata contiene ancora il modello di dominio per l'altro sottosistema), quindi è conforme al tuo modello.

Molti modelli di progettazione possono essere utilizzati nella modellazione del dominio. Questo vale anche per i modelli di design Facade e Adapter. Sebbene la differenza tra questi due modelli potrebbe non essere chiara nel regno "modello di progettazione", è più chiara nel regno "modellazione del dominio".

Ho letto entrambe le definizioni e sembrano più o meno la stessa cosa.

Veramente ?

Ho notato che il termine Adapter è talvolta usato per descrivere quella che in realtà è una Strategia , forse perché la parola è più espressiva.

Ad esempio, in Zend Framework , tutte le classi Adapter sono in realtà implementazioni del pattern Strategy , perché racchiudono solo il codice nativo dietro le classi, per avere diversi comportamenti.

Gli adattatori vengono spesso utilizzati per eseguire il wrapping di codice legacy o "vecchio stile".

L'obiettivo principale del pattern Facade è rendere la classe o il sottosistema più facile da usare, mentre l'obiettivo principale del pattern Adapter è adattare l'interfaccia a ciò che il client si aspetta.