miércoles, 27 de mayo de 2009

SISTEMA VALIDADOR

En este post, se presenta el código fuente de un sistema de validación sencillo hecho en java y conectado a una base de datos de MySQL. En primera instancia quiero aclarar que el sistema utiliza los patrones creacionales singleton y prototype; el primero garantiza que la conexión a la base de datos sea única, mientras el segundo ofrece flexibilidad y extensibilidad, en caso de que se quieran agregar mas tipos de usuarios al sistema (claro esta que estas no son las únicas ventajas que ofrecen). Como descripción general diremos que el sistema maneja con dos tipos de usuarios, el primero tiene todos los permisos y puede consultar listas de clientes registrados , así como eliminar registros y modificarlos (usuario tipo A), el otro únicamente puede consultar su registro y midificarlo (Usuario tipo b); la persistencia de datos se hace en mySQL . En primera instancia se presenta el diagrama de clases del sistema, luego se hacen algunas observaciones y finalmente se presenta el código fuente.

Diagrama de clases.


Como podrá observar hay una clase llamada usuario y dos subclases de ésta denominadas tipoUsarioA y tipoUsuarioB; estas clases son la estructura del prototype en el programa, el patrón de diseño singleton se encuentra en la clase conexión. A parte de estas clases existe una adicional que es la que presenta la interfaz gáfica al usuario una vez se ha validado su identidad correctamente, esta clase llamada ModuloPrincipal es la que genera la ventana que se presenta al inicio de este post.

Observaciones.


Este programa funciona con una base de datos de mySQL, por lo tanto para ejecutarlo debe tener éste gestor instalado, o en tal caso instalarlo, cunado lo instale tiene que hacer dos cosas, en primer lugar tiene que crear una base de datos concorde con el código, esta debe llamarse validador, y debe tener dos tablas clientes y usuarios; la primera tiene tres campos nombre apellido y documento, todos son del tipo varchar de tamaño 10; la tabla usuarios también tiene tres campos login, clave y tipo, los dos primeros son varchar de 20 y 10 correspondientemente ,y el tercero es char (tamaño 1); las llaves primartias son nombre y login respectivamente. Además de esto tiemne que revisar en la clase conexion, del código fuente, el usuario y la clave con la que se conecta el sistema, puede crear un usuario conforme con estos datos o modificar el código para hacerlo compatible con su mySQL.

Código Fuente.

package co.edu.udistrital.validador.Logica;

/**
* Clase que implementa la interface Cloneable
*/
public abstract class Usuario implements Cloneable {

private String tipoDeUsuario = "NaDa";
private boolean obtenerUsuarios = false;
private boolean entrarSistema = false;
private boolean eliminarUsuario = false;
private boolean modificarUsuario = false;
private boolean adicionarUsuario = false;
private String nombre;
private String identificacion;
private String apellido;

/**
* metodo que recibe el nombre del tipo de Usuario
* @param String
* @uml.property name="tipoDeUsuario"
*/
public void setTipoDeUsuario(String usuario) {
this.tipoDeUsuario = usuario;

}


/**
* metodo que recibe el valor boolena de entrarsistema
* @param boolean
* @uml.property name="entarSistema"
*/
public void setEntrarSistema(boolean b) {
this.entrarSistema = b;
}

/**
* metodo que recibe el valor boolena de obtenerUsuarios
* @param boolean
* @uml.property name="obtenerUsuarios"
*/
public void setObtenerUsuario(boolean b) {
this.obtenerUsuarios = b;
}

/**
* metodo que recibe el valor boolean de EliminarUsuario
* @param boolean
* @uml.property name="eliminarUsuario"
*/
public void setEliminarUsuario(boolean b) {
this.eliminarUsuario = b;

}
/**
* metodo que recibe el valor boolean de EliminarUsuario
* @param boolean
* @uml.property name="eliminarUsuario"
*/
public void setModifiarUsuario(boolean b) {
this.modificarUsuario = b;


}
/**
* metodo que recibe el valor boolean de EliminarUsuario
* @param boolean
* @uml.property name="eliminarUsuario"
*/
public void setAdicionarUsuario(boolean b) {
this.adicionarUsuario = b;

}
public void setIdentificacion(String identificacion) {
this.identificacion = identificacion;
}

public void setNombre(String nombre) {

this.nombre = nombre;
}

public void setapellido(String apellido) {
this.apellido = apellido;
}
public boolean getEliminarUsuario(){
return this.eliminarUsuario;
}
public boolean getObtenerUsuario(){
return this.obtenerUsuarios;
}
public boolean getModifiarUsuario(){
return this.modificarUsuario;
}
public String getTipoDeUsuario() {
return this.tipoDeUsuario;
}
public boolean getAdicionarUsuario(){
return this.adicionarUsuario;
}
public String getIdentificacion() {
return identificacion;
}

public String getNombre() {
return nombre;
}

public String getApellido() {
return apellido;
}

public String adicionarUsuario() {
String CadenaSQL;
if (adicionarUsuario) {
CadenaSQL = "INSERT INTO clientes VALUES('" + this.nombre + "','" + this.apellido + "','" + this.identificacion + "')";
return CadenaSQL;
}else{
return CadenaSQL = null;
}
}

public String modificarUsuario() {
String CadenaSQL;
if (modificarUsuario) {
CadenaSQL = "UPDATE clientes SET apellido = '" + this.apellido + "', documento = '" + this.identificacion + "' WHERE (nombre = '" + this.nombre + "')";
return CadenaSQL;
}else{
return CadenaSQL = null;
}

}

public String eliminarUsusario() {
String CadenaSQL;
if (eliminarUsuario) {
CadenaSQL = "DELETE FROM clientes WHERE(nombre = '" + this.nombre + "')";
return CadenaSQL;
}else{
return CadenaSQL = null;
}
}

public String consultarUsuarios() {
String CadenaSQL;
if (obtenerUsuarios) {
CadenaSQL = "SELECT * FROM clientes";
return CadenaSQL;
}else{
return CadenaSQL = null;
}
}

public String consultarUnUsuario() {
String CadenaSQL;
CadenaSQL = "SELECT * FROM clientes WHERE(nombre = '" + this.nombre + "')";
return CadenaSQL;
}

}


