¿Cuál es el patrón de diseño de la fachada?

¿Es la fachada una clase que contiene muchas otras clases?

¿Qué lo convierte en un patrón de diseño? Para mí, es como una clase normal.

¿Me puede explicar este patrón de fachada ?

Un patrón de diseño es una forma común de resolver un problema recurrente. Las clases en todos los patrones de diseño son solo clases normales. Lo importante es cómo están estructurados y cómo trabajan juntos para resolver un problema dado de la mejor manera posible.

El patrón de diseño de Fachada simplifica la interfaz a un sistema complejo; porque generalmente está compuesto por todas las clases que componen los subsistemas del sistema complejo.

Una fachada protege al usuario de los complejos detalles del sistema y les proporciona una simplified viewde la misma que es easy to use. También es decouplesel código que utiliza el sistema a partir de los detalles de los subsistemas, lo que facilita la modificación del sistema más adelante.

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

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

Además, lo que es importante al aprender patrones de diseño es poder reconocer qué patrón se ajusta a su problema dado y luego usarlo adecuadamente. Es muy común hacer un mal uso de un patrón o tratar de ajustarlo a algún problema solo porque lo conoces. Tenga en cuenta esas dificultades mientras aprende \ usando patrones de diseño.

Wikipedia tiene un gran ejemplo del patrón 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();
    }
}

Como se explicó en la respuesta anterior, proporciona una interfaz simple para el cliente consumidor. Por ejemplo: "ver ESPN" es la función prevista. Pero implica varios pasos como:

1. Encienda la televisión si es necesario;
2. Verifique el funcionamiento del satélite / cable;
3. Cambie a ESPN si es necesario.

Pero la fachada simplificará esto y solo proporcionará la función "ver ESPN" al cliente.

Facade oculta las complejidades del sistema y proporciona una interfaz para el cliente desde donde el cliente puede acceder 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 explicación corta y simple:

• El patrón de fachada proporciona una interfaz unificada a un conjunto de interfaces en un subsistema.
• Facade define una interfaz de nivel superior que hace que el subsistema sea más fácil de usar.

Intente comprender el escenario con y sin Fachada:
si desea transferir el dinero de accout1 a la cuenta2, los dos subsistemas que se invocarán son: retirar de la cuenta1 y depositar en la cuenta2.

Una fachada no debe describirse como una clase que contiene muchas otras clases. De hecho, es una interfaz para estas clases y debería facilitar el uso de las clases; de lo contrario, la clase de fachada no sirve para nada.

En cuanto a sus consultas:

¿Es Facade una clase que contiene muchas otras clases?

Si. Es un contenedor para muchos subsistemas en aplicación.

¿Qué lo convierte en un patrón de diseño? Para mí es como una clase normal.

Todos los patrones de diseño también son clases normales. @ Unmesh Kondolikar respondió correctamente esta consulta.

¿Puedes explicarme sobre esta fachada? Soy nuevo en el diseño de patrones.

Según GoF, el patrón de diseño de la fachada se define como:

Proporcione una interfaz unificada a un conjunto de interfaces en un subsistema. Facade Pattern define una interfaz de nivel superior que hace que el subsistema sea más fácil de usar

El patrón de fachada generalmente se usa cuando:

1. Se requiere una interfaz simple para acceder a un sistema complejo.
2. Las abstracciones e implementaciones de un subsistema están estrechamente acopladas.
3. Necesita un punto de entrada a cada nivel de software en capas.
4. El sistema es muy complejo o difícil de entender.

Tomemos un ejemplo de una palabra real del sitio web de cleartrip .

Este sitio web ofrece opciones para reservar

1. Vuelos
2. Hoteles
3. Vuelos + Hoteles

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

    }
}

Explicación:

1. FlightBooking, TrainBooking and HotelBooking son diferentes subsistemas de sistema grande: TravelFacade

2. TravelFacade ofrece una interfaz simple para reservar una de las siguientes opciones

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

