Spring Controller-annotatie is een specialisatie van de @Component-annotatie. Spring Controller-annotatie wordt doorgaans gebruikt in combinatie met geannoteerde handler-methoden op basis van de RequestMapping-annotatie.
Spring Controller
De Spring Controller-annotatie kan alleen worden toegepast op klassen. Het wordt gebruikt om een klasse aan te duiden als een webverzoekhandler en wordt meestal gebruikt in combinatie met een Spring MVC-applicatie.
Spring RestController
Spring @RestController is een handige annotatie die zelf is geannoteerd met @Controller en @ResponseBody. Deze annotatie wordt gebruikt om een klasse aan te duiden als een request handler voor RESTful webservices.
Voorbeeld van een Spring Controller
Laten we een eenvoudige Spring-applicatie maken waarin we zowel een standaard MVC-controller als een REST-controller zullen implementeren. Maak een “Dynamic Web Project” in Eclipse en converteer het vervolgens naar een Maven-project. Dit geeft ons een op Maven gebaseerde webapplicatiestructuur en we kunnen onze applicatie daar bovenop bouwen. Onderstaande afbeelding toont de uiteindelijke projectstructuur van onze Spring MVC Controller-applicatie. 
We hebben de volgende afhankelijkheden nodig voor onze applicatie.
<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>
Laten we eens kijken naar het inzetdescriptor-bestand (web.xml) waarin we de servlet DispatcherServlet configureren als de frontcontroller.
<?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>
Tenslotte hebben we het volgende Spring-contextbestand. Hier configureren we onze applicatie om op annotaties gebaseerd te zijn en geven we de hoofdpackage op voor het scannen van Spring-componenten. We configureren ook de InternalResourceViewResolver-bean en geven details van de viewpagina’s op.
<?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>
Onze configuratie-XML-bestanden zijn klaar, laten we nu naar de Controller-klasse gaan.
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";
}
}
We hebben een enkele verzoekverwerkmethode gedefinieerd, deze accepteert GET-verzoeken met URI “/hello” en retourneert de pagina “home.jsp” als antwoord. Let op dat we een attribuut instellen voor het model, dat zal worden gebruikt in de home.jsp-pagina. Hier is onze eenvoudige home.jsp pagina-code.
<%@ 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>
Spring MVC Controller Test
Onze conventionele op servlet gebaseerde Spring MVC-toepassing met een eenvoudige controller is klaar, exporteer het gewoon als het WAR-bestand en implementeer het op Tomcat of een andere servletcontainer. Ga vervolgens naar URL https://localhost:8080/Spring-Controller/hello en je zou het volgende scherm als output moeten zien. 
Spring RestController Voorbeeld
Laten we nu onze toepassing uitbreiden om ook REST API’s bloot te leggen. Maak een modelklasse die als JSON-reactie wordt verzonden.
package com.journaldev.spring.model;
public class Person {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
Hier is onze eenvoudige REST-controllerklasse.
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;
}
}
Bouw de toepassing opnieuw in om onze REST API’s te testen.
Spring REST Controller Test
Ga naar URL https://localhost:8080/Spring-Controller/rest en je zou de volgende uitvoer moeten krijgen. 
Ga naar URL https://localhost:8080/Spring-Controller/rest/person/get en je krijgt het volgende JSON-antwoord: 
Laten we nu de naamparameterwaarde verstrekken in de URL, ga naar https://localhost:8080/Spring-Controller/rest/person/get?name=Pankaj en je krijgt het volgende JSON-antwoord. 
Samenvatting
Spring Controller is de ruggengraat van Spring MVC-applicaties. Hier begint onze bedrijfslogica. Bovendien helpt RestController ons bij het gemakkelijk maken van op REST gebaseerde webservices.
Je kunt de voorbeeldprojectcode downloaden vanuit onze GitHub Repository.
Source:
https://www.digitalocean.com/community/tutorials/spring-controller-spring-mvc-controller