L’annotation Spring Controller est une spécialisation de l’annotation @Component. L’annotation Spring Controller est généralement utilisée en combinaison avec des méthodes de gestionnaire annotées basées sur l’annotation RequestMapping.
Spring Controller
L’annotation Spring Controller peut être appliquée uniquement aux classes. Elle est utilisée pour marquer une classe comme gestionnaire de requêtes Web. Elle est principalement utilisée avec une application Spring MVC.
Spring RestController
Spring @RestController est une annotation de commodité qui est elle-même annotée avec @Controller et @ResponseBody. Cette annotation est utilisée pour marquer une classe comme gestionnaire de requêtes pour les services Web RESTful.
Exemple de contrôleur Spring
Créons une application Spring simple où nous implémenterons un contrôleur MVC standard ainsi qu’un contrôleur REST. Créez un « Projet Web Dynamique » dans Eclipse puis convertissez-le en projet Maven. Cela nous fournira une structure d’application Web basée sur Maven et nous pourrons construire notre application dessus. L’image ci-dessous montre la structure finale du projet de notre application contrôleur Spring MVC. 
Nous aurions besoin des dépendances suivantes pour notre application.
<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 -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.9.6</version>
</dependency>
Examinons le descripteur de déploiement (web.xml) où nous configurerons le servlet DispatcherServlet comme contrôleur frontal.
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance" xmlns="https://xmlns.jcp.org/xml/ns/javaee"
xsi:schemaLocation="https://xmlns.jcp.org/xml/ns/javaee https://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" id="WebApp_ID" version="3.1">
<display-name>Spring-Controller</display-name>
<!-- Add Spring MVC DispatcherServlet as front controller -->
<servlet>
<servlet-name>spring</servlet-name>
<servlet-class>
org.springframework.web.servlet.DispatcherServlet
</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/spring-servlet.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>spring</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
</web-app>
Enfin, nous avons le fichier de contexte Spring suivant. Ici, nous configurons notre application pour qu’elle soit basée sur des annotations et nous fournissons un package racine pour scanner les composants Spring. Nous configurons également le bean InternalResourceViewResolver et fournissons les détails des pages de vue.
<?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" />
<!-- Resolves views selected for rendering by @Controllers to JSP resources
in the /WEB-INF/views directory -->
<beans:bean
class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<beans:property name="prefix" value="/WEB-INF/views/" />
<beans:property name="suffix" value=".jsp" />
</beans:bean>
</beans:beans>
Nos fichiers XML de configuration sont prêts, passons maintenant à la classe Contrôleur.
package com.journaldev.spring.controller;
import java.text.DateFormat;
import java.util.Date;
import java.util.Locale;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
@Controller
public class HomeController {
@GetMapping("/hello")
public String home(Locale locale, Model model) {
Date date = new Date();
DateFormat dateFormat = DateFormat.getDateTimeInstance(DateFormat.LONG, DateFormat.LONG, locale);
String formattedDate = dateFormat.format(date);
model.addAttribute("serverTime", formattedDate);
return "home";
}
}
Nous avons défini une seule méthode de gestionnaire de requêtes, elle accepte les requêtes GET avec l’URI « /hello » et renvoie la page « home.jsp » en tant que réponse. Remarquez que nous définissons un attribut pour le modèle, qui sera utilisé dans la page home.jsp. Voici notre code de la page home.jsp simple.
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<html>
<head>
<title>Home</title>
</head>
<body>
<h1>Hello world!</h1>
<p>The time on the server is ${serverTime}.</p>
</body>
</html>
Test du contrôleur Spring MVC
Notre application Spring MVC classique basée sur les servlets avec un contrôleur simple est prête, il suffit de l’exporter en tant que fichier WAR et de le déployer sur Tomcat ou tout autre conteneur de servlets. Ensuite, allez à l’URL https://localhost:8080/Spring-Controller/hello et vous devriez voir l’écran suivant en sortie. 
Exemple de contrôleur Spring RestController
Maintenant, étendons notre application pour exposer également des APIs REST. Créez une classe de modèle qui sera envoyée en réponse JSON.
package com.journaldev.spring.model;
public class Person {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
Voici notre classe de contrôleur REST simple.
package com.journaldev.spring.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import com.journaldev.spring.model.Person;
@RestController
public class PersonRESTController {
@RequestMapping("/rest")
public String healthCheck() {
return "OK";
}
@RequestMapping("/rest/person/get")
public Person getPerson(@RequestParam(name = "name", required = false, defaultValue = "Unknown") String name) {
Person person = new Person();
person.setName(name);
return person;
}
}
Redéployez l’application à nouveau pour tester nos APIs REST.
Test du contrôleur Spring REST
Allez à l’URL https://localhost:8080/Spring-Controller/rest et vous devriez obtenir la sortie suivante. 
Allez à l’URL https://localhost:8080/Spring-Controller/rest/person/get et vous obtiendrez la réponse JSON suivante : 
Maintenant, fournissons la valeur du paramètre de nom dans l’URL, allez à https://localhost:8080/Spring-Controller/rest/person/get?name=Pankaj et vous obtiendrez la réponse JSON suivante. 
Résumé
Le contrôleur Spring est l’épine dorsale des applications Spring MVC. C’est là que commence notre logique métier. De plus, RestController nous aide à créer facilement des services web reposants.
Vous pouvez télécharger le code de l’exemple du projet depuis notre référentiel GitHub.
Source:
https://www.digitalocean.com/community/tutorials/spring-controller-spring-mvc-controller