Desarrollo rápido de aplicaciones CRUD con OpenXava.
0. Índice de contenidos.
- 1. Entorno.
- 2. Introducción.
- 3. Descarga.
- 4. Configuración del entorno.
- 5. Arrancando nuestra primera aplicación.
- 6. Añadir una nueva tabla a la aplicación.
- 7. Añadir referencias entre tablas.
- 8. Conclusiones.
1. Entorno
Este tutorial está escrito usando el siguiente entorno:
- Hardware: portátil MAC (2GHz Intel Core i7, 8GB 1333 MHz DDR3)
- Sistema Operativo: Mac OS X Mavericks 10.9
2. Introducción.
Hoy en día tenemos que convivir con una multitud de frameworks que nos ofrecen muchísimas funcionalidades y utilidades para desarrollar aplicaciones. Ya dependerá de nuestros gustos o necesidades el usar un framework u otro.
Dentro de este amplio mundillo hay uno que llevo tiempo siguiendo y que me gustaría enseñaros. Este framework es OpenXava: framework Java de código abierto diseñado para desarrollar aplicaciones de gestión, tipo CRUD, de una forma muy rápida y sencilla.
Está basado en Java, y sólo necesita de POJOs, JPA y anotaciones de Java para funcionar. No necesitamos desarrollar ni interfaces web ni lógica de negocio para hacer que nuestra aplicación funcione. OpenXava ya se encarga de generar todo ese código por nosotros.
A parte de ello, lo interesante es que las aplicaciones que se desarrollan con este framework pueden ser desplegadas en portales (como Liferay), como aplicaciones portlet on un simple click.
3. Descargar el software.
Antes de empezar necesitaremos una serie de componentes previamente instalados en nuestro portátil o PC. Necesitaremos tener:
- Versión 5, o superior, de Java (échale un vistazo a nuestro tutorial de cómo instalar Java 7 en tu MAC).
- Eclipse para desarrolladores JEE (http://www.eclipse.org/downloads/)
Una vez tenemos nuestro JDK y nuestro Eclipse instalados ya sólo falta instalar OpenXava.
Para ello iremos a la siguiente URL http://www.OpenXava.org/es/web/guest/home y pulsaremos sobre la opción «descargar OpenXava» para descargarnos la última versión del framework (en mi caso la versión 4.9), o directamente desde sourceforge: http://sourceforge.net/projects/openxava/files/openxava/4.9/
Si lo hacemos desde la web oficial, antes de poder descargar el framework, nos aparecerá un pequeño formulario de inscripción que lo que hará será enviarnos a nuestro correo electrónico un enlace de descarga. Así quedaremos inscritos en las newsletters del framework. Pero como he comentado antes, podéis descargar la distribución de forma directa desde sourceforge.
Una vez hemos descargado el zip descomprimiremos el archivo en nuestro equipo.
4. Configuración del entorno.
Para echar un ojo de forma rápida a este framework empezaremos con los proyectos ejemplo que vienen contenidos en la distribución. Lo primero que haremos será arrancar nuestro Eclipse usando como workspace el que viene contenido en la distribución de OpenXava que acabamos de descargarnos:
Una vez hemos arrancado Eclipse en el workspace de OpenXava, podremos comprobar cómo Eclipse nos carga con una serie de proyectos ejemplo que OpenXava ya tiene preparados para nosotros. Será con ellos con los que empecemos a «trastear»:
Para ejecutar los ejemplos que OpenXava necesitaremos descargarnos un Apache Tomcat 6, o usar el que viene contenido dentro de la distribución de OpenXava (versión 6 igualmente). Para nuestro ejemplo usaremos el que viene contenido en la distribución ya que está configurado para que podamos lanzar de una forma rápida y sencilla los ejemplos.
A mi me gusta tener Tomcat asociado a Eclipse de modo que para hacerlo iremos a «Preferencias/Server/Runtime environments/Add» y seleccionaremos la opción Apache Tomcat version 6. Una vez dentro de la opción de añadir indicaremos a Eclipse el path en donde nuestro tomcat se encuentra (en nuestro caso dentro de la distribución de OpenXava), y pulsaremos «Aceptar».
5. Arrancando nuestra primera aplicación.
Como os he comentado antes, OpenXava sólo necesita de POJOs para poder funcionar. De echo si echamos un ojo a una de las aplicaciones que el workspace ya tiene preparadas para nosotros, en este caso la llamada «MiEscuela», podremos ver que dentro del código fuente sólo tenemos una clase, la clase Profesor, la cual es un Entity de la base de datos:
@Entity
public class Profesor {
@Id @Column(length=5)
@Required
private String codigo;
@Column(length=40)
@Required
private String nombre;
public String getCodigo() {
return codigo;
}
public void setCodigo(String codigo) {
this.codigo = codigo;
}
public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
}
No busques más código fuente porque no lo vas a encontrar. OpenXava se encarga de generar todo el código necesario para realizar toda la gestión CRUD de esa tabla por ti. De modo que cuando crees una aplicación OpenXava, sólamente vas a necesitar definir las clases que representaran las tablas de la base de datos y sus relaciones. El trabajo restante ya lo hace OpenXava por ti.
Para arrancar la aplicación compilaremos el proyecto y pulsaremos sobre la opción «desplegarWar» de la tarea ant que ya viene programada (previamente hemos arrancado el server):
Si todo ha ido correctamente, abriremos nuestro navegador y introduciendo la siguiente URL: http://localhost:8080/MiEscuela/modules/Profesor, podremos comprobar como en cuestión de minutos hemos montado una completa aplicación CRUD con todas sus operaciones, filtros en las consultas y opciones de exportación de datos:
6. Añadir una nueva tabla a la aplicación.
En este apartado crearemos otra tabla en la base de datos y crearemos la parte CRUD de la misma en menos de un minuto. Para ello crearemos la nueva tabla en la base de datos (en este ejemplo usamos hsqldb):
CREATE MEMORY TABLE ALUMNO(NUMERO INTEGER NOT NULL PRIMARY KEY,NOMBRE VARCHAR(40),PROFESOR_CODIGO VARCHAR(5))
Tras la creación de la tabla sólo nos queda crear el Entity en nuestro código fuente. Vamos a crear la clase Alumno:
@Entity
public class Alumno {
@Id
@Column(length = 2)
@Required
private int numero;
@Column(length = 40)
@Required
private String nombre;
public int getNumero() {
return numero;
}
public void setNumero(int numero) {
this.numero = numero;
}
public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
}
Llegados a este punto, sólo nos queda volver a compilar y desplegar nuestro proyecto. Accedemos a http://localhost:8080/MiEscuela/modules/Alumno y el resultado es el siguiente:
7. Añadir referencias entre tablas.
La forma que tenemos para poder añadir referencias entre tablas es con la anotación «ManyToOne».
Vamos a añadir una referencia a Profesor desde la entidad Alumno. Para ellos añadiremos un atributo nuevo en la clase Alumno que sea de tipo Profesor y le pondremos la anotación ManyToOne:
@Entity
public class Alumno {
@Id
@Column(length = 2)
@Required
private int numero;
@Column(length = 40)
@Required
private String nombre;
@ManyToOne
private Profesor profesor;
public int getNumero() {
return numero;
}
public void setNumero(int numero) {
this.numero = numero;
}
public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
public Profesor getProfesor() {
return profesor;
}
public void setProfesor(Profesor profesor) {
this.profesor = profesor;
}
}
Volvemos a compilar, desplegamos en el server, arrancamos la aplicación y como resultado obtenemos lo siguiente:
Como se puede observar OpenXava ya ha incluido en la parte de detalle de los alumnos un nuevo componente relacionado con Profesor que nos permite seleccionar los profesores y asociarlos a los Alumnos:
Vamos a guardar el nuevo alumno en la base de datos:
8. Conclusiones.
En este tutorial hemos podido comprobar la potencia de OpenXava en cuanto a la generación y desarrollo de aplicaciones CRUD se refiere. Gracias a frameworks como éste podemos agilizar mucho la creación de aplicaciones de gestión ya que sólamante deja en manos del programador el diseño y análisis del modelo de datos. El resto déjaselo a OpenXava ya que él hará el trabajo por ti.
Por supuesto, OpenXava es capaz de hacer muchas más cosas, pero eso…lo dejamos para tutoriales futuros.
