Quel est le design pattern de façade?

Question

Est-ce que facade est 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 conception Facade ?

Answer 1

Un patron de conception est une manière courante de résoudre un problème récurrent. Les classes dans tous les patrons de conception ne sont que des classes normales. Ce qui est important, c'est comment elles sont structurées et comment elles travaillent ensemble pour résoudre un problème donné de la meilleure manière possible.

Le patron de conception Façade simplifie l'interface vers un système complexe, car il est généralement composé de toutes les classes qui constituent les sous-systèmes du système complexe.

Une Façade protège l'utilisateur des détails complexes du système et lui fournit une vue simplifiée de celui-ci qui est facile à utiliser. Elle désolidarise également le code qui utilise le système des détails des sous-systèmes, facilitant ainsi la modification du système ultérieurement.

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

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

De plus, ce qui est important lors de l'apprentissage des patrons de conception, c'est d'être capable de reconnaître quel patron convient à votre problème donné et de l'utiliser de manière appropriée. Il est très courant de mal utiliser un patron ou d'essayer de l'appliquer à un problème juste parce que vous le connaissez. Soyez conscient de ces pièges lors de l'apprentissage/utilisation des patrons de conception.

Answer 2

Wikipédia propose un excellent exemple du patron de conception Façade.

/* Parties complexes */

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

/* Façade */

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

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

    public void start() {
        processeur.freeze();
        ram.load(ADRESSE_DE_BOOT, hd.read(SECTEUR_DE_BOOT, TAILLE_SECTEUR));
        processeur.jump(ADRESSE_DE_BOOT);
        processeur.execute();
    }
}

/* Client */

class You {
    public static void main(String[] args) {
        ComputerFacade ordinateur = new ComputerFacade();
        ordinateur.start();
    }
}

Answer 3

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

1. Allumer la télévision si nécessaire ;
2. Vérifier que le satellite / câble fonctionne ;
3. Passer à ESPN si nécessaire.

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

Answer 4

La façade cache 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 "Inventaire vérifié";
}
}

public class Payment {
public String deductPayment(String orderID) {
    return "Paiement déduit avec succès";
}
}

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("Étapes suivantes complétées:" + step1
                    + " & " + step2);
   }
}

public class Client {
       public static void main(String args[]){
         OrderFacade orderFacade = new OrderFacade();
         orderFacade.placeOrder("OR123456");
         System.out.println("Traitement de la commande terminé");
       }
  }

Answer 5

Une façade ne doit pas être décrite comme une classe qui contient beaucoup d'autres classes. C'est en fait une interface vers ces classes et devrait rendre l'utilisation des classes plus facile, sinon la classe de façade est inutile.