Quel est le modèle de conception de la façade?

La façade est-elle une classe qui contient beaucoup d'autres classes?

Qu'est-ce qui en fait un modèle de conception? Pour moi, c'est comme une classe normale.

Pouvez-vous m'expliquer ce modèle de façade ?

Un modèle de conception est un moyen courant de résoudre un problème récurrent. Les classes de tous les modèles de conception ne sont que des classes normales. Ce qui est important, c'est comment ils sont structurés et comment ils travaillent ensemble pour résoudre un problème donné de la meilleure façon possible.

Le modèle de conception de façade simplifie l'interface à un système complexe; car il est généralement composé de toutes les classes qui composent les sous-systèmes du système complexe.

Une façade protège l'utilisateur des détails complexes du système et lui en fournit un simplified viewqui l'est easy to use. C'est également decouplesle code qui utilise le système à partir des détails des sous-systèmes, ce qui facilite la modification du système ultérieurement.

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

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

En outre, ce qui est important lors de l'apprentissage des modèles de conception, c'est d'être capable de reconnaître quel modèle correspond à votre problème donné, puis de l'utiliser de manière appropriée. Il est très courant de mal utiliser un motif ou d'essayer de l'adapter à un problème simplement parce que vous le connaissez. Soyez conscient de ces pièges tout en apprenant \ en utilisant des modèles de conception.

Wikipedia a un excellent exemple de motif de façade.

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

Comme expliqué dans la réponse précédente, il fournit une interface simple au client consommateur. Par exemple: "regarder ESPN" est la fonction prévue. Mais cela implique plusieurs étapes comme:

1. Allumez la télévision si nécessaire;
2. Vérifiez le fonctionnement du satellite / câble;
3. Passez à ESPN si nécessaire.

Mais la façade simplifiera cela et fournira simplement la fonction «regarder ESPN» au client.

Facade masque les complexités du système et fournit une interface au client à partir de laquelle le client peut accéder au système.

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

Une explication courte et simple:

• Le modèle de façade fournit une interface unifiée à un ensemble d'interfaces dans un sous-système.
• Facade définit une interface de niveau supérieur qui facilite l'utilisation du sous-système.

Essayez de comprendre le scénario avec et sans façade:
Si vous souhaitez transférer de l'argent de compte1 vers compte2, les deux sous-systèmes à invoquer sont: retirer du compte1 et déposer sur le compte2.

Une façade ne doit pas être décrite comme une classe qui contient beaucoup d'autres classes. Il s'agit en fait d'une interface avec ces classes et devrait faciliter l'utilisation des classes sinon la classe de façade est inutile.

Concernant vos requêtes:

Est-ce que Facade est une classe qui contient beaucoup d'autres classes?

Oui. C'est un wrapper pour de nombreux sous-systèmes en application.

Qu'est-ce qui en fait un modèle de conception? Pour moi, c'est comme une classe normale

Tous les modèles de conception sont également des classes normales. @ Unmesh Kondolikar a correctement répondu à cette question.

Pouvez-vous m'expliquer cette façade, je suis nouveau dans la conception de modèles.

Selon le GoF, le modèle de conception de façade est défini comme suit:

Fournissez une interface unifiée à un ensemble d'interfaces dans un sous-système. Le modèle de façade définit une interface de niveau supérieur qui rend le sous-système plus facile à utiliser

Le modèle de façade est généralement utilisé lorsque:

1. Une interface simple est nécessaire pour accéder à un système complexe.
2. Les abstractions et les implémentations d'un sous-système sont étroitement couplées.
3. Besoin d'un point d'entrée pour chaque niveau de logiciel en couches.
4. Le système est très complexe ou difficile à comprendre.

Prenons un exemple concret de site Web cleartrip .

Ce site Web propose des options pour réserver

1. Vols
2. Hôtels
3. Vols + Hôtels

Extrait de code:

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

    }
}

Explication:

1. FlightBooking, TrainBooking and HotelBooking sont différents sous-systèmes d'un grand système: TravelFacade

2. TravelFacade offre une interface simple pour réserver l'une des options ci-dessous

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

3. réserver l'API de TravelFacade appelle en interne les API des sous-systèmes

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

