Validador de Usuarios

Éste programa realiza la validación de ingreso de un usuario, que puede pertenecer a  un tipo específico, mediante la comprobación de datos existentes en una base de datos, creada en Mysql.   Éste programa   implementan los patrones de factory method para la creacion de los usuarios, y el patrón singletón, que garantiza una única instacia de la clase conexión a la base de datos, para  realizar las consultas. 
Inicialmente creamos la clase encargada de retornar la conexión.  Ésta se encuentra en la paquete bd.
package bd;
import java.sql.*;
/**
 * Clase encargada de realizar la conexion con la base de datos esta misma clase se encarga de consultar y hacer persistencia de datos.
 * 
 * @author Katherin Zubieta y Johanna Gutierrez
 */
public class Conexion {
    static private String bd = "validacionUsuarios";
    static private String login = "root";
    static private String password = "root";
    static private String url = "jdbc:mysql://localhost/" + bd;
    static private Conexion conex = null;
    private String CadenaSql;
    private Connection conexion = null;
    /**
     * El contructor se encarga de realizar la conexion a la base de datos
     * y muestra en  consola mensajes si se pudo o no conectar a la base de datos.
     * 
     * @exception sqlEx  SQLException
     * @exception ex   ClassNotFoundException
     */
    private Conexion() {
        try {
            System.out.println("Tratando de cargar el driver");
            Class.forName("com.mysql.jdbc.Driver");
            conexion = DriverManager.getConnection(url, login, password);
            if (conexion != null) {
                System.out.println("Conexion a base de datos " + bd + " OK");
            }
        } catch (SQLException sqlEx) {
            System.out.println(sqlEx);
        } catch (ClassNotFoundException ex) {
            System.out.println(ex);
        }
    }
    /**
     * Método en el cual a la clase se le implementa del patrón Singleton
     * @return Conexion
     */
    static public Conexion getConexion() {
        if (conex == null) {
            conex = new Conexion();
        }
        return conex;
    }
    /**
     *
     * Método que realizar las consultas, para poder usarla debe existir
     * una conexion a base de datos.
     *
     *
     * @return ResultSet
     * @exception ex  SQLException
     */
    public ResultSet Consultar() {
        ResultSet tabla = null;
        try {
            Statement stmt = conexion.createStatement();
            tabla = stmt.executeQuery(CadenaSql);
        } catch (SQLException ex) {
            System.out.println(ex);
        }
        return tabla;
    }
    /**
     * Método en el cual se le asigna el valor a la cadenaSql
     *
     * @param  String cadena;
     */
    
    public void setCadena(String cadena) {
        CadenaSql = cadena;
    }
    /**
     * Método el cual retorna la conexion existente.
     *
     * @return  Connection;
     */
    public Connection getConectar() {
        return conexion;
    }
    /**
     * Método encargado de realizar la desconexion a base de datos
     */
    public void desconectar() {
        conexion = null;
    }
}
Ahora creamos nuestro creador, debido a que implementamos Factory Method, y debido a éste patrón,  hemos separado éstas clases en un paquete  (logica) , diferente al de la clase conexión.
package logica;
/**
 * Clase abstracta encargada de definir
 * el tipo de usuario que se creará.
 *
 * @author Katherin Zubieta y Johanna Gutierrez
 */
public abstract class Creador {
    /**
     * Método que retorna el tipo sesion de usuario creado.
     *
     * @return TipoUsuario
     */
    public TipoUsuario construir() {
        TipoUsuario tipoUs = factoryMethod();
        return tipoUs;
    }
    /**
     * Método abstracto que retorna el tipo se sesion de usuario
     * @return TipoUsuario
     */
    public abstract TipoUsuario factoryMethod();
}
Ahora creamos cada creador segun el tipo de usuario.
package logica;
/**
 * Clase encargada de construir el tipo de sesion 
 * del usuario hereda de la clase Creador.
 *
 * @author Katherin Zubieta y Johanna Gutierrez
 */
public class CreadorComun extends Creador {
    /**
     * Método que retorna el tipo de sesion del usuario
     * @return TipoUsuario
     */
    public TipoUsuario factoryMethod() {
        return new Comun();
    }
}
package logica;
/**
 * Clase encargada de construir el tipo de sesion
 * del usuario hereda de la clase Creador.
 *
 * @author Katherin Zubieta y Johanna Gutierrez
 */
