É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:
