Spring Data es uno de los frameworks que se encuentra dentro de la plataforma de Spring. Su objetivo es simplificar al desarrollador la persistencia de datos contra distintos repositorios de información .
Vamos a ver una introducción a este framework y como ayuda a simplificar nuestro trabajo. Nos apoyaremos en JPA para ello.
Spring Data y JPA
Es momento de configurar un proyecto utilizando JPA . Usaremos en un proyecto Maven creado a través de Spring Boot con todas sus dependencias , incluyendo las de Spring Data.
<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>com.arquitecturajava</groupId> <artifactId>springData</artifactId> <version>0.0.1-SNAPSHOT</version> <packaging>jar</packaging> <name>springData</name> <description>Demo project for Spring Boot</description> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>1.3.6.RELEASE</version> <relativePath /> <!-- lookup parent from repository --> </parent> <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding> <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-test</artifactId> <scope>test</scope> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.39</version> </dependency> </dependencies> <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build> </project>
Visto el fichero de Maven, vamos a configurar los beans necesarios para acceder a una base de datos. En este caso nos vamos a centrar en un enfoque orientado a anotaciones puro.
package com.arquitecturajava; import java.util.Properties; import javax.sql.DataSource; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.ComponentScan; import org.springframework.data.jpa.repository.config.EnableJpaRepositories; import org.springframework.jdbc.datasource.DriverManagerDataSource; import org.springframework.orm.jpa.JpaTransactionManager; import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean; import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter; import org.springframework.transaction.PlatformTransactionManager; import org.springframework.transaction.annotation.EnableTransactionManagement; @EnableJpaRepositories("com.arquitecturajava") @EnableTransactionManagement @ComponentScan("com.arquitecturajava") public class SpringConfiguracion { @Bean public DataSource dataSource() { DriverManagerDataSource dataSource = new DriverManagerDataSource(); dataSource.setDriverClassName("com.mysql.jdbc.Driver"); dataSource.setUrl("jdbc:mysql://localhost:3306/CursoJPA"); dataSource.setUsername("root"); dataSource.setPassword("mysql"); return dataSource; } @Bean LocalContainerEntityManagerFactoryBean entityManagerFactory(DataSource dataSource) { LocalContainerEntityManagerFactoryBean entityManagerFactoryBean = new LocalContainerEntityManagerFactoryBean(); entityManagerFactoryBean.setDataSource(dataSource); entityManagerFactoryBean.setJpaVendorAdapter(new HibernateJpaVendorAdapter()); entityManagerFactoryBean.setPackagesToScan("com.arquitecturajava"); Properties jpaProperties = new Properties(); jpaProperties.put("hibernate.dialect", "org.hibernate.dialect.MySQLDialect"); entityManagerFactoryBean.setJpaProperties(jpaProperties); return entityManagerFactoryBean; } @Bean public PlatformTransactionManager transactionManager() { JpaTransactionManager txManager= new JpaTransactionManager(); txManager.setEntityManagerFactory(entityManagerFactory(dataSource()).getObject()); return txManager; } }
Hemos utilizado la anotación @Bean para definir los diferentes beans, Datasource EntityManagerFactory y TransactionManager. Es momento de crear una Entidad.
Spring Data y Entities
En este caso es bastante sencillo y basta con crear la clase Persona.
package com.arquitecturajava; import javax.persistence.Entity; import javax.persistence.Id; @Entity public class Persona { public String getDni() { return dni; } public void setDni(String dni) { this.dni = dni; } 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; } @Id private String dni; private String nombre; private String apellidos; public Persona(String dni, String nombre, String apellidos) { super(); this.dni = dni; this.nombre = nombre; this.apellidos = apellidos; } public Persona() { super(); } }
El último paso es crear un interface de tipo Repositorio que nos permita gestionar las operaciones fundamentales:
import java.util.List; import org.springframework.data.jpa.repository.JpaRepository; import com.arquitecturajava.Persona; public interface PersonaRepository extends JpaRepository<Persona,String>{ }
Se puede observar que el interface de repositorio para almacenar los objetos Persona extiende de JpaRepository. Esta es una clase que pertenece a SpringData. Es momento de usar Spring Framework , cargar los diferentes beans e invocar al método save del repositorio.
package com.arquitecturajava.repositories; package com.arquitecturajava; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.context.annotation.AnnotationConfigApplicationContext; import com.arquitecturajava.repositories.PersonaRepository; @SpringBootApplication public class SpringDataApplication { public static void main(String[] args) { AnnotationConfigApplicationContext contexto= new AnnotationConfigApplicationContext(SpringConfiguracion.class); Persona p= new Persona("3","juan","gomez"); PersonaRepository pRepositorio= contexto.getBean(PersonaRepository.class); pRepositorio.save(p); } }
Acabamos de almacenar una entidad en la base de datos. Todo ha sido muy sencillo. ¿En qué nos a ayudado Spring Data?. En mucho, no hemos tenido que implementar la clase de repositorio.
La mera declaración del interface ha sido suficiente para poder salvar la información. Al usar Spring Data la mayor parte del código que tendríamos que implementar es aportado por el propio framework. Sus ventajas y versatilidad son enormes.
Otros artículos relacionados :
Hola Cecilio, compré el curso de spring dta pero no veo los códigos. Crees que los puedas subir?
Si no te preocupes lo voy a revisar acabo de ver que no estan
Hola Cecilio, muy buen ejemplo pero me surge una consulta, en aplicaciones de alta transaccionalidad, Spring data y JPA ya maneja las conexiones a base de datos de forma eficiente para no saturar los pool de conexiones? o en caso de que no,cómo podríamos configurar las conexiones para que no haya una posible saturación?
Deberías configurar el pool de conexiones e incrementar o decrementar según tu necesidad https://stackoverflow.com/questions/38672900/how-to-manage-database-connection-pool-in-spring-jpa
Muchas gracias Cecilio !
de nada 🙂
Saludos tengo una duda que no he podido resolver, en un escenario en el que tengo que afectar 2 bases de datos de manera transaccional, como puedo revertir la primera operacion si en la segunda salio algo mal?
Deberías usar algo como atomikos
[…] Introducción a Spring Data y JPA: JPA es el estándar de persistencia de Java y Spring Data es un framework que simplifica mucho el trabajo con el estándar. […]
Hola, como puedo determinar cual es la mejor configuración de JPA y Spring porque he visto muchas implementaciones y estoy confundido:S
Depende bastante de lo que uses . Hoy por hoy mucha gente integra Spring Data para la capa de JPA ya que simplifica bastante
Gracias!
Buenas tardes!
Interesante el tema me gustaría me ayuden en la implementación de Spring Data con JPA tengo dudas como por ejemplo donde pongo la conexión a la base de datos?, como hago referencia a una conexión de lase cuando quiero persistir los datos?
Debería ir en el persistence.xml o sino a nivel de xml de spring
Saludos,
Gracias por importante aporte. Me puede por favor indicar un ejemplo de esta implementacion por favor, es decir como y en que parte hace la inyeccion el dao de spring data jpa, de antemano te agradezco tu aporte.
Yo tengo la duda de que si al utilizar estos frameworks cambia la idea de realizar complejas consultas en sql como se realizaba antes, y realizar esta lógica en java para unicamente persistir a traves de jpa, o por el contrario podemos realizar con facilidad estas consultas con varios joins, subconsultas etc.. a través de jpa.
Un saludo.
Si que es posible tienes varias anotaciones que lo facilitan
Gracias por el post. Una duda: como quedaria el repository en el caso de que necesite implementar metodos propios?
Gracias
Podrías implementarlos de muchas formas , una es con derived queries ,y el se encargaría de crear las queries. Otra es usando @Query y ligandolo a jpa