Qual è il modello di progettazione della facciata?

La facciata è una classe che contiene molte altre classi?

Cosa lo rende un modello di design? Per me è come una lezione normale.

Puoi spiegarmi questo modello di facciata ?

Un modello di progettazione è un modo comune di risolvere un problema ricorrente. Le classi in tutti i modelli di progettazione sono solo normali. Ciò che è importante è come sono strutturati e come lavorano insieme per risolvere un determinato problema nel miglior modo possibile.

Il modello di progettazione della facciata semplifica l'interfaccia con un sistema complesso; perché di solito è composto da tutte le classi che compongono i sottosistemi del sistema complesso.

Una facciata protegge l'utente dai dettagli complessi del sistema e fornisce loro uno simplified viewche è easy to use. È anche decouplesil codice che utilizza il sistema dai dettagli dei sottosistemi, rendendo più semplice la modifica del sistema in un secondo momento.

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

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

Inoltre, ciò che è importante durante l'apprendimento dei modelli di progettazione è essere in grado di riconoscere quale modello si adatta al proprio problema e quindi utilizzarlo in modo appropriato. È una cosa molto comune abusare di un modello o cercare di adattarlo a qualche problema solo perché lo conosci. Siate consapevoli di queste insidie ​​mentre imparate \ usando i modelli di progettazione.

Wikipedia ha un grande esempio di modello di facciata.

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

Come spiegato nella risposta precedente, fornisce una semplice interfaccia per il client che consuma. Ad esempio: "watch ESPN" è la funzione prevista. Ma prevede diversi passaggi come:

1. Accendere la TV se necessario;
2. Verificare il funzionamento via satellite / cavo;
3. Passare a ESPN, se necessario.

Ma la facciata semplificherà tutto ciò e fornirà semplicemente la funzione "watch ESPN" al cliente.

Facade nasconde le complessità del sistema e fornisce un'interfaccia al client da cui il client può accedere al 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");
       }
  }

Una spiegazione breve e semplice:

• Il modello di facciata fornisce un'interfaccia unificata a una serie di interfacce in un sottosistema.
• Facade definisce un'interfaccia di livello superiore che semplifica l'utilizzo del sottosistema.

Cerca di capire lo scenario con e senza facciata:
se vuoi trasferire il denaro da accout1 a account2, i due sottosistemi da invocare sono, prelevare da account1 e depositare su account2.

Una facciata non dovrebbe essere descritta come una classe che contiene molte altre classi. In realtà è un'interfaccia per queste classi e dovrebbe facilitare l'utilizzo delle classi, altrimenti la classe della facciata è inutile.

Per quanto riguarda le tue domande:

Facade è una classe che contiene molte altre classi?

Sì. È un wrapper per molti sottosistemi in applicazione.

Cosa lo rende un modello di design? Per me è come una lezione normale

Anche tutti i modelli di progettazione sono classi normali. @ Unmesh Kondolikar ha giustamente risposto a questa domanda.

Puoi spiegarmi questa facciata, sono nuovo a progettare modelli.

Secondo GoF, il modello di progettazione della facciata è definito come:

Fornire un'interfaccia unificata a un set di interfacce in un sottosistema. Il modello di facciata definisce un'interfaccia di livello superiore che semplifica l'utilizzo del sottosistema

Il modello di facciata viene in genere utilizzato quando:

1. È necessaria una semplice interfaccia per accedere a un sistema complesso.
2. Le astrazioni e le implementazioni di un sottosistema sono strettamente accoppiate.
3. È necessario un punto di accesso per ogni livello di software a più livelli.
4. Il sistema è molto complesso o difficile da capire.

Facciamo un esempio reale di sito Web Cleartrip .

Questo sito Web offre opzioni per prenotare

1. voli
2. Alberghi
3. Voli + Hotel

Snippet di codice:

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){

    }
}

Spiegazione:

1. FlightBooking, TrainBooking and HotelBooking sono diversi sottosistemi di grandi sistemi: TravelFacade

2. TravelFacade offre una semplice interfaccia per prenotare una delle seguenti opzioni

   Flight Booking
   Train Booking 
   Hotel Booking
   Flight + Hotel booking 
   Train + Hotel booking
   

