Consumindo API com Java, Spring Boot e Gradle

Consumindo API com Java, Spring Boot e Gradle: um passo a passo simples e direto, utilizando a API do Studio Ghibli.

Este guia sobre como consumir uma API externa foi escrito para quem já tem algum conhecimento em Java, Spring Boot, Gradle, REST (ou outras linguagens, frameworks, ferramentas de automação e arquiteturas). Caso você esteja iniciando seus estudos, recomendo começar com a série de tutoriais API REST com Java e Spring Boot.

Neste tutorial, vamos usar a Studio Ghibli API.

Observação: quando este artigo foi escrito, o endereço da API utilizada era https://ghibliapi.herokuapp.com/, atualmente fora do ar. Tudo indica que a mesma API foi transferida para https://ghibliapi.vercel.app/.

Configurando o ambiente

Como usual, aqui também usaremos o Spring Initializr, uma ferramenta que vai nos ajudar a agilizar o processo de configuração e estruturação das bases de nossa aplicação.

Como você pode ver, vamos usar somente as dependências Spring Web e Spring Boot Dev Tools. A primeira nos ajuda a construir aplicações web e RESTful, enquanto a segunda nos permite realizar reinicializações rápidas da nossa aplicação. Como ainda não estamos lidando com banco de dados, não vamos selecionar Spring Data JPA ou outras dependências de driver de banco de dados por enquanto. Se pretendermos nos conectar a um banco de dados posteriormente, poderemos simplesmente adicionar novas dependências ao nosso projeto a qualquer momento.

Após baixar o ZIP fornecido pelo Spring Initializr, podemos importar o projeto para nossa IDE. Aqui estou utilizando o IntelliJ IDEA.

Diferentemente do Maven, no qual as dependências são colocadas no arquivo pom.xml , no Gradle temos o arquivo build.gradle para definir nossas configurações e dependências.

Feito isso, podemos começar a escrever o código da nossa aplicação.

E como a ideia é deixar tudo o mais simples possível, vamos consumir uma API que não requer autenticação. Existem muitas APIs gratuitas divertidíssimas por aí. Como dito antes, aqui vamos brincar com a API do Studio Ghibli.

Arquitetura, classes e endpoints do projeto

Neste projeto, vamos usar a arquitetura Controller-Service-Model. Ela é bastante útil quando vamos trabalhar com pequenas aplicações REST.

Então, vamos começar com o nosso Model.

Model

Como estamos brincando com o Studio Ghibli, os principais objetos da nossa aplicação serão os filmes. Assim, no package “model”, podemos criar a classe Film. Por enquanto, teremos apenas três atributos: title, original_title e original_title_romanised. Devemos escrever exatamente assim, pois é assim que esses campos foram criados na API (para verificar isso, você pode acessar a documentação).

No mundo da POO (Programação Orientada a Objetos), como sempre, devemos ter os métodos getter. Como não estamos usando o Lombok, devemos escrevê-los por conta própria.

Then our Film class will look like this:

Então, nossa classe Film ficará assim:

Agora vamos para a camada Service.

Service

Como sempre, primeiro vamos criar o package “service”. Em seguida, criamos a classe FilmService dentro dele. A primeira coisa que devemos fazer após a criação da classe é escrever a anotação @Service do Spring.

Em seguida, devemos instanciar um objeto RestTemplate e marcá-lo com a anotação @Autowired (já que estamos lidando com injeção de dependência).

Por enquanto, vamos ter apenas dois métodos. O primeiro vai servir para consumir a Ghibli API e retornar todas as suas informações. Chamaremos esse método de findAllFilmsComplete. Este método vai retornar um array Object, que será acessado por meio do template que declaramos anteriormente, usando seu método getForObject e passando o URL da API como parâmetro.

Nosso segundo método será o findAllFilms, que retornará um array de objetos Film. Da mesma forma, vamos usar o método getForObject e passar o URL da API como parâmetro. A diferença aqui é que estamos usando a classe Film (isto é, nosso modelo). Isso significa que os campos que serão retornados são somente aqueles que escrevemos como atributos na classe Film – portanto não teremos as informações completas dos filmes, mas apenas as que escolhemos.

Nossa classe FilmService ficará assim:

Controller

Por último, mas não menos importante, devemos escrever nossa classe FilmController no package “controller”. Primeiro, marcamos a classe com as anotações @RestController e @RequestMapping do Spring. Em seguida, declaramos um objeto FilmService com a anotação @Autowired.

Agora só precisamos escrever os métodos que chamarão os métodos do service. Para chamar o método findAllFilmsComplete , criamos um método getAllFilmsComplete que também retorna um array Object e o anotamos com @GetMapping (passando como parâmetro o caminho que será chamado).

E para chamar o método findAllFilms, criamos um método getAllFilms que retorna um array de objetos Film. Também o anotamos com @GetMapping, mas desta vez não precisamos passar um parâmetro, pois queremos chamá-lo no URL raiz.

Nossa classe controller ficará assim:

Você pode ter notado que não estamos trabalhando com uma camada Repository em nossa arquitetura. A razão disso é que, por enquanto, não estamos nos conectando a um banco de dados, portanto não estamos salvando nenhuma informação. É por isso que não precisamos de repositórios e DTOs.

Falta apenas uma etapa para executarmos e testarmos nossa aplicação. Na classe ExternalApiApplication (aquela que foi criada automaticamente pelo Spring Initializr), devemos escrever um método que crie (através de um RestTemplateBuilder) e retorne um RestTemplate e marcá-lo com a anotação @Bean do Spring. Como mostra a documentação, essa anotação é usada para indicar que um método produz um bean a ser gerenciado pelo contêiner do Spring.

Vai ficar assim:

Agora estamos prontos para testar as chamadas para a API com o Postman.

Testando com o Postman

Depois de executar a aplicação Spring Boot, podemos ir ao Postman e fazer uma solicitação GET para http://localhost:8080/.

Como você pode ver, foram retornados todos os filmes da Ghibli com os campos que definimos em nossa classe Film.

Se fizermos uma solicitação para http://localhost:8080/complete, todos os filmes serão retornados com suas informações completas, assim como quando fazemos uma solicitação diretamente ao URL original da API.

Com isso, conseguimos fazer o básico de como consumir uma API externa utilizando Java, Spring Boot e Gradle.

Agora podemos ir além e brincar um pouco.

Criando métodos para melhorar nossas pesquisas

Pesquisando por título

Uma forma de melhorar nossas consultas à API é, por exemplo, criando um método que encontre todos os filmes que contenham a palavra (ou parte da palavra) que você digitou.

Por exemplo, podemos escrever o método findFilmsByTitle em nossa classe de service, como mostrado acima, e chamá-lo no controller, como mostrado abaixo.

Quando fazemos a requisição para o caminho http://localhost:8080/title passando o parâmetro “ki”, por exemplo, obtemos todos os filmes que contêm essa substring. Observe que funciona tanto para o campo “title” quanto para o campo “original_title_romanised”, e também para letras maiúsculas e minúsculas.

Adicionando mais atributos à classe Film

Para obter mais informações sobre os filmes, podemos adicionar à nossa classe Film mais atributos que correspondem aos campos JSON.

Só de adicionarmos os atributos e seus getters à nossa classe, eles já serão retornados quando fizermos uma solicitação ao nosso caminho raiz.

Listando os diretores

Também podemos obter uma lista com os nomes de todos os diretores que trabalharam nos filmes do Studio Ghibli. Uma maneira de fazer isso é criar um método como este na classe service:

Obtendo os filmes mais recentes

Outra listagem interessante que podemos fazer é ordenar os filmes dos mais novos para os mais antigos. Para isso podemos criar dois métodos: um private apenas para ordenar a lista, e um public que vai pegar a lista e chamar o primeiro para ordená-la e retorná-la. Pode ser algo assim:

Melhorando o código e testando (de novo) no Postman

Você pode ter notado que não estamos mais usando nosso template em cada um dos métodos. Como muitos dos nossos métodos usam o mesmo objeto, é melhor declará-lo apenas uma vez, no início da nossa classe:

Então, podemos chamar nossos novos métodos service em nossa classe controller assim:

No Postman, quando fazemos requisições ao endpoint “directors”, obtemos uma lista de todos os diretores que fizeram parte de um filme da Ghibli:

E se fizermos requisições ao endpoint “newest”, obteremos uma lista com todos os filmes, do mais novo ao mais antigo:

Conclusão

É assim que você pode consumir uma API externa e se divertir com ela em sua aplicação. Existem muitos métodos que você pode criar para obter diversas informações sobre os filmes do Studio Ghibli. Seja criativo e continue explorando essa e outras APIs!

Você pode acessar o código completo deste projeto no GitHub.

Gosta de lógica de programação e de estudar algoritmos? Os livros Lógica de Programação – JavaScript e HTML e Entendendo Algoritmos – guia ilustrado são uma excelente dica para se aprofundar nesses temas.

Quer fazer uma API REST completa, do início ao fim, utilizando boas práticas, integrando com banco de dados até realizar testes no Postman? Veja a série API REST com Java e Spring Boot.