Desarrollando con Flex, flexmdi, PureMVC, BlazeDS, Spring, JPA, Hibernate,... (parte 9)

Comenzaremos, en este artículo, con la creación de las tablas (el script funciona para MySQL pero, es sencillo adaptarlo a otras bases de datos) y de los DAOs (Data Access Object) u objetos Java de acceso a datos, de nuestra aplicación Mocky.

Suponiendo que nuestra MySQL está ya perfectamente instalada, abriremos una consola y escribiremos:

shell> mysql -u root -p
Enter password: *********
Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 3
Server version: 5.0.51b-community-nt MySQL Community Edition (GPL)

Type 'help;' or '\h' for help. Type '\c' to clear the buffer.

mysql> create database mocky;
Query OK, 1 row affected (0.00 sec)

mysql> use mocky;
Database changed

Con esto nuestra base de datos estará ya creada y podremos comenzar a crear las primeras tablas e insertar sus registros:

CREATE TABLE `mk_rol` (
  `idrol` decimal(22,0) NOT NULL,
  `nombre` varchar(100) NOT NULL,
  `activo` decimal(22,0) NOT NULL,
  PRIMARY KEY  (`idrol`)
);

INSERT INTO `mk_rol` values (1, 'Administrador', 1);
INSERT INTO `mk_rol` values (2, 'Usuario', 1);

CREATE TABLE `mk_rolrol` (
  `idrolpadre` decimal(22,0) NOT NULL,
  `idrolhijo` decimal(22,0) NOT NULL,
 PRIMARY KEY  (`idrolpadre`,`idrolhijo`)
);

INSERT INTO `mk_rolrol` values (1, 2);

CREATE TABLE `mk_usuario` (
  `idusuario` decimal(22,0) NOT NULL,
  `nombreusuario` varchar(50) NOT NULL,
  `password` varchar(50) NOT NULL,
  `nombrereal` varchar(100) NOT NULL,
  `activo` decimal(22,0) NOT NULL,
  PRIMARY KEY  (`idusuario`)
);

INSERT INTO `mk_usuario` values (1, 'admin', 'cambiala', 'Administrador 1', 1);
INSERT INTO `mk_usuario` values (2, 'user', 'cambiala', 'Usuario 1', 1);

CREATE TABLE `mk_usuariorol` (
  `idusuario` decimal(22,0) NOT NULL,
  `idrol` decimal(22,0) NOT NULL,
  PRIMARY KEY  (`idusuario`,`idrol`)
);

INSERT INTO `mk_usuariorol` values (1, 1);
INSERT INTO `mk_usuariorol` values (2, 2);

El modelo de datos es muy sencillo, con el script anterior hemos creado cuatro tablas que guardarán el modelo de datos para la seguridad:

1. mk_rol: son los distintos roles de usuario de nuestra aplicación.
2. mk_rolrol: un árbol de roles, para que un rol pueda heredar los permisos de otros.
3. mk_usuario: son los distintos usuarios de la aplicación.
4. mk_usuariorol: asigna roles a los usuarios.

Alguna de estas tablas tienen un campo "activo", que indica si el registro es válido o si no debería tenerse en cuenta (1=válido, 0=no válido).

Ahora seguiremos los siguientes pasos para construir los objetos de acceso a datos, utilizando para ello JPA:

1. Con nuestro Eclipse abierto, seleccionaremos el proyecto mocky que, como recordaremos, tiene las clases Java de nuestra aplicación.
2. Pinchando con el botón derecho del ratón sobre el proyecto y seleccionando "New-Package" crearemos un nuevo paquete.
3. En la siguiente ventana, en el campo "Name" introduciremos el valor "org.wika2.mocky.model" y pulsaremos el botón "Finish".
4. Repetiremos el proceso para los siguientes dos paquetes "org.wika2.mocky.dao.jpa" y "org.wika2.mocky.service.impl".
5. Crearemos nuestra primera clase de modelo Java, pinchando con el botón derecho del ratón sobre la carpeta de fuentes "src" y seleccionando "New-Class".
6. En la siguiente ventana, en el campo "Package" introduciremos el valor "org.wika2.mocky.model" y en el nombre de la clase (campo "Name") vamos a poner "MkRol". El resto de los campos los dejaremos "tal cual" y pulsaremos el botón "Finish".

Se nos abrirá el editor de textos, donde pegaremos el siguiente código Java:

package org.wika2.mocky.model;

import javax.persistence.*;

@Entity
@Table(name = "MK_ROL")
public class MkRol implements java.io.Serializable {

private Integer idRol;
private String nombre;
private Integer activo;

public MkRol() {
}

public MkRol(Integer idRol, String nombre, Integer activo) {
  this.idRol = idRol;
  this.nombre = nombre;
  this.activo = activo;
}

@Column(name = "ACTIVO", nullable = false, precision = 22, scale = 0)
public Integer getActivo() {
  return this.activo;
}

@Id
@GeneratedValue(strategy = GenerationType.TABLE, generator = "MK_ROL_TG")
@TableGenerator(allocationSize = 1, name = "MK_ROL_TG", table = "MK_SEQUENCETABLE", pkColumnName = "SEQ_NAME", valueColumnName = "SEQ_COUNT", pkColumnValue = "MK_ROL")
@Column(name = "IDROL", unique = true, nullable = false, precision = 22, scale = 0)
public Integer getIdRol() {
  return this.idRol;
}

@Column(name = "NOMBRE", nullable = false, length = 100)
public String getNombre() {
  return this.nombre;
}

public void setActivo(Integer activo) {
  this.activo = activo;
}

public void setIdRol(Integer idRol) {
  this.idRol = idRol;
}

public void setNombre(String nombre) {
  this.nombre = nombre;
}

}

Como podemos observar, hemos declarado, mediante anotaciones JPA, que esta clase es una entidad "@Entity" que corresponde con una tabla de una base de datos "@Table" con tres columnas "@Column", una de las cuales es el identificador "@Id" de la misma.

La columna identificador (corresponde con la PrimaryKey de la tabla MySQL) tiene un generador de valores únicos, controlado por JPA mediante la declaración de las anotaciones @GeneratedValue y @TableGenerator. Este generador de valores únicos utiliza una nueva tabla MySQL que tiene el valor siguiente, mantenido automáticamente, a utilizar por cada entidad de nuestra aplicación.

El delegar la generación de identificadores en una tabla puede ocasionar, quizá, problemas de rendimiento... pero es la manera más cómoda de independizar nuestro desarrollo del gestor de datos.

Debemos crear en nuestra MySQL esta nueva tabla, utilizando el siguiente script:

CREATE TABLE `mk_sequencetable` (
  `seq_name` varchar(100) NOT NULL,
  `seq_count` decimal(22,0) NOT NULL,
  PRIMARY KEY  (`seq_name`)
);

INSERT INTO `mk_sequencetable` values ('MK_ROL', 1);
INSERT INTO `mk_sequencetable` values ('MK_ROLROL', 1);
INSERT INTO `mk_sequencetable` values ('MK_USUARIO', 1);
INSERT INTO `mk_sequencetable` values ('MK_USUARIOROL', 1);

La columna "seq_name" contiene un nombre único para la secuencia (que yo hago coincidir con el nombre de la tabla) y el "seq_count" contiene el siguiente valor (comenzando por 1 pero serviría cualquier número) a asignar al identificador de esa tabla.