RestController de Spring

Tutoriels

Spring

La notation Spring RestController est une annotation pratique qui est elle-même annotée avec @Controller et @ResponseBody. Cette annotation est appliquée à une classe pour la marquer comme un gestionnaire de requêtes. La notation Spring RestController est utilisée pour créer des services web RESTful en utilisant Spring MVC. Spring RestController se charge de mapper les données de la requête à la méthode du gestionnaire de requêtes définie. Une fois que le corps de la réponse est généré à partir de la méthode du gestionnaire, il le convertit en réponse JSON ou XML.

Exemple de Spring RestController

Voyons comment nous pouvons facilement utiliser RestController pour créer un service web REST dans Spring. Nous réutiliserons l’implémentation du Repository Spring et créerons un service web RESTful. Nous créerons une application Web autonome et n’utiliserons pas Spring Boot ici. Nous exposerons également nos API pour prendre en charge à la fois JSON et XML dans la requête et la réponse. L’image ci-dessous montre la structure finale de notre projet. Les classes de modèle et de Repository sont déjà fournies dans le tutoriel du Repository Spring. Nous nous concentrerons davantage sur l’implémentation du RestController ici.

Dépendances Maven pour Spring RestController

Jetons un coup d’œil aux dépendances nécessaires pour créer notre projet exemple de 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>

Nous avons besoin des bibliothèques Spring MVC, Jackson et JAXB pour prendre en charge à la fois les requêtes et les réponses XML et JSON de notre service web REST. Notre fichier web.xml est utilisé pour configurer Spring MVC DispatcherServlet en tant que contrôleur frontal. Regardons maintenant le fichier de contexte Spring.

<?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 partie la plus importante est les beans jsonMessageConverter et xmlMessageConverter définis et configurés dans la propriété messageConverters de RequestMappingHandlerAdapter. C’est tout ce dont nous avons besoin pour indiquer à Spring que nous voulons que notre application prenne en charge à la fois JSON et XML et que ce sont les beans à utiliser pour la transformation.

Classe Spring RestController

Voici l’implémentation de notre 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")
	// Retourner une liste est pris en charge avec une réponse JSON uniquement
	// Si vous voulez du XML, ajoutez alors une classe d'enveloppe en tant qu'élément XML racine, par exemple 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);
	}
}

Veuillez noter que nous avons uniquement défini nos API REST ici, toute la logique métier fait partie de la classe Repository. Si notre méthode renvoie une liste ou un tableau, alors Spring ne prendra en charge que la réponse JSON, car l’élément racine XML ne peut pas être anonyme mais le JSON peut l’être. Si vous souhaitez prendre en charge le renvoi d’une liste au format XML, vous devrez créer une classe enveloppe pour contenir cette liste et la renvoyer. Nous attendons un objet Employee en tant que demande dans certaines des méthodes, Spring se chargera de l’analyse du corps de la demande et de sa conversion en objet Employee pour ces méthodes. De même, nous renvoyons un objet Employee en tant que corps de réponse, là encore Spring se chargera de le convertir en réponse JSON/XML.

En-têtes de demande Accept et Content-Type

Nous avons configuré notre application REST pour fonctionner à la fois avec XML et JSON. Comment saura-t-elle si la demande est XML ou JSON ? Et si la réponse doit être envoyée au format JSON ou XML ? C’est là que les en-têtes de demande Accept et Content-Type sont utilisés. Content-Type : Définit le type de contenu dans le corps de la demande, si sa valeur est « application/xml », alors Spring traitera le corps de la demande comme un document XML. Si sa valeur est « application/json », alors le corps de la demande est traité comme du JSON. Accept : Définit le type de contenu que le client attend en tant que réponse. Si sa valeur est « application/xml », alors une réponse XML sera envoyée. Si sa valeur est « application/json », alors une réponse JSON sera envoyée.