public class CreadorCorporativo extends Creador {
    /**
     * Método que retorna el tipo de sesion del usuario
     * @return TipoUsuario
     */
    public TipoUsuario factoryMethod() {
        return new Corporativo();
    }
}
package logica;
/**
 * Clase encargada de construir el tipo de sesion
 * del usuario hereda de la clase Creador.
 *
 * @author Katherin Zubieta y Johanna Gutierrez
 */
public class CreadorLocal extends Creador {
    /**
     * Método  que retorna el tipo de sesion del usuario
     * @return TipoUsuario
     */
    public TipoUsuario factoryMethod() {
        return new Local();
    }
}
package logica;
/**
 * Clase encargada de construir el tipo de sesion
 * del usuario hereda de la clase Creador.
 *
 * @author Katherin Zubieta y Johanna Gutierrez
 */
public class CreadorRemoto extends Creador {
    /**
     * Método  que retorna el tipo de sesion del usuario
     * @return TipoUsuario
     */
    public TipoUsuario factoryMethod() {
        return new Remoto();
    }
}
y ahora las clases correspondiente a cada creador.
package logica;
import java.sql.ResultSet;
import java.sql.SQLException;
import javax.swing.JOptionPane;
/**
 *
 * Clase que define el tipo de sesion del usuario,
 *hereda de la clase TipoUsuario
 *
 * @author Katherin Zubieta y Johanna Gutierrez
 */
public class Comun extends TipoUsuario {
    /**
     * Constructor de la clase
     * define el atributo del tipo de usuario y sus permisos correspondientes.
     */
    public Comun() {
        tipoUsuario = "Usuario comun";
        permisos = "Usted puede Visualizar:\n\n Usuarios del tipo remoto.\n Usuarios de su mismo tipo.";
    }
    /**
     * Método heredado mediante el cual se verifica la existencia del usuario
     * en la base de datos, mediante el nombre y contraseña de usuario,
     * se existir el usuario entonces captura los
     * campos correspondientes al tipo de usuario.
     *
     * @exception ex SQLException
     */
    @Override
    public void capturaRelacion() {
        existe = false;
        conexion.setCadena("SELECT * FROM registro where nombre ='" + this.getNombre() + "'");
        ResultSet tabla = conexion.Consultar();
        try {
            while (tabla.next()) {
                if (this.getClave().compareTo(tabla.getString("clave")) == 0) {
                    this.setTipo(tabla.getString("tipoUsuario"));
                    existe = true;
                }
            }
        } catch (SQLException ex) {
            JOptionPane.showMessageDialog(null, "Problemas con la tabla");
        }
    }
}
package logica;
import java.sql.ResultSet;
import java.sql.SQLException;
import javax.swing.JOptionPane;
/**
 *
 * Clase que define el tipo de sesion del usuario,
 *hereda de la clase TipoUsuario
 *
 * @author Katherin Zubieta y Johanna Gutierrez
 */
public class Corporativo extends TipoUsuario {
    /**
     * Constructor de la clase
     * define el atributo del tipo de usuario y sus permisos correspondientes.
     */
    public Corporativo() {
        tipoUsuario = "Usuario corporativo";
        permisos = "Usted puede:\n\n Visualizar y modificar todos los tipos de usuario ";
    }
    /**
     * Método mediante el cual se verifica la existencia del usuario
     * en la base de datos, mediante el nombre y contraseña de usuario,
     * se existir el usuario entonces captura los
     * campos correspondientes al tipo de usuario.
     *
     * @exception ex SQLException
     */
    @Override
    public void capturaRelacion() {
        existe = false;
        conexion.setCadena("SELECT * FROM registro where nombre ='" + this.getNombre() + "'");
        ResultSet tabla = conexion.Consultar();
        try {
            while (tabla.next()) {
                if (this.getClave().compareTo(tabla.getString("clave")) == 0) {
                    this.setTipo(tabla.getString("tipoUsuario"));
                    existe = true;
                }
            }
        } catch (SQLException ex) {
            JOptionPane.showMessageDialog(null, "Problemas con la tabla");
        }
    }
}
package logica;
import java.sql.ResultSet;
import java.sql.SQLException;
import javax.swing.JOptionPane;
/**
 *
 * Clase que define el tipo de sesion del usuario,
 *hereda de la clase TipoUsuario
 *
 * @author Katherin Zubieta y Johanna Gutierrez
 */