3. la API de libro de TravelFacade llama internamente a las API de subsistemas siguientes

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

4. De esta forma, TravelFacadeproporciona una API más simple y fácil sin exponer las API del subsistema.

Conclusiones clave: (del artículo de journaldev de Pankaj Kumar )

1. El patrón de fachada es más como un ayudante para aplicaciones de cliente
2. El patrón de fachada se puede aplicar en cualquier punto de desarrollo, generalmente cuando crece el número de interfaces y el sistema se completa x .
3. Las interfaces del subsistema no conocen Facade y no deberían tener ninguna referencia de la interfaz Facade
4. El patrón de fachada debe aplicarse para un tipo similar de interfaces , su propósito es proporcionar una única interfaz en lugar de múltiples interfaces que realice el mismo tipo de trabajos

Eche un vistazo al artículo de creación de fuentes también para una mejor comprensión.

El patrón de fachada es una envoltura de muchas otras interfaces en un resultado para producir una interfaz más simple.

Los patrones de diseño son útiles ya que resuelven problemas recurrentes y, en general, simplifican el código. En un equipo de desarrolladores que aceptan usar los mismos patrones, mejora la eficiencia y la comprensión al mantener el código de los demás.

Intenta leer sobre más patrones:

Patrón de fachada: http://www.dofactory.com/Patterns/PatternFacade.aspx#_self1

o más generalmente: http://www.dofactory.com/Patterns/Patterns.aspx

Un uso adicional del patrón Fachada podría ser reducir la curva de aprendizaje de su equipo. Dejame darte un ejemplo:

Supongamos que su aplicación necesita interactuar con MS Excel haciendo uso del modelo de objetos COM proporcionado por Excel. Uno de los miembros de su equipo conoce todas las API de Excel y crea una Fachada, que cumple con todos los escenarios básicos de la aplicación. Ningún otro miembro del equipo necesita pasar tiempo aprendiendo API de Excel. El equipo puede usar la fachada sin conocer las partes internas o todos los objetos de MS Excel involucrados en el cumplimiento de un escenario. ¿No es genial?

Por lo tanto, proporciona una interfaz simplificada y unificada sobre un subsistema complejo.

Otro ejemplo de fachada: digamos que su aplicación se conecta a la base de datos y muestra resultados en la interfaz de usuario. Puede usar la fachada para hacer que su aplicación sea configurable, como en la ejecución utilizando una base de datos o con objetos simulados. Por lo tanto, realizará todas las llamadas de la base de datos a la clase de fachada, donde leerá la configuración de la aplicación y decidirá activar la consulta db o devolver el objeto simulado. de esta manera, la aplicación se vuelve independiente de db en caso de que db no esté disponible.

Una fachada expone funciones simplificadas que se denominan principalmente y la implementación oculta la complejidad con la que los clientes tendrían que lidiar. En general, la implementación utiliza múltiples paquetes, clases y funciones allí. Las fachadas bien escritas hacen que el acceso directo a otras clases sea raro. Por ejemplo, cuando visito un cajero automático y retiro una cantidad. El cajero automático oculta si va directamente al banco de su propiedad o si va a través de una red negociada para un banco externo. El cajero automático actúa como una fachada que consume múltiples dispositivos y subsistemas que, como cliente, no tengo que tratar directamente.

Hay un muy buen ejemplo de la vida real del patrón: el motor de arranque del automóvil .

Como conductores, solo giramos la llave y el auto arranca. Lo más sencillo posible. Detrás de escena, intervienen muchos otros sistemas de automóviles (como batería, motor, combustible, etc.) para que el automóvil arranque con éxito, pero están ocultos detrás del motor de arranque.

Como puede ver, el motor de arranque es la Fachada. Nos brinda una interfaz fácil de usar, sin preocuparnos por la complejidad de todos los demás sistemas de automóviles.

Resumamos:

El patrón Facade simplifica y oculta la complejidad de los bloques de código grandes o API, proporcionando una interfaz más limpia, comprensible y fácil de usar.

