Como consumir JSON de um serviço RESTful e converter em objeto Java — Exemplo de Spring RestTemplate
Hoje vou escrever sobre a classe RESTTemplate do framework Spring MVC. Como seus predecessores JdbcTemplate e JmsTemplate, o RestTemplate é outra classe utilitária que permite interagir com serviços RESTful a partir de uma aplicação Java usando o Framework Spring. É um recurso que suporta quase todos os métodos REST, como por exemplo GET, POST, HEAD, PUT ou DELETE, apesar de usarmos apenas o método GET neste artigo para consumir um serviço RESTful e converter a resposta JSON em objetos Java. É um exemplo básicos, mas interessante, dado que você encontrará frequentemente cenários para consumir um serviço RESTful.
Também estou usando o Spring Boot para executar essa pequena aplicação com um método main() em vez de gerar um arquivo WAR e implantar no tomcat para demonstrar o exemplo. Realmente acho a conveniência oferecida pelo Spring Boot excelente, pois incorpora o servlet contêiner como o Tomcat, o que é suficiente para executar este programa.
Todo código fonte desse exemplo pode ser encontrado no meu github: https://github.com/gcbrandao/rest-example e pode ser copiado para sua maquina usando o comando: git clone https://github.com/gcbrandao/rest-example.git
O que nós construiremos?
Nós criaremos um aplicativo que usa o RestTemplate do Spring para recuperar uma cotação aleatória do Spring Boot em https://gturnquist-quoters.cfapps.io/api/random.
Serviços RESTful gratuitos na Internet para testes
Para criar um cliente REST, você precisa de um serviço REST que possa fornecer o conteúdo JSON que você deseja consumir. Embora você possa desenvolver um serviço REST com o próprio Framework Spring, para fins de teste, é melhor usarmos um serviço RESTful gratuito disponível na Internet. Por exemplo http://jsonplaceholder.typicode.com que possui várias API´s RESTful muito úteis como http://jsonplaceholder.typicode.com/posts/1 retornará dados de postagem com id = 1, como no exemplo abaixo:
{
"userId": 1,
"Id": 1,
"Title": "a title "
"Body": "the body of the content"
}No entanto, para esse exemplo usarei outro serviço REStful gratuito do próprio site do Spring Framework que retorna um JSON para usarmos de exemplo disponível em https://spring.io :
https://gturnquist-quoters.cfapps.io/api/random{
"type":"success",
"value":{
"id":10,
"quote":"Really loving Spring Boot, makes stand alone Spring apps easy."
}
}
Programa Java para consumir JSON de um serviço RESTful usando Spring RestTemplate
Começando com Spring Initializr
Para todos os aplicativos Spring, você deve começar com o Spring Initializr. O Initializr oferece uma maneira rápida de obter todas as dependências necessárias para um aplicativo e faz muitas configurações para você alem de ja gerar toda a estrutura de arquivos e diretórios do projeto. Como este exemplo precisa ser nada mais que um aplicativo da Web, você precisa incluir apenas a dependência da Web. A imagem a seguir mostra a Inicialização configurada para este projeto de amostra:
A listagem a seguir mostra o arquivo pom.xml criado quando você escolhe o Maven:
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.1.7.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.example</groupId>
<artifactId>rest-exemple</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>rest-exemple</name>
<description>Demo project for Spring Boot and RestTemplate</description>
<properties>
<java.version>1.8</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>Esses arquivo do pom.xml se torna simples assim porque o spring-boot-starter-web inclui tudo o que você precisa para construir um aplicativo da web, incluindo as classes Jackson necessárias para trabalhar com o JSON.
Com a instalação do projeto concluída, você pode criar um aplicativo simples que consome um serviço RESTful.
O serviço RESTful que usaremos a seguir esta disponível em https://gturnquist-quoters.cfapps.io/api/random. Ele busca aleatoriamente citações sobre o Spring Boot e as retorna como documentos JSON.
Se você solicitar esse URL por meio de um navegador da Web qualquer, receberá um documento JSON parecido com este:
{
type: "success",
value: {
id: 10,
quote: "Really loving Spring Boot, makes stand alone Spring apps easy."
}
}Isso é fácil, mas não é muito útil quando buscado através de um navegador pois essa informação não é visualmente clara para entendimento humano.
Uma maneira mais útil de consumir um serviço REST é por meio de programação. Para ajudá-lo nessa tarefa, o Spring fornece uma classe de modelo chamada RestTemplate. O RestTemplate torna a interação com a maioria dos serviços RESTful com uma linha de código. Primeiro, você precisa criar uma classe de domínio para conter os dados necessários. O exemplo a seguir mostra a classe Quote, que você pode ser usada como sua classe de domínio:
/rest-example/src/main/java/com/example/restexample/Quote.javapackage com.example.restexample;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
@JsonIgnoreProperties(ignoreUnknown = true)
public class Quote {
private String type;
private Value value;
public Quote() {
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public Value getValue() {
return value;
}
public void setValue(Value value) {
this.value = value;
}
@Override
public String toString() {
return "Quote{" +
"type='" + type + '\'' +
", value=" + value +
'}';
}
}
Essa classe Java simples possui várias propriedades e métodos getter correspondentes. Ele é anotada com @JsonIgnoreProperties da biblioteca de processamento JSON Jackson para indicar que quaisquer propriedades não vinculadas neste tipo devem ser ignoradas.
Para vincular seus dados diretamente aos seus tipos customizados, é necessário especificar o nome da variável exatamente igual à chave no documento JSON retornado da API. Caso o nome da variável e a chave no documento JSON não correspondam, você poderá usar a anotação @JsonProperty para especificar a chave exata do documento JSON. (Em nosso exemplo cada nome de variável corresponde a uma chave no JSON, portanto, não precisaremos dessa anotação aqui.)
Também precisamos de uma classe adicional para os dados da própria cotação interna. Faremos a classe Value para preencher os valores necessário como mostrado a seguir em /rest-example/src/main/java/com/example/restexample/Value.java:
/rest-example/src/main/java/com/example/restexample/Value.javapackage com.example.restexample;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
@JsonIgnoreProperties(ignoreUnknown = true)
public class Value {
private Long id;
private String quote;
public Value() {
}
public Long getId() {
return this.id;
}
public String getQuote() {
return this.quote;
}
public void setId(Long id) {
this.id = id;
}
public void setQuote(String quote) {
this.quote = quote;
}
@Override
public String toString() {
return "Value{" +
"id=" + id +
", quote='" + quote + '\'' +
'}';
}
}
Ela usa as mesmas anotações, mas mapeia para outros campos de dados.
Finalizando o aplicativo
O Initalizr cria uma classe com um método main (). Os detalhes a seguir mostram a classe que o Initializr cria (em /rest-example/src/main/java/com/example/restexample/ConsumingRestApplication.java):
package com.example.restexample;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.client.RestTemplateBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;
@SpringBootApplication
public class ConsumingRestApplication {
private static final Logger log = LoggerFactory.getLogger(ConsumingRestApplication.class);
public static void main(String[] args) {
SpringApplication.run(ConsumingRestApplication.class, args);
}
@Bean
public RestTemplate restTemplate(RestTemplateBuilder builder) {
return builder.build();
}
@Bean
public CommandLineRunner run(RestTemplate restTemplate) throws Exception {
return args -> {
Quote quote = restTemplate.getForObject(
"https://gturnquist-quoters.cfapps.io/api/random", Quote.class);
log.info("Resultado da Chamada REST: " + quote.toString());
};
}
}Rodando a aplicação
Podemos executar o aplicativo via linha de comando com Maven. Podemos também criar um único arquivo JAR executável que contenha todas as dependências, classes e recursos necessários e executá-lo. A criação de um jar executável facilita o envio, a versão e a implantação do serviço como um aplicativo durante todo o ciclo de vida do desenvolvimento, em diferentes ambientes e assim por diante.
Usando o Maven, podemos executar o aplicativo usando ./mvnw spring-boot:run Como alternativa, você pode criar o arquivo JAR com ./mvnw clean package e, em seguida, executar o arquivo JAR, da seguinte maneira:
java -jar rest-exemple-0.0.1-SNAPSHOT.jarO resultado do nosso aplicativo pode ser visto na log do console da aplicação e você deve ver uma saída semelhante à seguinte, mas com uma mensagem de cotação provavelmente diferente pois o serviço retorna uma cotação aleatória:
Resultado da Chamada REST: Quote{type=’success’, value=Value{id=7, quote=’The real benefit of Boot, however, is that it’s just Spring. That means any direction the code takes, regardless of complexity, I know it’s a safe bet.’}}
Mais uma vez muito obrigado por ler o meu artigo e espero que esse conteúdo possa te ajudar no inicio de seus estudos e para começar a entender melhor como funciona uma aplicação RESTful.
