Spring Data REST Accediendo a Datos

Construiremos una aplicación Java con el Framework Spring que nos permita el acceso a una base de datos MySQL permitiéndonos obtener, editar, ingresar, eliminar datos almacenados en la DB, Spring Data REST combina automáticamente las funcionalidades de Spring HATEOAS y Spring Data JPA lo que nos proporciona múltiples facilidades.

 

Este tutorial hace uso de los conocimientos aprendidos en los tutoriales anteriores: Servicios RESTful con Spring y Acceso a Base de Datos MySQL con Spring JPA-Hibernate, se recomienda leerlos, mas no es absolutamente necesario.

 

Creamos nuestro proyecto como hemos aprendido en tutoriales anteriores, el archivo pom.xml será el siguiente:

 

<?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>tutor.programacion</groupId>
    <artifactId>SpringDataRest</artifactId>
    <version>0.0.1</version>
    <packaging>jar</packaging>
    
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>
    
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.2.0.RELEASE</version>
    </parent>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-rest</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
    
</project>

Agregamos el archivo de configuración de propiedades application.properties para configurar la conexión a la base de datos MySQL, iniciamos el servidor y creamos una BD llamada datos, editamos el archivo application.properties con los datos correspondientes para acceder a esta BD, se vería de este modo:

# Configurar la coneccion a la base de datos
spring.datasource.url = jdbc:mysql://localhost:3306/datos
spring.datasource.username = root
spring.datasource.password = 159159
spring.datasource.driverClassName = com.mysql.jdbc.Driver

# Indicar el DBMS
spring.jpa.database: MYSQL

Creamos la entidad para representar un conjunto de usuarios que almacenaremos en la tabla Usuario, utilizamos las correspondientes anotaciones JPA.

@Entity
public class Usuario implements Serializable {

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    Long id;

    @NotNull
    String nombre;

    String email;
    LocalDate creado;
}

Por simplicidad se han omitido los métodos get, set y los import, el proyecto completo se encuentra al final en un archivo descargable.

 

Para usar LocalDate de Java 8 requerimos agregar al archivo pom.xml la librería jackson-datatype-jsr310 cuando Jackson la detecte la usara automáticamente, también es posible usar Joda-Time, otra cosa que debemos hacer indicarle a JPA como tratar este tipo de datos ya que por defecto los almacena como Blob, por lo que creamos un convertidor para que los objetos LocalDate sean guardados  como sql.Date.

import java.time.LocalDate;
import java.sql.Date;
import javax.persistence.AttributeConverter;
import javax.persistence.Converter;

@Converter(autoApply = true)
public class LocalDateConverter implements AttributeConverter<LocalDate, Date> {
    @Override
    public Date convertToDatabaseColumn(LocalDate entityValue) {
        return Date.valueOf(entityValue);
    }
    @Override
    public LocalDate convertToEntityAttribute(Date databaseValue) {
        return databaseValue.toLocalDate();
    }
}

Necesitamos crear un repositorio que se ocupara de las operaciones para Usuario, el mismo será una interface que hereda de PagingAndSortingRepository, en tutoriales anteriores vimos la interface CrudRepsitory, PagingAndSortingRepository la extiende agregando métodos de paginación y ordenación.

import org.springframework.data.repository.PagingAndSortingRepository;
import org.springframework.data.repository.query.Param;
import org.springframework.data.rest.core.annotation.RepositoryRestResource;

@RepositoryRestResource(collectionResourceRel = "user", path = "user")
public interface UsuarioRepository extends PagingAndSortingRepository<Usuario, Long> {

    List<Usuario> findByNombre(@Param("nombre") String name);
}

Finalmente creamos la clase principal que contiene el método main el cual iniciara nuestra aplicación.

@EnableJpaRepositories
@Import(RepositoryRestMvcConfiguration.class)
@SpringBootApplication
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

Compilamos y ejecutamos la aplicación, recordamos que el servidor MySQL debe estar corriendo y contener la base de datos correspondiente con los datos de conexión correctos, luego de ejecutar accedemos a la dirección localhost:8080 en el navegador, veremos: 

El enlace marcado en rojo nos permite acceder a los usuarios que se encuentren almacenados, en este momento no tenemos ninguno, también podemos indicar las opciones page, size o sort, para el número de página, el tamaño y la ordenación.

En este enlace veríamos una lista de todos los usuario en la base de datos, en la parte inferior se observan los datos de paginación como el tamaño de página, el total de elementos, el total de páginas y el número de la página actual, accediendo al enlace marcado veremos una lista de todos los enlaces de consulta creados por la interface UsuarioRepository en este ejemplo únicamente el enlace para la consulta findByNombre 

 

Este enlace nos permite buscar un usuario por nombre.

 

De momento no tenemos datos por lo  que se nos dificulta probar todos las funcionalidades que tiene nuestro proyecto solo con unas cuantas líneas de código gracias a Spring Framework.

 

En el siguiente tutorial veremos como agregar, editar, buscar, eliminar datos en la BD MySQL mediante un cliente REST que programaremos utilizando JavaFX.

 

• Descargar código: Descargar Código Fuente
• Más tutoriales: Serie de Tutoriales Spring Framework