public class Local extends TipoUsuario {
    /**
     * Constructor de la clase
     * define el atributo del tipo de usuario y sus permisos correspondientes.
     */
    public Local() {
        tipoUsuario = "Usuario local";
        permisos = "Usted puede Visualizar:\n\n Usuarios de su mismo tipo.";
    }
    /**
     * Método heredado mediante el cual se verifica la existencia del usuario
     * en la base de datos, mediante el nombre y contraseña de usuario,
     * se existir el usuario entonces captura los
     * campos correspondientes al tipo de usuario.
     *
     * @exception ex SQLException
     */
    @Override
    public void capturaRelacion() {
        existe = false;
        conexion.setCadena("SELECT * FROM registro where nombre ='" + this.getNombre() + "'");
        ResultSet tabla = conexion.Consultar();
        try {
            while (tabla.next()) {
                if (this.getClave().compareTo(tabla.getString("clave")) == 0) {
                    this.setTipo(tabla.getString("tipoUsuario"));
                    existe = true;
                }
            }
        } catch (SQLException ex) {
            JOptionPane.showMessageDialog(null, "Problemas con la tabla");
        }
    }
}
package logica;
import java.sql.ResultSet;
import java.sql.SQLException;
import javax.swing.JOptionPane;
/**
 *
 * Clase que define el tipo de sesion del usuario,
 *hereda de la clase TipoUsuario
 *
 * @author Katherin Zubieta y Johanna Gutierrez
 */
public class Remoto extends TipoUsuario {
    /**
     * Constructor de la clase
     * define el atributo del tipo de usuario y sus permisos correspondientes.
     */
    public Remoto() {
        this.tipoUsuario = "Usuario remoto";
        this.permisos = "Usted puede Visualizar:\n\n Usarios del tipo comun. \n Usuarios del tipo local. \n Usuarios de su mismo tipo.";
    }
    /**
     * Método heredado mediante el cual se verifica la existencia del usuario
     * en la base de datos, mediante el nombre y contraseña de usuario,
     * se existir el usuario entonces captura los
     * campos correspondientes al tipo de usuario.
     *
     * @exception ex SQLException
     */
    @Override
    public void capturaRelacion() {
        existe = false;
        conexion.setCadena("SELECT * FROM registro where nombre ='" + this.getNombre() + "'");
        ResultSet tabla = conexion.Consultar();
        try {
            while (tabla.next()) {
                if (this.getClave().compareTo(tabla.getString("clave")) == 0) {
                    this.setTipo(tabla.getString("tipoUsuario"));
                    existe = true;
                }
            }
        } catch (SQLException ex) {
            JOptionPane.showMessageDialog(null, "Problemas con la tabla");
        }
    }
}
Ahora creamos la clase que maneja los datos de cada usuario.
package logica;
import bd.Conexion;
/**
 *
 * @author Katherin Zubieta y Johanna Gutierrez
 *
 * Ésta clase maneja los datos de la sesion del usuario
 */