package co.edu.udistrital.validador.Logica;
/**
* Clase que define un tipo de usuario, hereda de la clase Usuario
*/

public class TipoUsuarioA extends Usuario{
/**
* Metodo heredado de la clase usuario, que a su vez implementa
* la interface Cloneable
*
* @return Object
*/
public Object clone(){
Object o=null;
try{
o=super.clone();
}catch(CloneNotSupportedException e){
System.out.println("Error en tiempo de clonacion");
}
return o;
}

/**
* Metodo que crea la clonacion y ejecuta la autoclonacion
*
* @return Usuario
*/
public Usuario copiarTipo(){
Usuario a=(Usuario)clone();
a.setTipoDeUsuario("Usuario de Tipo A");
a.setEntrarSistema(true);
a.setObtenerUsuario(true);
a.setEliminarUsuario(true);
a.setAdicionarUsuario(true);
a.setModifiarUsuario(true);
return a;
}

}


package co.edu.udistrital.validador.Logica;

/**
* Clase que define un tipo de usuario, hereda de la clase Usuario
*/
public class TipoUsuarioB extends Usuario {
/**
* Metodo heredado de la clase usuario, que a su vez implementa
* la interface Cloneable
*
* @return Object
*/
public Object clone() {
Object o = null;
try {
o = super.clone();
} catch (CloneNotSupportedException e) {
System.out.println("Error en tiempo de clonacion");
}
return o;
}

/**
* Metodo que crea la clonacion y ejecuta la autoclonacion
*
* @return Usuario
*/
public Usuario copiarTipo() {
Usuario a = (Usuario) clone();
a.setTipoDeUsuario("Usuario de Tipo B");
a.setEntrarSistema(true);
a.setModifiarUsuario(true);
return a;
}
}


package co.edu.udistrital.validador.Logica;

import co.edu.udistrital.validador.bd.Conexion;
import java.sql.*;

/**
* Clase que valida ingreso a los tipos de ususario. Esta clase implementa el patron Singleton ya que solo se necesita una instancia de esta.
*/
public class Validador {

private Conexion conexion;
private int tipoUsuario=0;
private boolean valida;
private String usuario;
private String clave;

/**
* Retorna el numero de clave validada que ingreso el cliente
* @return int
* @uml.property name="tipoUsuario"
*/
public int getTipoUsuario() {
return this.tipoUsuario;
}

public Validador() {
//Crea una instancia de la clase conexion
conexion = Conexion.getConexion();
}

/**
* consulta la tabla usuarios en la base de datos y valida
* segun la clave ingresado por el cliente
*
* @param String
* @return int
*/
public boolean validar(String cla, String usu) {
this.valida = false;
this.clave = cla;
this.usuario=usu;
conexion.setCadena("SELECT * FROM usuarios where login ='"+usuario+"'");
ResultSet tabla = conexion.Consultar();
try {
while (tabla.next()) {
if (this.clave.compareTo(tabla.getString("clave"))==0) {
this.tipoUsuario = Integer.parseInt(tabla.getString("tipo"));
this.valida = true;
}

}
} catch (SQLException ex) {
System.out.println("Problemas con la tabla");
}
return this.valida;
}
}


package co.edu.udistrital.validador.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.
*/
public class Conexion {

static private String bd = "validador";
static private String login = "usuario2";
static private String password = "1234";
static private String url = "jdbc:mysql://localhost/" + bd;
static private Conexion conex = null;
private String CadenaSql;
private Connection conexion = null;

/**
* el contructor se encargada de realizar la conexion a la base de datos
* y muestra en consola mensajes si se pudo o no conectar a labase de datos.
*/
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);
}
}

public String EjecutarSql() {
try {
Statement stmt = conexion.createStatement();
stmt.executeUpdate(CadenaSql);

} catch (SQLException ex) {

System.out.println("Totio");
}
return ("Fue un exito");
}

