JDBI con Spring Boot

JDBI es una librería de código abierto para Java que actúa como una capa de abstracción sobre JDBC (Java Database Connectivity).

Permite interactuar con bases de datos relacionales de forma más rápida y limpia, reduciendo el código repetitivo (boilerplate) sin ocultar el lenguaje SQL.

Creando un proyecto Spring Boot con JDBI

Iremos al sitio para crear nuestro proyecto: https://start.spring.io/

Agregaremos las dependencias de MariaDB y Spring Jdbc.

Una vez creado el proyecto agregaremos una más, la dependencia de JDBI:

pom.xml

        <dependency>
            <groupId>org.jdbi</groupId>
            <artifactId>jdbi3-core</artifactId>
            <version>3.2.5</version>
        </dependency>
        <dependency>
            <groupId>org.jdbi</groupId>
            <artifactId>jdbi3-sqlobject</artifactId>
            <version>3.2.5</version>
        </dependency>
        <dependency>
            <groupId>org.jdbi</groupId>
            <artifactId>jdbi3-spring5</artifactId> 
            <version>3.2.5</version>
        </dependency>

El diseño de nuestra aplicación será modular:

• repository: para el acceso a los datos de la BD. 
• model: para el mapeo objeto-relacional. 
• service: contiene la lógica de negocio. 
• controller: el punto de entrada de las peticiones HTTP.
• config: para las configuraciones.

Base de datos de la aplicación

Usaremos MariaDB como BD. El nombre de la BD sera ``soporte_tecnico``. Nuestra tabla es la siguiente:

CREATE OR REPLACE TABLE usuarios(
id int PRIMARY KEY, password varchar(255),
nombre varchar(255), apellidos varchar(255),
correo varchar(255), cvesis varchar(255)
);

Esta entidad relacional describe los atributos de un usuario.

Capa de mapeo objeto-relacional

Crearemos nuestra clase tipo que mapee los atributos de la tabla usuarios.

Usuario.java

package com.codemonkey.demo_jdbi.model;

import org.jdbi.v3.core.mapper.reflect.ColumnName;
import org.jdbi.v3.core.mapper.reflect.JdbiConstructor;

public class Usuario {
    @ColumnName("id") private Long id;
    @ColumnName("nombre") private String nombre;
    @ColumnName("apellidos")private String apellidos;
    @ColumnName("correo") private String correo;
    @ColumnName("cvesis")private String cvesis;


   public Usuario(
    @ColumnName("id") Long id,
    @ColumnName("nombre") String nombre,
    @ColumnName("apellidos") String apellidos,
    @ColumnName("correo") String correo,
    @ColumnName("cvesis") String cvesis) {
    this.id = id;
    this.nombre = nombre;
    this.apellidos = apellidos;
    this.correo = correo;
    this.cvesis = cvesis;
	}


    public Long getId() {
        return id;
    }

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

    public String getNombre() {
        return nombre;
    }

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

    public String getApellidos() {
        return apellidos;
    }

    public void setApellidos(String apellidos) {
        this.apellidos = apellidos;
    }

    public String getCorreo() {
        return correo;
    }

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

    public String getCvesis() {
        return cvesis;
    }

    public void setCvesis(String cvesis) {
        this.cvesis = cvesis;
    }
}

No incluiremos el campo del password.

Capa de datos

Crearemos una interface para el repositorio de datos.

UsuarioRepository.java

package com.codemonkey.demo_jdbi.repository;

import com.codemonkey.demo_jdbi.model.Usuario;
import org.jdbi.v3.sqlobject.config.RegisterConstructorMapper;
import org.jdbi.v3.sqlobject.statement.SqlQuery;
import org.jdbi.v3.sqlobject.statement.SqlUpdate;
import java.util.List;

@RegisterConstructorMapper(Usuario.class) 
public interface UsuarioRepository {

    @SqlQuery("SELECT id, nombre, apellidos, correo, cvesis FROM usuarios")
    List<Usuario> listarUsuarios();

    @SqlUpdate("INSERT INTO usuarios(id, password, nombre, apellidos, correo, cvesis) VALUES (:id, :password, :nombre, :apellidos, :correo, :cvesis)")
    void insertar(Long id, String password,String nombre, String apellidos, String correo, String cvesis);
}