public abstract class TipoUsuario {
    protected String nombreUsuario;
    protected String claveUsuario;
    protected String tipoUsuario;
    protected boolean existe;
    protected Conexion conexion;
    public String permisos;
    /**
     * Crea una instacia de la clase conexión
     * con los datos de la clase.
     *
     */
    public TipoUsuario() {
        conexion = Conexion.getConexion();
        existe = false;
    }
    /**
     * Método que retorna el tipo de usuario
     * @return String
     */
    public String getTipoUsuario() {
        return tipoUsuario;
    }
    /**
     * Método que retorna el nombre de usuario.
     * @return String
     */
    public String getNombre() {
        return nombreUsuario;
    }
    /**
     * Método que retorna la contraseña del usuario.
     * @return String
     */
    public String getClave() {
        return claveUsuario;
    }
    /**
     * Método que recibe el nombre del usuario
     * @param nombre  String  alamacena el nombre del usuario
     */
    public void setNombre(String nombre) {
        this.nombreUsuario = nombre;
    }
    /**
     * Método que recibe la contraseña del usuario.
     * @param clave  String  almacena la contaseña del usuario
     */
    public void setClave(String clave) {
        this.claveUsuario = clave;
    }
    /**
     * Método que retorna el valor de verdad de existencia del usuario.
     * @return boolean
     */
    public boolean getExistencia() {
        return existe;
    }
    /**
     * Método que recibe el tipo de usuario.
     * @param tipo String identificador principal de la clase de usuario.
     */
    public void setTipo(String tipo) {
        this.tipoUsuario = tipo;
    }
    /**
     * Método que retorna la informacion de los permisos
     * para lo que el usuario puede realizar en la sesion
     * debido al tipo de usuario.
     * @return String
     */
    public String getInformacion() {
        return permisos;
    }
    /**
     * Método abstracto de la clase.
     */
    public abstract void capturaRelacion();
}
Ahora necesitamos una clase que nos permita visualizar nuestro programa, por ende, tenemos la ventana encargada de solicitar los datos básicos.  las siguientes dos clase estan en paquetes distintos debido a que ellas solo representan la interfaz de la aplicación.
package interfaz;
import java.awt.event.*;
import java.awt.*;
import javax.swing.JOptionPane;
import logica.*;
/**
 * Clase que presenta al usuario una ventana
 * para el ingreso de los datos y validar su existencia.
 * Hereda de Frame e implementa ActionListener.
 *
 * 
 * @author Katherin  Zubieta y Johanna Gutierrez
 */
public class Validacion extends Frame implements ActionListener {
    private Creador creador;
    private Label Usuario,  Clave;
    private TextField txfUs,  txfCl;
    private Button Salir,  Ingresar;
    private TipoUsuario us;
    /**
     * Constructor de la clase, inicializa todos los atributos.
     */
    public Validacion() {
        setLayout(null);
        this.setBackground(Color.BLACK);
        this.setResizable(false);
        Ingresar = new Button("Ingresar");
        creador = new CreadorLocal();
        us = creador.construir();
        Usuario = new Label("USUARIO :");
        Usuario.setForeground(Color.white);
        txfUs = new TextField(25);
        txfUs.setText(null);
        txfUs.setBackground(Color.white);
        Clave = new Label("CONTRASEÑA :");
        Clave.setForeground(Color.white);
        txfCl = new TextField(30);
        txfCl.setText(null);
        Salir = new Button("Cancelar");
        add(Usuario);
        Usuario.setBounds(30, 60, 90, 20);
        add(txfUs);
        txfUs.setBounds(195, 60, 170, 20);
        txfUs.addActionListener(this);
        add(Clave);
        Clave.setBounds(30, 90, 90, 20);
        add(txfCl);
        txfCl.setBounds(195, 90, 170, 20);
        txfCl.addActionListener(this);
        add(Ingresar);
        Ingresar.setBounds(50, 150, 90, 30);
        Ingresar.addActionListener(this);
        add(Salir);
        Salir.setBounds(250, 150, 90, 30);
        Salir.addActionListener(this);
        addWindowListener(new Cierre());
    }
    /**
     * Main de la aplicación, inicializa y fija los valores de la propia ventana.
     * @param args
     */
    public static void main(String[] args) {
        Validacion miIngreso = new Validacion();
        miIngreso.setTitle("Validar Usuario y Contraseña");
        miIngreso.setLocation(400, 200);
        miIngreso.setSize(400, 200);
        miIngreso.setVisible(true);
    }
    /**
     * Método que recibe un evento del mouse para
     * identificar que botón fue seleccionado.
     * @param e ActionEvent
     */
    public void actionPerformed(ActionEvent e) {
        if (e.getSource() == Ingresar) {
            if (txfUs.getText().length() != 0 && txfCl.getText().length() != 0) {
                us.setNombre(txfUs.getText());
                us.setClave(txfCl.getText());
                us.capturaRelacion();
                if (us.getExistencia() == true) {
                    if (us.getTipoUsuario().compareTo("local") == 0) {
                        creador = new CreadorLocal();
                        us = creador.construir();
                    }
                    if (us.getTipoUsuario().compareTo("remoto") == 0) {
                        creador = new CreadorRemoto();
                        us = creador.construir();
                    }
                    if (us.getTipoUsuario().compareTo("comun") == 0) {
                        creador = new CreadorComun();
                        us = creador.construir();
                    }
                    if (us.getTipoUsuario().compareTo("corporativo") == 0) {
                        creador = new CreadorCorporativo();
                        us = creador.construir();
                    }
                    this.dispose();
                    MenuUsuario MiMenu = new MenuUsuario(us);
                } else {
                    JOptionPane.showMessageDialog(null,
                            "Usuario y/o contrase�a incorrectos ",
                            "Ingrese nuavamente sus datos", 0);
                }
            } else {
                JOptionPane.showMessageDialog(
                        null,
                        " Existen Campos en blanco, <>",
                        "Informacion Incompleta", 2);
            }
        }
        if (e.getSource() == Salir) {
            System.exit(0);
        }
    }
    class Cierre extends WindowAdapter {
        /**
         * Método que recibe un evento del mouse en  la ventana, y se encarga de finalizar la ejecución de la aplicación.
         * @param e WindowEvent
         */
        @Override
        public void windowClosing(WindowEvent e) {
            System.exit(0);
        }
    }
}
y ahora la ventana que se generará si el usuario esta registrado, en ella se describe los permisos que el usuario posee segun su tipo de usuario.
package interfaz;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import logica.TipoUsuario;
/**
 * Clase donde que presenta la ventana donde se muestra la informacion
 * de los permisos del usuario.
 * Hereda de Frame e implementa ActionListener
 *
 * @author Katherin Zubieta y Johanna Gutierrez
 */
