@RepositoryRestResource y Spring Framework

El uso de la anotación @RepositoryRestResource nos puede ser muy práctica en muchas ocasiones cuando queremos construir arquitecturas REST complejas de una forma rápida dentro de Spring Framework.  Normalmente cuando trabajamos con Spring Framework es relativamente común utilizar Spring Data para automatizar la gestión de repositorios . Vamos a ver un ejemplo , para ello en primer lugar mostraremos las dependencias de Maven vía Spring Boot.

<?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.example</groupId>
	<artifactId>demo</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>

	<name>demo</name>
	<description>Demo project for Spring Boot</description>

	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.1.0.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</artifactId>
		</dependency>

		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<scope>runtime</scope>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>

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

</project>

Una vez definidas las dependencias es momento de ver el contenido del fichero application.properties que define una serie de parametrizaciones por defecto para JPA y la url de acceso REST para los repositorios.

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
spring.data.rest.basePath=/webapi

Una vez configuradas estas dos cosas el siguiente paso es construir el código necesario para trabajar con JPA y servicios REST. En primer lugar definimos la clase:

package com.arquitecturajava.springrest;

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();
	}

}

@RepositoryRestResource

En segundo lugar tenemos que implementar el interface de Spring Data que se encargará de automatizar la creación del repositorio y publicarlo vía REST.

package com.arquitecturajava.springrest;

import org.springframework.data.repository.CrudRepository;
import org.springframework.data.rest.core.annotation.RepositoryRestResource;

@RepositoryRestResource(path="/personas")
public interface PersonaRepository extends CrudRepository<Persona, String>{

}

Usamos el interface CrudRepository para implementar de forma automática las operaciones de persistencia más básicas.

Añadimos a este interface la anotación @RepositoryRestResource esta anotación se encargará de publicar el repositorio cómo servicio REST y acceder a las operaciones fundamentales que todo repositorio implementa.

Una vez hecho esto el siguiente paso es arrancar la aplicación de Spring Boot y comprobar que en la URL personas accedemos la información de estas sin problema.

Como vemos se accede a la información y ademas disponemos de links directos a un mayor detalle . El uso de Spring Data REST puede ser muy útil en nuestros proyectos si tenemos enfoque de arquitecturas SPA por ejemplo. Aprendamos a usar este framework y eliminemos muchos de los problemas y dudas que nos aparecen cuando construimos este tipo de arquitecturas.

Otros artículos relacionados:

1. Spring REST Service con @RestController
2. Spring MVC @RequestMapping
3. Spring MVC Flash Attributes
4. Swagger documentando nuestro API REST
5. Arquitecturas REST y sus niveles
6. Spring Data REST