Java Spring Boot: empezando con JPA Hibernate y Mariadb

Este post es un codekata en Java usando el ORM Hibernate junto con Spring Boot. Spring Boot es una tecnología de desarrollo para Java que tenemos disponible en Spring, que orienta un proyecto a crear microservicios y se facilita mucho la programación.

Por otro lado, con Hibernate tenemos un ORM, en el que la creación de bases de datos, su manteniento y trabajo diario se facilita. Se puede llegar a mantener un proyecto con Hibernate sin tener que picar ninguna línea de código SQL. Esto facilita de nuevo mucho la programación.

Este post sirve de codekata de copia y pega para el caso de Mysql/Mariadb/Oracle, etc..

¡Vamos al grano con el codekata!

Iniciando proyecto

De nuevo, si tenemos el Spring CLI instalado en un sistema UNIX podemos ir al terminal y lanzar los siguientes comandos para inicializar el proyecto:

spring init --list

Con este anterior comandos podemos ver las dependencias que tenemos disponibles. Con el comando siguiente, si seguimos el codekata, podemos instalar web para peticiones HTTP, las devtools para que reinicie automáticamente con cada cambio en los fuentes, mariadb para conectarnos con Mariadb y data-jpa para usar el acceso a BD con el ORM de Hibernate:

spring init -d=web,devtools,mariadb,data-jpa testing-hibernate

Si no tenemos el Spring CLI podemos usar herramientas alternativas, el IDE, o el generador online de proyectos: https://start.spring.io/

Configurando el proyecto

Lo siguiente que necesitaremos es generar un fichero de configuraciones, por ejemplo, un src/main/resources/application.properties con algo parecido a lo siguiente:

spring.jpa.hibernate.ddl-auto=update
spring.datasource.url=jdbc:mariadb://localhost:3306/testing_hibernate
spring.datasource.username=usuario
spring.datasource.password=contraseña
spring.datasource.driver-class-name=org.mariadb.jdbc.Driver

Si todo ha ido bien, ya podemos arrancarlo con un comando como el siguiente:

mvn spring-boot:run

..y veremos por pantalla los clásicos mensajes de que está arracando Spring Boot:

Iniciando un controlador REST

Si estamos usando Spring Boot, probablemente lo siguiente que queremos es un controlador. Con ello luego vamos a usar Hibernate, podría ser algo así src/main/java/com/example/testinghibernate/rest/MainController.java:

package com.example.testinghibernate.rest;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class MainController {
    @GetMapping("/")
    public String prueba() {
        return "Esto es una prueba";
    }
}

Ahora si vamos al navegador a la dirección http://localhost:8080/ deberíamos de ver algo parecido a lo siguiente:

Las entidades de Hibernate

En los ORM como Hibernate, los conceptos se mapean en clases. Estos conceptos que se llaman entidades. Depende de la naturaleza del programa que estemos haciendo, tendremos entidades como Task.java, Proccess.java, Book.java, Car.java, Motorbike.java, etc..

Una posible entidad para empezar a probar, podría ser src/main/java/com/example/testinghibernate/entity/Something.java:

package com.example.testinghibernate.entity;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Something {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String title;
    private int intValue;
    private boolean booleanValue;
    private long longValue;

    public Something() {}

    public String getTitle() {
        return this.title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public int getIntValue() {
        return this.intValue;
    }

    public void setIntValue(int intValue) {
        this.intValue = intValue;
    }

    public boolean isBooleanValue() {
        return this.booleanValue;
    }

    public boolean getBooleanValue() {
        return this.booleanValue;
    }

    public void setBooleanValue(boolean booleanValue) {
        this.booleanValue = booleanValue;
    }

    public long getLongValue() {
        return this.longValue;
    }

    public void setLongValue(long longValue) {
        this.longValue = longValue;
    }

    public Long getId() {
        return id;
    }

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

Creando la base de datos con Hibernate

Con lo que tenemos de código hasta ahora, la primera vez que el proyecto se conecte a la base de datos, hará la magia de crear la BD. Es decir, si todo ha ido bien, después de arrancar el proyecto con la entidad del apartado anterior, podemos ir a la base de datos y tenemos que ver algo como lo siguiente:

Si vamos al grano, simplemente ha cogido los campos de la clase Something y los ha convertido en campos de la tabla Something, sin tener que hacer absolutamente nada nosotros.

El repositorio, adaptador, a base de datos

Parafraseando la teoría, este repositorio se corresponde en patrones de diseño de software con lo que se llamaría un adaptador a base de datos. En este caso, un adaptador a base de datos de Mariadb pero con la magia de Hibernate sin picar código SQL de momento ni tener que conectar con la BD manualmente. Podría ser algo como el código siguiente src/main/java/com/example/testinghibernate/entity/SomethingRepository.java:

package com.example.testinghibernate.entity;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface SomethingRepository extends JpaRepository<Something, Long>{}

EDITADO: Lo siquiente es poner este repositorio en el controlador accesible con una variable para que esté disponible en todo el controlador. Podemos hacer entonces lo siguiente al principio de la clase:

@RestController
public class MainController {
    @Autowired
    SomethingRepository somethingRepository;

    @GetMapping("/")
    public String prueba() {
        return "Esto es una prueba";
    }
}

Creando un punto de entrada en el controlador para insertar registros en base de datos

La siguiente operación sobre la BD que podemos querer hacer es insertar datos. Mediante el controlador anterior le podríamos añadir un endpoint que los inserte. Podría ser algo como lo siguiente, un punto de entrada nuevo:

    @GetMapping("/insert")
    public String insert() {
        Something newEntity = new Something();
        newEntity.setBooleanValue(true);
        newEntity.setIntValue((int) (Math.random() * 100 + 1));
        newEntity.setLongValue((long) (Math.random() * 100000 + 1));
        newEntity.setTitle("Nueva entidad");

        somethingRepository.save(newEntity);

        return "¡Insertada una entidad de prueba!";
    }

Atención, que ahora hemos metido un elemento nuevo el repositorio.

Comprobando los inserts a base de datos

Por no complicar el post, lo dejamos así, y accediendo a http://localhost:8080/insert deberíamos de ver algo como lo siguiente si todo ha ido bien:

..y en la base de datos veremos por ejemplo:

Creando un punto de entrada en el controlador para obtener todos los registros

Lo siguiente que podemos querer es obtener los datos y mostrarlos en un endpoint. Este endpoint se podría añadir por ejemplo en el controlador anterior con una función como la siguiente:

    @GetMapping("/selectAll")
    public List<Something> select() {
        return somethingRepository.findAll();
    }

Es más sencillo que el del insert, porque sólo necesitamos que el repositorio de la entidad Something nos devuelva todos los regisros. Esta función ya la proporciona de nuevo Hibernate, con lo que si vamos al navegador debemos ver algo como lo siguiente:

Otras funciones de manejo de datos que proporciona Hibernate

Siguiendo el codekata, tenemos en Hibernate funciones parecidas como en otros ORMs:

• findAll()
• findBy(..
• findById(..
• delete(..
• deleteAll()
• save(..
• saveAll(..
• saveAndFlush(..
• count()

Todas las funciones disponibles para Hibernate se pueden ver en el siguiente enlace:
https://docs.spring.io/spring-data/jpa/docs/current/api/org/springframework/data/jpa/repository/support/SimpleJpaRepository.html

Aparte de esto, podemos crear nuestras propias funciones, podemos añadir código SQL personalizado también, etcétera..

Terminando y referencias

Para terminar, creo que lo siguiente interesante puede ser el cómo ampliar las funciones de acceso a BD, o el tema de las migrations (cómo alterar la base de datos), pero esto es tema para otro post.

El tema de Hibernate es muy grande, como en otros ORM o en otros lenguajes, me remito a la documentación oficial para más información:
https://spring.io/guides/gs/accessing-data-jpa/
https://hibernate.org/