public class MenuUsuario extends Frame implements ActionListener {
    private Button salir;
    private JTextArea informacion;
    private TipoUsuario relacion;
    private Font fuente1;
    /**
     * Constructor de la clase Inicializa todos sus atributos, recibe comoparámetro un TipoUsuario
     * @param datos  TipoUsuario
     */
    public MenuUsuario(TipoUsuario datos) {
        this.setLayout(null);
        this.setResizable(false);
        relacion = datos;
        this.setTitle("BIENVENIDO  " + " ***** " + relacion.getTipoUsuario() + " ***** ");
        this.setSize(380, 280);
        this.setLocation(200, 70);
        this.setBackground(Color.BLACK);
        salir = new Button("Salir");
        salir.setBounds(160, 210, 70, 40);
        salir.addActionListener(this);
        add(salir);
        informacion = new JTextArea();
        informacion.setSize(250, 150);
        informacion.setLocation(70, 50);
        add(informacion);
        fuente1 = new Font("Helvética", Font.ITALIC + Font.ROMAN_BASELINE, 12);
        informacion.setFont(fuente1);
        informacion.setText(relacion.permisos);
        this.setVisible(true);
        informacion.setForeground(Color.blue);
        informacion.setEditable(false);
        addWindowListener(new Cierre());
    }
    /**
     * Método que recibe un evento del mouse en su botón,
     * de modo que finaliza la ejecución de la aplicación.
     * @param e ActionEvent
     */
    public void actionPerformed(ActionEvent e) {
        if (e.getSource() == salir) {
            System.exit(0);
        }
    }
}
class Cierre extends WindowAdapter {
    /**
     * Método que recibe un evento del mouse en  la ventana, y se encarga de finalizar la ejecución de la aplicación.
     * @param e WindowEvent
     */
    @Override
    public void windowClosing(WindowEvent e) {
        System.exit(0);
    }
}
package interfaz;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import logica.TipoUsuario;
/**
 * Clase donde que presenta la ventana donde se muestra la informacion
 * de los permisos del usuario.
 * Hereda de Frame e implementa ActionListener
 *
 * @author Katherin Zubieta y Johanna Gutierrez
 */
public class MenuUsuario extends Frame implements ActionListener {
    private Button salir;
    private JTextArea informacion;
    private TipoUsuario relacion;
    private Font fuente1;
    /**
     * Constructor de la clase Inicializa todos sus atributos, recibe comoparámetro un TipoUsuario
     * @param datos  TipoUsuario
     */
    public MenuUsuario(TipoUsuario datos) {
        this.setLayout(null);
        this.setResizable(false);
        relacion = datos;
        this.setTitle("BIENVENIDO  " + " ***** " + relacion.getTipoUsuario() + " ***** ");
        this.setSize(380, 280);
        this.setLocation(200, 70);
        this.setBackground(Color.BLACK);
        salir = new Button("Salir");
        salir.setBounds(160, 210, 70, 40);
        salir.addActionListener(this);
        add(salir);
        informacion = new JTextArea();
        informacion.setSize(250, 150);
        informacion.setLocation(70, 50);
        add(informacion);
        fuente1 = new Font("Helvética", Font.ITALIC + Font.ROMAN_BASELINE, 12);
        informacion.setFont(fuente1);
        informacion.setText(relacion.permisos);
        this.setVisible(true);
        informacion.setForeground(Color.blue);
        informacion.setEditable(false);
        addWindowListener(new Cierre());
    }
    /**
     * Método que recibe un evento del mouse en su botón,
     * de modo que finaliza la ejecución de la aplicación.
     * @param e ActionEvent
     */
    public void actionPerformed(ActionEvent e) {
        if (e.getSource() == salir) {
            System.exit(0);
        }
    }
}
class Cierre extends WindowAdapter {
    /**
     * Método que recibe un evento del mouse en  la ventana, y se encarga de finalizar la ejecución de la aplicación.
     * @param e WindowEvent
     */
    @Override
    public void windowClosing(WindowEvent e) {
        System.exit(0);
    }
}
Para un mejor entendimiento de la aplicación, sobre los requisitos de instalación y funcionamiento, se han creado los manuales concernientes a la instalacion de eclipse, del programa, y la ejecución del programa.
Puede  acceder a ellos  en la siguiente dirección:
Publicado por en 1 comentario:

PATRONES DE COMPORTAMIENTO

Los patrones de comportamiento describen no sólamente patrones de objetos o clases sino también patrones de comunicación entre ellos.   La variación de la encapsulación es la base de muchos patrones de comportamiento. Cuando un aspecto de un programa cambia frecuentemente, estos patrones definen un objeto que encapsula dicho aspecto. Los patrones definen una clase abstracta que describe la encapsulación del objeto.
Publicado por en No hay comentarios:

PATRON INTERPRETER

Motivación:
A veces es conveniente representar un problema, como palabras de algún lenguaje sencillo.  Éste patrón describe cómo  definir la representación de una gramática, representar palabras del lenguaje y cómo interpretarlas.  

Estructura:

Este patrón utiliza una Clase para representar cada Regla de la Gramática, siendo los símbolos del lado izquierdo de cada regla una Instancia de la Clase. Además Cada Expresión Regular definida por esta gramática puede ser representada mediante un Árbol Abstracto de Sintaxis que se elabora a partir de cada Instancia de la Clase. 

Participantes:

  • AbstractExpression

Declara una operación abstracta del intérprete, común a todos los nodos en el árbol de abstracto sintaxis.

 

  • TerminalExpression

Implementa una operación del intérprete asociada  con los símbolos terminales de la gramática.

Requiere una instancia para terminar los símbolos en las sentencias.

 

  • NonterminalExpression

Una clase como esta es requerida para todas las reglas R ::= R1 R2 ... Rn en la gramática.

Mantiene instacias de las variables de tipo AbstractExpression

 Para cada uno de los símbolos de R1  a través de Rn.

Implementa una operación del interprete para símbolos no terminales en la gramática. Típicamente el interprete llama así mismo recursivamente en las variables representadas de R1 a través de Rn.

 

  • Context:

Contiene la información global para la interpretación.

  • Client:

Construye o da la sintaxis del árbol abstracto representando una sentencia particular en el lenguaje que el programador define. La sintaxis del árbol abstracto reúne instancias de NonterminalExpression y clases TerminalExpressione.

Invoca operaciones del interprete.

Referencias:
Publicado por en No hay comentarios:

PATRON MEDIATOR

Motivación:
Cuando muchos objetos interactúan con otros objetos, se puede formar una estructura muy compleja, con objetos con muchas conexiones con otros objetos. En un caso extremo cada objeto puede conocer a todos los demás objetos. Para evitar esto el patrón Mediator encapsula el comportamiento de todo un conjunto de objetos en un solo objeto.
Estructura:
Participantes:
  • Mediator  (mediador ):
Define una interfaz para la comunicación con los objetos Collegue.
  • ConcreteMediator  (mediador concreto):
Implementa el comportamietno cooperativo a través de la cordinacion de objetos Collgue.
Conoce y mantiene sus  colleagues.
  • Colleague   (colegas):
