Spring é um dos frameworks Java EE mais amplamente utilizados. Já vimos anteriormente como usar o Spring MVC para criar aplicações web baseadas em Java. Hoje aprenderemos a criar Serviços Web Restful do Spring usando o Spring MVC e depois testá-los com o cliente Rest. No final, também veremos como invocar o serviço web Restful do Spring usando a API Spring RestTemplate. 
REST do Spring
Nós iremos usar a versão mais recente do Spring, 4.0.0.RELEASE, e utilizar a integração do Spring com o JSON do Jackson para enviar respostas JSON na chamada REST. O tutorial é desenvolvido no ambiente de desenvolvimento Spring STS para criar facilmente o código esqueleto do Spring MVC e, em seguida, estendê-lo para implementar a arquitetura Restful. Crie um novo projeto Spring MVC no STS, nosso projeto final se parecerá com a imagem abaixo. Vamos analisar cada um dos componentes um por um. 
Arquivos de Configuração XML do Spring REST
Nosso arquivo pom.xml fica assim.
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="https://maven.apache.org/POM/4.0.0" xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="https://maven.apache.org/POM/4.0.0 https://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.journaldev</groupId>
<artifactId>SpringRestExample</artifactId>
<name>SpringRestExample</name>
<packaging>war</packaging>
<version>1.0.0-BUILD-SNAPSHOT</version>
<properties>
<java-version>1.6</java-version>
<org.springframework-version>4.0.0.RELEASE</org.springframework-version>
<org.aspectj-version>1.7.4</org.aspectj-version>
<org.slf4j-version>1.7.5</org.slf4j-version>
<jackson.databind-version>2.2.3</jackson.databind-version>
</properties>
<dependencies>
<!-- Jackson -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>${jackson.databind-version}</version>
</dependency>
<!-- Spring -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${org.springframework-version}</version>
<exclusions>
<!-- Exclude Commons Logging in favor of SLF4j -->
<exclusion>
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>${org.springframework-version}</version>
</dependency>
<!-- AspectJ -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjrt</artifactId>
<version>${org.aspectj-version}</version>
</dependency>
<!-- Logging -->
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>${org.slf4j-version}</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>jcl-over-slf4j</artifactId>
<version>${org.slf4j-version}</version>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>${org.slf4j-version}</version>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.15</version>
<exclusions>
<exclusion>
<groupId>javax.mail</groupId>
<artifactId>mail</artifactId>
</exclusion>
<exclusion>
<groupId>javax.jms</groupId>
<artifactId>jms</artifactId>
</exclusion>
<exclusion>
<groupId>com.sun.jdmk</groupId>
<artifactId>jmxtools</artifactId>
</exclusion>
<exclusion>
<groupId>com.sun.jmx</groupId>
<artifactId>jmxri</artifactId>
</exclusion>
</exclusions>
<scope>runtime</scope>
</dependency>
<!-- @Inject -->
<dependency>
<groupId>javax.inject</groupId>
<artifactId>javax.inject</artifactId>
<version>1</version>
</dependency>
<!-- Servlet -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<version>2.5</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>javax.servlet.jsp</groupId>
<artifactId>jsp-api</artifactId>
<version>2.1</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
</dependency>
<!-- Test -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.7</version>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<artifactId>maven-eclipse-plugin</artifactId>
<version>2.9</version>
<configuration>
<additionalProjectnatures>
<projectnature>org.springframework.ide.eclipse.core.springnature</projectnature>
</additionalProjectnatures>
<additionalBuildcommands>
<buildcommand>org.springframework.ide.eclipse.core.springbuilder</buildcommand>
</additionalBuildcommands>
<downloadSources>true</downloadSources>
<downloadJavadocs>true</downloadJavadocs>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>2.5.1</version>
<configuration>
<source>1.6</source>
<target>1.6</target>
<compilerArgument>-Xlint:all</compilerArgument>
<showWarnings>true</showWarnings>
<showDeprecation>true</showDeprecation>
</configuration>
</plugin>
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>exec-maven-plugin</artifactId>
<version>1.2.1</version>
<configuration>
<mainClass>org.test.int1.Main</mainClass>
</configuration>
</plugin>
</plugins>
</build>
</project>
A ferramenta STS gera o arquivo pom.xml para nós. No entanto, eu atualizei o Framework Spring, AspectJ, SLF4J e a versão do Jackson para a mais recente até hoje. A maior parte é comum e gerada automaticamente, o ponto importante a ser observado é que eu adicionei as bibliotecas Jackson JSON nas dependências, pois as usaremos para converter objetos em JSON e vice-versa.
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="https://java.sun.com/xml/ns/javaee"
xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="https://java.sun.com/xml/ns/javaee https://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
<!-- The definition of the Root Spring Container shared by all Servlets and Filters -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/spring/root-context.xml</param-value>
</context-param>
<!-- Creates the Spring Container shared by all Servlets and Filters -->
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<!-- Processes application requests -->
<servlet>
<servlet-name>appServlet</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/spring/appServlet/servlet-context.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>appServlet</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
</web-app>
Este arquivo é gerado automaticamente e eu não alterei nada nele. No entanto, se você quiser alterar os arquivos de configuração de contexto e sua localização, você pode fazê-lo no arquivo web.xml.
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="https://www.springframework.org/schema/beans"
xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="https://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- Root Context: defines shared resources visible to all other web components -->
</beans>
Este arquivo contém os recursos compartilhados que serão visíveis para todos os componentes da web. Estaremos desenvolvendo um serviço REST simples, e é por isso que não alterei nada aqui.
<?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">
<!-- DispatcherServlet Context: defines this servlet's request-processing infrastructure -->
<!-- Enables the Spring MVC @Controller programming model -->
<annotation-driven />
<!-- Handles HTTP GET requests for /resources/** by efficiently serving up static resources in the ${webappRoot}/resources directory -->
<resources mapping="/resources/**" location="/resources/" />
<!-- 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>
<!-- Configure to plugin JSON as request and response in method handler -->
<beans:bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
<beans:property name="messageConverters">
<beans:list>
<beans:ref bean="jsonMessageConverter"/>
</beans:list>
</beans:property>
</beans:bean>
<!-- Configure bean to convert JSON to POJO and vice versa -->
<beans:bean id="jsonMessageConverter" class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
</beans:bean>
<context:component-scan base-package="com.journaldev.spring.controller" />
</beans:beans>
Grande parte é gerada automaticamente e contém configurações padrão. No entanto, pontos importantes a serem observados são o elemento annotation-driven para suportar configurações baseadas em anotações e a inclusão do MappingJackson2HttpMessageConverter no RequestMappingHandlerAdapter messageConverters, para que a API Jackson entre em ação e converta JSON para Java Beans e vice-versa. Com essa configuração, estaremos usando JSON no corpo da solicitação e recebendo dados JSON na resposta.
Classes do Modelo Spring REST
Vamos escrever uma classe POJO simples que servirá como entrada e saída para nossos métodos de serviço web RESTful.
package com.journaldev.spring.model;
import java.io.Serializable;
import java.util.Date;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.databind.ser.std.DateSerializer;
public class Employee implements Serializable{
private static final long serialVersionUID = -7788619177798333712L;
private int id;
private String name;
private Date createdDate;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@JsonSerialize(using=DateSerializer.class)
public Date getCreatedDate() {
return createdDate;
}
public void setCreatedDate(Date createdDate) {
this.createdDate = createdDate;
}
}
O único ponto importante a ser observado é o uso da anotação @JsonSerialize para usar a classe DateSerializer para conversão de data do tipo Java para o formato JSON e vice-versa.
Endpoints de Serviços Web Restful do Spring
Teremos os seguintes endpoints de serviços web rest.
| Sl. No | URI | HTTP Method | Details |
|---|---|---|---|
| 1 | /rest/emp/dummy | GET | Health Check service, to insert a dummy data in the Employees data storage |
| 2 | /rest/emp/{id} | GET | To get the Employee object based on the id |
| 3 | /rest/emps | GET | To get the list of all the Employees in the data store |
| 4 | /rest/emp/create | POST | To create the Employee object and store it |
| 5 | /rest/emp/delete/{id} | PUT | To delete the Employee object from the data storage based on the id |
Temos uma classe definindo todos esses URIs como constantes de String.
package com.journaldev.spring.controller;
public class EmpRestURIConstants {
public static final String DUMMY_EMP = "/rest/emp/dummy";
public static final String GET_EMP = "/rest/emp/{id}";
public static final String GET_ALL_EMP = "/rest/emps";
public static final String CREATE_EMP = "/rest/emp/create";
public static final String DELETE_EMP = "/rest/emp/delete/{id}";
}
Classe de Controlador de Serviço Web Restful do Spring
Nossa classe EmployeeController publicará todos os endpoints de serviço web mencionados acima. Vamos olhar o código da classe e então aprenderemos sobre cada um dos métodos em detalhes.
package com.journaldev.spring.controller;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import com.journaldev.spring.model.Employee;
/**
* Handles requests for the Employee service.
*/
@Controller
public class EmployeeController {
private static final Logger logger = LoggerFactory.getLogger(EmployeeController.class);
//Mapa para armazenar funcionários, idealmente deveríamos usar um banco de dados
Map empData = new HashMap();
@RequestMapping(value = EmpRestURIConstants.DUMMY_EMP, method = RequestMethod.GET)
public @ResponseBody Employee getDummyEmployee() {
logger.info("Start getDummyEmployee");
Employee emp = new Employee();
emp.setId(9999);
emp.setName("Dummy");
emp.setCreatedDate(new Date());
empData.put(9999, emp);
return emp;
}
@RequestMapping(value = EmpRestURIConstants.GET_EMP, method = RequestMethod.GET)
public @ResponseBody Employee getEmployee(@PathVariable("id") int empId) {
logger.info("Start getEmployee. ID="+empId);
return empData.get(empId);
}
@RequestMapping(value = EmpRestURIConstants.GET_ALL_EMP, method = RequestMethod.GET)
public @ResponseBody List getAllEmployees() {
logger.info("Start getAllEmployees.");
List emps = new ArrayList();
Set empIdKeys = empData.keySet();
for(Integer i : empIdKeys){
emps.add(empData.get(i));
}
return emps;
}
@RequestMapping(value = EmpRestURIConstants.CREATE_EMP, method = RequestMethod.POST)
public @ResponseBody Employee createEmployee(@RequestBody Employee emp) {
logger.info("Start createEmployee.");
emp.setCreatedDate(new Date());
empData.put(emp.getId(), emp);
return emp;
}
@RequestMapping(value = EmpRestURIConstants.DELETE_EMP, method = RequestMethod.PUT)
public @ResponseBody Employee deleteEmployee(@PathVariable("id") int empId) {
logger.info("Start deleteEmployee.");
Employee emp = empData.get(empId);
empData.remove(empId);
return emp;
}
}
Para simplificar, estou armazenando todos os dados dos funcionários no HashMap empData. A anotação @RequestMapping é usada para mapear o URI da solicitação para o método do manipulador. Também podemos especificar o método HTTP que deve ser usado pela aplicação cliente para invocar o método REST. A anotação @ResponseBody é usada para mapear o objeto de resposta no corpo da resposta. Assim que o objeto de resposta é retornado pelo método do manipulador, o MappingJackson2HttpMessageConverter entra em ação e o converte para uma resposta JSON. A anotação @PathVariable é a maneira fácil de extrair os dados do URI REST e mapeá-los para o argumento do método. A anotação @RequestBody é usada para mapear os dados JSON do corpo da solicitação no objeto Employee, novamente isso é feito pelo mapeamento do MappingJackson2HttpMessageConverter. O restante do código é simples e autoexplicativo, nossa aplicação está pronta para implantação e teste. Basta exportar como arquivo WAR e copiá-lo no diretório de aplicativos da web do contêiner de servlet. Se você tiver o servidor configurado no STS, pode simplesmente executá-lo no servidor para implantá-lo. Estou usando o WizTools RestClient para invocar as chamadas REST, mas você também pode usar a extensão Chrome Postman. As capturas de tela abaixo mostram as diferentes invocações das APIs REST expostas por nossa aplicação e sua saída. Verificação de Saúde – Chamada REST do Funcionário Falso 
Criar Chamada REST POST de Funcionário: Certifique-se de que o Content-Type da solicitação esteja definido como “application/json”, caso contrário, você receberá o Código de Erro HTTP 415. 
Chamada REST para Obter Funcionário 
Chamada REST para Excluir Funcionário 
Chamada REST para Obter Todos os Funcionários 
Programa Cliente Rest do Spring
Os clientes REST são bons para testar nosso serviço web rest, mas na maioria das vezes, precisamos invocar serviços REST através de nosso programa. Podemos usar o RestTemplate do Spring para invocar esses métodos facilmente. Abaixo está um programa simples que invoca os métodos rest da nossa aplicação usando a API RestTemplate.
package com.journaldev.spring;
import java.util.LinkedHashMap;
import java.util.List;
import org.springframework.web.client.RestTemplate;
import com.journaldev.spring.controller.EmpRestURIConstants;
import com.journaldev.spring.model.Employee;
public class TestSpringRestExample {
public static final String SERVER_URI = "https://localhost:9090/SpringRestExample";
public static void main(String args[]){
testGetDummyEmployee();
System.out.println("*****");
testCreateEmployee();
System.out.println("*****");
testGetEmployee();
System.out.println("*****");
testGetAllEmployee();
}
private static void testGetAllEmployee() {
RestTemplate restTemplate = new RestTemplate();
//não podemos obter List porque o conversor JSON não conhece o tipo de
//objeto na lista e, portanto, converte-o para o tipo de objeto JSON padrão LinkedHashMap
List emps = restTemplate.getForObject(SERVER_URI+EmpRestURIConstants.GET_ALL_EMP, List.class);
System.out.println(emps.size());
for(LinkedHashMap map : emps){
System.out.println("ID="+map.get("id")+",Name="+map.get("name")+",CreatedDate="+map.get("createdDate"));;
}
}
private static void testCreateEmployee() {
RestTemplate restTemplate = new RestTemplate();
Employee emp = new Employee();
emp.setId(1);emp.setName("Pankaj Kumar");
Employee response = restTemplate.postForObject(SERVER_URI+EmpRestURIConstants.CREATE_EMP, emp, Employee.class);
printEmpData(response);
}
private static void testGetEmployee() {
RestTemplate restTemplate = new RestTemplate();
Employee emp = restTemplate.getForObject(SERVER_URI+"/rest/emp/1", Employee.class);
printEmpData(emp);
}
private static void testGetDummyEmployee() {
RestTemplate restTemplate = new RestTemplate();
Employee emp = restTemplate.getForObject(SERVER_URI+EmpRestURIConstants.DUMMY_EMP, Employee.class);
printEmpData(emp);
}
public static void printEmpData(Employee emp){
System.out.println("ID="+emp.getId()+",Name="+emp.getName()+",CreatedDate="+emp.getCreatedDate());
}
}
A maior parte do programa é simples de entender, no entanto, ao invocar o método rest que retorna uma Coleção, precisamos usar LinkedHashMap porque a conversão de JSON para objeto não conhece o objeto Employee e o converte para a coleção de LinkedHashMap. Podemos escrever um método de utilidade para converter de LinkedHashMap para nosso objeto Java Bean. Quando executamos o programa acima, obtemos a seguinte saída no console.
ID=9999,Name=Dummy,CreatedDate=Tue Mar 04 21:02:41 PST 2014
*****
ID=1,Name=Pankaj Kumar,CreatedDate=Tue Mar 04 21:02:41 PST 2014
*****
ID=1,Name=Pankaj Kumar,CreatedDate=Tue Mar 04 21:02:41 PST 2014
*****
2
ID=1,Name=Pankaj Kumar,CreatedDate=1393995761654
ID=9999,Name=Dummy,CreatedDate=1393995761381
Outro ponto é que os métodos put do RestTemplate não têm opção para definir o objeto de resposta porque o método PUT deve ser usado para armazenar algo no servidor e um simples código de status HTTP 200 deve ser suficiente.
Baixar Projeto de Serviço Web Restful do Spring
Isso é tudo para o tutorial da aplicação web Spring Restful. Faça o download do projeto de exemplo no link acima e experimente para aprender mais. ATUALIZAÇÃO: Devido a muitos pedidos para fornecer um exemplo semelhante com XML, além de oferecer suporte tanto para XML quanto para JSON, eu estendi esta aplicação em Exemplo Spring REST XML JSON para dar suporte a ambas as solicitações e respostas em XML e JSON. Eu sugiro fortemente que você passe por isso para ver a beleza do framework Spring e como é fácil alcançar isso.
Você pode baixar o projeto completo em nosso Repositório no GitHub.