Qual é o padrão de design da fachada?

191

A fachada é uma classe que contém muitas outras classes?

O que o torna um padrão de design? Para mim, é como uma aula normal.

Você pode me explicar esse padrão de fachada ?

Kevin
fonte
7
Todo padrão de design tem em sua implementação um monte de classes.
Felix Kling
1
O padrão de fachada cria uma interface fácil de usar, ocultando várias interfaces em uma classe. Este artigo tem mais detalhes .
User3199690
bem explicado neste post programmerzdojo.com/java-tutorials/…
rishi007bansod
Teve de polegares para baixo isso porque "não mostram esforço de pesquisa"
Roy Truelove
1
@RoyTruelove, faça o que quiser. Não se importa, desde que haja respostas de suporte para a pergunta. Alguma resposta de suporte para a pergunta?
kevin

Respostas:

190

Um padrão de design é uma maneira comum de resolver um problema recorrente. Classes em todos os padrões de design são apenas classes normais. O importante é como eles são estruturados e como trabalham juntos para resolver um determinado problema da melhor maneira possível.

O padrão de design da fachada simplifica a interface para um sistema complexo; porque geralmente é composto de todas as classes que compõem os subsistemas do sistema complexo.

Uma Fachada protege o usuário dos detalhes complexos do sistema e fornece a ele um simplified viewdeles easy to use. É também decoupleso código que usa o sistema a partir dos detalhes dos subsistemas, facilitando a modificação posterior do sistema.

http://www.dofactory.com/Patterns/PatternFacade.aspx

http://www.blackwasp.co.uk/Facade.aspx

Além disso, o que é importante ao aprender padrões de design é ser capaz de reconhecer qual padrão se encaixa em seu problema específico e usá-lo adequadamente. É uma coisa muito comum abusar de um padrão ou tentar ajustá-lo a algum problema apenas porque você o conhece. Esteja ciente dessas armadilhas enquanto aprende \ usando padrões de design.

Unmesh Kondolikar
fonte
9
@ Kevin: Saber quando usá-los é a parte mais difícil. Em teoria, os padrões podem ser fáceis, mas na prática são difíceis. Você só pode aprender isso como experiência, ie. codificação, codificação, codificação.
Felix Kling
O padrão de design de fachada também é usado para ocultar o implemento da classe de detalhes e fornecer a API pública com segurança.
yebw
29
$ Em jQuery é apenas simples exemplo de padrão de design de fachada que fornece interface simples e esconder toda a complexidade
Ajay Beniwal
para quem procura um padrão de design de fachada com exemplo do mundo real. me deparei com este pequeno tutorial do youtube. Espero que seja útil youtu.be/dLjJo2v2re8
Sankar ganesh
podemos ter mais de uma camada de fachada para sistema único quando o aplicativo cresce?
Jeeva Jsb
99

A Wikipedia tem um ótimo exemplo de padrão de fachada.

/* Complex parts */

class CPU {
    public void freeze() { ... }
    public void jump(long position) { ... }
    public void execute() { ... }
}

class Memory {
    public void load(long position, byte[] data) { ... }
}

class HardDrive {
    public byte[] read(long lba, int size) { ... }
}

/* Facade */

class ComputerFacade {
    private CPU processor;
    private Memory ram;
    private HardDrive hd;

    public ComputerFacade() {
        this.processor = new CPU();
        this.ram = new Memory();
        this.hd = new HardDrive();
    }

    public void start() {
        processor.freeze();
        ram.load(BOOT_ADDRESS, hd.read(BOOT_SECTOR, SECTOR_SIZE));
        processor.jump(BOOT_ADDRESS);
        processor.execute();
    }
}

/* Client */

class You {
    public static void main(String[] args) {
        ComputerFacade computer = new ComputerFacade();
        computer.start();
    }
}
Erdem Gezer
fonte
6
Este é um bom exemplo. Um cliente precisa ser capaz de reunir todas as etapas de uma fachada, se assim o desejar, nada deve ser oculto por métodos particulares.
Rob
2
Imho isso não é um bom exemplo, pois não enfatiza o caso de uso. O exemplo mostra apenas, como TO disse, uma aula regular. A associação ao hardware é uma composição. Talvez exagere no exemplo no wiki, mas usar injeção de dependência em vez de instanciar os submódulos enfatizaria a intenção e possivelmente evitaria a confusão do OT.
precisa saber é o seguinte
Este é um exemplo incrível, pois apenas resume milhares de palavras em poucas palavras para entender o próprio conceito. Descanso são apenas os detalhes dos diferentes cenários que se pode ter (é claro que um padrão de design nunca pode cobrir todos os cenários).
Syed
41

