La anotación Spring Controller es una especialización de la anotación @Component. La anotación Spring Controller se usa típicamente en combinación con métodos de controladores anotados basados en la anotación RequestMapping.
Spring Controller
La anotación Spring Controller solo se puede aplicar en clases. Se utiliza para marcar una clase como un controlador de solicitudes web. Se usa principalmente con aplicaciones de Spring MVC.
Spring RestController
Spring @RestController es una anotación de conveniencia que está anotada con @Controller y @ResponseBody. Esta anotación se utiliza para marcar una clase como controlador de solicitudes para servicios web RESTful.
Ejemplo de Controlador Spring
Creemos una aplicación Spring simple donde implementaremos un controlador MVC estándar y también un controlador REST. Cree un “Proyecto Web Dinámico” en Eclipse y luego conviértalo en un proyecto Maven. Esto nos proporcionará una estructura de aplicación web basada en Maven y podremos construir nuestra aplicación sobre ella. La siguiente imagen muestra la estructura final del proyecto de nuestra aplicación de controlador Spring MVC. 
Necesitaríamos las siguientes dependencias para nuestra aplicación.
<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>
Veamos el descriptor de implementación (web.xml) donde configuraremos el servlet DispatcherServlet como el controlador 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>
Finalmente, tenemos el siguiente archivo de contexto de Spring. Aquí estamos configurando nuestra aplicación para que sea basada en anotaciones y proporcionando el paquete raíz para escanear los componentes de Spring. También estamos configurando el bean InternalResourceViewResolver y proporcionando detalles de las páginas de vista.
<?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>
Nuestros archivos de configuración XML están listos, pasemos a la clase del Controlador ahora.
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";
}
}
Hemos definido un único método de manejo de solicitudes, que acepta solicitudes GET con URI “/hello” y devuelve la página “home.jsp” como respuesta. Observe que estamos estableciendo un atributo en el modelo, que se utilizará en la página home.jsp. Aquí está nuestro código simple de la página home.jsp.
<%@ 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>
Prueba de controlador Spring MVC
Nuestra aplicación Spring MVC convencional basada en servlets con un controlador simple está lista. Simplemente expórtela como un archivo WAR y despliéguela en Tomcat o cualquier otro contenedor de servlets. Luego vaya a la URL https://localhost:8080/Spring-Controller/hello y debería ver la siguiente pantalla como salida. 
Ejemplo de Spring RestController
Ahora extendamos nuestra aplicación para exponer también APIs REST. Cree una clase de modelo que se enviará como respuesta 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;
}
}
Aquí está nuestra simple clase de controlador REST.
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;
}
}
Vuelva a implementar la aplicación para probar nuestras APIs REST.
Prueba de controlador Spring REST
Ve a la URL https://localhost:8080/Spring-Controller/rest y deberías obtener la siguiente salida. 
Ve a la URL https://localhost:8080/Spring-Controller/rest/person/get y obtendrás la siguiente respuesta JSON: 
Ahora proporcionemos el valor del parámetro nombre en la URL, ve a https://localhost:8080/Spring-Controller/rest/person/get?name=Pankaj y obtendrás la siguiente respuesta JSON. 
Resumen
El Controlador Spring es el pilar de las aplicaciones Spring MVC. Aquí es donde comienza nuestra lógica empresarial. Además, RestController nos ayuda a crear fácilmente servicios web basados en REST.
Puedes descargar el código del proyecto de ejemplo desde nuestro Repositorio en GitHub.
Source:
https://www.digitalocean.com/community/tutorials/spring-controller-spring-mvc-controller