lunes, 29 de septiembre de 2008

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.

lunes, 22 de septiembre de 2008

Una buena noticia: Oracle sí elige, finalmente, Flex

Hace unos meses, casi ya un año, os anuncié, en un artículo anterior, el rumor de que Oracle apostaba por Flex para el nuevo desarrollo de Metalink y del Enterprise Manager, entre otros de sus productos.

Se han hecho esperar pero, por fin ha visto la luz -yo lo he descubierto esta misma mañana- el nuevo Metalink. Por supuesto, aunque nadie lo diga explicitamente, se deja notar que Flex ha sido la tecnología -no creo equivocarme- que subyace bajo este nuevo producto.

Una interesante noticia para los desarrolladores de Flex, que ven su apuesta reforzada por compañías como Oracle, y también una buena noticia para los usuarios de Oracle Metalink, su centro de soporte.

jueves, 4 de septiembre de 2008

Aprendiendo idiomas, problemas antiguos, métodos modernos

El otro día comentábamos, en el trabajo, sobre los diferentes (e infructuosos) métodos que todos nosotros hemos probado alguna vez para aprender idiomas: en el colegio, por fascículos, en academias, con aupairs, unos meses en el extranjero, escuchando la radio, etc.

Alguno de estos métodos los volvemos a probar con nuestros hijos, dando así al método una segunda oportunidad (¿para fracasar?).

Pues siendo que los padres de nuestros hijos son tecnólogos y que nuestros hijos son hijos de la tecnología... deberíamos utilizar métodos más modernos.

Hoy lo que está de moda son las redes sociales y también el aprendizaje de idiomas es 2.0

Algunos ejemplos:

http://www.livemocha.com
http://www.soziety.com
http://www.palabea.net

Este último tiene muy buena pinta, aunque yo no los he probado y solo tengo referencias. Se basan en el "intercambio de nativos" ;-) Nosotros somos nativos hispanohablantes y estableceremos contactos con otros nativos de aquellos idiomas que queremos aprender.

Se utiliza, en muchos de ellos, Skype o productos similares y, además de aprender, se puede "ligar" que siempre ha sido el mejor método para aprender idiomas.

Para los críos/adolescentes, ya que el control de edades es más rígido, se ha puesto de moda el "Hotel Habbo" (http://www.habbo.com), aunque la finalidad no es estrictamente el aprendizaje de idiomas.

miércoles, 3 de septiembre de 2008

Google Chrome: un nuevo navegador para la web

Google ha publicado hoy, en fase beta, lo que será su más próxima y "sonada" novedad... un nuevo navegador web llamado "Google Chrome".

Personalmente no entiendo muy bien el sentido de "esto" a día de hoy, aunque puedo intuirlo...

Por una parte, Google dona cantidad de dinero a la organización Mozilla para que ésta, entre otras cosas, mejore el desarrollo de Firefox y lo convierta en un rival, no mejor que ya lo es, que le robe cuota de mercado a IE.

El movimiento, supongo que, quizá tendrá que ver con alguna estrategia de Google para lanzar a Chrome como el navegador ideal para la telefonía móvil y ocupar una posición privilegia en este tipo de dispositivos (dispositivos que se convertirán en los futuros puntos de acceso universales a Internet).

Un movimiento similar a lo que hizo cuando anunció el SDK Android y que solo pretende dar un toque de atención (a veces en beneficio y a veces en perjuicio de los usuarios) a Sun, Microsoft, Apple, ...

La buena noticia: tiene muy buena pinta, es muy sencillo y agradable de usar. Está basado en el motor webkit (http://webkit.org) que es el mismo utilizado por Safari.

La mala noticia: si tiene éxito, otro más para comprobar la compatibilidad de nuestros desarrollos: IE, Firefox, Opera, Konqueror, Safari, ... y ahora Chrome. Tampoco aporta ninguna novedad frente a la competencia.

Más en: http://www.google.com/chrome

De momento solo disponible para Windows, pero se dice que en próximos días verán la luz las versiones Linux y Mac.