Controlador Rest do Spring

Tutoriais

Spring

Exemplo de Spring RestController

A anotação Spring RestController é uma anotação conveniente que é ela própria anotada com @Controller e @ResponseBody. Esta anotação é aplicada a uma classe para marcá-la como um manipulador de solicitações. A anotação Spring RestController é usada para criar serviços web RESTful usando o Spring MVC. O Spring RestController cuida do mapeamento dos dados da solicitação para o método manipulador definido. Uma vez que o corpo da resposta é gerado a partir do método manipulador, ele o converte em uma resposta JSON ou XML.
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. Criaremos um aplicativo Web independente e não usaremos 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á são fornecidas no tutorial do Repositório Spring. Vamos nos concentrar mais na implementação do RestController aqui.

Spring RestController Maven Dependencies

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 examinar o 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 informar ao Spring que queremos que nossa aplicação suporte tanto JSON quanto 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")
	
// O retorno como Lista é suportado apenas com resposta JSON

	
// Se você deseja XML, adicione uma classe wrapper como elemento XML raiz, 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);
	}
}

Observe que aqui apenas definimos nossas APIs REST, 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ó dará suporte à resposta JSON, pois o elemento raiz XML não pode ser anônimo, mas o JSON pode. Se desejar dar suporte ao retorno de uma lista como XML, será necessário criar uma classe de invólucro para manter essa lista e retorná-la. Em alguns dos métodos, estamos esperando um objeto Employee como a solicitação; o Spring cuidará da análise do corpo da solicitação e da conversão para o objeto Employee para esses métodos. Da mesma forma, estamos retornando um objeto Employee como corpo da resposta; novamente, o Spring cuidará da conversão para resposta JSON/XML.

Headers de Solicitação Accept e Content-Type

Configuramos nossa aplicação REST para funcionar com XML e JSON. 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 Headers de Solicitação Accept e Content-Type são utilizados. 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”, a resposta será enviada como XML. Se o valor for “application/json”, a resposta será enviada como JSON.