PATRON FACHADA (FACADE)

Clasificación:

Patrón Estructural.

Propósito:

Proporcionar una interfaz de alto nivel, unificada a un conjunto de interfaces en un subsistema, haciendo  más fácil de usar todas aquellas, minimizando las  comunicaciones y dependencias entre el liente y los subsistemas.

También conocido como:

Facade.

Intención:

Su objetivo es reducir al mínimo la comunicación y las dependencias entre los subsistemas;  una  manera de lograr este objetivo es introducir un objeto que proporciona la fachada de una sola  interfaz simplificada a la más general de las instalaciones de un subsistema.

Motivación :

Estructurar un sistema en subsistemas ayudando a  reducir la complejidad, estructurando un entorno de programación. 

Aplicabilidad: 

Proporciona una interfaz sencilla a un subsistema complejo, – a medida que un subsistema evoluciona va teniendo más clases, más pequeñas, más flexibles y configurables, – existen clientes que no necesitan tanta flexibilidad y que quieren una visión más simple del subsistema ,– sólo los clientes que necesiten detalles de más bajo nivel accederán a las clases detrás de la fachada, puesto que cuando hay muchas dependencias entre los clientes y las clases de implementación de una abstracción es cuando la fachada desacopla el subsistema de los clientes y de otros subsistemas, mejorando la independencia de subsistemas y la portabilidad.

Para estructurar un sistema en capas –la fachada define el punto de entrada de cada nivel, – se pueden simplificar las dependencias obligando a los subsistemas a comunicarse únicamente a través de sus fachadas.

Estructura :

 Los participantes:

• Facade: 

 Conoce qué clases son responsables de las peticiones y así, delega las peticiones a los objetos apropiados.

• Subsystem: 

 Implementa la funcionalidad del subsistema, realiza el trabajo solicitado por el objeto Façade y no  conoce, ni mantiene referencia alguna del objeto mismo Facade. 

Colaboraciones:

Los clientes se comunican con el subsistema haciendo peticiones a la Fachada, que las envía a los objetos del subsistema apropiados (la fachada podría también traducir su interfaz a la de las interfaces del subsistema), de modo que los clientes que usan la fachada no tienen que acceder a los objetos del subsistema directamente. 

Consecuencias:

Oculta a los clientes los componentes del subsistema, reduciendo  el número de objetos con los que tienen que tratar los clientes.

Disminuye el acoplamiento entre un subsistema y sus clientes, un menor acoplamiento facilita el cambio de los componentes del subsistema sin afectar a sus clientes – 

Las fachadas permiten estructurar el sistema en capas, reduciendo las dependencias de compilación. No evita que las aplicaciones puedan usar las clases del subsistema si lo necesitan, eligiendo entre facilidad de uso y generalidad.

El acoplamiento débil permite variar los componentes del subsistema, sin que ello afecte a sus clientes.

La reducción de las dependencias de compilación es de vital importancia en los grandes sistemas de software. 

Una fachada también puede simplificar los sistemas de portar a otras plataformas, ya que es menos probable  que la construcción de un subsistema requiere de la construcción todos los demás. 

Implementación:

package logica;

public class Fachada {

    

    public  String activarAire()

    {

        

        AireAcondicionadoCarro aire = new AireAcondicionadoCarro();

        aire.activarAire();

        return aire.getEstadoAlarma();

    }

    public  String activarLuces()

    {

        LucesCarro luces = new LucesCarro();

        luces.encenderLuces();

        return luces.getEstadoLuces();

    }

    public  String activarAlarma()

    {

        AlarmaCarro alarma = new AlarmaCarro();

        alarma.activarAlarma();

        return alarma.getEstadoAlarma();

    }

}

package logica;

public class AlarmaCarro {

    private String estadoAlarma;

    public void activarAlarma()

    {

        estadoAlarma= "Se ha activado la alarma";

    }

    public void desactivarAlarma()

    {

        estadoAlarma = "Se ha desactivado la alarma";

    }

    public String getEstadoAlarma()

    {

        return estadoAlarma;

    }

package logica;

public class AireAcondicionadoCarro {

    private String estadoAire;

    

    public void activarAire()

    {

        estadoAire = "Aire acondicionado encendido";

    }

    

     public String getEstadoAlarma()

    {

        return estadoAire;

    }

}

package logica;

public class LucesCarro

{

    private String estadoLuces;

    public void encenderLuces()

    { estadoLuces = "Se han encendido las luces";

    }

