Controlador Spring – Controlador Spring MVC

A anotação Spring Controller é uma especialização da anotação @Component. A anotação Spring Controller é tipicamente usada em combinação com métodos de manipulador anotados com base na anotação RequestMapping.

Spring Controller

A anotação Spring Controller pode ser aplicada apenas em classes. É usada para marcar uma classe como manipulador de solicitações da web. É principalmente usada com aplicativos Spring MVC.

Spring RestController

O @RestController Spring é uma anotação de conveniência que é ela mesma anotada com @Controller e @ResponseBody. Esta anotação é usada para marcar uma classe como manipulador de solicitações para serviços da web RESTful.

Exemplo de Controlador Spring

Vamos criar uma aplicação Spring simples onde implementaremos um controlador MVC padrão, bem como um controlador REST. Crie um “Projeto Web Dinâmico” no Eclipse e depois converta-o para projeto Maven. Isso nos fornecerá uma estrutura de aplicação web baseada em Maven e podemos construir nossa aplicação em cima dela. A imagem abaixo mostra a estrutura final do projeto da nossa aplicação de Controlador Spring MVC. Precisaremos das seguintes dependências para nossa aplicação.

<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>

Vamos dar uma olhada no descritor de implantação (web.xml) onde configuraremos o servlet DispatcherServlet como o 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>

Por fim, temos o seguinte arquivo de contexto do Spring. Aqui estamos configurando nossa aplicação para ser baseada em anotações e fornecendo o pacote raiz para a varredura dos componentes Spring. Também estamos configurando o bean InternalResourceViewResolver e fornecendo detalhes das páginas de visualização.

<?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>

Nossos arquivos de configuração XML estão prontos, vamos passar para a classe Controlador agora.

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";
	}

}

Definimos um único método manipulador de solicitação, ele está aceitando solicitações GET com URI “/hello” e retornando a página “home.jsp” como resposta. Observe que estamos definindo um atributo para o modelo, que será usado na página home.jsp. Aqui está o código simples da 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>

Teste de Controlador Spring MVC

Nossa aplicação Spring MVC convencional baseada em servlet com um controlador simples está pronta, basta exportá-la como arquivo WAR e implantá-la no Tomcat ou em qualquer outro contêiner de servlets. Em seguida, vá para o URL https://localhost:8080/Spring-Controller/hello e você deverá ver a seguinte tela como saída.

Exemplo de RestController Spring

Agora vamos estender nossa aplicação para expor também APIs REST. Crie uma classe de modelo que será enviada como resposta 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;
	}
	
}

Aqui está nossa classe de Controlador REST simples.

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;
	}

}

Implante a aplicação novamente para testar nossas APIs REST.

Teste de Controlador Spring REST

Vá para o URL `https://localhost:8080/Spring-Controller/rest` e você deverá obter a seguinte saída. Vá para o URL `https://localhost:8080/Spring-Controller/rest/person/get` e você obterá a seguinte resposta JSON: Agora, forneça o valor do parâmetro de nome no URL, vá para `https://localhost:8080/Spring-Controller/rest/person/get?name=Pankaj` e você obterá a seguinte resposta JSON.

Resumo

O Spring Controller é a espinha dorsal das aplicações Spring MVC. É aqui que nossa lógica de negócios começa. Além disso, o RestController nos ajuda a criar facilmente serviços web baseados em REST.

Você pode baixar o código do projeto de exemplo de nosso Repositório no GitHub.