Qual é a diferença entre o padrão de fachada e adaptador?

Tenho lido as duas definições e elas parecem exatamente as mesmas. Alguém poderia apontar quais são as suas diferenças?

obrigado

A página wiki do Facade Pattern tem uma breve nota sobre isso.

"Um adaptador é usado quando o wrapper deve respeitar uma interface específica e deve suportar um comportamento polimórfico. Por outro lado, uma fachada é usada quando se deseja uma interface mais fácil ou mais simples de trabalhar."

Ouvi uma analogia em que você deve pensar em seu controle remoto universal que configurou para funcionar com todos os seus diferentes sistemas de som - você pressiona "on" e liga seu decodificador, seu receptor e sua TV. Talvez seja um home theater realmente chique que escurece as luzes e fecha as cortinas também. Isso é uma fachada - um botão / função que cuida de um conjunto mais complicado de etapas.

O padrão Adapter apenas vincula duas interfaces incompatíveis.

EDIT: Uma analogia rápida para o padrão do adaptador (com base nos comentários) pode ser algo como um adaptador DVI-para-VGA. As placas de vídeo modernas costumam ser DVI, mas você tem um monitor VGA antigo. Com um adaptador que se conecta à entrada DVI esperada de sua placa de vídeo e tem sua própria entrada VGA, você poderá fazer seu monitor antigo funcionar com sua nova placa de vídeo.

Adaptador == fazendo um pino quadrado se encaixar em um orifício redondo.

Fachada == um único painel de controle para executar todos os componentes internos.

Honestamente, muitos padrões podem ser implementados da mesma maneira programaticamente - a diferença está na intenção.

O padrão de design do Adaptador tem como objetivo 'traduzir' a interface de uma ou mais classes em uma interface que o cliente espera usar - o adaptador traduziria as chamadas para a interface esperada na interface real que as classes agrupadas usam.

O padrão Facade é usado quando uma interface mais simples é desejada (e, novamente, poderia ser implementado da mesma maneira envolvendo as classes ofensivas). Você não diria que está usando uma fachada quando a interface existente é incompatível, apenas quando você precisa para torná-lo mais legível, menos mal projetado, etc.

Fachada:

Principais conclusões : (do artigo do Journaldev por Pankaj Kumar)

1. O padrão de fachada é mais como um auxiliar para aplicativos clientes
2. O padrão de fachada pode ser aplicado em qualquer ponto de desenvolvimento, geralmente quando o número de interfaces aumenta e o sistema fica complexo .
3. As interfaces do subsistema não reconhecem o Façade e não devem ter nenhuma referência à interface do Façade
4. O padrão de fachada deve ser aplicado para tipos semelhantes de interfaces , seu objetivo é fornecer uma única interface em vez de várias interfaces que fazem o tipo de trabalho semelhante

Diagrama de classe de fachada:

Adaptador:

1. É um padrão estrutural
2. É útil trabalhar com duas interfaces incompatíveis
3. Faz as coisas funcionarem depois de projetadas

Diagrama de classes do adaptador:

Você pode encontrar mais detalhes sobre o adaptador nesta postagem SE:

Diferença entre o padrão da ponte e o padrão do adaptador

Principais diferenças:

1. Facade define uma nova interface, enquanto o Adapter usa uma interface antiga . O adaptador faz com que duas interfaces existentes funcionem juntas em vez de definir uma interface inteiramente nova
2. Adapter e Facade são invólucros; mas são tipos diferentes de invólucros. A intenção do Façade é produzir uma interface mais simples, e a intenção do Adaptador é projetar para uma interface existente

Dê uma olhada no artigo de criação de fontes também para melhor compreensão.

Uma fachada é projetada para organizar vários serviços por trás de um único gateway de serviço. Um adaptador é projetado para fornecer uma maneira de usar uma interface conhecida para acessar outra desconhecida.

O propósito de um

fachada é simplicidade

adaptador é interoperabilidade .

Fachada geralmente é contrastada com Adaptador.

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

Como de costume, existem semelhanças entre vários padrões. Mas eu veria assim:

• Uma fachada é usada para encapsular uma camada inteira e oferece alguns métodos para acessá-la "convenientemente"
• Um adaptador é usado, onde você tem dois componentes que já deveriam funcionar juntos, mas não funcionam, apenas por causa de algumas diferenças "não importantes" na interface.

Vou tentar explicar isso em palavras simples, sem muita formalidade.

Imagine que você tenha algumas classes de domínio e, a partir da IU, deseja interagir com elas. Uma fachada pode ser usada para fornecer funções que podem ser chamadas a partir da camada de IU para que a camada de IU não conheça nenhuma classe de domínio além da fachada. Isso significa que, em vez de chamar as funções nas classes de domínio, você chama uma única função da fachada, que será responsável por chamar as funções necessárias das outras classes.