Conforme explicado na resposta anterior, ele fornece uma interface simples para o cliente consumidor. Por exemplo: "watch ESPN" é a função pretendida. Mas envolve várias etapas, como:

  1. Ligue a TV, se necessário;
  2. Verifique o funcionamento do satélite / cabo;
  3. Mude para ESPN, se necessário.

Mas a fachada simplificará isso e apenas fornecerá a função "watch ESPN" ao cliente.

Aravind
fonte
29

O Facade oculta as complexidades do sistema e fornece uma interface para o cliente de onde o cliente pode acessar o sistema.

public class Inventory {
public String checkInventory(String OrderId) {
    return "Inventory checked";
}
}

public class Payment {
public String deductPayment(String orderID) {
    return "Payment deducted successfully";
}
}


public class OrderFacade {
private Payment pymt = new Payment();
private Inventory inventry = new Inventory();

public void placeOrder(String orderId) {
    String step1 = inventry.checkInventory(orderId);
    String step2 = pymt.deductPayment(orderId);
    System.out
            .println("Following steps completed:" + step1
                    + " & " + step2);
   }
}

public class Client {
       public static void main(String args[]){
         OrderFacade orderFacade = new OrderFacade();
         orderFacade.placeOrder("OR123456");
         System.out.println("Order processing completed");
       }
  }
KaviK
fonte
É permitido que os subsistemas se comuniquem sem passar pelo OrderFacade? No seu exemplo, entre Paymente Inventory?
Isuru
19

Uma explicação curta e simples:

  • O padrão de fachada fornece uma interface unificada para um conjunto de interfaces em um subsistema.
  • Fachada define uma interface de nível superior que facilita o uso do subsistema.

Tente entender o cenário com e sem Fachada:
Se você deseja transferir o dinheiro da conta1 para a conta2, os dois subsistemas a serem invocados são: retirar da conta1 e depositar na conta2.

com e sem fachada

Arun Raaj
fonte
Explicação e exemplo simples e claro, obrigado! Você também poderia explicar o que define um subsistema? Quando o subsistema pode consistir em subclasses / funções relativamente não relacionadas, sua definição se aplica a quase todas as classes. As classes do subsistema devem ter uma relação muito estreita, por exemplo, formar um módulo ou uma biblioteca, que alguém possa chamar de fachada, fachada?
Benni
@Benni Sim, o subsistema (seria uma classe) pode consistir em funções relativamente não relacionadas, mas fachada é uma classe na qual você decide quais funções específicas chamar. Você deseja reservar um "pacote turístico", selecionar o hotel, táxi, voo em um local / formulário e, internamente, a fachada chamará as funções de diferentes classes apropriadas e retornará o resultado final. Não é?
Arun Raaj
10

Uma fachada não deve ser descrita como uma classe que contém muitas outras classes. Na verdade, é uma interface para essas classes e deve facilitar o uso das classes, caso contrário a classe da fachada é inútil.

llMll
fonte
7

Em relação às suas consultas:

O Facade é uma classe que contém muitas outras classes?

Sim. É um invólucro para muitos subsistemas em aplicação.

O que o torna um padrão de design? Para mim, é como uma aula normal

Todos os padrões de design também são classes normais. @ Unmesh Kondolikar respondeu corretamente a esta pergunta.

Você pode me explicar sobre essa fachada? Sou novo em projetar padrões.

De acordo com o GoF, o padrão de design do Facade é definido como:

Forneça uma interface unificada para um conjunto de interfaces em um subsistema. Padrão de fachada define uma interface de nível superior que facilita o uso do subsistema

O padrão Fachada é normalmente usado quando:

  1. Uma interface simples é necessária para acessar um sistema complexo.
  2. As abstrações e implementações de um subsistema estão fortemente acopladas.
  3. Precisa de um ponto de entrada para cada nível de software em camadas.
  4. O sistema é muito complexo ou difícil de entender.

Vamos dar um exemplo real do site cleartrip .

Este site oferece opções para reservar

  1. Passagens aéreas
  2. Hotéis
  3. Voos + Hotéis

Fragmento de código:

import java.util.*;

public class TravelFacade{
    FlightBooking flightBooking;
    TrainBooking trainBooking;
    HotelBooking hotelBooking;

    enum BookingType {
        Flight,Train,Hotel,Flight_And_Hotel,Train_And_Hotel;
    }; 

    public TravelFacade(){
        flightBooking = new FlightBooking();
        trainBooking = new TrainBooking();
        hotelBooking = new HotelBooking();        
    }
    public void book(BookingType type, BookingInfo info){
        switch(type){
            case Flight:
                // book flight;
                flightBooking.bookFlight(info);
                return;
            case Hotel:
                // book hotel;
                hotelBooking.bookHotel(info);
                return;
            case Train:
                // book Train;
                trainBooking.bookTrain(info);
                return;
            case Flight_And_Hotel:
                // book Flight and Hotel
                flightBooking.bookFlight(info);
                hotelBooking.bookHotel(info);
                return;
             case Train_And_Hotel:
                // book Train and Hotel
                trainBooking.bookTrain(info);
                hotelBooking.bookHotel(info);
                return;                
        }
    }
}
class BookingInfo{
    String source;
    String destination;
    Date    fromDate;
    Date     toDate;
    List<PersonInfo> list;
}
class PersonInfo{
    String name;
    int       age;
    Address address;
}
class Address{

}
class FlightBooking{
    public FlightBooking(){

    }
    public void bookFlight(BookingInfo info){

    }
}
class HotelBooking{
    public HotelBooking(){

    }
    public void bookHotel(BookingInfo info){

    }
}
class TrainBooking{
    public TrainBooking(){

    }
    public void bookTrain(BookingInfo info){

    }
}

Explicação:

  1. FlightBooking, TrainBooking and HotelBooking Existem diferentes subsistemas do sistema grande: TravelFacade

  2. TravelFacade oferece uma interface simples para reservar uma das opções abaixo

    Flight Booking
    Train Booking 
    Hotel Booking
    Flight + Hotel booking 
    Train + Hotel booking
    
  3. reservar API do TravelFacade internamente chama abaixo APIs de subsistemas

    flightBooking.bookFlight
    trainBooking.bookTrain(info);
    hotelBooking.bookHotel(info);
    
  4. Dessa forma, TravelFacadefornece API mais simples e fácil, sem expor APIs do subsistema.

Principais conclusões : (do artigo do journaldev de 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 do desenvolvimento, geralmente quando o número de interfaces cresce e o sistema fica completo x .
  3. As interfaces do subsistema não conhecem o Facade e não devem ter nenhuma referência à interface do Facade
  4. O padrão de fachada deve ser aplicado a interfaces semelhantes ; seu objetivo é fornecer uma única interface em vez de múltiplas interfaces que executam o mesmo tipo de tarefas

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

Ravindra babu
fonte
6

O padrão de fachada é um invólucro de muitas outras interfaces em um resultado para produzir uma interface mais simples.

Os padrões de design são úteis, pois resolvem problemas recorrentes e, em geral, simplificam o código. Em uma equipe de desenvolvedores que concorda em usar os mesmos padrões, melhora a eficiência e a compreensão ao manter o código um do outro.

Tente ler sobre mais padrões:

Padrão de fachada: http://www.dofactory.com/Patterns/PatternFacade.aspx#_self1

ou mais geralmente: http://www.dofactory.com/Patterns/Patterns.aspx

Aim Kai
fonte
nileshgule.com/2012/07/facade-design-pattern.html Tentei descrever o padrão de design do Facade aqui com um exemplo do processo de verificação de empréstimos à habitação.
Nilesh Gule 16/07/2012
6

Um uso adicional do padrão Fachada poderia ser reduzir a curva de aprendizado de sua equipe. Deixe-me lhe dar um exemplo:

Vamos supor que seu aplicativo precise interagir com o MS Excel, usando o modelo de objeto COM fornecido pelo Excel. Um dos membros da sua equipe conhece todas as APIs do Excel e ele cria uma fachada sobre ela, que atende a todos os cenários básicos do aplicativo. Nenhum outro membro da equipe precisa gastar tempo aprendendo a API do Excel. A equipe pode usar a fachada sem conhecer os elementos internos ou todos os objetos do MS Excel envolvidos na realização de um cenário. Não é ótimo?

Assim, ele fornece uma interface simplificada e unificada sobre um subsistema complexo.

Anand Patel
fonte
5

Outro exemplo de fachada: digamos que seu aplicativo se conecte ao banco de dados e exiba resultados na interface do usuário. Você pode usar o facade para tornar seu aplicativo configurável, como em execução usando banco de dados ou com objetos simulados. Portanto, você fará todas as chamadas do banco de dados para a classe facade, onde lerá a configuração do aplicativo e decidirá acionar a consulta db ou retornar o objeto simulado. dessa maneira, o aplicativo se torna independente do banco de dados, caso o db esteja indisponível.

aish
fonte
5

Uma fachada expõe funções simplificadas que são chamadas principalmente e a implementação oculta a complexidade com a qual os clientes teriam que lidar. Em geral, a implementação usa vários pacotes, classes e funções nele. Fachadas bem escritas tornam raro o acesso direto a outras classes. Por exemplo, quando visito um caixa eletrônico e retiro alguma quantia. O caixa eletrônico oculta se está indo diretamente para o banco próprio ou se está passando por uma rede negociada para um banco externo. O caixa eletrônico atua como uma fachada consumindo vários dispositivos e subsistemas que, como cliente, não tenho que lidar diretamente.

ManojPatra
fonte
5

Há um exemplo muito bom do padrão na vida real - o motor de partida do carro .

Como motoristas, apenas ligamos a chave e o carro dá partida. Tão simples quanto possível. Nos bastidores, muitos outros sistemas de automóveis estão envolvidos (como bateria, motor, combustível, etc.), para que o carro inicie com sucesso, mas eles estão escondidos atrás do motor de partida.

Como você pode ver, o acionador de partida do carro é a fachada. Ele nos fornece uma interface fácil de usar, sem se preocupar com a complexidade de todos os outros sistemas automotivos.

Vamos resumir:

O padrão Facade simplifica e oculta a complexidade de grandes blocos de código ou APIs, fornecendo uma interface mais limpa, compreensível e fácil de usar.

Jordan Enev
fonte
4

Uma fachada é uma classe com um nível de funcionalidade que fica entre um kit de ferramentas e um aplicativo completo, oferecendo um uso simplificado das classes em um pacote ou subsistema. A intenção do padrão Facade é fornecer uma interface que facilite o uso de um subsistema. - Extrair do livro Design Patterns em C #.

Sean Hunter
fonte
4

Fachada discute o encapsulamento de um subsistema complexo em um único objeto de interface. Isso reduz a curva de aprendizado necessária para alavancar com sucesso o subsistema. Também promove a dissociação do subsistema de seus muitos clientes potencialmente. Por outro lado, se a Fachada for o único ponto de acesso para o subsistema, limitará os recursos e a flexibilidade que "usuários avançados" possam precisar.

Fonte: https://sourcemaking.com/design_patterns/facade

Pang
fonte
3

Um padrão de design é uma solução reutilizável geral para um problema comum dentro de um determinado contexto no design de software.

O padrão de design do Facade é um padrão estrutural, pois define uma maneira de criar relacionamentos entre classes ou entidades. O padrão de design da fachada é usado para definir uma interface simplificada para um subsistema mais complexo.

O padrão de fachada é ideal ao trabalhar com um grande número de classes interdependentes ou com classes que exigem o uso de vários métodos, principalmente quando são de uso complicado ou difíceis de entender. A classe de fachada é um "invólucro" que contém um conjunto de membros que são facilmente compreendidos e simples de usar. Esses membros acessam o subsistema em nome do usuário da fachada, ocultando os detalhes da implementação.

O padrão de design da fachada é particularmente útil ao agrupar subsistemas mal projetados, mas que não podem ser refatorados porque o código-fonte não está disponível ou a interface existente é amplamente utilizada. Às vezes, você pode decidir implementar mais de uma fachada para fornecer subconjuntos de funcionalidades para diferentes propósitos.

Um exemplo de uso do padrão de fachada é a integração de um site com um aplicativo de negócios. O software existente pode incluir grandes quantidades de lógica de negócios que devem ser acessadas de uma maneira específica. O site pode exigir apenas acesso limitado a essa lógica comercial. Por exemplo, o site pode precisar mostrar se um item à venda atingiu um nível limitado de estoque. O método IsLowStock da classe facade pode retornar um valor booleano para indicar isso. Nos bastidores, esse método pode ocultar as complexidades do processamento do estoque físico atual, do estoque recebido, dos itens alocados e do baixo nível de estoque de cada item.

Program-Me-Rev
fonte
2

Todos os padrões de design são algumas classes organizadas de uma maneira ou de outra que se adequam a um aplicativo específico. O objetivo do padrão de fachada é ocultar a complexidade de uma operação ou operações. Você pode ver um exemplo e aprender o padrão de fachada em http://preciselyconcise.com/design_patterns/facade.php

Sai Sunder
fonte
2

É simplesmente criar um wrapper para chamar vários métodos. Você tem uma classe A com os métodos x () e y () e B com os métodos k () e z (). Você deseja chamar x, y, z de uma vez. Para fazer isso usando o padrão Facade, basta criar uma classe Facade e criar um método, digamos xyz (). Em vez de chamar cada método (x, ye z) individualmente, basta chamar o método wrapper (xyz ()) da classe de fachada que chama esses métodos.

Padrão semelhante é o repositório, mas é principalmente para a camada de acesso a dados.

Jeff Schreib
fonte
1

É basicamente um sistema de liberação de janela única. Você atribui qualquer trabalho que ele delegará a um método específico em outra classe.

Saurabh
fonte
1

O padrão de fachada fornece uma interface unificada para o grupo de interfaces do subsistema. A fachada define uma interface de alto nível, que simplifica o trabalho com o subsistema.

Taras Melnyk
fonte