     public String getEstadoLuces()

    {

        return estadoLuces;

    }

}

package interfaz;

import logica.Fachada;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.WindowAdapter;

import java.awt.event.WindowEvent;

import javax.swing.JButton;

import javax.swing.JFrame;

import javax.swing.JTextArea;

public class Conductor extends JFrame implements ActionListener{

    private Fachada facha;

    private Conductor conduc;

    private JButton encenderAire;

 private JButton activarAlarma;

    private JTextArea txtArea;

 public Conductor(){

  this.setSize(400,500);

        this.setLayout(null);

        this.setDefaultCloseOperation(Conductor.DISPOSE_ON_CLOSE);

        this.setTitle(":::Carro:::");

        txtArea = new JTextArea();

        txtArea.setSize(350, 250);

        txtArea.setLocation(10, 10);

        txtArea.setText("");

        txtArea.setEditable(false);

        add(txtArea);

      

  encenderAire = new JButton();

  encenderAire.setSize(150, 50);

  encenderAire.setLocation(50, 300);

  encenderAire.setText("Aire Acondicionado Encendido");

        this.getContentPane().add(encenderAire);

        encenderAire.addActionListener(this);

        activarAlarma = new JButton();

        activarAlarma.setSize(150, 50);

        activarAlarma.setLocation(50, 350);

        activarAlarma.setText("Alarma Encendida");

        this.getContentPane().add(activarAlarma);

        activarAlarma.addActionListener(this);

        addWindowListener(new Cierre());

        facha = new Fachada();

 }

    public void actionPerformed(ActionEvent e) {

        if (e.getSource() == encenderAire) {

            txtArea.setText(facha.activarAire());

        }

        if (e.getSource() == activarAlarma)

        {

            txtArea.setText(facha.activarAlarma());

        }

 }

     class Cierre extends WindowAdapter {

        @Override

        public void windowClosing(WindowEvent e) {

            System.exit(0);

        }

    }

}

package interfaz;

/**

 *

 * @author Katherin

 */

public class Main {

    public static void main(String[] args) {

        Conductor ventana=new Conductor();

        ventana.setVisible(true);

    }

}

Usos conocidos:

ObjectWorks \ Smalltalk compilador sistema.  ET en el marco de aplicación + + [WGM88], puede tener una aplicación incorporada en herramientas de navegación para la inspección de sus objetos en tiempo de ejecución. Estas son herramientas de navegación  aplicado en un subsistema que incluye una clase llamada Fachada  "ProgrammingEnvironment". Esta fachada se define como operaciones InspectObject  y InspectClass para acceder a los navegadores.

Las opciones del sistema operativo [CIRM93] utiliza para componer muchas fachadas marcos  en uno. Las principales opciones son abstracciones en procesos, almacenamiento, y la dirección  espacios. Para cada una de estas abstracciones hay un subsistema correspondiente,  aplicarse como un marco, que apoya a las opciones de portar una gran variedad de  plataformas de hardware. Dos de estos subsistemas tienen un "representante" (es decir, la fachada).  Estos representantes son FileSystemInterface (almacenamiento) y de dominio (dirección  espacios). 

Patrones relacionados:

•  Normalmente sólo hace falta un objeto Fachada, por lo cual suele implementarse como Singleton. 
• Abstract Factory se puede utilizar con Fachada para proporcionar una interfaz para la creación de  subsistema de objetos en un subsistema de manera independiente. Resumen de fábrica también se puede  utilizarse como una alternativa a la fachada para ocultar las clases específicas de la plataforma.
• Mediator es similar a la fachada en el sentido de que la funcionalidad de los resúmenes clases. Sin embargo, el propósito del Mediador es arbitraria resumen de comunicación  entre colega objetos, a menudo la centralización de la funcionalidad que no pertenece  en cualquiera de ellos. Un mediador de colegas y son conscientes de comunicarse con  el mediador en lugar de comunicarse unos con otros directamente. En contraste, un  fachada simplemente resúmenes de la interfaz con el subsistema de objetos para que sean más fáciles  a utilizar, pero no definir nuevas funciones, y las clases del subsistema no sabe  sobre él.  

Referencias:

 PDF-Departamento de Sistemas Informáticos y Programación Curso de doctorado 1999 - 2000 Patrones  de  diseño orientado a objetos. 

 DesIgn Patterns: Elements of Reusable Object-Oriented Software Gamma, Helm, Johnson,   Vlissides Editorial              Addison-Wesley.