RestController di Spring

Tutorial

Spring

L’annotazione Spring RestController è un’annotazione di comodità che è a sua volta annotata con @Controller e @ResponseBody. Questa annotazione viene applicata a una classe per contrassegnarla come gestore delle richieste. L’annotazione Spring RestController viene utilizzata per creare servizi web RESTful utilizzando Spring MVC. Spring RestController si occupa di mappare i dati della richiesta al metodo del gestore delle richieste definito. Una volta generato il corpo della risposta dal metodo del gestore, lo converte in una risposta JSON o XML.

Esempio di Spring RestController

Vediamo quanto sia facile utilizzare RestController per creare un servizio web REST in Spring. Riutilizzeremo l’implementazione del Repository di Spring e creeremo un servizio web RESTful. Creeremo un’applicazione Web indipendente e non utilizzeremo Spring Boot qui. Esporremo anche le nostre API per supportare sia richieste che risposte JSON e XML. L’immagine sottostante mostra la struttura finale del nostro progetto. Le classi Model e Repository sono già fornite nel tutorial del Repository di Spring. Ci concentreremo maggiormente sull’implementazione di RestController qui.

Spring RestController Maven Dipendenze

Diamo un’occhiata alle dipendenze necessarie per creare il nostro progetto di esempio Spring RestController.

<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-webmvc</artifactId>
	<version>5.0.7.RELEASE</version>
</dependency>
<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-web</artifactId>
	<version>5.0.7.RELEASE</version>
</dependency>

<!-- Jackson for REST JSON Support -->
<dependency>
	<groupId>com.fasterxml.jackson.core</groupId>
	<artifactId>jackson-databind</artifactId>
	<version>2.9.6</version>
</dependency>
<!-- JAXB for XML Response, needed to explicitly define from Java 9 onwards -->
<dependency>
	<groupId>javax.xml.bind</groupId>
	<artifactId>jaxb-api</artifactId>
	<version>2.3.0</version>
</dependency>
<dependency>
	<groupId>org.glassfish.jaxb</groupId>
	<artifactId>jaxb-runtime</artifactId>
	<version>2.3.0</version>
	<scope>runtime</scope>
</dependency>
<dependency>
	<groupId>javax.activation</groupId>
	<artifactId>javax.activation-api</artifactId>
	<version>1.2.0</version>
</dependency>

Abbiamo bisogno delle librerie Spring MVC, Jackson e JAXB per supportare sia le richieste che le risposte XML e JSON dal nostro servizio web REST. Il nostro file web.xml viene utilizzato per configurare Spring MVC DispatcherServlet come controller front-end. Ora diamo un’occhiata al file Spring Context.

<?xml version="1.0" encoding="UTF-8"?>
<beans:beans
	xmlns="https://www.springframework.org/schema/mvc"
	xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
	xmlns:beans="https://www.springframework.org/schema/beans"
	xmlns:context="https://www.springframework.org/schema/context"
	xsi:schemaLocation="https://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd
		https://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
		https://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

	<!-- Enables the Spring MVC @Controller programming model -->
	<annotation-driven />

	<context:component-scan
		base-package="com.journaldev.spring" />

	<beans:bean id="jsonMessageConverter"
		class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter" />
	<beans:bean id="xmlMessageConverter"
		class="org.springframework.http.converter.xml.Jaxb2RootElementHttpMessageConverter" />

	<beans:bean
		class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
		<beans:property name="messageConverters">
			<beans:list>
				<beans:ref bean="jsonMessageConverter" />
				<beans:ref bean="xmlMessageConverter" />
			</beans:list>
		</beans:property>
	</beans:bean>

</beans:beans>

La parte più importante sono i bean jsonMessageConverter e xmlMessageConverter definiti e impostati nella proprietà messageConverters di RequestMappingHandlerAdapter. Questo è tutto ciò che serve per dire a Spring che vogliamo che la nostra applicazione supporti sia JSON che XML e questi sono i bean da utilizzare per la trasformazione.

Classe Spring RestController

Ecco l’implementazione della nostra classe Spring RestController.

package com.journaldev.spring.controller;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

import com.journaldev.spring.model.Employee;
import com.journaldev.spring.repository.EmployeeRepository;

@RestController
public class EmployeeRestController {

	@Autowired
	private EmployeeRepository repository;
	
	@GetMapping("/rest/employee/get/{id}")
	public Employee getEmployeeByID(@PathVariable("id") int id) {
		return repository.retrieve(id);
	}
	
	@GetMapping("/rest/employee/getAll")
	//Il ritorno di una List è supportato solo con una risposta JSON
	//Se vuoi XML, aggiungi una classe wrapper come elemento radice XML, ad esempio EmployeeList
	public List getAllEmployees() {
		return repository.getAll();
	}

	@PostMapping("/rest/employee/create")
	public Employee createEmployee(@RequestBody Employee emp) {
		repository.store(emp);
		return emp;
	}
	
	@GetMapping("/rest/employee/search/{name}")
	public Employee getEmployeeByName(@PathVariable("name") String name) {
		return repository.search(name);
	}
	
	@DeleteMapping("/rest/employee/delete/{id}")
	public Employee deleteEmployeeByID(@PathVariable("id") int id) {
		return repository.delete(id);
	}
}

Si noti che abbiamo solo definito le nostre API REST qui, tutta la logica di business fa parte della classe Repository. Se il nostro metodo restituisce una lista o un array, allora Spring supporterà solo la risposta JSON perché l’elemento radice XML non può essere anonimo, ma JSON può. Se si desidera supportare il ritorno della lista come XML, sarà necessario creare una classe wrapper per contenere questa lista e restituirla. Ci aspettiamo l’oggetto Employee come richiesta in alcuni dei metodi, Spring si occuperà di analizzare il corpo della richiesta e convertirlo in oggetto Employee per questi metodi. Allo stesso modo, restituiamo l’oggetto Employee come corpo della risposta, nuovamente Spring si occuperà di convertirlo in una risposta JSON/XML.

Intestazioni di richiesta Accept e Content-Type

Abbiamo configurato la nostra applicazione REST per funzionare sia con XML che con JSON. Quindi come saprà se la richiesta è XML o JSON. E se la risposta deve essere inviata in formato JSON o XML. Qui vengono utilizzate le intestazioni di richiesta Accept e Content-Type. Content-Type: Definisce il tipo di contenuto nel corpo della richiesta, se il suo valore è “application/xml”, allora Spring tratterà il corpo della richiesta come documento XML. Se il suo valore è “application/json”, allora il corpo della richiesta viene trattato come JSON. Accept: Definisce il tipo di contenuto che il client si aspetta come risposta. Se il suo valore è “application/xml”, verrà inviata una risposta XML. Se il suo valore è “application/json”, verrà inviata una risposta JSON.