Cada  Colleague sabe sobre su objeto de la  clase Mediator.
Cada  colleague se comunica con el mediator, de lo contrario debe  comunicarse con otro colleague.
Referencias:
Publicado por en No hay comentarios:

PATRON CHAIN OF RESPONSIBILITY

Motivación:
"Cadena de Responsabilidad".  Permite a un número de clases atender a una petición requerida, sin saber ninguna de ellas las características de las otras. Provee de un cierto desacoplamiento entre las clases. Cada objeto sabe cómo evaluar la petición para una acción y, si no la puede controlar por si mismo, sabe solamente cómo pasarla a otro objeto, por ello la “cadena”.  La cadena de responsabilidad puede ser implementada utilizando una cadena predefinida oestática, o las cadenas pueden ser dinámicas, construidas en tiempo de ejecución teniendo cada objeto su propio sucesor cuando sea necesario.
Estructura:
Participantes:
  • Handler (Aprobación)
Define una interface para el manejo de las solicitudes.
(optional) implementa el sucesor de enlaces.
  • ConcreteHandler (Director, VicePresidente, Presidente)
Se ocupa de las solicitudes, es responsable del acceso al sucesor del enlace. Si el ConcreteHandler puede manejar la solicitud, de lo contrario envía la solicitud a un sucesor.
  • Client (ChainApp)
