El problema.

Se solicita desarrollar un sistema de administración de usuarios con un CRUD (Create, Read,

Update, Delete) básico  nos advierten que la aplicación es un prototipo inicial el cual esta
propenso a cambios, pues aún no se tienen definidas las ventanas con las que se va a trabajar ni
la información requerida, por le momento se trabajará con una BD MySql, pero posiblemente se
tenga que migrar a otro sistema gestor....

La solución.

Se aplica el MVC permitiendo independizar la lógica y la parte visual del sistema usando para eso
un controlador que administra los procesos sirviendo como puente entre estos.

para la BD se usa MySql, reutilizando la BD creada en el ejemplo de conexión con Java, el Scritp
es el siguiente.
1
2 CREATE DATABASE /*!32312 IF NOT EXISTS*/`usuarios` /*!40100 DEFAULT CHARACTER SET latin1 */;
3
4 USE `usuarios`;
5
6 /*Table structure for table `persona` */
7
DROP TABLE IF EXISTS `persona`;
8
9 CREATE TABLE `persona` (
10   `id` int(10) NOT NULL,
11   `nombre` varchar(30) default NULL,
  `edad` int(3) default NULL,
12   `profesion` varchar(30) default NULL,
13   `telefono` decimal(10,0) default NULL,
14   PRIMARY KEY  (`id`)
15 ) ENGINE=InnoDB DEFAULT CHARSET=latin1;
16
/*Data for the table `persona` */
17
18
De esta forma se crea la Base de Datos a la que se va a apuntar, la cual contiene solo una
tabla Persona con la que se realizan todas las operaciones CRUD.

La agrupación de clases de nuestro sistema es:

Como vemos tenemos la parte visual compuesta por las

clases VentanaPrincipal, VentanaRegistro, VentanaBuscar, la lógica de negocio se establece
en el modelo el cual se compone por la clase Logica y Conexión y aplicamos los
patrones DAO y VO por medio de las clases PersonaDao y PersonaVo y por ultimo el
controlador se define en la clase Coordinador, encargada de establecer todas las relaciones del
sistema, la clase Principal prepara las instancias iniciales del sistema y posteriormente lo
ejecuta.
Veamos como funciona el Patrón:  

El Modelo.

Como se mencionó, en el modelo tenemos la lógica de negocio, serán todas las clases vinculadas
con el CRUD a nivel interno, que en ultimas es en lo que gira nuestro sistema.

Clase Logica.

Esta clase permite realizar las operaciones asociadas a la lógica de negocio como tal, desde ella
realizamos las validaciones y llamados a las operaciones CRUD del sistema.

En caso de que se requieran procesos adicionales asociados a la lógica de negocio, aquí será

donde se creen los métodos para dichos procesos, por ejemplo
el método validarRegistro determina si los datos son correctos y permite registrar la persona en
el Dao.

1
2 public void validarRegistro(PersonaVo miPersona) {
3 PersonaDao miPersonaDao;
/*Valida que solo se ingresen id de 3 digitos*/
4    if (miPersona.getIdPersona() > 99) {
5  miPersonaDao = new PersonaDao();
6  miPersonaDao.registrarPersona(miPersona);
 }else {
7    JOptionPane.showMessageDialog(null,"El documento de la persona debe" +
8  " ser mas de 3 digitos","Advertencia",JOptionPane.WARNING_MESSAGE);
9               }
10  }
11

Clase Conexión.

En esta clase tenemos la cadena de conexión con la que trabajará nuestra aplicación, en ella

se define la base de datos, el usuario, password y driver de conexión, si por ejemplo en un futuro
se nos pide conectarnos a una base de datos diferente o establecer un sistema gestor distinto
(pero con la misma estructura de tablas y campos), tan solo modificaremos esta clase y dicho
cambio sera transparente para el resto del sistema.
(Tener en cuenta que los datos de login y password corresponden a los que yo dejé por defecto al
instalar MySql, es decir login root y sin contraseña)
1
2
3 public Conexion() {
      try{
4          //obtenemos el driver de para mysql
5          Class.forName("com.mysql.jdbc.Driver");
6          //obtenemos la conexión
7          conn = DriverManager.getConnection(url,login,password);
8
         if (conn!=null){
9             System.out.println("Conección a base de datos "+bd+" OK");
10          }
11       }
      catch(SQLException e){
12          System.out.println(e);
13       }catch(ClassNotFoundException e){
14          System.out.println(e);
      }catch(Exception e){
15          System.out.println(e);
16       }
17    }
18
19

Clase PersonaVo. 

Al utilizar este tipo de clases, aplicamos el patrón Value Object o VO (Anteriormente conocidas

como DTO Data Transfer Object) en el que representamos las entidades (Tablas) de la base de
datos, la tabla persona tiene los campos id, nombre, edad, profesión  teléfono  entonces nuestra
clase Vo tendrá estos mismos atributos y de esta manera podremos transportar un objeto persona
con todos estos valores por medio de los métodos set y get de cada atributo.

Este patrón nos facilita enormemente el transporte de la información, evitando que se envíen gran

cantidad de parámetros a un método cuando queremos hacer un registro o
actualización, también en caso de que se modifique la tabla de la BD, nuestra clase deberá ser
modificada así como los métodos que obtienen la información, mas no los métodos que la
transportan.

