MANEJO MYBATIS GENERATOR

Buen día en esta oportunidad les mostrare el manejo de MYBATIS GENERATOR una muy buena herramienta para la generación del MAPPING de las tablas y/o objetos de BD cuando se maneja MYBATIS , ya que en si se pueden hacer a mano dicho MAPPING pero a veces es un poco engorroso y demora un tiempo por eso es mejor ya generar dicho MAPPING .

Para el DUMMY realizado, he preparado 2 formas de hacerlo.

I. Desde un APP DINAMIC WEB simple:
Para este manejo realizaremos los siguientes pasos:

1. Crear un APP Dinamic Web project desde ECLIPSE. (En mi caso MyBatisGenerator_SIMPLE )

2. Dentro de MyBatisGenerator_SIMPLE\WebContent\WEB-INF\lib poner la librerías:
- junit-4.8.jar
- ojdbc6-11.1.0.jar
- mybatis-3.0.6.jar
- mybatis-generator-core-1.3.1.jar
- mybatis-generator-core-1.3.1-sources.jar
- mybatis-generator-core-1.3.1-javadoc.jar


3. Crear el archivo de configuración de MYBATIS GENERATOR llamado generatorConfig.xml en mi caso en la ruta: MyBatisGenerator_SIMPLE\resources\pe\com\javaman\mybatis\mybatis

4. Dentro de este XML configuraremos las rutas de salida de: MAPPER, OBJETOS, MAPPING, CONEXIÓN, JAR JDBC, etc.

5. Creamos una clase JUnit Test llamada GeneradorMyBatis.java en mi caso en la ruta: MyBatisGenerator_SIMPLE\test\pe\com\javaman\mybatis\generador. Esta clase buscara la ruta del XML generatorConfig.xml y generara los MAPPINGs respectivos en las ruta definidas en el XML.

6. Al ejecutar la clase GeneradorMyBatis.java se genera lo siguiente:
- BEANs: MyBatisGenerator_SIMPLE\src\pe\com\javaman\mybatis\bean.
- MAPPERs: MyBatisGenerator_SIMPLE\src\pe\com\javaman\mybatis\mapper.
- MAPPINGs: MyBatisGenerator_SIMPLE\resources\pe\com\javaman\mybatis\mapping


II. Desde un APP WEB maven:
Para este manejo realizaremos los siguientes pasos:


1. Crear un APP MAVEN Web project desde ECLIPSE. (En mi caso MyBatisGenerator_MAVEN ).

2. Crear el POM.xml y dentro definir la DEPENDENCIAS de cada Librería (JAR) requerido.

3. Dentro de MyBatisGenerator_MAVEN\src\main\webapp\WEB-INF\lib poner la librerías:
- ojdbc6-11.1.0.jar (Solo para la GENERACION con MYBATIS GENERATOR ya que lo demás será controlado por MAVEN).

4. Crear el archivo de configuración de MYBATIS GENERATOR llamado generatorConfig.xml en mi caso en la ruta: MyBatisGenerator_MAVEN\src\main\resources\pe\com\javaman\mybatis\mybatis

5. Dentro de este XML configuraremos las rutas de salida de: MAPPER, OBJETOS, MAPPING, CONEXIÓN, JAR JDBC, etc.

6. Creamos una clase JUnit Test llamada GeneradorMyBatis.java en mi caso en la ruta: MyBatisGenerator_MAVEN\src\test\java\pe\com\javaman\mybatis\generador. Esta clase buscara la ruta del XML generatorConfig.xml y generara los MAPPINGs respectivos en las ruta definidas en el XML.

7. Al ejecutar la clase GeneradorMyBatis.java se genera lo siguiente:
- BEANs: MyBatisGenerator_MAVEN\src\main\java\pe\com\javaman\mybatis\bean.
- MAPPERs: MyBatisGenerator_MAVEN\src\main\java\pe\com\javaman\mybatis\mapper.
- MAPPINGs: MyBatisGenerator_MAVEN\src\main\resources\pe\com\javaman\mybatis\mapping.

El Dummy esta soportado por una BD ORACLE 11gR2 y el SCRIPT manejador se encuentra en la ruta: MyBatisGenerator_MAVEN\src\main\resources\ScriptBD.sql

Para mayor detalle descargar el Dummy completo pulsar: Aquí

INTEGRACIÓN: SPRING 3 + MYBATIS 3 + JAXWS 2.1.3 + MAVEN

En esta oportunidad postearé sobre una muy Buena integración basada en 3 FRAMEWORKs de últimos y conocidos:

- - SPRING 3 = Manejo de sesiones, factory, services.
- - MYBATIS 3.0.5 = Persistencia y Mapping.
- - JAXWS 2.1.3 = Servicio Web.

