Ir al contenido principal

Instalando Apache NetBeans 10 y configurarlo con Jakarta EE

Groovy: Un lenguaje dinámico y ágil para la Plataforma Java

El primer post de este año quisiera dedicarlo a un lenguaje interesante. Este es Groovy: Un lenguaje dinámico como JavaScript, pero no es interpretado; tiene acceso a todo el API de Java, se ejecuta sobre el JVM, y por tanto puede interactuar con nuestras aplicaciones Java. Podemos tener algunas clases en Groovy y otras en Java. Más información lo puedes encontrar en Wikipedia.

Lo bueno de este lenguaje es que - a gran diferencia de Java - no necesita de una clase "Main" para ejecutar la aplicación. Es como JavaFX, PHP, o como JavaScript, que ejecuta las instrucciones de arriba a medida que se van declarando. Por tanto, un "HolaTodos" puede ser así

package demogroovy

public class Prueba{
    public static void main(String[] a){
        System.out.println("Hola a todos");
    }
}

o así:

package demogroovy
println("Hola a todos")

Ambos son válidos en Groovy. Notar que los punto-y-coma (;) son opcionales.

NetBeans nos permite crear clases Groovy en cualquier proyecto Java. Por tanto, necesitamos crear un proyecto Java cualquiera (web o desktop) y luego crear las clases Groovy.


 No voy hacer un tutorial de Groovy ya que hay uno bueno aquí: http://groovy.org.es/ en español, o si deseas la fuente en inglés, aquí está la web oficial: http://groovy.codehaus.org/. Solo voy a resaltar cosas muy interesantes de este lenguaje. Por ejemplo, el acceso a base de datos:

Como está hecho en Java, entonces debe utilizar las bibliotecas de java. Si deseo acceder a la base de datos Apache Derby, debo utilizar sus drivers; si uso MySQL, debo usar su respectivo driver, y así.


Un ejemplo que adapto de "Tutorial 6 - Groovy SQL" es este:

package demogroovy

import groovy.sql.Sql;

sql=Sql.newInstance("jdbc:derby://localhost:1527/sample",
        "app","app",
        "org.apache.derby.jdbc.ClientDriver")
println "ID Prod.\tDescripción"
sql.eachRow("select * from product",
    {println "${it.product_id}\t${it.description} "})

fila=sql.firstRow("select customer_id,name,email from customer")
println "Cliente ${fila.customer_id}:${fila.name} -> ${fila.email}"

Aquí estoy usando la base de datos "sample" que viene como ejemplo en NetBeans.


La simpleza del lenguaje permite ahorrar tiempo en programación. Por ejemplo, podemos tener un JavaBean en Java:

package demogroovy.beans;

public class Cliente {

    private int id;
    private String nombre;
    private String correo;

    public Cliente() {
    }

    public String getCorreo() {
        return correo;
    }

    public void setCorreo(String correo) {
        this.correo = correo;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getNombre() {
        return nombre;
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;
    }
}

Luego, podemos tener un DAO hecho en Groovy:

package demogroovy.dao
import groovy.sql.Sql;
import demogroovy.beans.Cliente

class ClientesDao {
    private def sql;
    ClientesDao(){
        sql=Sql.newInstance("jdbc:derby://localhost:1527/sample", //URL del JDBC
        "app","app", //usuario y contraseña
        "org.apache.derby.jdbc.ClientDriver") //driver del JDBC
    }

    def getClientes(){
        def lista=[];
/*notar las comillas de los alias de cada campo. Esto nos asegura que cada campo
será asociado a cada propiedad del bean Cliente.
*/
        sql.eachRow("SELECT customer_id as \"id\",name as \"nombre\",email as \"correo\" FROM customer"){
             Cliente c=new Cliente(it.toRowResult()) //se instancia y pone las propiedades segun corresponda de acuerdo al metodo toRowResult()
            lista << c //agrega a la lista
        }
        return lista;
    }

    def updateCliente(Cliente c){
        sql.executeUpdate("UPDATE customer SET name=?, email=? WHERE customer_id=?",[c.nombre,c.correo,c.id])
    }

}
Notemos que para acceder a las propiedades del bean no necesitamos usar los métodos set/get.. solo accedemos a la propiedad misma.

Y para acceder al dao, lo hacemos como si fuera un objeto java:

List<Cliente> clientes= (List) dao.getClientes();

Es un ahorro de código, de esfuerzo y de tinta si se desea imprimir los códigos fuentes (¿aún se hace eso? Por el bien de la naturaleza espero que ya no).

Aquí he colgado un proyecto de cómo usar un JFrame + JTable para acceder a una base de datos, usando una clase Groovy para el DAO.
http://diesil-java.googlecode.com/files/DemoGroovy.tar.gz
Utiliza el Apache Derby, por lo que primero debemos iniciar el servidor. En su defecto, se puede utilizar otra base de datos, y hacer los cambios respectivos.

Comentarios

Entradas más populares de este blog

RESTful... la forma más ligera de hacer WebServices (Parte 1)

Quienes hayan usado SOAP para WebService, sabrán que es bien fácil de diseñar, pero algo complicado de consumir: se necesita toda una API para construir los clientes utilizando el WSDL. Por ejemplo, para PHP se necesita de la biblioteca NuSOAP. Entonces, para lograr el concepto de "lenguaje único XML" es un dolor de cabeza. Y más aún si el cliente es tan simple como JavaScript, manejar XML de SOAP provocaría suicidos masivos... o no usar WebServices.

Además, con SOAP se permite crear un solo servicio y ponerle varios métodos. Esto puede llevar a un mal diseño del servicio ya que podría tener un servicio que haga de todo: por ejemplo, un servicio de manejo de Clientes que permita también manejar Proveedores.

RESTful es una propuesta muy interesante de Roy Fielding que permite manejar los servicios web con métodos definidos, manteniendo la simpleza del protocolo como XML, pero que cada servicio sea identificado únicamente con un solo URI.

En este post veremos cómo crear un Ser…

¿Por valor o por referencia?

Esta es una pregunta existencial para todo programador Java. Cada uno encuentra una respuesta satisfactoria. Pero ahora veremos, basándonos en el libro para Certificación SCJP 1.5 de Katty Sierra, sobre la respuesta correcta.

Contraseñas encriptadas con Java

¿Quién no ha querido encriptar texto o archivo? Hay diversas maneras para hacer eso, por ejemplo, utilizando un diccionario donde se reemplazara cada caracter por un código.. y para poder desencriptarlo se debería utilizar el mismo diccionario para revertir el proceso. Pero si el diccionario cae en manos de alguien que no queremos que lo sepa, entonces estamos en peligro.
Cuando yo programaba en pascal, mi encriptación favorita era invirtiendo los bits... pero cualquiera también puede invertir los bits y listo.
Pero ya gente experta logró algoritmos de encriptación populares. Los más conocidos: MD5 y SHA.
En este post hablaremos cómo encriptar texto, sobretodo las contraseñas, utilizando MD5 o SHA.