Um adaptador, por outro lado, pode ser usado para integrar outros componentes externos que podem ter a mesma funcionalidade que você precisa, mas suas funções não são chamadas da mesma forma. Digamos que você tenha uma Carclasse em seu domínio e trabalhe com um fornecedor externo de automóveis que também tenha uma classe Carro definida. Nesta aula, você tem a funçãocar.getDoors() mas o provedor externo tem o equivalente car.getNumDoors(). Você não deseja alterar a maneira como chama essa função, portanto, pode usar uma classe de adaptador para agrupar a classe Car externa, de modo que uma chamada getDoors()de do adaptador seja delegada à getNumDoors()classe externa.

O padrão do adaptador permite que duas interfaces, anteriormente incompatíveis, funcionem uma com a outra. Possui 2 interfaces separadas em jogo.

O padrão Façade pega uma interface conhecida, que é de baixo nível / granulação fina, e a envolve com uma interface de nível / granulação de curso superior. Possui uma única interface, que foi simplificada ao agrupar com outra.

O adaptador faz com que duas interfaces funcionem juntas.

A fachada expõe uma única classe a um nível superior e mais limitado. Por exemplo, uma fachada de modelo de vista pode expor apenas certas propriedades somente leitura de uma classe de nível inferior.

Fachada

Abstrai a complexidade para fornecer uma interface mais simples. Digamos, por exemplo, um sistema operacional de computador abstraia a complexidade do hardware subjacente. Ou uma linguagem de programação de alto nível (Python / JavaScript) abstrai a complexidade quando comparada a uma linguagem de baixo nível (C).

Adaptador

É análogo a adaptadores de hardware. Digamos que você queira conectar USB devicea a serial port, você precisará de a USB-serial port adapter.

O padrão do adaptador vincula duas interfaces incompatíveis, fornecendo uma nova interface.

O padrão de fachada simplifica um subsistema complexo (com vários componentes) com uma única interface.

A diferença entre esses dois padrões é clara, mas não no domínio dos Design Patterns, mas na Modelagem de Domínio. A seguir, explicarei o porquê.

Em primeiro lugar, quero reiterar que outras pessoas disseram aqui e, em seguida, adicionarei a observação:

Uma Fachada é uma interface para um subsistema (um sistema externo ou legado) que simplifica o acesso do cliente (nós). O Façade oculta a interface do outro subsistema (agrega algumas chamadas, ou oculta algumas APIs que não precisamos), portanto, seu cliente só acessa aquele subsistema através deste Façade.

Por outro lado, um adaptador é um wrapper em torno de outro serviço ou objeto. Faz com que o objeto empacotado se conforme a uma interface padrão que o cliente espera. Digamos que haja um método no objeto "Razão", que você precisa fazer um ajuste (alterar seus parâmetros, alterar seu nome, etc.). Você pode envolvê-lo com um adaptador.

Agora, ainda assim a diferença pode não ser clara. É aí que eu quero trazer à tona a principal diferença entre esses dois padrões, não deixando espaço para mais confusão :

O Façade não muda o modelo de domínio do outro subsistema, enquanto o Adaptador sim. Esta é a principal diferença. Período.

É por isso que você combina esses dois ao criar uma camada anticorrupção . Digamos que você tenha um subsistema que deseja usar, mas não quer que seu modelo de domínio confunda seu modelo de domínio. O que você faria? Você criaria uma camada anticorrupção. Quão? Primeiro, você cria uma fachada, que simplifica o acesso à interface para o subsistema, e depois os adaptadores para os objetos de domínio usados ​​nessa interface (lembre-se de que a fachada ainda mantém o modelo de domínio para o outro subsistema), para que esteja em conformidade com seu modelo.

Muitos padrões de projeto podem ser usados ​​na modelagem de domínio. Isso também se aplica aos padrões de projeto de Fachada e Adaptador. Embora a diferença entre esses dois padrões possa não ser clara no domínio de "padrão de design", é mais clara no domínio de "modelagem de domínio".

Tenho lido as duas definições e elas parecem exatamente as mesmas.

Sério ?

Percebi que o termo Adaptador às vezes é usado para descrever o que é de fato uma Estratégia , talvez porque a palavra seja mais expressiva.

Por exemplo, no Zend Framework , todas as classes Adapter são de fato implementações do padrão Strategy , porque elas envolvem apenas código nativo atrás de classes, para ter vários comportamentos.

Os adaptadores são freqüentemente usados ​​para envolver código legado ou "estilo antigo".

O objetivo principal do padrão Façade é tornar a classe ou subsistema mais fácil de usar, enquanto o objetivo principal do padrão Adaptador é ajustar a interface ao que o cliente espera.