3. prenotare l'API di TravelFacade chiama internamente sotto le API dei sottosistemi

   flightBooking.bookFlight
   trainBooking.bookTrain(info);
   hotelBooking.bookHotel(info);
   

4. In questo modo, TravelFacadefornisce API più semplici e facili senza esporre le API del sottosistema.

Key takeaways: (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 punto dello sviluppo, di solito quando il numero di interfacce aumenta e il sistema diventa completo x .
3. Le interfacce del sottosistema non sono a conoscenza di Facade e non dovrebbero avere riferimenti all'interfaccia di Facade
4. Il modello di facciata deve essere applicato per un tipo simile di interfacce , il suo scopo è quello di fornire una singola interfaccia piuttosto che più interfacce che svolgono il tipo simile di lavori

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

Il modello di facciata è un involucro di molte altre interfacce in un risultato per produrre un'interfaccia più semplice.

I modelli di progettazione sono utili in quanto risolvono problemi ricorrenti e in generale semplificano il codice. In un team di sviluppatori che accettano di utilizzare gli stessi schemi, migliora l'efficienza e la comprensione nel mantenere il codice degli altri.

Prova a leggere altri schemi:

Modello di facciata: http://www.dofactory.com/Patterns/PatternFacade.aspx#_self1

o più in generale: http://www.dofactory.com/Patterns/Patterns.aspx

Un ulteriore uso del modello Façade potrebbe essere quello di ridurre la curva di apprendimento della tua squadra. Lasciate che vi faccia un esempio:

Supponiamo che l'applicazione debba interagire con MS Excel facendo uso del modello a oggetti COM fornito da Excel. Uno dei membri del tuo team conosce tutte le API di Excel e crea una facciata su di essa, che soddisfa tutti gli scenari di base dell'applicazione. Nessun altro membro del team deve dedicare tempo all'apprendimento dell'API di Excel. Il team può utilizzare la facciata senza conoscere gli interni o tutti gli oggetti di MS Excel coinvolti nella realizzazione di uno scenario. Non è grande?

Pertanto, fornisce un'interfaccia semplificata e unificata su un sottosistema complesso.

Un altro esempio di facciata: supponiamo che l'applicazione si colleghi al database e visualizzi i risultati sull'interfaccia utente. È possibile utilizzare la facciata per rendere configurabile l'applicazione, come in esecuzione utilizzando il database o con oggetti finti. Quindi effettuerai tutte le chiamate del database alla classe della facciata, dove leggerà la configurazione dell'app e deciderà di attivare la query db o restituire l'oggetto simulato. in questo modo l'applicazione diventa indipendente dal db nel caso in cui db non sia disponibile.

Una facciata espone funzioni semplificate che vengono per lo più chiamate e l'implementazione nasconde la complessità che i clienti dovrebbero altrimenti affrontare. In generale l'implementazione utilizza più pacchetti, classi e funzioni lì dentro. Facciate ben scritte rendono raro l'accesso diretto ad altre classi. Ad esempio, quando visito un bancomat e prelevo un importo. L'ATM nasconde se sta andando direttamente alla banca di proprietà o se sta attraversando una rete negoziata per una banca esterna. L'ATM si comporta come una facciata che consuma più dispositivi e sottosistemi che come cliente non devo affrontare direttamente.

C'è un ottimo esempio nella vita reale del modello: il motore di avviamento dell'auto .

Come guidatori, basta accendere la chiave e la macchina inizia. Il più semplice possibile. Dietro le quinte, sono coinvolti molti altri sistemi di auto (come batteria, motore, carburante, ecc.), Affinché l'auto si avvii con successo, ma sono nascosti dietro il motorino di avviamento.

Come puoi vedere, il motorino di avviamento è la facciata. Ci dà un'interfaccia facile da usare, senza preoccuparci della complessità di tutti gli altri sistemi di auto.

Riassumiamo:

Il modello Facade semplifica e nasconde la complessità di blocchi di codice di grandi dimensioni o API, fornendo un'interfaccia più pulita, comprensibile e facile da usare.

Una facciata è una classe con un livello di funzionalità compreso tra un toolkit e un'applicazione completa, che offre un utilizzo semplificato delle classi in un pacchetto o sottosistema. L'intento del modello di facciata è di fornire un'interfaccia che renda un sottosistema facile da usare. - Estratto dal libro Design Patterns in C #.

La facciata discute dell'incapsulamento di un sottosistema complesso all'interno di un singolo oggetto interfaccia. Ciò riduce la curva di apprendimento necessaria per sfruttare con successo il sottosistema. Promuove anche il disaccoppiamento del sottosistema dai suoi potenzialmente molti client. D'altra parte, se la facciata è l'unico punto di accesso per il sottosistema, limiterà le funzionalità e la flessibilità di cui "gli utenti esperti" potrebbero aver bisogno.

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

Un modello di progettazione è una soluzione riutilizzabile generale a un problema che si verifica comunemente in un determinato contesto nella progettazione del software.

Il modello di progettazione della facciata è un modello strutturale in quanto definisce un modo per creare relazioni tra classi o entità. Il modello di progettazione della facciata viene utilizzato per definire un'interfaccia semplificata per un sottosistema più complesso.

Il modello di facciata è ideale quando si lavora con un gran numero di classi interdipendenti o con classi che richiedono l'uso di più metodi, in particolare quando sono complicati da usare o difficili da capire. La classe di facciata è un "involucro" che contiene un insieme di membri che sono facilmente comprensibili e semplici da usare. Questi membri accedono al sottosistema per conto dell'utente della facciata, nascondendo i dettagli di implementazione.

Il modello di progettazione della facciata è particolarmente utile quando si avvolgono sottosistemi mal progettati ma che non possono essere sottoposti a refactoring poiché il codice sorgente non è disponibile o l'interfaccia esistente è ampiamente utilizzata. A volte puoi decidere di implementare più di una facciata per fornire sottoinsiemi di funzionalità per scopi diversi.

Un esempio di utilizzo del modello di facciata è l'integrazione di un sito Web con un'applicazione aziendale. Il software esistente può includere grandi quantità di logica aziendale a cui è necessario accedere in un modo particolare. Il sito Web potrebbe richiedere solo un accesso limitato a questa logica aziendale. Ad esempio, potrebbe essere necessario che il sito Web mostri se un articolo in vendita ha raggiunto un livello limitato di scorte. Il metodo IsLowStock della classe di facciata potrebbe restituire un valore booleano per indicarlo. Dietro le quinte, questo metodo potrebbe nascondere la complessità dell'elaborazione dello stock fisico corrente, dello stock in entrata, degli articoli allocati e del livello di stock basso per ciascun articolo.

Tutti i modelli di progettazione sono alcune classi organizzate in un modo o nell'altro che si adatta a un'applicazione specifica. Lo scopo del modello di facciata è nascondere la complessità di un'operazione o delle operazioni. Puoi vedere un esempio e imparare il modello di facciata da http://preciselyconcise.com/design_patterns/facade.php

Sta semplicemente creando un wrapper per chiamare più metodi. Hai una classe A con metodo x () e y () e classe B con metodo k () e z (). Volete chiamare x, y, z contemporaneamente, per farlo usando il modello Facade basta creare una classe Facade e creare un metodo diciamo xyz (). Invece di chiamare ogni metodo (x, ye z) singolarmente, basta chiamare il metodo wrapper (xyz ()) della classe della facciata che chiama quei metodi.

Un modello simile è un repository ma è principalmente per il livello di accesso ai dati.

È fondamentalmente un sistema di gioco a finestra singola. Assegni qualsiasi lavoro che delegherà a un metodo particolare in un'altra classe.

Il modello di progettazione della facciata rientra nel modello di progettazione strutturale. In breve, facciata significa l'aspetto esteriore. Significa che nel modello di progettazione della facciata nascondiamo qualcosa e mostriamo solo ciò che effettivamente richiede il cliente. Maggiori informazioni sul blog di seguito: http://www.sharepointcafe.net/2017/03/facade-design-pattern-in-aspdotnet.html

Il modello di facciata fornisce un'interfaccia unificata al gruppo di interfacce del sottosistema. La facciata definisce un'interfaccia di alto livello, che semplifica il lavoro con il sottosistema.