JDBI como alternativa a JDBC, JPA, Hibernate ...

Para todos aquellos que estén cansados de usar siempre lo mismo (JDBC, JPA, Hibernate, etc.) cuando trabajan con base de datos en sus aplicaciones pueden optar por usar JDBI, una librería que promete facilitarnos la existencia. Su página oficial dice:

JDBI is a SQL convenience library for Java. It attempts to expose relational database access in idiommatic Java, using collections, beans, and so on, while maintaining the same level of detail as JDBC. It exposes two different style APIs, a fluent style and a sql object style

No me dejaran mentir al decir que cuando se trabaja con aplicaciones demasiado robustas los desarrolladores sufrimos al trabajar con extensos archivos confusos y difíciles de mantener. Peor aún cuando el equipo original de trabajo "olvido" documentar el proyecto.

La pregunta obligada es: ¿Me conviene abandonar mis proyectos hechos en X o Y framework / librerías y optar por algo nuevo? La respuesta puede ser demasiado ambigua. Para ciertos proyectos en los que se tiene demasiada dependencia a los frameworks / librerías es un rotundo NO. Simplemente porque cambiar a algo nuevo implicaría reescribir prácticamente todo el proyecto, hacer pruebas y volver a sufrir los tormentos a los que ya estamos acostumbrados. Sin embargo, para proyectos en los que necesariamente se deben hacer ajustes y mejoras puede que optar por nuevas cosas sería una solución.

En la página oficial de JDBI puedes encontrar varios ejemplos.

ConexionJDBI.groovy

/**
*
*@description Uso de JDBI en Groovy
*/

//Aquí agrego las librerías que se usarán
@Grapes( [@Grab(group='org.jdbi', module='jdbi', version='2.77') ,
@Grab(group='mysql', module='mysql-connector-java', version='5.1.23') ,
@GrabConfig(systemClassLoader=true)
]
)

import java.sql.ResultSet;
import java.sql.SQLException;
import org.skife.jdbi.v2.sqlobject.Bind;
import org.skife.jdbi.v2.sqlobject.SqlQuery;
import org.skife.jdbi.v2.sqlobject.customizers.RegisterMapper;
import org.skife.jdbi.v2.DBI;
import org.skife.jdbi.v2.Handle;
import org.skife.jdbi.v2.tweak.*;
import org.skife.jdbi.v2.*;
import org.skife.jdbi.v2.util.*;

class ConexionJDBI{

        static main(args) {
                String nombre=""
                DBI dbi = new DBI("jdbc:mysql://localhost:3306/test",
                "root",
                "5432");
                Handle h = dbi.open();
                if(!dbi.open().isInTransaction()){
            println "No esta realizando alguna transaccion";
        }
                h.execute("create table cliente (id int primary key, name varchar(100))");
                h.execute("insert into cliente (id, name) values (?, ?)", 1, "Jacobo");
                println "Tabla creada"

                try {
                        println "Consultando..."
                        nombre = h.createQuery("select test.cliente.name from test.cliente where id = :id")
                    .bind("id", 2)
                    .map(StringMapper.FIRST)
                    .first();
            println "Nombre del cliente: "+nombre      
                }
                catch(Exception e) {
                    println "Error: "+e
                }
        h.close();
               
        }
}

Donde:
Aquí definimos los parámetros necesarios para la conexión a la base de datos "test"

DBI dbi = new DBI("jdbc:mysql://localhost:3306/test","root","5432");

Creamos un "manejador":
Handle h = dbi.open(); y abrimos la conexión a la base de datos.
Creamos una tabla e insertamos dos valores:

h.execute("create table cliente (id int primary key, name varchar(100))");
h.execute("insert into cliente (id, name) values (?, ?)", 1, "Jacobo");

Y por último obtenemos el registro insertado:

nombre = h.createQuery("select test.cliente.name from test.cliente where id = :id")
                    .bind("id", 2)
                    .map(StringMapper.FIRST)
                    .first();
            println "Nombre del cliente: "+nombre      

Como se puede ver no es tan complicado comparándolo con JDBC y más aún con JPA y/o Hibernate.

Links
JDBI como alternativa a JDBC
JDBI con Groovy (2)

Comentarios

Opciones de visualización de comentarios

Seleccione la forma que prefiera para mostrar los comentarios y haga clic en «Guardar las opciones» para activar los cambios.
Imagen de ezamudio

peras y manzanas

Está bien comparar JDBC con JDBI, pero no veo por qué lo comparas con JPA o Hibernate. Estos últimos son ORMs, son herramientas que trabajan a un nivel de abstracción arriba de JDBC.

En todo caso, podría ser útil compararlo con la JdbcTemplate de Spring, o con GroovySql.

Habría que revisar los detalles de JDBI, por ejemplo cómo se manejan transacciones, o si ese Handle es algo que se pueda usar en un try-with-resources, si las excepciones arrojadas son checadas o de runtime, etc.

No sé si sea válido compararlo con jOOQ, al menos en la modalidad de uso de jOOQ más básica que es el fluent API, sin ORM ni nada.