1
2 /**
3  * @return the idPersona
4  */
public Integer getIdPersona() {
5     return idPersona;
6 }
7 /**
 * @param idPersona the idPersona to set
8  */
9 public void setIdPersona(Integer idPersona) {
10     this.idPersona = idPersona;
}
11
12
Clase PersonaDao.

Cuando utilizamos estas clases, aplicamos el patrón Data Access

Object o DAO, básicamente este patrón consiste en centralizar los procesos de acceso a la base
de datos evitando inconsistencias y posibles problemáticas cuando esto se realiza a lo largo de la
aplicación.
Con este patrón independizamos la lógica de negocio de la lógica de acceso a datos obteniendo
mayor organización y flexibilidad en el sistema.

1
2
public void eliminarPersona(String codigo)
3 {
4 Conexion conex= new Conexion();
5 try {
6  Statement estatuto = conex.getConnection().createStatement();
 estatuto.executeUpdate("DELETE FROM persona WHERE id='"+codigo+"'");
7         JOptionPane.showMessageDialog(null, " Se ha Eliminado" +
8  " Correctamente","Información",JOptionPane.INFORMATION_MESSAGE);
9  estatuto.close();
 conex.desconectar();
10
11  } catch (SQLException e) {
12         System.out.println(e.getMessage());
 JOptionPane.showMessageDialog(null, "No se Elimino");
13      }
14 }
15
16

La Vista.

Aquí se define la parte visual del sistema, en la vista estableceremos todas las ventanas o
interfaces gráficas de usuario, mediante las cuales representamos todo el modelo permitiendo
la interacción entre la aplicación y el cliente.

Clase VentanaPrincipal.
Esta clase representa la ventana inicial de la aplicación, posee un área de texto con una pequeña
descripción y 2 botones que darán inicio a los eventos principales del sistema.

se comunica con el modelo mediante la clase coordinador y desde esta se cargan las otras
ventanas de la aplicación.

Clase VentanaRegistro.

Permite el ingreso de información a la BD, en ella se evidencian todos los campos de la tabla
Persona y presenta un medio gráfico para las clases PersonaVo y PersonaDao, al ejecutar el
evento de registro se establece comunicación entre el coordinador y la clase Lógica donde se
encuentran todas las validaciones y casos para el ingreso de información.

Clase VentanaBuscar.

Esta clase permite realizar las operaciones de Consulta, Actualización y eliminación de la tabla
Persona, igual que la anterior representa la parte visual del modelo y se ejecutan los eventos para
la lógica de los procesos anteriores, la forma de obtener los datos y como se
le envían parámetros de consulta a la BD.
El Controlador.

Esta parte del patrón es la que define la lógica de administración del sistema, establece

la conexión entre la vista y el modelo.

Clase Principal.

Esta clase contiene el método main que ejecuta la aplicación, el método hace un llamado

al método iniciar el cual crea las instancias de las clases ventanas y la
clase Logica  estableciendo las relaciones con la clase Coordinador.

A cada instancia de las clases se les envía una instancia de la clase Coordinador, y a la instancia

de Coordinador se le envía cada instancia de las clases, esto por medio de los métodos set y get
estableciendo las relaciones necesarias y por ultimo se usa la instancia de la
clase VentanaPrincipal para cargarla en pantalla. 

1
2
3 private void iniciar() {
4 /**Se instancian las clases*/
5  miVentanaPrincipal=new VentanaPrincipal();
 miVentanaRegistro=new VentanaRegistro();
6  miVentanaBuscar= new VentanaBuscar();
7  miLogica=new Logica();
8  miCoordinador= new Coordinador();
9
/**Se establecen las relaciones entre clases*/
10  miVentanaPrincipal.setCoordinador(miCoordinador);
11  miVentanaRegistro.setCoordinador(miCoordinador);
12  miVentanaBuscar.setCoordinador(miCoordinador);
 miLogica.setCoordinador(miCoordinador);
13
14 /**Se establecen relaciones con la clase coordinador*/
15  miCoordinador.setMiVentanaPrincipal(miVentanaPrincipal);
16  miCoordinador.setMiVentanaRegistro(miVentanaRegistro);
 miCoordinador.setMiVentanaBuscar(miVentanaBuscar);
17  miCoordinador.setMiLogica(miLogica);
18
19  miVentanaPrincipal.setVisible(true);
}
20
21
22
Clase Coordinador.

Esta clase contiene toda la lógica de relaciones en el aplicativo, es el puente entre el modelo y las
vistas.

Puede contener instancias locales tanto de clases de la vista como de clases del modelo, estas
instancias tienen sus respectivos métodos set y get permitiendo el flujo de llamados del sistema.

Cuando se desea registrar una persona desde la clase VentanaRegistro se hace un llamado

al método registrarPersona() de la clase Coordinador, posteriormente esta clase llama
al método ValidarRegistro() de la clase Logica y esta a su vez realiza las validaciones
correspondientes para determinar si se llama o no al método RegistrarPersona() de la
clase PersonaDao. 

1
2
public Logica getMiLogica() {
3   return miLogica;
4 }
5
6 public void setMiLogica(Logica miLogica) {
7   this.miLogica = miLogica;
}
8
9 public void mostrarVentanaRegistro() {
10   miVentanaRegistro.setVisible(true);
}
11
12 public void mostrarVentanaConsulta() {
13   miVentanaBuscar.setVisible(true);
14 }
15
public void registrarPersona(PersonaVo miPersona) {
16   miLogica.validarRegistro(miPersona);
17 }
18
19