Los invito a continuar leyendo, aportando y porque no, cuestionando cada entrada
Es regla comenzar con una breve explicación de que es Roo.
Creo que la definición mas cercana y genérica que lo describe es que es un Framework de aplicaciónes Web.
En resumidas palabras, Roo facilita el diseño y desarrollo de aplicaciones WEB, brindando herramientas para construir aplicaciones de forma rápida, con la ventaja de tener cubierto el reporting, seguridad, uso de diferentes motores de bases de datos etc.
Para encontrar una explicacion mas en detalle de lo que es un FW de app Web, nada mejor que Wikipedia Que es un FrameWork de aplicaciones Web .
Explicado, pasamos a un ejemplo muy sencillo, que seria crear un CRUD para dos entidades utilizando ingeniería inversa(lo hacemos los mas sencillo posible, luego explicaremos como se establecen relaciones o modifican vistas).
Este ejemplo nos servirá a futuro para continuar con los otros temas que mencioné.
Para este ejemplo, en el motor de base de datos me salgo del SL y utilizaré SQLServer ,para el desarrollo el entorno por excelencia de Roo "Spring tool Suite" STS en su version 2.9.1 , mas un servidor Apache Apache ,todo montado sobre Ubuntu 11.04 (excepto, claro está, SQL Server en el cual utilizo Windows Server 2008 virtualizado en Ubuntu)
- El primer paso es crear una Base de datos con nuestro SQLServer, como venimos comentando crearemos dos entidades sencillas dentro de esta base (Movimiento y tipo de movimiento), ya que nuestro primer objetivo es demostrar la facilidad de uso de Roo y las funcionalidades "de fabrica".
- CREATE TABLE [dbo].[MOVIMIENTO](
[ID_MOVIMIENTO] [bigint] IDENTITY(1,1) NOT NULL,
[MONTO] [numeric](15, 5) NULL,
[ID_TIPO_MOVIMIENTO] [bigint] NULL,
[ID_PERIODO] [bigint] NULL,
[DESCRIPCION] [varchar](100) COLLATE Modern_Spanish_CI_AS NULL,
[ID_SOCIO] [bigint] NULL,
[USUARIO_CREACION] [varchar](100) COLLATE Modern_Spanish_CI_AS NULL,
[FECHA_CREACION] [datetime] NULL,
[HOST_CREACION] [varchar](100) COLLATE Modern_Spanish_CI_AS NULL,
[USUARIO_MODIFICACION] [varchar](100) COLLATE Modern_Spanish_CI_AS NULL,
[FECHA_MODIFICACION] [datetime] NULL,
[HOST_MODIFICACION] [varchar](100) COLLATE Modern_Spanish_CI_AS NULL,
CONSTRAINT [PK_TIPO5] PRIMARY KEY CLUSTERED
( [ID_MOVIMIENTO] ASC) WITH (IGNORE_DUP_KEY = OFF) ON [PRIMARY] ) ON [PRIMARY]
CREATE TABLE [dbo].[TIPO_MOVIMIENTO](
[ID_TIPO_MOVIMIENTO] [bigint] IDENTITY(1,1) NOT NULL,
[DESCRIPCION] [varchar](100) NULL,
[USUARIO_CREACION] [varchar](100) NULL,
[FECHA_CREACION] [datetime] NULL,
[HOST_CREACION] [varchar](100) NULL,
[USUARIO_MODIFICACION] [varchar](100) NULL,
[FECHA_MODIFICACION] [datetime] NULL,
[HOST_MODIFICACION] [varchar](100) NULL,
CONSTRAINT [PK_TIPO11] PRIMARY KEY CLUSTERED
( [ID_TIPO_MOVIMIENTO] ASC)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]) ON [PRIMARY]
- Veran al final, algunas columnas de auditoría, estas se encuentran para facilitar las tareas de traceo de acciones en la Base de datos, no es requisito tenerlas, pero las considero una buena metodologia de diseño y liberar a la aplicación de tareas repetitivas de este tipo. Delegando esta acción a la Base de datos. La cual mediante un trigger, modificaria los campos ante un insert o update.
- El proximo paso es abrir Spring Tool Suite (o STS, como prefieran) y crearemos un nuevo proyecto de tipo "Spring Roo Project", para esto, dentro de STS vamos al menú File-->New-->Other (o su traducción Archivo--> Nuevo --> Otros) y en los Wizards buscamos la entrada SpringSource Tool Suite y allí Spring Roo Project
En esta ventana setearemos las condiciones para crear el proyecto, pueden tomar las que utilizo yo a fin de que el ejemplo salga lo mas directo posible, en lo que se refiere al IDE tengo estructura de Ubuntu, aun así no difiere mucho con el IDE de Windows.
En project name colocamos test y en top level package name colocamos com.alliance.test (luego explicaremos el porque de esta nomenclatura). Los demas campos los dejamos como viene "de fabrica" y por ultimo presionamos next y luego finish.
Luego de haber pulsado Finish y Roo creado las dependencias (momento que ya explicaremos que son "dependencias"), estructura y archivos necesarios. nos aparece una ventana similar a la siguiente:
Una vez creado el proyecto vamos al Shell de Roo (solapa al pie de la ventana, linea de entrada de comando), si no aparece en la solapa de STS, podemos abrirla desde Windows-->Show View-->Other-->Spring-->Roo Shell.
Esta ventana nos permitirá colocar los comandos para que Roo nos conecta a la base de datos, cree las vistas, genere beans, apliquemos reportes etc.
Ok. Entonces, con nuestro Sheel abierto vamos a colocar el siguiente comando
persistence setup --provider HIBERNATE --database MSSQL --hostName GOTEST6 --userName sa --password 111111
persistence setup --> le estamos indicando a ROO que vamos a setear nuestra persistencia
--provider HIBERNATE --> indicamos cual sera nuestro framework de persistencia (pueden ser otros FW)
--database MSSQL --> informo cual es nuestra BD a utilizar (pueden ser otras BD)
--hostName 127.0.0.1 --> IP del servidor donde se aloja la BD, puede ser el nombre
--userName sa --password 111111 no hay mucho que explicar.
Ahora si apretamos Enter y dejamos que ROO se ocupe del resto. Si todo funciona OK, tendremos la siguiente pantalla.
Notaran que en la solapa del shell aparecieron varias lineas comentando las acciones,en este paso nos interesa la que indica el archivo de propiedades "database.properties" si hacemos click en este vinculo, se abrira en la parte superior el archivo de propiedades creado anteriormente. el cual tiene una forma similar a la siguiente
#Updated at Tue Oct 23 16:57:28 ART 2012
#Tue Oct 23 16:57:28 ART 2012
database.driverClassName=net.sourceforge.jtds.jdbc.Driver
database.url=jdbc\:jtds\:sqlserver\://192.168.0.133\:1433/test
database.username=sa
database.password=111111
No dejan de ser los seteos a un objeto conexión de BD, solo que este archivo pasa a ser de configuración y no es necesario que creemos el objeto que se comunicará a la BD, ya que ROO hizo por nosotros este trabajo.
Creada la persistencia, vamos al siguiente, que es recuperar la estructura de mi base de datos (recuerden que lo primero que realizamos fue crear nuestro modelo de datos con 2 tablas) para poder realizar la ingenieria inversa.
Para esto, utilizaremos el siguiente comando, el cual explicaremos tal como lo hicimos en el momento de definir la persistencia.
database introspect --schema dbo --enableViews no
database introspect --> le decimos a Roo que haga un trabajo de introspección a nuestra BD utilizando el archivo de configuracion creado cuando definimos la persistencia.
--schema dbo --> Esquema a recuperar
--enableViews no --> si las tenemos podemos colocar que las recupere en este caso no tenemos vistas en nuestro modelo con lo cual no es necesario.
Explicado, procedemos a dar enter y volver a delegar en ROO la responsabilidad del trabajo.
NOTA: Roo trabajo con addon, los cuales son añadidos que ofrecen funcionalidad, para este paso necesitaremos instalar el addon para JDBC 01 Y Y 1.2.4.0010 #jdbcdriver driverclass:net.sourceforge.jtds.jdbc.Driver
Este lo podemos instalar con el siguiente comando: addon install id --searchResultId 01
Si todo fue OK tendremos el mensaje Deploying...done. como respuesta a que fue correctamente instalado.
De esta manera habilitamos el ADDON para JDBC (ahondaremos luego este tema, ya que es una característica muy utilizada)
Si todo fue OK, nos aparecer en el shell el XML con la estructura de la base de datos, vale recordar que estos archivos como son internos de ROO, no conviene modificarlos, salvo alguna razón de causa mayor.
A continuación nos queda crear los archivos core o aquellos que nos darán el soporte para los crud (*.java, *.aj), para ello utilizaremos el siguiente comando
database reverse engineer --schema dbo --includeTables " MOVIMIENTO TIPO_MOVIMIENTO" --enableViews no
database reverse engineer --> le decimos a ROO que realice la ingenieria reversa, para ello utilizara el XML creado cuando realizamos la introspección.
--schema dbo --> indicamos esquema
--includeTables " MOVIMIENTO TIPO_MOVIMIENTO" --> le decimos cuales tablas debe tener en cuenta (si no colocamos este parametro, lo hara para todas las tablas que tiene el modelo)
--enableViews no --> no tenemos vista colocamos que no las habilite.
Damos enter y vuelve ROO al trabajo. Si todo va OK, el shell nos informará el proceso de creación de los archivos para cada una de las entidades, similar a como se muestra en la pantalla siguiente, solapa de pie de pagina.
En este momento conviene hacer un recuento de lo que hicimos.
- Creamos nuestra BD a la cual llamamos test
- Creamos nuestro proyecto Spring Roo
- Definimos la persistencia en el proyecto
- Realizamos una introspección de la BD
- Realizamos el Scafolding (andamiaje +/-) de los archivos Core
Que nos queda?
Definir nuestras vistas y realizar el deploy. Parece poco? asi es, nos queda muy poco, con lo cual vamos a poner manos a la obra y terminar el ejemplo.
el primero de los comandos es:
web mvc setup
El cual define el framework a utilizar, en este caso utilizare MVC, pero también podemos utilizar JSF o GWT, el cual los dejo para explicarlo en post siguientes.
Luego de dar enter, veremos que la solapa del Shell nos muestra la creación de muchos archivos, entre ellos de extensión XML, TAGX o PROPERTIES. No se apresuren que la explicación de cada uno de estos archivos lo haremos luego de finalizar el ejemplo.
Y por ultimo nos queda realizar la implementacion de las vistas, con el siguiente comando.
web mvc all --package ~.web
Básicamente, con este comando le estamos diciendo a ROO que nos genere los controllers y vistas asociadas a cada una de las entidades de nuestro modelo (just reminder MOVIMIENTO y TIPO_MOVIMIENTO).
Si todo fue OK, el shell deberia decir algo similar a lo que muestra la imagen siguiente.
Listo, nuestra aplicación se encuentra preparada para ser utilizada. Para esto vamos al Project Explorer, botón derecho sobre nuestra aplicación y seguimos la siguiente ruta: Run AS-->Maven Build y escribimos dentro de GOALS
-e clean tomcat:run
Luego click sobre run y aguardamos a que ROO realice el deploy correspondiente.
Nos daremos cuenta de que ROO compilo todo OK cuando en el shell tengamos la leyenda que muestra la imagen (si el texto es similar al de abajo, no se preocupen por el color rojo)
Como pueden ver en la figura, se encuentra la dirección a la cual tenemos que dirigirnos para poder ver y utilizar nuestra aplicación, en mi caso:
http://localhost:8080/test
La aplicación a sido creada, las relaciones enlazadas, pero nos surgen muchas preguntas:
Como agrego seguridad?
y los reportes?
Como puedo limpiar los campos para que me aparezca solo el dato que necesito?
Existe alguna variante de ROO?
Porque esa estructura de direcorios?
que son los archivos AJ?
Y si no quiero hacer ingeniería inversa?
Y JSF?
Y Oracle?
Y..y..?
Esta y muchas otras preguntas que puedan surgir o ustedes tener, en próximas entregas.
No hay comentarios:
Publicar un comentario