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.

"El Santo Grial..." Desarrollo de Aplicaciones EJB

He realizado una búsqueda en la "WWW" sobre los Frameworks que soportan EJB, obteniendo como resultado una gran gama de entornos de productividad, donde cada cual se destaca dependiendo de la tarea especifica que pueda realizar, sin embargo, según lo publicado y leído en la basta información de la Internet, Spring se lleva muchas de las glorias, al crear y utilizar aspect-oriented programming (AOP) e Inversion of Control (IOC), además de ser bastante flexible para conectarse mediante configuración XML a un sin fin de frameworks, por lo cual es posible utilizar Strut, Ibatis, Hibernate, DWR, ZKoss, solo por nombrar algunos, esta disponibilidad de entornos hace posible que la productividad mejore ya que nos enfocamos al desarrollo como tal, ahora bien, para los recién iniciados la experiencia no es muy halagadora cuando de auto-enseñanza se trata, para ello conseguí el Santo Grial, GROOVY and GRAILS.

Groovy es un lenguaje script dinámico creado en JAVA, GRAILS es un entorno de trabajo que soporta las mejores tecnologías a saber Groovy, Spring, Hibernate, SiteMesh y además soporta una serie de plugins para expandir funcionalidades, las aplicaciones básicas son creadas automáticamente en sus capas subyacentes con el script generado en groovy.
Por "arte de magia" podemos generar una aplicación que incluye funcionalidades CRUD (Create, Read, Update, Delete), con unas cuantas linea de código, además se simplifica el lenguaje Java, y es posible utilizar Beans existentes, lo cual significa poder migrar aplicaciones con pocos cambios, todo fue construido bajo la filosofia de "Ruby on Rails" con la ventaja que el lenguaje Groovy es compilado a ByteCodes, es decir, al final es Java.
Sorprende que un Framework posea tantas bondades, pues como todo no es una panacea, pero parece ser que sus ventajas son mas que las desventajas, por ejemplo una de las desventajas seria la de aprender un nuevo lenguaje con la salvedad de que Groovy es mucho mas sencillo y simplificado que Java y con el mismo poder de OOP.
Seguiré investigando estos temas por lo pronto me dedicare a crear una aplicación mas compleja en GRAILS y les comentare.

Powered by ScribeFire.

Bienvenidos!!!

En Hora Buena!!!

El presente blog sera un reflejo, desde mi punto de vista, de lo que nos trae la tecnología en su amplia y gran diversidad respecto a nuestro mundo, principalmente dedicare algo de tiempo a realizar comentarios sobre Programación "OOP", los Frameworks, los adelantos tecnológicos actuales, refiriéndome a "actual" el alcance en nuestro pequeño mundo, ya que el basto conocimiento desplegado en Internet no es posible abarcarlo del todo ni al navegar 24 horas al día...