My Blog ha sido movido a SliceTech WordPress!

En 6 segundos estara entrando a mi nuevo Blog. Si no, visite
http://slicetech.x10.bz
actualice su Marcalibros.

martes, 4 de marzo de 2008

Manejo de XML con Groovy

Si se esta escribiendo, leyendo, o trabajando con archivos de XML, en Java esto representa un considerable esfuerzo y cantidad de trabajo, alternativas como el W3C DOM hacen la vida mas fácil, sin embargo, Java no te ayuda mucho en términos de lenguaje, este no es capaz de adaptarse a nuestras necesidades.
Groovy nos permite a las clases actuar como si ella tuvieran propiedades en tiempo de ejecución, en igual medida, si estas propiedades no son conocidas cuando la clase es compilada. GPath fue construida con esta característica lo que le permite navegar por el documento XML, como si fuera XPath, es decir, GPath simula en lenguaje Java lo que seria XPhat de XML.
Para refinarlo y entenderlo mas, supongamos que tenemos el siguiente archivo .xml denominado customers.xml
<?xml version="1.0" ?>
<customers>
<corporate>
<customer name="Bill Gates" company="Microsoft" />
<customer name="Steve Jobs" company="Apple" />
<customer name="Jonathan Schwartz" company="Sun" />
</corporate>
<consumer>
<customer name="John Doe" />
<customer name="Jane Doe" />
</consumer>
</customers>

Podremos imprimir los nombres de usuario corporativos <customer name> con sus nombres y sus compañías a las que pertenecen usando el siguiente código en Groovy:

class prueba {

static void main(args) {
def customers = new XmlSlurper().parse(new File('customers.xml'))
for (customer in customers.corporate.customer){
println "${customer.@name} works for ${customer.@company}"
}
}
}

Características como esta son las que le dan poder a Groovy, pero que es GPath, es un bloque de código usado para la navegación de objetos, su nombre fue tomado por similitud de la tecnología XPath de XML. Como Xpath esta dirigido a construir mediante expresiones cortas y compactas haciéndolo mas fácil de leer. En nuestro codigo el color Verde representa el GPath.



Powered by ScribeFire.

viernes, 29 de febrero de 2008

Groovy y JDBC

La Magia del SQL en Groovy es encontrada en una elegante API denominada GroovySql. Usando abstracciones con funcionalidades implicitas e iteradores, GroovySql maneja limpiamente el recurso JDBC para nosotros. Groovy remueve el trabajo duro a realizar al programar un codigo para JDBC, esto implica que nos podemos enfocar a realizar los queries y analizar sus resultados.
Como ejemplo de lo citado anteriormente , he aqui un codigo de programacion para JDBC en lenguaje java.


Listado 1 Código de JDBC en Lenguaje Java

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
/*importacion de librerias*/
public class JDBCExample1 {
public static void main(String[] args) {
Connection con = null;
Statement stmt = null;
ResultSet rs = null;
/*Declaracion de miembros de clase a utilizar*/
try{
Class.forName("org.gjt.mm.mysql.Driver");
/*uso del driver JDBC correspondiente*/
con = DriverManager.getConnection("jdbc:mysql://localhost:3306/words",
"words", "words");
/*realiza la conexión a base de datos*/
stmt = con.createStatement();
/*creación de el statement*/
rs = stmt.executeQuery("select * from word");
/*uso de resulset en respuesta a la ejecución de la consulta*/
while (rs.next()) {
/*iterando el contenedor rs para obtener cada uno de los registros*/
System.out.println("word id: " + rs.getLong(1) +
" spelling: " + rs.getString(2) +
" part of speech: " + rs.getString(3));
}
}catch(SQLException e){
e.printStackTrace();
}catch(ClassNotFoundException e){
e.printStackTrace();
/*excepciones*/
}finally{
try{rs.close();}catch(Exception e){}
try{stmt.close();}catch(Exception e){}
try{con.close();}catch(Exception e){}
/*cierre y limpieza de recursos*/
}
}
}
El anterior codigo posee 40 lineas de esfuerzo de codificación "no incluyo los comentarios" en un lenguaje estricto en su sintaxis como lo es java y su correcta ejecución mostrara en pantalla el contenido de una tabla.
¿En cuantas lineas es posible reducir el código usando Groovy? 30, 20, 10 tal vez , observe como groovy elegantemente me permite enfocarme en la consulta que representa mi objetivo principal, mientras el lenguaje se encarga de el manejo de los recursos subyacentes a mi objetivo, a continuación listado de Groovy que realiza la misma tarea que el anterior presentado en Java.
Listado 2 Código de JDBC en Lenguaje Groovy
import groovy.sql.Sql
class GroovySqlExample1{
static void main(args) {
sql = Sql.newInstance("jdbc:mysql://localhost:3306/words", "words",
"words", "org.gjt.mm.mysql.Driver")
sql.eachRow("select * from word"){ row |
println row.word_id + " " + row.spelling + " " +
row.part_of_speech
}
}
}
No esta mal ¿cierto?, Utilizando solo 10 lineas incluyendo las 3 finales de llaves de cierre, se ha logrado codificar el mismo comportamiento del código en Java sin depender del cierre de las conexiones, del cierre del contenedor resulset, o cualquier otra cosa familiarizada don las tareas que están en rededor de la base de datos, y no es que esto no se realice, simplemente Groovy lo hace por nosotros y lo mejor de todo es que sigue siendo Java.


El articulo es una traducción y modificación tomado de la referencia developerworks

Powered by ScribeFire.