4. De cette manière, TravelFacadefournit une API plus simple et plus facile sans exposer les API de sous-système.

Points clés à retenir: (extrait de l' article journaldev de Pankaj Kumar )

1. Le modèle de façade ressemble plus à une aide pour les applications clientes
2. Le modèle de façade peut être appliqué à n'importe quel stade du développement, généralement lorsque le nombre d'interfaces augmente et que le système devient complet x .
3. Les interfaces de sous-système ne connaissent pas Facade et ne devraient pas avoir de référence à l'interface Facade
4. Le modèle de façade doit être appliqué pour des types d'interfaces similaires , son but est de fournir une interface unique plutôt que plusieurs interfaces qui effectuent le même type de travail

Jetez également un œil à l' article sur la création de sources pour une meilleure compréhension.

Le modèle de façade est un wrapper de nombreuses autres interfaces dans un résultat pour produire une interface plus simple.

Les modèles de conception sont utiles car ils résolvent des problèmes récurrents et simplifient en général le code. Dans une équipe de développeurs qui acceptent d'utiliser les mêmes modèles, cela améliore l'efficacité et la compréhension lors de la maintenance du code de chacun.

Essayez de lire plus de modèles:

Modèle de façade: http://www.dofactory.com/Patterns/PatternFacade.aspx#_self1

ou plus généralement: http://www.dofactory.com/Patterns/Patterns.aspx

Une utilisation supplémentaire du modèle Façade pourrait être de réduire la courbe d'apprentissage de votre équipe. Laisse moi te donner un exemple:

Supposons que votre application ait besoin d'interagir avec MS Excel en utilisant le modèle objet COM fourni par Excel. L'un des membres de votre équipe connaît toutes les API Excel et il crée une façade par-dessus, qui remplit tous les scénarios de base de l'application. Aucun autre membre de l'équipe n'a besoin de consacrer du temps à l'apprentissage de l'API Excel. L'équipe peut utiliser la façade sans connaître les internes ou tous les objets MS Excel impliqués dans la réalisation d'un scénario. N'est-ce pas génial?

Ainsi, il fournit une interface simplifiée et unifiée au-dessus d'un sous-système complexe.

Autre exemple de façade: disons que votre application se connecte à la base de données et affiche les résultats sur l'interface utilisateur. Vous pouvez utiliser la façade pour rendre votre application configurable, comme en cours d'exécution à l'aide d'une base de données ou avec des objets fictifs. Vous ferez donc tous les appels de base de données à la classe de façade, où elle lira la configuration de l'application et décidera de lancer la requête db ou de renvoyer l'objet fictif. de cette façon, l'application devient indépendante de la base de données si la base de données n'est pas disponible.

Une façade expose des fonctions simplifiées qui sont principalement appelées et l'implémentation cache la complexité que les clients auraient autrement à gérer. En général, l'implémentation utilise plusieurs packages, classes et fonctions. Des façades bien écrites rendent l'accès direct à d'autres classes rare. Par exemple, lorsque je visite un guichet automatique et que je retire un montant. Le guichet automatique cache s'il va directement à la banque détenue ou s'il passe par un réseau négocié pour une banque externe. Le guichet automatique agit comme une façade consommant plusieurs appareils et sous-systèmes avec lesquels, en tant que client, je n'ai pas à traiter directement.

Il existe un très bon exemple concret du modèle: le démarreur de voiture .

En tant que conducteurs, nous allumons simplement la clé et la voiture démarre. Aussi simple que possible. Dans les coulisses, de nombreux autres systèmes de voiture sont impliqués (comme la batterie, le moteur, le carburant, etc.), pour que la voiture démarre avec succès, mais ils sont cachés derrière le démarreur.

Comme vous pouvez le voir, le démarreur de la voiture est la façade. Cela nous donne une interface facile à utiliser, sans nous soucier de la complexité de tous les autres systèmes automobiles.

Résumons:

Le modèle Facade simplifie et masque la complexité des grands blocs de code ou API, offrant une interface plus claire, compréhensible et facile à utiliser.

Une façade est une classe avec un niveau de fonctionnalité qui se situe entre une boîte à outils et une application complète, offrant une utilisation simplifiée des classes dans un package ou sous-système. L'intention du modèle de façade est de fournir une interface qui rend un sous-système facile à utiliser. - Extrait du livre Design Patterns en C #.

Facade traite de l'encapsulation d'un sous-système complexe dans un seul objet d'interface. Cela réduit la courbe d'apprentissage nécessaire pour exploiter avec succès le sous-système. Il favorise également le découplage du sous-système de ses clients potentiellement nombreux. D'un autre côté, si la façade est le seul point d'accès pour le sous-système, elle limitera les fonctionnalités et la flexibilité dont les «utilisateurs expérimentés» peuvent avoir besoin.

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

Un modèle de conception est une solution générale réutilisable à un problème courant dans un contexte donné dans la conception de logiciels.

Le modèle de conception de façade est un modèle structurel car il définit une manière de créer des relations entre des classes ou des entités. Le modèle de conception de façade est utilisé pour définir une interface simplifiée vers un sous-système plus complexe.

Le modèle de façade est idéal lorsque vous travaillez avec un grand nombre de classes interdépendantes, ou avec des classes qui nécessitent l'utilisation de plusieurs méthodes, en particulier lorsqu'elles sont compliquées à utiliser ou difficiles à comprendre. La classe de façade est un «wrapper» qui contient un ensemble de membres faciles à comprendre et simples à utiliser. Ces membres accèdent au sous-système pour le compte de l'utilisateur de la façade, masquant les détails de mise en œuvre.

Le modèle de conception de façade est particulièrement utile lors de l'emballage de sous-systèmes qui sont mal conçus mais ne peuvent pas être refactorisés car le code source n'est pas disponible ou l'interface existante est largement utilisée. Parfois, vous pouvez décider d'implémenter plusieurs façades pour fournir des sous-ensembles de fonctionnalités à des fins différentes.

Un exemple d'utilisation du modèle de façade est l'intégration d'un site Web avec une application métier. Le logiciel existant peut inclure de grandes quantités de logique métier auxquelles il faut accéder d'une manière particulière. Le site Web peut ne nécessiter qu'un accès limité à cette logique métier. Par exemple, le site Web peut avoir besoin de montrer si un article à vendre a atteint un niveau de stock limité. La méthode IsLowStock de la classe de façade peut renvoyer une valeur booléenne pour l'indiquer. En coulisse, cette méthode pourrait masquer les complexités du traitement du stock physique actuel, du stock entrant, des articles alloués et du faible niveau de stock pour chaque article.

Tous les modèles de conception sont des classes organisées d'une manière ou d'une autre qui convient à une application spécifique. Le motif de façade a pour but de masquer la complexité d'une ou plusieurs opérations. Vous pouvez voir un exemple et apprendre le modèle de façade sur http://precatelyconcise.com/design_patterns/facade.php

Il s'agit simplement de créer un wrapper pour appeler plusieurs méthodes. Vous avez une classe A avec les méthodes x () et y () et une classe B avec les méthodes k () et z (). Vous voulez appeler x, y, z à la fois, pour faire cela en utilisant le modèle Facade, vous créez simplement une classe Facade et créez une méthode, disons xyz (). Au lieu d'appeler chaque méthode (x, y et z) individuellement, vous appelez simplement la méthode wrapper (xyz ()) de la classe de façade qui appelle ces méthodes.

Un modèle similaire est référentiel, mais il s agit principalement de la couche d accès aux données.

Il s'agit essentiellement d'un système de dégagement de fenêtre unique. Vous attribuez tout travail qu'il déléguera à une méthode particulière dans une autre classe.

Le modèle de conception de façade relève du modèle de conception structurelle. En bref, Façade signifie l'aspect extérieur. Cela signifie que dans le modèle de conception de façade, nous cachons quelque chose et ne montrons que ce dont le client a réellement besoin. En savoir plus sur le blog ci-dessous: http://www.sharepointcafe.net/2017/03/facade-design-pattern-in-aspdotnet.html

Le modèle de façade fournit une interface unifiée au groupe d'interfaces de sous-système. La façade définit une interface de haut niveau, ce qui simplifie le travail avec le sous-système.