Die Spring Controller-Annotation ist eine Spezialisierung der @Component-Annotation. Die Spring Controller-Annotation wird typischerweise in Kombination mit annotierten Handler-Methoden verwendet, die auf der RequestMapping-Annotation basieren.
Spring Controller
Die Spring Controller-Annotation kann nur auf Klassen angewendet werden. Sie wird verwendet, um eine Klasse als Web-Anforderungs-Handler zu kennzeichnen. Sie wird hauptsächlich in Verbindung mit einer Spring MVC-Anwendung verwendet.
Spring RestController
Der Spring @RestController ist eine Bequemlichkeits-Annotation, die selbst mit @Controller und @ResponseBody annotiert ist. Diese Annotation wird verwendet, um eine Klasse als Anforderungs-Handler für RESTful-Webdienste zu kennzeichnen.
Spring Controller Beispiel
Erstellen wir eine einfache Spring-Anwendung, in der wir sowohl einen Standard-MVC-Controller als auch einen REST-Controller implementieren werden. Erstellen Sie ein „Dynamic Web Project“ in Eclipse und konvertieren Sie es dann in ein Maven-Projekt. Dies bietet uns eine auf Maven basierende Webanwendungsstruktur, auf der wir unsere Anwendung aufbauen können. Das folgende Bild zeigt die endgültige Projektstruktur unserer Spring MVC Controller-Anwendung. 
Für unsere Anwendung benötigen wir folgende Abhängigkeiten.
<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>
Werfen wir einen Blick auf den Bereitstellungsdescriptor (web.xml), wo wir das Servlet DispatcherServlet als Front-Controller konfigurieren werden.
<?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>
Zuletzt haben wir folgende Spring-Kontextdatei. Hier konfigurieren wir unsere Anwendung für die annotationsbasierte Verwendung und geben das Stammverzeichnis für das Scannen von Spring-Komponenten an. Wir konfigurieren auch das Bean InternalResourceViewResolver und geben Details zu den Ansichtsseiten an.
<?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>
Unsere Konfigurations-XML-Dateien sind bereit, lassen Sie uns nun zur Controller-Klasse übergehen.
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";
}
}
Wir haben eine einzelne Anforderungshandlermethode definiert, die GET-Anforderungen mit der URI „/hello“ akzeptiert und die Seite „home.jsp“ als Antwort zurückgibt. Beachten Sie, dass wir ein Attribut im Modell setzen, das auf der home.jsp-Seite verwendet wird. Hier ist unser einfacher home.jsp Seitencode.
<%@ 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
Unsere konventionelle servletbasierte Spring MVC-Anwendung mit einem einfachen Controller ist bereit. Exportieren Sie sie einfach als WAR-Datei und deployen Sie sie auf Tomcat oder einem anderen Servlet-Container. Gehen Sie dann zur URL https://localhost:8080/Spring-Controller/hello und Sie sollten den folgenden Bildschirm als Ausgabe sehen. 
Spring RestController Beispiel
Erweitern wir nun unsere Anwendung, um auch REST-APIs freizulegen. Erstellen Sie eine Model-Klasse, die als JSON-Antwort gesendet wird.
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 ist unsere einfache REST-Controller-Klasse.
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;
}
}
Deployen Sie die Anwendung erneut, um unsere REST-APIs zu testen.
Spring REST Controller Test
Gehen Sie zur URL https://localhost:8080/Spring-Controller/rest und Sie sollten folgende Ausgabe erhalten. 
Gehen Sie zur URL https://localhost:8080/Spring-Controller/rest/person/get und Sie erhalten folgende JSON-Antwort: 
Jetzt geben wir den Namen als Parameterwert in der URL an, gehen Sie zu https://localhost:8080/Spring-Controller/rest/person/get?name=Pankaj und Sie erhalten folgende JSON-Antwort. 
Zusammenfassung
Spring Controller ist das Rückgrat von Spring MVC-Anwendungen. Hier beginnt unsere Geschäftslogik. Darüber hinaus hilft uns RestController dabei, REST-basierte Webdienste einfach zu erstellen.
Sie können den Beispielprojektcode aus unserem GitHub-Repository herunterladen.
Source:
https://www.digitalocean.com/community/tutorials/spring-controller-spring-mvc-controller