/**
*
* Funcion encargada de realizar las consultas para poder usarla debe existir
* una conexion a base de datos
*
*
* @return ResultSet
*/
public ResultSet Consultar() {
ResultSet tabla = null;
try {
Statement stmt = conexion.createStatement();
tabla = stmt.executeQuery(CadenaSql);
} catch (SQLException ex) {
System.out.println(ex);
}
return tabla;
}

/**
* Setter que asigna el valor a la cadenaSql
*
* @param String cadena;
*/
public void setCadena(String cadena) {
CadenaSql = cadena;
}

/**
* getter que retorna
*
* @return Connection;
*/
public Connection getConectar() {
return conexion;
}

/**
* Funcion encargada de realizar la desconexion a base de datos
*/
public void desconectar() {
conexion = null;
}

/**
* Funcion encargada de retornar el objeto conexion y garantiza que la clase se instancie una sola vez.
* @return Conexion
* @uml.property name="conexion"
*/
static public Conexion getConexion() {
if (conex == null) {
conex = new Conexion();
}
return conex;
}
}


package co.edu.udistrital.validador.presentacion;

import co.edu.udistrital.validador.Logica.*;
import co.edu.udistrital.validador.bd.*;
import java.awt.event.ActionEvent;

import javax.swing.*;

import java.awt.*;
import java.awt.event.*;
import java.sql.SQLException;
import java.util.StringTokenizer;


import javax.swing.table.DefaultTableModel;
/**
* clase que se encarga de generar la interfaz gráfica para los usarios registrados.
* @author Priscilos
*/

/**
* Clase que se encarga de generar la interfaz gr�fica y de relacionarla co la l�gica
*/

public class Presentacion implements ActionListener {

//atributos de la GUI
private JFrame frame;
private JButton aceptar;
private JButton clear;
private JLabel log;
private JLabel pass;
private JPasswordField txtpassword;
private JTextField txtloging;
private Container pane;

//atributos de validacion y usuarios
private Validador val;
private TipoUsuarioA TipoA;
private TipoUsuarioB TipoB;
private Usuario usuario = null;

/**
* El costructor de la clase inicializa todos los componentes de la GUI
*
*/

public Presentacion() {
frame = new JFrame("Validador");
aceptar = new JButton("Aceptar");
clear = new JButton("Cls");
log= new JLabel("Usuario: ");
pass= new JLabel("Password: ");
txtpassword = new JPasswordField(0);
txtloging = new JTextField(0);
pane = new JPanel();
val = new Validador();

TipoA = new TipoUsuarioA();
TipoB = new TipoUsuarioB();

pane = frame.getContentPane();
pane.setLayout(null);

log.setBounds(30, 20, 100, 20);
pass.setBounds(30, 60, 100, 20);
txtloging.setBounds(130, 20 , 200, 25);
txtpassword.setBounds(130, 60, 200, 25);
aceptar.setBounds(240, 120, 90, 30);
clear.setBounds(30, 120, 90, 30);
aceptar.addActionListener(this);
clear.addActionListener(this);

frame.add(clear);
frame.add(aceptar);
frame.add(log);
frame.add(pass);
frame.add(txtpassword);
frame.add(txtloging);
frame.pack();

frame.setBounds(450, 450, 380, 200);
frame.setResizable(false);
frame.setVisible(true);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}

/**
* Este m�todo se encarga de inicializar el usuario adecuaado de acuerdo con la validaci�n
* @param t - tipo de usuario(dato que se optiene en la validaci�n)
* @return Usuario que ingresa al sistema.
*/

public Usuario mostrarTipo(int t) {
switch (t) {
default:

case 1:
usuario = TipoA.copiarTipo();
break;

case 2:
usuario = TipoB.copiarTipo();
break;
}

return usuario;
}

/**
* M�todo principal del programa
* @param args
*/

public static void main(String[] args) {
new Presentacion();
}

/**
* M�todo de la interface ActionListener, que se implementa, para manejar
* los eventos generados por los botones que hacen parte del programa.
*/

public void actionPerformed(ActionEvent e) {
if (e.getSource().equals(this.aceptar)) {

/*
* Despues de oprimir el boton aceptar se corre esta lineas de codigo.
* Aqu� se llama el meto validar de validaci�n para validar el tipo de usuario.
* Si el usuario existe en el sistema el m�todo validar devuelve true.
* Luego con los dato otrogados por la clase validador se muestra un mensaje con el tipo de usuario.
*/

if (val.validar(this.txtpassword.getText(),this.txtloging.getText())) {
new ModuloPrincipal(this.mostrarTipo(val.getTipoUsuario()));
} else {
JOptionPane.showMessageDialog(null, "USUARIO NO EXISTE", "ERROR", JOptionPane.ERROR_MESSAGE);

}
}
if (e.getSource().equals(this.clear)) {
this.txtpassword.setText("");
}
}
}

2 comentarios:

ArkanGelL dijo...

:( por que no publicaste el codigo fuente de la clase ModuloPrincipal ????

Anónimo dijo...

JAJAJA severa broma ese codigo....