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 baseados na anotação RequestMapping.

Spring Controller

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

Spring RestController

Spring @RestController é 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 em seguida converta-o para um projeto Maven. Isso nos fornecerá uma estrutura de aplicativo web baseada no Maven, na qual podemos construir nossa aplicação. A imagem abaixo mostra a estrutura final do projeto de nosso aplicativo 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>

Finalmente, temos o seguinte arquivo de contexto 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 XML de configuração estão prontos, vamos passar para a classe do 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ções, que aceita solicitações GET com URI “/hello” e retorna 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 de nossa 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 baseada em servlet convencional 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 Controlador Spring Rest

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

}

Implante novamente a aplicação 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

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

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