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:
- mk_rol: son los distintos roles de usuario de nuestra aplicación.
- mk_rolrol: un árbol de roles, para que un rol pueda heredar los permisos de otros.
- mk_usuario: son los distintos usuarios de la aplicación.
- 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:
- Con nuestro Eclipse abierto, seleccionaremos el proyecto mocky que, como recordaremos, tiene las clases Java de nuestra aplicación.
- Pinchando con el botón derecho del ratón sobre el proyecto y seleccionando "New-Package" crearemos un nuevo paquete.
- En la siguiente ventana, en el campo "Name" introduciremos el valor "org.wika2.mocky.model" y pulsaremos el botón "Finish".
- Repetiremos el proceso para los siguientes dos paquetes "org.wika2.mocky.dao.jpa" y "org.wika2.mocky.service.impl".
- 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".
- 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.