Inicia la solicitud de un objeto ConcreteHandler en la cadena.
Implementación:
El cliente hace una petición y según la elección, se crea o se hace la accion dependiendo la clase que tenga esa responsabilidad.
public abstract class Pinturas { /*public static int ERR = 3; public static int NOTICE = 5; public static int DEBUG = 7; */ protected String color; protected Pinturas next; // el siguiente elemento en la cadena public Pinturas setNext(Pinturas l) { next = l; return this; } abstract public void mensaje(String msg); }
public class PinturaBlanca extends Pinturas{ public PinturaBlanca() { this.color = "Blanca"; //this.mask = mask; } public void mensaje( String msg ) { if (color.compareTo(msg) == 0) { System.out.println("Pintamos de Blanco"); }else { if (next != null) { next.mensaje(msg); } } } }
public class PinturaAzul extends Pinturas{ public PinturaAzul() { this.color = "Azul"; //this.mask = mask; } public void mensaje( String msg ) { if (color.compareTo(msg) == 0) { System.out.println("Pintamos de Azul"); }else { if (next != null) { next.mensaje(msg); } } } }
public class PinturaAmarilla extends Pinturas{ public PinturaAmarilla() { this.color = "Amarillo"; //this.mask = mask; } public void mensaje( String msg ) { if (color.compareTo(msg) == 0) { System.out.println("Pintamos de Amarillo"); }else { if (next != null) { next.mensaje(msg); } } } }
public class Cliente { public static void main(String[] args) { // Construimos la cadena Pinturas pint = new PinturaAzul().setNext( new PinturaBlanca().setNext( new PinturaAmarilla() ) ); pint.mensaje("Amarillo"); } }
Referencias:
Publicado por en No hay comentarios:

PATRON TEMPLATE METHOD

Motivación:
"Template" significa plantilla.  Redefine los pasos de un algoritmo sin cambiar la estructura, permitiendo un cambio dinámico en la ejecución de un algoritmo.  De tal modo que cuando se implementa pasa a ser un algoritmo complejo, que evita la duplicación de código.
Estructura:
Participantes:
  • AbstractClass (DataObject)
Define operaciones abstractas primitivas que definen subclases concretas para aplicar las medidas de un algoritmo
Aplica un método de definición de plantilla el esqueleto de un algoritmo. La plantilla de las operaciones de llamadas a los métodos primitivos, así como operaciones definidas en AbstractClass o los de otros objetos.
  • ConcreteClass (CustomerDataObject)
Implementa operaciones primitivas para llevar a cavo  pasos  específicos de las clases del algoritmo.
Referencias:
Publicado por en No hay comentarios:

PATRON STATE Y MEMENTO

Motivación:
Para aquellas clases que, según su estado actual varía su comportamiento ante los diferentes mensajes, cuando se quiere  que un objeto cambie su comportamiento, según cambia su estado, se presenta el problema de la complejidad de código. un objeto de esta clase tendrá diferentes respuestas según su estado.
Estructura:
Participantes:
  • Contexto (Context):
Este integrante define la interfaz con el cliente. Mantiene una instancia de ConcreteState (Estado Concreto) que define su estado actual.
  • Estado (State):
Define una interfaz para el encapsulamiento de la responsabilidades asociadas con un estado particular de Context.
  • Subclases de EstadoConcreto (ConcreteState):
Cada una de estas subclases implementa el comportamiento o responsabilidad de Context.
El Contexto (Context) delega el estado específico al objeto ConcreteState actual Un objeto Context puede pasarse a sí mismo como parámetro hacia un objeto State. De esta manera la clase State puede acceder al contexto si fuese necesario. Context es la interfaz principal para el cliente. El cliente puede configurar un contexto con los objetos State. Una vez hecho esto, los clientes no tendrán que tratar con los objetos State directamente. Tanto el objeto Context como los objetos de ConcreteState pueden decidir el cambio de estado.
Refrencias:
PATRON  MEMENTO
Motivación:
Se usa este patrón cuando se quiere poder restaurar el sistema desde estados pasados y por otra parte, es usado cuando se desea facilitar el hacer y deshacer de determinadas operaciones, para lo que habrá que guardar los estados anteriores de los objetos sobre los que se opere.
Estructura:
Participantes:
  • Memento.
- Almacena el estado interno de un objeto Originator.   El Memento puede almacenarmucho o parte del estado interno de Originator.
- Tiene dos interfaces. Una para Caretaker, que le permite manipular el Memento únicamente para pasarlo a otros objetos. La otra interfaz sirve para que Originator pueda almacenar/restaurar su estado interno, sólo Originator puede acceder a esta interfaz, al menos en teoría. 
  • Originator.
- Originator crea un objeto Memento conteniendo una fotografía de su estado interno.
- Originator usa a Memento para restaurar su estado interno.
  •  Caretaker
- Es responsable por mantener a salvo a Memento.
- No opera o examina el contenido de Memento.
Referencias:
Publicado por en No hay comentarios:

PATRON ITERATOR

Motivación:
La idea principal en este patrón es tomar la responsabilidad del acceso y recorrido de la lista y colocarla dentro del objetoiterator. La clase Iterator define una interfaz para el acceso de los elementos de la lista. Un objeto iterador es responsable de mantener la pista del elemento actual; esto es, sabe cuáles elementos ya han sido recorridos. 

Separar el mecanismo de recorrido del objeto List nos permite definir iteradores para diferentes políticas de recorrido sin tener que enumerarlas en la interfaz de List. 

Cabe notar que el iterador y la lista están acoplados, y el cliente debe saber que es una lista lo que se está recorriendo, en lugar de algún otra estructura agregada. De ahí que el cliente comprometa una estructura agregada particular. Sería mejor si se pudira cambiar la clase agregada sin cambiar el código cliente. Esto se logra generalizando el concepto de iterador para soportar iteración polimorfa. 

Se define  una clase AbstractList que provea una interfaz común para manipular listas. De igual forma, necesitamos una clase abstracta Iterator que defina una interfaz de iteración común. Luego podemos definir subclasses iteradoras concretas para las diferentes implementaciones de la lista. Como resultado, el mecanismo de iteración llega a ser independiente de las clases agregadas concretas. 

El problema restante radica en cómo crear el iterador. Como se quiere es escribir código independiente de las subclasses concretas de List, no se puede instanciar una clase específica. En su lugar, hay q hacer  a los objetos de la lista responsables por la creación de su iterador correspondiente. Esto requiere una operación tal como CreateIterator, por medio de la cual los clientes solicitan un objeto iterador.

Estructura:
Participantes:
  • Iterator: 
El cual define una interfaz para el acceso y recorrido de los elementos.
  • ConcreteIterator: 
El cual implementa la interfaz de Iterator y mantiene la pista de la posición actual en el recorrido del agregado.
  • Aggregate: 
El cual define una interfaz para la creación de un objeto Iterator.
  • ConcreteAggregate: 
El cual implementa la interfaz de creación de Iterator para retornar una instancia del ConcreteIterator adecuado.
Referencias:
Publicado por en No hay comentarios:
Suscribirse a: Entradas (Atom)