Una fachada es una clase con un nivel de funcionalidad que se encuentra entre un kit de herramientas y una aplicación completa, que ofrece un uso simplificado de las clases en un paquete o subsistema. La intención del patrón Facade es proporcionar una interfaz que haga que un subsistema sea fácil de usar. - Extracto del libro Design Patterns en C #.

Facade analiza la encapsulación de un subsistema complejo dentro de un único objeto de interfaz. Esto reduce la curva de aprendizaje necesaria para aprovechar con éxito el subsistema. También promueve el desacoplamiento del subsistema de sus muchos clientes potenciales. Por otro lado, si la Fachada es el único punto de acceso para el subsistema, limitará las características y la flexibilidad que puedan necesitar los "usuarios avanzados".

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

Un patrón de diseño es una solución reutilizable general a un problema común dentro de un contexto dado en el diseño de software.

El patrón de diseño de Fachada es un patrón estructural, ya que define una manera de crear relaciones entre clases o entidades. El patrón de diseño de fachada se utiliza para definir una interfaz simplificada para un subsistema más complejo.

El patrón de fachada es ideal cuando se trabaja con una gran cantidad de clases interdependientes, o con clases que requieren el uso de múltiples métodos, particularmente cuando son complicados de usar o difíciles de entender. La clase de fachada es un "contenedor" que contiene un conjunto de miembros que son fáciles de entender y fáciles de usar. Estos miembros acceden al subsistema en nombre del usuario de la fachada, ocultando los detalles de implementación.

El patrón de diseño de la fachada es particularmente útil cuando se envuelven subsistemas que están mal diseñados pero que no se pueden refactorizar porque el código fuente no está disponible o la interfaz existente se usa ampliamente. A veces puede decidir implementar más de una fachada para proporcionar subconjuntos de funcionalidad para diferentes propósitos.

Un ejemplo de uso del patrón de fachada es para integrar un sitio web con una aplicación comercial. El software existente puede incluir grandes cantidades de lógica de negocios a las que se debe acceder de una manera particular. El sitio web puede requerir solo acceso limitado a esta lógica de negocios. Por ejemplo, el sitio web puede necesitar mostrar si un artículo en venta ha alcanzado un nivel limitado de existencias. El método IsLowStock de la clase de fachada podría devolver un valor booleano para indicar esto. Detrás de escena, este método podría estar ocultando las complejidades de procesar el stock físico actual, el stock entrante, los artículos asignados y el bajo nivel de stock para cada artículo.

Todos los patrones de diseño son algunas clases organizadas de una forma u otra que se adapta a una aplicación específica. El propósito del patrón de fachada es ocultar la complejidad de una operación u operaciones. Puede ver un ejemplo y aprender el patrón de fachada en http://preciselyconcise.com/design_patterns/facade.php

Simplemente está creando un contenedor para llamar a varios métodos. Tiene una clase A con método x () e y () y clase B con método k () y z (). Desea llamar a x, y, z a la vez, para hacer eso usando el patrón Facade, simplemente cree una clase Facade y cree un método, digamos xyz (). En lugar de llamar a cada método (x, y y z) individualmente, simplemente llame al método de envoltura (xyz ()) de la clase de fachada que llama a esos métodos.

Un patrón similar es el repositorio pero es principalmente para la capa de acceso a datos.

Básicamente es un sistema de limpieza de ventana única. Usted asigna cualquier trabajo que delegará a un método particular en otra clase.

Facade Design Pattern viene bajo Structural Design Pattern. En resumen Fachada significa la apariencia exterior. Significa que en el patrón de diseño de Fachada ocultamos algo y mostramos solo lo que el cliente realmente requiere. Lea más en el siguiente blog: http://www.sharepointcafe.net/2017/03/facade-design-pattern-in-aspdotnet.html

El patrón de fachada proporciona una interfaz unificada para el grupo de interfaz del subsistema. La fachada define una interfaz de alto nivel, que simplifica el trabajo con el subsistema.