Acabamos de ver como usar Java equals y hashcode
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="[Link]
xmlns:xsi="[Link]
xsi:schemaLocation="[Link]
[Link]
<modelVersion>4.0.0</modelVersion>
[Link]
<groupId>[Link]</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>[Link]</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>[Link]</version>
<relativePath />
</parent>
<properties>
<[Link]>UTF-8</[Link]>
<[Link]>UTF-8</[Link]
ing>
<[Link]>1.8</[Link]>
</properties>
<dependencies>
<dependency>
<groupId>[Link]</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
<groupId>[Link]</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
[Link]
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.39</version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>[Link]</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>
COMO REALIZAR
TODOS
MIS CURSOS
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 [Link];
[Link]
import [Link];
import [Link];
import [Link];
import [Link];
import
[Link];
import [Link];
import [Link];
import
[Link];
import [Link];
import [Link];
import
[Link]
;
@EnableJpaRepositories("[Link]")
@EnableTransactionManagement
@ComponentScan("[Link]")
public class SpringConfiguracion {
@Bean
public DataSource dataSource() {
DriverManagerDataSource dataSource = new
DriverManagerDataSource();
[Link]("[Link]");
[Link]("jdbc:mysql://localhost:3306/CursoJPA");
[Link]("root");
[Link]("mysql");
[Link]
return dataSource;
}
@Bean
LocalContainerEntityManagerFactoryBean
entityManagerFactory(DataSource dataSource) {
LocalContainerEntityManagerFactoryBean
entityManagerFactoryBean = new
LocalContainerEntityManagerFactoryBean();
[Link](dataSource);
[Link](new
HibernateJpaVendorAdapter());
[Link]("[Link]");
Properties jpaProperties = new Properties();
[Link]("[Link]",
"[Link]");
[Link](jpaProperties);
return entityManagerFactoryBean;
@Bean public PlatformTransactionManager transactionManager() {
JpaTransactionManager txManager= new
JpaTransactionManager();
[Link](entityManagerFactory(dataSource()).g
[Link]
etObject());
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 [Link];
import [Link];
import [Link];
@Entity
public class Persona {
public String getDni() {
return dni;
}
public void setDni(String dni) {
[Link] = dni;
}
public String getNombre() {
return nombre;
[Link]
}
public void setNombre(String nombre) {
[Link] = nombre;
}
public String getApellidos() {
return apellidos;
}
public void setApellidos(String apellidos) {
[Link] = apellidos;
}
@Id
private String dni;
private String nombre;
private String apellidos;
public Persona(String dni, String nombre, String apellidos) {
super();
[Link] = dni;
[Link] = nombre;
[Link] = apellidos;
}
public Persona() {
super();
}
[Link]
El último paso es crear un interface de tipo Repositorio que nos permita gestionar las
operaciones fundamentales:
import [Link];
import [Link];
import [Link];
public interface PersonaRepository extends
JpaRepository&amp;amp;lt;Persona,String&amp;amp;gt;{
}
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 [Link];
package [Link];
import [Link];
import
[Link]
ext;
[Link]
import [Link];
@SpringBootApplication
public class SpringDataApplication {
public static void main(String[] args) {
AnnotationConfigApplicationContext contexto=
new
AnnotationConfigApplicationContext([Link]);
Persona p= new Persona("3","juan","gomez");
PersonaRepository pRepositorio=
[Link]([Link]);
[Link](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.
[Link]
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 :
¿Qué es Spring Boot?
Java Override y encapsulación
Tomcat context xml y su configuración
JPA Join Fetch y su uso.
[Link]