Qual é a diferença entre a Fachada e o Padrão Adaptador?

Eu tenho lido ambas as definições e elas parecem as mesmas. Alguém poderia apontar quais são 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 quer uma interface mais fácil ou mais simples para trabalhar.”

Eu ouvi uma analogia que você deve pensar em seu controle remoto universal que você configurou para trabalhar com todos os seus diferentes sistemas estéreo – você pressiona “on” e liga seu decodificador, seu receptor e sua TV. Talvez seja um home theater realmente chique e ofusca as luzes e também atrai as sombras. Isso é uma fachada – um botão / function que cuida de um conjunto de etapas mais complicado.

O padrão do adaptador 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. Placas de vídeo modernas são frequentemente DVI, mas você tem um monitor VGA antigo. Com um adaptador que se conecta à input DVI esperada da sua placa de vídeo e tem sua própria input VGA, você poderá fazer seu monitor antigo funcionar com sua nova placa de vídeo.

Adaptador == fazendo um pino quadrado encheckboxr em um buraco 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 conector serve para ‘converter’ a interface de uma ou mais classs em uma interface que o cliente espera usar – o adaptador converteria as chamadas para a interface esperada na interface real usada pelas classs quebradas.

O padrão Facade é usado quando uma interface mais simples é desejada (e, novamente, pode ser implementada da mesma forma envolvendo as classs problemáticas). Você não diria que está usando uma fachada quando a interface existente é incompatível, exatamente quando você precisa para torná-lo mais legível, menos mal projetado, etc.

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 um desconhecido.

Fachada:

Principais tópicos: (do artigo journaldev de Pankaj Kumar)

  1. O padrão de fachada é mais como um ajudante para aplicativos clientes
  2. O padrão de fachada pode ser aplicado em qualquer ponto de desenvolvimento, geralmente quando o número de interfaces cresce e o sistema fica complexo .
  3. As interfaces do subsistema não estão cientes do Facade e não devem ter nenhuma referência da interface do Facade
  4. O padrão de fachada deve ser aplicado para tipos similares de interfaces , sua finalidade é fornecer uma interface única em vez de várias interfaces que fazem o mesmo tipo de trabalho

Diagrama de classs da fachada:

insira a descrição da imagem aqui

Adaptador:

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

Diagrama de classs do adaptador:

insira a descrição da imagem aqui

Você pode encontrar mais detalhes sobre o Adaptador nesta postagem:

Diferença entre padrão de ponte e padrão de adaptador

Principais diferenças

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

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

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 methods para acessá-la “convenientemente”
  • Um adaptador é usado, onde você tem dois componentes que já devem funcionar juntos, mas não, 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 classs de domínio e da interface do usuário que você deseja interagir com elas. Uma fachada pode ser usada para fornecer funções que podem ser chamadas a partir da camada de interface do usuário, de modo que a camada de interface do usuário não saiba sobre nenhuma class de domínio que não seja a fachada. Isso significa que, em vez de chamar as funções nas classs de domínio, você chama uma única function da fachada, que será responsável por chamar as funções necessárias das outras classs.

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 maneira. Digamos que você tenha uma class Car no seu domínio e trabalhe com um provedor de carro externo que tenha uma class Car também definida. Nesta class, você tem a function car.getDoors() mas o provedor externo possui o equivalente car.getNumDoors() . Você não deseja alterar a maneira como chama essa function, portanto, pode usar uma class de adaptador para getDoors() a class Car externa para que uma chamada para getDoors() do adaptador seja delegada para getNumDoors() da class externa.

O padrão de adaptador permite que duas interfaces, anteriormente incompatíveis, trabalhem entre si. Tem 2 interfaces separadas em jogo.

O padrão Fachada usa uma interface conhecida, que é de baixo nível / granulação fina, e a envolve com uma interface de nível superior / claro. Tem uma interface única, que foi simplificada por envolvimento com outro.

O adaptador faz duas interfaces trabalharem juntas.

A fachada expõe uma única class a um nível mais alto e mais limitado. Por exemplo, uma fachada de modelo de exibição pode expor apenas algumas propriedades somente leitura de uma class de nível inferior.

A fachada é geralmente contrastada com o 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 | +--------------------------------------------------------------+-----------------------------------------------+ 

Eu tenho lido ambas as definições e elas parecem as mesmas.

Mesmo ?

Tenho notado que o termo Adapter é algumas 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 classs do Adapter são na verdade implementações do padrão Strategy , porque elas envolvem apenas o código nativo por trás de classs, para ter vários comportamentos.

Os adaptadores costumam ser usados ​​para envolver códigos legados ou “antigos”.

Depois de ler tudo isso, devo dizer que o propósito de um

fachada é simplicidade

adaptador é interoperabilidade .

Fachada

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

Adaptador

É análoga a um adaptador de hardware. Digamos que você queira conectar um USB device a uma serial port , você precisará de um USB-serial port adapter .

Intereting Posts