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.

Groovy es mas productivo... vea el ejemplo

Iterator el iterador es una de las mas comunes y útiles tácticas en todo tipo de situaciones de programación, Un iterador es el tipo de código "helper", este te permite acceder data rápidamente en cualquier contenedor o colección, uno a la vez. Groovy toma ventaja de el concepto de iterador del lenguaje Java, haciendolo implicito y mas simple de utilizar. en el listado 1 se puede observar el esfuerzo que se toma para imprimir cada elemento en una colección de cadena "String" usando el lenguaje Java.

Listado1 iterador en java
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class JavaIteratorExample {
  public static void main(String[] args) {
     Collection coll = new ArrayList();
     coll.add("JMS");
     coll.add("EJB");
     coll.add("JMX");
     for(Iterator iter = coll.iterator(); iter.hasNext();){
        System.out.println(iter.next());
     }
  }
}

En el siguiente listado usted podrá observar la simplificación del esfuerzo que Groovy realiza. Aquí se evita el uso de la interface iterator y solo se usa el método sobre la propia colección. Groovy concluye aceptar los métodos de iterator manera implícita, el cual es evocado para cada ciclo de la iteraccion. El listado 2 realiza la misma operación que el listado 1 en Groovy

Listado2 iterador en Groovy
class IteratorExample1{
   static void main(args) {
     coll = ["JMS", "EJB", "JMX"]
     coll.each{ item | println item }
   }
}

Como se puede Observar, en un típico código Java, Groovy controla los iteradores permitiéndome centrarme en el comportamiento del contenedor. Groovy permite que se cambie limpiamente la responsabilidad del manejo del recurso, en Java el programador es el responsable, en Groovy el mismo es el responsable. Groovy en la carga de procesamiento o manejo de recursos es extremadamente poderoso, esto hace que el trabajo de el programador sea mucho mas facil y consecuentemente mas rapido, lo que traducimos como productivo.

El presente es una traduccion de un articulo conseguido en la referencia developerworks

Powered by ScribeFire.