El uso de Spring Boot JPA es cada día mas importante ya que poco a poco más proyectos van pasando de usar Spring clásico a ser arrancados con Spring Boot . Por lo tanto configurar Spring Boot para trabajar con JPA es casi siempre necesario. Vamos a ver cómo hacerlo. El primer paso es generar un proyecto de Spring Boot que soporte JPA en este caso es sencillo ya que solo necesitamos un starter adicional el de spring-data-jpa . vamos a ver cómo queda el fichero de Maven:
<?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.2.4.RELEASE</version> <relativePath/> <!-- lookup parent from repository --> </parent> <groupId>com.arquitecturajava</groupId> <artifactId>jpa</artifactId> <version>0.0.1-SNAPSHOT</version> <name>jpa</name> <description>Demo project for Spring Boot</description> <properties> <java.version>1.8</java.version> </properties> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> <exclusions> <exclusion> <groupId>org.junit.vintage</groupId> <artifactId>junit-vintage-engine</artifactId> </exclusion> </exclusions> </dependency> </dependencies> <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build> </project>
Spring Starters (Web y Persistencia)
Acabamos de configurar Spring Boot con los dos starters que necesitamos para este proyecto uno es el starter web y otro es el starter de Spring Data para JPA.
Spring Boot JPA y entidades
Una vez que tenemos configurado el proyecto de arranque el primer paso es generar una entidad que pueda ser persistida.
package com.arquitecturajava.jpa.models; import javax.persistence.Entity; import javax.persistence.Id; @Entity public class Persona { @Id private String nombre; private String apellidos; private int edad; 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 int getEdad() { return edad; } public void setEdad(int edad) { this.edad = edad; } public Persona(String nombre, String apellidos, int edad) { super(); this.nombre = nombre; this.apellidos = apellidos; this.edad = edad; } public Persona() { super(); } }
Spring Boot JPA y properties
Ya tenemos la entidad definida y contiene las anotaciones necesarias. El siguiente paso es configurar los parámetros contra la base de datos usando el fichero de application.properties que Spring Boot nos provee en la estructura de carpetas.
En el deberemos de rellenar las propiedades clásicas con una estructura determinada haciendo referencia a un datasource y al propio hibernate y su dialecto para conectarse a la base de datos:
spring.datasource.url=jdbc:mysql://localhost:8889/springjpa spring.datasource.username=root spring.datasource.password=root spring.datasource.driver.class=com.mysql.jdbc.Driver spring.jpa.properties.hibernate.dialect = org.hibernate.dialect.MySQL5Dialect
Repositorios de Spring
Una vez configurado Spring para poder gestionar JPA . La forma mas sencilla de trabajar con ello es usar un @Repository con @PersistenceContext de tal manera que podamos crear un repositorio amigable usando un interface y su implementación.
Veamos el código:
package com.arquitecturajava.web1.repositories; import java.util.List; import com.arquitecturajava.web1.models.Persona; public interface PersonaRepository { List<Persona> buscarTodos(); void insertar(Persona persona); void borrar(Persona persona); Persona buscarUno(String nombre); }
Implementamos:
package com.arquitecturajava.web1.repositories; import java.util.List; import javax.persistence.EntityManager; import javax.persistence.PersistenceContext; import javax.persistence.TypedQuery; import org.springframework.stereotype.Repository; import org.springframework.transaction.annotation.Transactional; import com.arquitecturajava.web1.models.Persona; @Repository public class PersonaRepositoryJPA implements PersonaRepository { @PersistenceContext EntityManager em; @Override public List<Persona> buscarTodos() { TypedQuery<Persona> consulta= em.createQuery("select p from Persona p",Persona.class); return consulta.getResultList(); } @Transactional public void insertar(Persona persona) { em.persist(persona); } @Transactional public void borrar(Persona persona) { em.remove(em.merge(persona)); } @Override public Persona buscarUno(String nombre) { // TODO Auto-generated method stub return em.find(Persona.class, nombre); } }
Esta sería una solución clásica
Repositorios de Spring Data y simplificación
Realizado este paso recordemos que Spring nos permite de forma transparente crear interfaces de repositorios apoyados en su framework Spring Data . Esto nos automatiza las operaciones básicas sin que tengamos que construirlas nosotros mismos. Un ejemplo sencillo sería:
package com.arquitecturajava.jpa.repositories; import org.springframework.data.repository.CrudRepository; import com.arquitecturajava.jpa.models.Persona; public interface PersonaRepository extends CrudRepository < Persona, String > { }
podríamos por lo tanto eliminar el código anterior .
Spring Data es Amplio
Spring Data es un framework amplio y aunque parezca muy sencillo de manejar implementa conceptos complejos . Ahora y a disponemos de las piezas necesarias para acceder a la base de datos vía JPA (Entidad ,Fichero de Configuración,Repositorio) con Spring Data como framework de apoyo que nos ayuda a simplificar todo.
Una vez realizados los cambios a nivel Spring Boot JPA lo último que queda es ver cuál es el contenido del programa principal que invoca a este repositorio y nos selecciona los datos de la base de datos.
package com.arquitecturajava.jpa; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.CommandLineRunner; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import com.arquitecturajava.jpa.repositories.PersonaRepository; @SpringBootApplication public class JpaApplication implements CommandLineRunner { @Autowired PersonaRepository repositorio; public static void main(String[] args) { SpringApplication.run(JpaApplication.class, args); } @Override public void run(String...args) throws Exception { repositorio.findAll().forEach((p) - > System.out.println(p.getNombre())); } }
Simplemente inyectamos el repositorio y ejecutamos Spring Boot desde linea de consola:
Los registros de la base de datos se imprimen en la consola . Finalmente hemos visto como se configura JPA con Spring y como hacer uso de Spring Data . Accediendo a los datos de forma rápida usando el interface CommandLineRunner
gracias. Buen aporte
De nada 🙂
Hola Cecilio, tras seguir los pasar me encuentro con este error al arrancar la aplicación..
***************************
APPLICATION FAILED TO START
***************************
Description:
Field empresaDao in com.improchange.demeter.DemeterApplication required a bean of type ‘dao.EmpresaDao’ that could not be found.
The injection point has the following annotations:
– @org.springframework.beans.factory.annotation.Autowired(required=true)
Action:
Consider defining a bean of type ‘dao.EmpresaDao’ in your configuration.
Igual no has anotado la clase con @repository?
en el fichero “application.properties” se puede definir un pool de conexiones ?
Con definir el datasource es suficiente , si necesitaras varios datasources ya sería otra cosa.
hola Ricardo, en la documentación de spring boot indican que solo puedes definir un datasource, para configurar distintos datasources tendrias que implementar tus propios spring bean ya sea con anotaciones o xml.