Qual é o padrão de design da fachada?

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 ?

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.

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();
    }
}

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.

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");
       }
  }

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.

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.

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.

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

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.

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.

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.

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.

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 #.

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

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.

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

É 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.

É 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.

Fachada Design Pattern vem em Structural Design Pattern. Em suma Fachada significa a aparência exterior. Isso significa que, no padrão de design da fachada, ocultamos algo e mostramos apenas o que o cliente realmente exige. Leia mais no blog abaixo: http://www.sharepointcafe.net/2017/03/facade-design-pattern-in-aspdotnet.html

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.