Controlador de Rest do Spring

Tutoriais

Spring

@ControladorRest é uma anotação de conveniência que, por sua vez, é anotada com @Controller e @ResponseBody. Esta anotação é aplicada a uma classe para marcá-la como um manipulador de solicitações. A anotação @ControladorRest do Spring é usada para criar serviços web RESTful usando o Spring MVC. O @ControladorRest do Spring cuida do mapeamento dos dados da solicitação para o método do manipulador definido. Uma vez que o corpo da resposta é gerado a partir do método do manipulador, ele o converte em uma resposta JSON ou XML.

Exemplo de @ControladorRest do Spring

Vamos ver como podemos usar facilmente o RestController para criar um serviço web REST no Spring. Vamos reutilizar a implementação do Repositório Spring e criar um serviço web RESTful. Vamos criar uma aplicação Web independente e não usar o Spring Boot aqui. Também vamos expor nossas APIs para suportar tanto JSON quanto XML em solicitações e respostas. A imagem abaixo mostra a estrutura final do nosso projeto. As classes Model e Repository já estão fornecidas no tutorial do Repositório Spring. Daremos mais atenção à implementação do RestController aqui.

Dependências Maven do Spring RestController

Vamos dar uma olhada nas dependências necessárias para criar nosso projeto de exemplo Spring RestController.

<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 JSON Support -->
<dependency>
	<groupId>com.fasterxml.jackson.core</groupId>
	<artifactId>jackson-databind</artifactId>
	<version>2.9.6</version>
</dependency>
<!-- JAXB for XML Response, needed to explicitly define from Java 9 onwards -->
<dependency>
	<groupId>javax.xml.bind</groupId>
	<artifactId>jaxb-api</artifactId>
	<version>2.3.0</version>
</dependency>
<dependency>
	<groupId>org.glassfish.jaxb</groupId>
	<artifactId>jaxb-runtime</artifactId>
	<version>2.3.0</version>
	<scope>runtime</scope>
</dependency>
<dependency>
	<groupId>javax.activation</groupId>
	<artifactId>javax.activation-api</artifactId>
	<version>1.2.0</version>
</dependency>

Precisamos das bibliotecas Spring MVC, Jackson e JAXB para oferecer suporte a solicitações e respostas XML e JSON em nosso serviço web REST. Nosso arquivo web.xml é usado para configurar o DispatcherServlet do Spring MVC como o controlador frontal. Vamos agora dar uma olhada no arquivo de contexto do Spring.

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

	<beans:bean id="jsonMessageConverter"
		class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter" />
	<beans:bean id="xmlMessageConverter"
		class="org.springframework.http.converter.xml.Jaxb2RootElementHttpMessageConverter" />

	<beans:bean
		class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
		<beans:property name="messageConverters">
			<beans:list>
				<beans:ref bean="jsonMessageConverter" />
				<beans:ref bean="xmlMessageConverter" />
			</beans:list>
		</beans:property>
	</beans:bean>

</beans:beans>

A parte mais importante são os beans jsonMessageConverter e xmlMessageConverter definidos e configurados na propriedade messageConverters do RequestMappingHandlerAdapter. Isso é tudo o que é necessário para dizer ao Spring que queremos que nossa aplicação ofereça suporte tanto a JSON quanto a XML, e esses são os beans a serem usados para a transformação.

Classe Spring RestController

Aqui está a implementação da nossa classe Spring RestController.

package com.journaldev.spring.controller;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

import com.journaldev.spring.model.Employee;
import com.journaldev.spring.repository.EmployeeRepository;

@RestController
public class EmployeeRestController {

	@Autowired
	private EmployeeRepository repository;
	
	@GetMapping("/rest/employee/get/{id}")
	public Employee getEmployeeByID(@PathVariable("id") int id) {
		return repository.retrieve(id);
	}
	
	@GetMapping("/rest/employee/getAll")
	//Retornar uma Lista é suportado apenas com resposta JSON
	//Se você quiser XML, adicione uma classe de invólucro como elemento raiz XML, por exemplo, EmployeeList
	public List getAllEmployees() {
		return repository.getAll();
	}

	@PostMapping("/rest/employee/create")
	public Employee createEmployee(@RequestBody Employee emp) {
		repository.store(emp);
		return emp;
	}
	
	@GetMapping("/rest/employee/search/{name}")
	public Employee getEmployeeByName(@PathVariable("name") String name) {
		return repository.search(name);
	}
	
	@DeleteMapping("/rest/employee/delete/{id}")
	public Employee deleteEmployeeByID(@PathVariable("id") int id) {
		return repository.delete(id);
	}
}

Perceba que só definimos nossas APIs REST aqui, toda a lógica de negócios faz parte da classe Repository. Se nosso método estiver retornando uma lista ou array, o Spring só suportará resposta JSON, pois o elemento raiz XML não pode ser anônimo, mas JSON pode. Se desejar suportar o retorno de lista como XML, será necessário criar uma classe de invólucro para conter essa lista e retorná-la. Estamos esperando um objeto Employee como solicitação em alguns métodos; o Spring cuidará de analisar o corpo da solicitação e convertê-lo para o objeto Employee para esses métodos. Da mesma forma, estamos retornando um objeto Employee como corpo de resposta; novamente, o Spring cuidará da conversão para resposta JSON/XML.

Cabeçalhos de Solicitação Accept e Content-Type

Configuramos nossa aplicação REST para funcionar com XML e JSON. Então, como ela saberá se a solicitação é XML ou JSON? E se a resposta deve ser enviada em formato JSON ou XML? Aqui é onde os cabeçalhos de solicitação Accept e Content-Type são usados. Content-Type: Define o tipo de conteúdo no corpo da solicitação; se o valor for “application/xml”, o Spring tratará o corpo da solicitação como um documento XML. Se o valor for “application/json”, o corpo da solicitação será tratado como JSON. Accept: Define o tipo de conteúdo que o cliente espera como resposta. Se o valor for “application/xml”, será enviada uma resposta XML. Se o valor for “application/json”, será enviada uma resposta JSON.