Adicionalmente, para la construcción del proyecto nos apoyaremos en MAVEN, para la generación de LOGs usaremos log4j y la base de datos esta en ORACLE 11g.

El Dummy preparado para ver el efecto de la integración es un WebService que tiene exponer datos de USUARIO para la consulta respectiva. Este WebService lo creo en base a una lógica de tipo TOP DOWN, osea generar el Servicio Web en base a un WSDL ya creado. Ese WSDL lo cree a mano en base a los estándares para WSDL y XSD existentes.







Las OPERACIONES soportadas por el WebService son:

1. consultaUsuarioForma_01:
INPUT: Primitivos: codigo, dni
OUTPUT: Cadena concatenada con datos de usuario filtrado.

2. consultaUsuarioForma_02:
INPUT: Primitivos: codigo, dni
OUTPUT: Objeto Usuario ya cargado y filtrado.

3. consultaUsuarioForma_03:
INPUT: Objeto Usuario seteado.
OUTPUT: Objeto Usuario ya cargado y filtrado.

4. consultaUsuarioForma_04:
INPUT: Objeto Usuario seteado.
OUTPUT: Lista de Objetos Usuario.

Lo bueno es que el JAXWS te brinda una mayor facilidad para el manejo de objetos y lista de objetos embebidos en dicho WebService que otros Framework como AXIS 1 y 2.

Descripción detallada del DUMMY:

- DummyWS\src\main\webapp\wsdl\DummyWS.wsdl : Interfaz en base a la cual se ha generado el proyecto J2EE.

- DummyWS\pom.xml: Archivo de configuracion de MAVEN. Aquí se declaran las DEPENDENCIAS, PLUGINs, etc.

- DummyWS\src\main\resources\pe\com\javaman\dummy\conexion\jdbc.properties: Archivo de configuración de los parámetros del Motor de Datos ORACLE.

- DummyWS\src\main\resources\pe\com\javaman\dummy\conexion\mybatis-config.xml: Archivo de configuración de MYBATIS. Aquí se configura los Alias a los objetos mapeados y las rutas respectivas de dichos objetos.

- DummyWS\src\main\resources\pe\com\javaman\dummy\mapping\Usuario.xml: Archivo de Mapping MYBATIS en base al Alias definidos y los parámetros de la tabla, Query o Procedure de base de datos.

- DummyWS\src\main\resources\Spring\applicationContext.xml: Spring aquí matriculamos los otros archivos de configuración manejados por Spring.

- DummyWS\src\main\resources\Spring\applicationDatasource.xml: Aquí amarramos la conexión a BD para que sea soportada por Spring.

- DummyWS\src\main\resources\Spring\applicationEntityBean.xml: Aquí matriculamos los objetos (Beans), que serán controlados por Spring.

- DummyWS\src\main\resources\Spring\applicationService.xml: Aquí matriculamos Servicios, Daos, Factory, Template, etc. Este es el Archivo de configuración más importante a mi parecer y donde usualmente aparecen los errores al no configurarlo bien.

- DummyWS\src\main\resources\log4j.properties: Archivo de configuración de LOG4J. Aquí definimos los niveles de salida en archive para INFO, DEBUG, ERROR.
- DummyWS\src\main\resources\Script_SQL.txt: String de creación de BD y objetos.

- DummyWS\src\main\java\pe\com\java\org\dummyws\DummySOAPService.java: Clase publica principal donde se definen las operaciones del WebService.

- DummyWS\src\main\java\pe\com\java\org\dummyws\service\UsuarioService.java: Clase Service donde se definen las operaciones del WebService.

- DummyWS\src\main\java\pe\com\java\org\dummyws\service\impl\UsuarioServiceImpl.java: Clase donde se implementa la clase UsuarioService.java.

- DummyWS\src\main\java\pe\com\java\org\dummyws\dao\UsuarioDao.java: Clase DAO donde se define la implementación de las operaciones de WebService.

- DummyWS\src\main\java\pe\com\java\org\dummyws\dao\impl\UsuarioDaoImpl.java: Clase DAO que implementa la clase UsuarioDao.java. Aquí se accede a la persistencia por medio de MYBATIS.

Para poder probar dicho Dummy es requerido manejar la IDE: Spring Suite v2.5 o un Eclipse Helios con el Plugin de MAVEN .


Para mayor detalle descargar el Dummy completo pulsar: Aquí

PRUEBAS MULTI-MODULE CON 'CLASSPATHSUITE'

Buen día en esta oportunidad mostrare sobre el manejo de una API muy buena para el manejo de las diferentes pruebas que nos podemos requerir realizar durante el desarrollo de software.

El API es ClasspathSuite y para explicarlos me basare en un escenario común:

“TENEMOS UN PROYECTO JAVA QUE ESTA COMPUESTO POR VARIOS MODULOS Y POR BUENAS PRACTICAS CADA MODULO LO TENEMOS EN APPs DISTINTAS. CADA APPs TIENE SUS CLASES DE PRUEBAS YA SEAN DE TIPO UNITARIAS Y INTEGRALES, Y REQUERIMOS ANTES DE INICIAR EL PROYECTO EJECUTAR TODAS.”

SOLUCION
- COMUN: Ejecutar clase por clase, modulo por modulo y verificar el correcto resultado de todos. Esto puede demorar.
- RECOMEMDADA: Ejecutar como máximo 3 clases, segmentada para un tipo UNITARIA, INTEGRAL y TODAS.

El DUMMY preparado muestra lo siguiente. Pasos:

1. Descagar los JARs: cpsuite-1.2.5-jar y JUnit 4.8.

2. Crear 2 proyectos JAVA que simularan a los MODULOS por separados y agregarle el JAR: JUnit:
- ModuloJAVA_01.
- ModuloJAVA_02.

3. A cada modulo crearle un clase Test que el resultado de la prueba sea correcto.
- TestModulo_01.java
- TestModulo_02.java

4. Crear un proyecto JAVA que simulara el proyecto principal llamado: DummyManejoClasspathSuite y agregarle los JARs: cpsuite-1.2.5-jar y JUnit 4.8.

5. Dentro de tipo proyecto principal damos en Botón Derecho sobre el proyecto --> Propiedades --> Java Build Path --> Pestaña Projects, y añadimos (botón Add...) todos los proyectos (en nuestro ejemplo: ModuloJAVA_01 y ModuloJAVA_02).

6. Dentro del modulo principal creamos 3 clases Test:
- AllTestJava.java: Clase que permite la ejecución de TODOS los TEST: (Unitarios y de Integración) sin restricción alguna.
- AllUnitTestJava.java: Clase que permite la ejecución de TODOS los TEST de tipo UNITARIOS. El Filtro se aplica en base a: 'Regex Expressions', en este caso es en base al nombre de la clase que NO contenga: 'IntegrationTest'.
- AllIntegrationTestJava.java: Clase que permite la ejecución de TODOS los TEST de tipo INTEGRALES. El Filtro se aplica en base a: 'Regex Expressions', en este caso es en base al nombre de la clase que SI contenga: 'IntegrationTest'.

7. Ejecutamos cada clase por separado y el resultado deberá de ser las pruebas Unitarias y/o Integrales completas según la clase Test ejecutada,


Para mayor detalle descargar el demo completo pulsando Aquí

MANEJO SELENIUM 2.0

En esta oportunidad mostrare sobre una muy buena herramienta para el manejo de pruebas unitarias a nivel de Interfaz, su nombre es SELENIUM. SELENIUM nos permite trabajar de distintas maneras. Requerimientos:

- SeleniumRemoteControl_1.0.zip: Paquete SELENIUM que contiene el Server, Driver por navegador. etc.
- Selenium IDE: Plugin FIREFOX para la generación de Script .java
- BlueDuckSRC: Servidor para desplegar Selenium por separado.
- Spring Suite v2.5: IDE Desarrollo basado en Eclipse.
- WebDriver: Librerías JAVA requeridas.
- MAVEN: Construcción del proyecto.
- TOMCAT: Contenedor de Servlets.

El tutorial abarca las algunas maneras para el manejo de SELENIUM, pero particularmente la mejor manera que he encontrado para su manejo es la siguiente:

ESCENARIO:

"Tengo una INTERFAZ registro de un USUARIO y deseo realizar una prueba unitaria del comportamiento de dicha sistema al ingresar los datos correctos y incorrectos".

¿QUE DEBERIA HACER?:

1. PRUEBA MANUAL: Ingresar por nuestra cuenta manualmente los datos y ver que pasa.

2. PRUEBA AUTOMATICA: Aquí entra a tallar Selenium ya que en caliente.

Para solucionar se aplicaría:

1. Generar un Proyecto MAVEN J2EE con Spring Suite v2.5.
2. Amarrar Tomcat al Proyecto WEB.
3. Crear un formulario de registro USUARIO en un JSP, con todas las validaciones necesarias.
4. Desplegar en el Tomcat el aplicativo Web.
5. Descargar el SELENIUM IDE para FIREFOX
6. Con SELENIUM IDE grabar los datos ingresados en el FORMULARIO y generar el Script .JAVA relacionado a WebDriver.
7. Ingresar el Script al APP previamente desplegado y ejecutar el Test.
8. Se levantara el FIREROX y se mostrara rápidamente los pasos realizados en el formulario.
9. Si el Test termina correctamente en VERDE todo esta OK.

Para descargar el demo completo pulsar Aquí

Para descargar un muy buen libro sobre dicho tema pulsar: Aquí

Aqui hay una muy buena exposicion brindada por AUTENTIA justo sobre el tema SELENIUM Ver

Saludos.