Integración de la base de datos H2 con Spring Boot

En esta guía, veremos cómo integrar la base de datos H2 con proyectos Spring Boot. ¿Qué es la base de datos H2? H2 es un embebido de código abierto, basado en Java...

Introducción

En esta guía, veremos cómo integrar la base de datos H2 con proyectos Spring Boot.

¿Qué es la base de datos H2?

H2 es una base de datos integrada de código abierto basada en Java. Es muy rápido y muy ligero. Por lo general, se usa como una base de datos en memoria, lo que significa que almacena los datos en la memoria y no conservará los datos en el disco. Aunque si necesitamos conservar los datos, con solo pulsar un interruptor, también puede conservar los datos.

La base de datos H2 no se recomienda para entornos de producción y se utiliza más bien para pruebas de concepto, pruebas, prototipos y aplicaciones similares.

Diferencia entre bases de datos persistentes y en memoria {#diferencia entre bases de datos persistentes y en memoria}

Vale la pena entender la diferencia entre persistentes y bases de datos en memoria. Las bases de datos persistentes conservan los datos en la memoria física: ese es el objetivo de las bases de datos. En el caso de las bases de datos en memoria, los datos se almacenan en la memoria del sistema y se perderán cuando se cierre el programa. En esencia, es como usar RAM para almacenar tus objetos.

Una vez que se cierra el programa, los datos se pierden.

¿Por qué usar bases de datos en memoria entonces?

Las bases de datos en memoria son útiles para las pruebas de concepto, ya que puede sustituir fácilmente una base de datos en memoria por una persistente. Se burla de la funcionalidad y el respaldo de una base de datos persistente real, al tiempo que le brinda la facilidad de uso y la flexibilidad de realizar consultas y objetos "persistentes", sin dejar de ser liviano.

Aunque H2 le permite persistir datos fuera de la memoria, no caiga en la tentación de reemplazar una base de datos más robusta, como PostgreSQL, MySQL, OracleDB, etc. con él.

Configuración del proyecto Spring Boot

Comencemos con una aplicación básica. La forma más fácil es usar Spring Initializr y generar un proyecto Spring Boot.

Asegúrese de agregar las dependencias Web, H2 y JPA (API de persistencia de Java).

Nuevamente, aunque H2 normalmente no se usa como una base de datos persistente, se burla de las bases de datos clásicas e interactúa con la API de persistencia.

Al hacer clic en el botón "Generar proyecto" se descargará el archivo SpringBootH2Integration.zip, que puede importar al IDE de su elección:

Spring Initializr{.img-responsive}

Comprender las configuraciones predeterminadas de H2

Spring Boot es un marco obstinado y realiza todas las configuraciones predeterminadas en función de las dependencias disponibles en el classpath.

Dado que agregamos H2 como una dependencia, Spring Boot sabe que en este proyecto nos conectaremos a la base de datos H2, por lo que configura automáticamente las propiedades relacionadas con H2, como la base de datos URL, username, password, etc.:

1
2
3
4
5
spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
spring.h2.console.enabled=false

Si observamos la propiedad datasource.url, el nombre del esquema es testdb y es una base de datos en memoria (referida como "mem"). Veremos cómo podemos anular los valores predeterminados en las próximas secciones.

Anulación de las configuraciones predeterminadas de H2

Para anular cualquier propiedad, simplemente redefina la propiedad con el valor actualizado en el archivo application.properties disponible en la carpeta src/main/resources.

Por ejemplo, la consola H2 está deshabilitada de manera predeterminada, así que habilitémosla agregando la siguiente propiedad en el archivo application.properties:

1
spring.h2.console.enabled=true

Realización de operaciones CRUD con H2 en Spring Boot

En las siguientes secciones, vamos a crear una Persona API, que es un servicio REST simple en el que interactuaremos con H2 usando Spring Boot.

Si aún no estás familiarizado con la creación de APIs REST, lee nuestra [Guía completa para crear API REST con Spring Boot](/construir-una-api-spring-boot-rest-con-la-guia-completa -de-java/)!

La API de persona realizará operaciones CRUD utilizando diferentes puntos finales. A continuación se muestran los detalles de los puntos finales:

  1. La llamada GET a /persons mostrará todos los objetos de persona disponibles en la base de datos H2.
  2. La llamada GET a /personas/{id} mostrará el objeto persona con la identificación dada.
  3. La llamada POST a /personas insertará un nuevo objeto de persona en la base de datos.
  4. La llamada DELETE a /personas/{id} eliminará el objeto persona con la identificación dada de la base de datos.

Antes de continuar, tiene sentido verificar que el proyecto que hemos creado en la sección anterior funciona bien y no contiene errores.

Para verificar, ejecute el archivo SpringBootH2IntegrationApplication.java de la misma forma que ejecutamos cualquier programa Java. Al hacerlo, la aplicación se iniciará y podremos ver el mensaje de inicio del servidor en la consola.

Desde la consola, podemos encontrar la URL donde podemos abrir la consola H2:

1
2018-08-18 22:43:30.578  INFO 3792 --- [ost-startStop-1] o.s.b.w.servlet.ServletRegistrationBean  : Servlet webServlet mapped to [/h2-console/*]

Recuerde que habilitamos la consola H2 en el archivo application.properties.

Abramos la consola H2 escribiendo http://localhost:8080/h2-consola en la barra de direcciones del navegador:

H2 consola 1{.img-responsive}

Haga clic en conectar para iniciar sesión y ver las distintas opciones:

H2 consola 2{.img-responsive}

Es posible que vea un valor diferente en la URL de JDBC, así que cambie la URL de la base de datos a jdbc:h2:mem:testdb en la pantalla de inicio de sesión, ya que esta es la URL predeterminada configurada por Spring Boot.

Implementación de una API REST con funcionalidades CRUD

Finalmente, activemos una API REST simple que realiza operaciones CRUD en una entidad Person.

Definición de una entidad

Naturalmente, comenzaremos con nuestro modelo de dominio y una definición del modelo Persona:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
@Entity
public class Person {

    @Id
    @GeneratedValue
    private int id;
    private String name;
    private int age;
    private String emailId;

    // Getters and setters
}

Definición de un repositorio de personas {#definición de un repositorio de personas}

Utilizando lo mejor de Spring Data JPA, crearemos un ‘CrudRepository’ realmente simple y generado automáticamente para nuestras entidades, llamado ‘PersonRepository’:

1
public interface PersonRepository extends CrudRepository<Person, Integer> {}

Sin más implementación, PersonRepository tiene funcionalidad CRUD a través de los métodos save(), findById(), deleteById() y update(), que aceptan cualquier entidad Person válida.

Definición de un servicio de persona {#definición de un servicio de persona}

Una vez que la interfaz del repositorio esté lista, creemos un servicio concreto para usar el repositorio para realizar la lectura, escritura y actualización:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
@Service
public class PersonService {

    @Autowired
    PersonRepository personRepository;

    public List<Person> findAll() {
        return personRepository.findAll();
    }

    public Person getPersonById(int id) {
        return personRepository.findById(id).get();
    }

    public void saveOrUpdate(Person person) {
        personRepository.save(person);
    }

    public void delete(int id) {
        personRepository.deleteById(id);
    }
}

Definición de un controlador de persona {#definición de un controlador de persona}

Finalmente, para exponer el servicio a los usuarios finales, crearemos una clase anotada @Controller, PersonController y expondremos algunos puntos finales:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
@RestController
public class PersonController {

    @Autowired
    PersonService personService;

    @GetMapping("/persons")
    private List<Person> getAllPersons() {
        return personService.findAll();
    }

    @GetMapping("/persons/{id}")
    private Person getPerson(@PathVariable("id") int id) {
        return personService.getPersonById(id);
    }

    @DeleteMapping("/persons/{id}")
    private void deletePerson(@PathVariable("id") int id) {
        personService.delete(id);
    }

    @PostMapping("/persons")
    private int savePerson(@RequestBody Person person) {
        personService.saveOrUpdate(person);
        return person.getId();
    }
}

¡Excelente! Ahora podemos probar la funcionalidad de la API y las respuestas que obtenemos.

Prueba de la API de persona

Para probar el servicio REST, usaremos Cartero, que se puede integrar fácilmente en el navegador Chrome usando su [extensión del navegador](https://chrome.google. com/webstore/detail/postman/fhbjgbiflinjbdggehcddcbncdddomop?hl=en) o como una herramienta independiente.

Caso de prueba 1: Crear una nueva persona

Usando cartero, configuraremos una solicitud POST válida para la creación de usuarios:

  1. Establecer tipo de solicitud: POST
  2. Establecer URL: http://localhost:8080/personas
  3. Establecer encabezado de solicitud: tipo de contenido: aplicación/json
  4. Set Body as: {"name":"person A", "age":23, "emailId": "[correo electrónico protegido]"}
  5. Haga clic en "Enviar"
  6. En la respuesta obtendremos un personId.

Prueba 1 Cartero{.img-responsive}

Para validar los datos insertados en la base de datos H2:

  1. Abra [consola H2] (http://localhost:8080/h2-console)
  2. Valide la tabla PERSONA. Nos mostrará los datos que hemos insertado en la solicitud POST.

Test 1 H2{.img-responsive}

Repita el Caso de prueba 1 con una persona diferente y tendrá objetos de dos personas insertados en la base de datos:

Test 11 H2{.img-responsive}

Caso de prueba 2: Recuperación del nuevo objeto de persona

Ahora, intentemos recuperar uno de estos usuarios, a través de su ID. Para hacer esto, construiremos una nueva solicitud en cartero:

  1. Tipo de solicitud: OBTENER
  2. URL: http://localhost:8080/personas/1
  3. Encabezado de solicitud: tipo de contenido: aplicación/json
  4. Haga clic en "Enviar"
  5. En respuesta, obtendremos datos de personas con id 1.

Test 2 Postman{.img-responsive}

Caso de prueba 3: Eliminación de un objeto de persona

Finalmente, intentemos eliminar a una persona de la base de datos:

  1. Tipo de solicitud: ELIMINAR
  2. URL: http://localhost:8080/personas/1
  3. Encabezado de solicitud: tipo de contenido: aplicación/json
  4. Haga clic en "Enviar"

Test 3 Postman{.img-responsive}

Después de ejecutar esto, valide que los datos se hayan eliminado de la base de datos H2:

Test 3 H2{.img-responsive}

Conclusión

En esta breve guía, analizamos cómo integrar la base de datos H2 en memoria con Spring Boot y creamos una API REST simple a su alrededor para mostrar el uso.

H2 es una base de datos incrustada y liviana escrita en Java, que generalmente se usa para la creación de prototipos.