Spring Boot con Hibernate

1. Información general

En este artículo, veremos cómo usar Spring Boot con Hibernate.

Construiremos una aplicación Spring Boot simple y veremos lo fácil que es integrarla con Hibernate.

2. Bootstrapping de la aplicación

Usaremos Spring Initializr para arrancar nuestra aplicación Spring Boot. Para este ejemplo, usaremos solo las configuraciones y dependencias necesarias para integrar Hibernate, agregando dependencias Web , JPA y H2 . Explicaremos estas dependencias en la siguiente sección.

Generemos el proyecto y lo abrimos en nuestro IDE. Podemos verificar la estructura del proyecto generado e identificar los archivos de configuración que necesitaremos.

Así es como se verá la estructura del proyecto:

3. Dependencias de Maven

Si abrimos pom.xml , veremos que tenemos spring-boot-starter-web y spring-boot-starter-test como dependencias de maven. Como sugieren sus nombres, estas son dependencias de inicio en Spring Boot.

Echemos un vistazo rápido a la dependencia que atrae a JPA:

 org.springframework.boot spring-boot-starter-data-jpa 

Esta dependencia incluye la API de JPA, la implementación de JPA, JDBC y otras bibliotecas necesarias. Dado que la implementación predeterminada de JPA es Hibernate, esta dependencia es suficiente para incorporarla también.

Finalmente, usaremos H2 como una base de datos muy ligera para este ejemplo:

 com.h2database h2 runtime 

Podemos usar la consola H2 para verificar que la base de datos esté funcionando, también para una GUI fácil de usar para nuestra entrada de datos. Sigamos adelante y habilítelo en application.properites :

spring.h2.console.enabled=true

Esto es todo lo que necesitábamos configurar para incluir Hibernate y H2 en nuestro ejemplo. Podemos verificar que la configuración fue exitosa en los registros cuando iniciamos la aplicación Spring Boot:

HHH000412: Hibernate Core {#Version}

HHH000206: hibernate.properties not found

HCANN000001: Anotaciones de Hibernate Commons {#Version}

HHH000400: Usando dialecto: org.hibernate.dialect.H2Dialect

Ahora podemos acceder a la consola H2 en localhost: // localhost: 8080 / h2-console / .

4. Creación de la entidad

Para comprobar que nuestro H2 funciona correctamente, primero crearemos una entidad JPA en una nueva carpeta de modelos :

@Entity public class Book { @Id @GeneratedValue private Long id; private String name; // standard constructors // standard getters and setters }

Ahora tenemos una entidad básica, desde la cual H2 puede crear una tabla. Reiniciando la aplicación y comprobando la consola H2, se creará una nueva tabla llamada Libro .

Para agregar algunos datos iniciales a nuestra aplicación, necesitamos crear un nuevo archivo SQL, con algunas declaraciones de inserción y ponerlo en nuestra carpeta de recursos . Podemos usar archivos import.sql (soporte de Hibernate) o data.sql (soporte de Spring JDBC) para cargar datos.

Aquí están nuestros datos de ejemplo:

insert into book values(1, 'The Tartar Steppe'); insert into book values(2, 'Poem Strip'); insert into book values(3, 'Restless Nights: Selected Stories of Dino Buzzati');

Nuevamente, podemos reiniciar la aplicación Spring Boot y verificar la consola H2; los datos ahora están en la tabla Book .

5. Creación del repositorio y el servicio

Continuaremos creando los componentes básicos para poder probar nuestra aplicación. Primero, agreguemos el repositorio JPA en una nueva carpeta de repositorios :

@Repository public interface BookRepository extends JpaRepository { }

Podemos usar la interfaz JpaRepository del marco Spring, que proporciona una implementación predeterminada para las operaciones básicas de CRUD .

A continuación, agreguemos BookService en una nueva carpeta de servicios :

@Service public class BookService { @Autowired private BookRepository bookRepository; public List list() { return bookRepository.findAll(); } }

Para probar nuestra aplicación, debemos verificar que los datos creados se puedan obtener del método list () del servicio.

Escribiremos el siguiente SpringBootTest :

@RunWith(SpringRunner.class) @SpringBootTest public class BookServiceUnitTest { @Autowired private BookService bookService; @Test public void whenApplicationStarts_thenHibernateCreatesInitialRecords() { List books = bookService.list(); Assert.assertEquals(books.size(), 3); } }

Al ejecutar esta prueba, podemos verificar que Hibernate crea los datos del Libro que luego son recuperados exitosamente por nuestro servicio. Eso fue todo, Hibernate se está ejecutando con Spring Boot.

6. Nombre de la tabla en mayúsculas

A veces, es posible que necesitemos tener los nombres de las tablas en nuestra base de datos escritos en letras mayúsculas. Como ya sabemos, por defecto Hibernate generará los nombres de las tablas en minúsculas .

También podríamos intentar establecer explícitamente el nombre de la tabla, así:

@Entity(name="BOOK") public class Book { // members, standard getters and setters }

Sin embargo, eso no funcionaría. Lo que funciona es establecer esta propiedad en application.properties :

spring.jpa.hibernate.naming.physical-strategy=org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl

Como resultado, podemos comprobar en nuestra base de datos que las tablas se hayan creado correctamente con letras mayúsculas.

7. Conclusión

En este artículo, analizamos lo fácil que es integrar Hibernate con Spring Boot. Usamos la base de datos H2, como una solución en memoria muy ligera.

Dimos un ejemplo completo de una aplicación que utiliza todas estas tecnologías y, finalmente, también dimos una pequeña pista sobre cómo establecer los nombres de las tablas en mayúsculas en nuestra base de datos.

Como siempre, todos los fragmentos de código mencionados en este artículo se pueden encontrar en nuestro repositorio de GitHub.