Esta interface tendrá dos métodos. Uno para consultar los datos con la instrucción SELECT y otro para insertar datos con INSERT.

Capa del servicio

Crearemos una clase tipo service para la lógica del negocio.

UsuarioService.java

package com.codemonkey.demo_jdbi.service;

import com.codemonkey.demo_jdbi.model.Usuario;
import com.codemonkey.demo_jdbi.repository.UsuarioRepository;
import org.jdbi.v3.core.Jdbi;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class UsuarioService {

    private final UsuarioRepository usuarioRepository;

    public UsuarioService(Jdbi jdbi) {
        this.usuarioRepository = jdbi.onDemand(UsuarioRepository.class);
    }

    public List<Usuario> listarUsuarios() {
        return usuarioRepository.listarUsuarios();
    }

    public void insertarUsuario(Long id, String password, String nombre, String apellidos, String correo, String cvesis) {
        usuarioRepository.insertar(id, password, nombre, apellidos, correo, cvesis);
    }
}

Capa para el acceso a las peticiones HTTP

Crearemos una clase tipo controller.

UsuarioController.java

package com.codemonkey.demo_jdbi.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ResquestBody;
import java.util.logging.Logger;
import java.util.logging.Level;
import com.codemonkey.demo_jdbi.service.UsuarioService;
import com.codemonkey.demo_jdbi.model.Usuario;
import java.util.List;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;


@RestController
@RequestMapping("/api/usuarios")
public class UsuarioController {

    private static final Logger LOGGER = Logger.getLogger(UsuarioController.class.getName());
	
	private UsuarioService usuarioService;

	@Autowired
    public UsuarioController(UsuarioService usuarioService) {
        this.usuarioService = usuarioService;
    }
	
    // http://localhost:8083/api/usuarios/hola
    @GetMapping("/hola")
    public String hola() {
        LOGGER.log(Level.INFO, "Entramos al primer servicio.");
        return "El servicio esta vivo.";
    }
	
	// http://localhost:8083/api/usuarios/all
	@GetMapping("/all")
	public ResponseEntity<List<Usuario>> getUsuarios() {
		LOGGER.info("\t ==== Obtenemos todos los usuarios. ====");
		List<Usuario> usuarios = usuarioService.listarUsuarios();
		
		if(usuarios.isEmpty()) {
			return ResponseEntity.noContent().build();
		}
		return ResponseEntity.ok(usuarios);
	}
	
	// http://localhost:8083/api/usuarios/insertar
    @PostMapping("/insertar")
    public ResponseEntity<String> insertarUsuario(@RequestBody Usuario usuario) {
    try {
        LOGGER.info("Insertando nuevo usuario: " + usuario.getNombre());
        usuarioService.insertarUsuario(
            usuario.getId(),
            "qwErt@3200$",
            usuario.getNombre(),
            usuario.getApellidos(),
            usuario.getCorreo(),
            usuario.getCvesis()
        );
        return ResponseEntity.status(HttpStatus.CREATED)
                             .body("Usuario insertado correctamente.");
    } catch (Exception e) {
        LOGGER.log(Level.SEVERE, "Error al insertar usuario", e);
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                             .body("Error al insertar usuario: " + e.getMessage());
    }
}


	
}

Esta clase expone tres apis:

• GET http://localhost:8083/api/usuarios/hola 
• GET http://localhost:8083/api/usuarios/all 
• POST http://localhost:8083/api/usuarios/insertar

La primera es para probar que la aplicación está activa. La segunda para consultar todos los datos de la tabla usuarios. La tercera para agregar un nuevo usuario.

Construimos la aplicación:

$ mvn clean install -X

Ejecutamos la aplicación:

$ mvn spring-boot:run

Hemos visto cómo crear una aplicación Spring Boot con Jdbi.

Enlaces:

https://jdbi.org/
https://codemonkeyjunior.blogspot.com/2016/02/jdbi-como-alternativa-jdbc.html
https://codemonkeyjunior.blogspot.com/2016/01/conociendo-jdbi.html
https://codemonkeyjunior.blogspot.com/2017/04/jdbi-con-groovy-2.html