Como consumir uma API externa em Java?

Como consumir uma API externa em Java?

Consumir APIs externas em Java é uma necessidade comum no desenvolvimento de aplicações modernas. Para isso, utilizamos ferramentas como RestTemplate e WebClient, que permitem fazer requisições HTTP para consumir dados de serviços externos.

1. Consumindo APIs com RestTemplate (Spring Boot)

O RestTemplate é uma das formas mais usadas para consumir APIs REST em projetos Spring Boot.

1.1 Adicionando Dependência ao Projeto

Se ainda não possui o Spring Web no seu projeto, adicione a seguinte dependência no pom.xml:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

1.2 Criando um Cliente para Consumo da API

Aqui está um exemplo de como fazer uma requisição GET para consumir uma API externa:

import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

@Service
public class ApiService {
    private final RestTemplate restTemplate = new RestTemplate();

    public String consumirApiExterna() {
        String url = "https://api.publicapis.org/entries";
        return restTemplate.getForObject(url, String.class);
    }
}

Explicação:

• getForObject(url, String.class): Faz uma requisição GET e retorna a resposta como String.
• O RestTemplate é um cliente HTTP que simplifica a comunicação com APIs externas.

1.3 Consumindo APIs com Parâmetros

Podemos passar parâmetros na URL:

public String buscarUsuario(String id) {
    String url = "https://jsonplaceholder.typicode.com/users/{id}";
    return restTemplate.getForObject(url, String.class, id);
}

Aqui, {id} é substituído pelo valor passado como argumento.

1.4 Fazendo uma Requisição POST

Para enviar dados para uma API externa:

public String criarUsuario(Usuario usuario) {
    String url = "https://jsonplaceholder.typicode.com/users";
    return restTemplate.postForObject(url, usuario, String.class);
}

2. Consumindo APIs com WebClient (Alternativa Reativa)

O WebClient é a alternativa moderna ao RestTemplate, recomendado para aplicações reativas e assíncronas.

2.1 Adicionando Dependência ao Projeto

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-webflux</artifactId>
</dependency>

2.2 Criando um Cliente WebClient

import org.springframework.stereotype.Service;
import org.springframework.web.reactive.function.client.WebClient;

@Service
public class ApiServiceReativo {
    private final WebClient webClient = WebClient.create("https://jsonplaceholder.typicode.com");

    public String buscarUsuarios() {
        return webClient.get()
                .uri("/users")
                .retrieve()
                .bodyToMono(String.class)
                .block(); // Bloqueia a execução até receber a resposta
    }
}

Explicação:

• WebClient.create("URL_BASE") cria um cliente HTTP.
• retrieve().bodyToMono(String.class).block() obtém o corpo da resposta de forma síncrona.

2.3 Fazendo uma Requisição POST com WebClient

public String criarUsuarioReativo(Usuario usuario) {
    return webClient.post()
            .uri("/users")
            .bodyValue(usuario)
            .retrieve()
            .bodyToMono(String.class)
            .block();
}

Diferencial: O WebClient permite chamadas assíncronas e fluxos reativos.

3. Diferença entre RestTemplate e WebClient

Conclusão

Tanto o RestTemplate quanto o WebClient são excelentes ferramentas para consumir APIs externas em Java. Para aplicações reativas e de alta performance, o WebClient é recomendado. Já para aplicações tradicionais, o RestTemplate ainda é amplamente utilizado.

Por que WebClient é a melhor opção para consumir APIs em Java?

O consumo de APIs externas é uma necessidade fundamental para aplicações modernas, permitindo integração com sistemas de terceiros. Em aplicações Java, o uso do RestTemplate foi a principal escolha por muitos anos, mas com o avanço do paradigma reativo, o WebClient se tornou a solução recomendada para garantir maior eficiência e performance. O entendimento de como consumir APIs de forma otimizada é essencial para desenvolvedores que trabalham com microserviços e aplicações distribuídas.

Algumas aplicações:

• Consumir APIs REST externas
• Integração com serviços de terceiros (pagamentos, notificações, etc.)
• Obter dados de microserviços
• Enviar e receber JSON via HTTP

Dicas para quem está começando

• Use RestTemplate para chamadas síncronas e WebClient para chamadas assíncronas
• Prefira WebClient para maior eficiência em aplicações escaláveis
• Ao consumir APIs públicas, sempre valide as respostas para evitar erros
• Utilize bodyToMono() para respostas únicas e bodyToFlux() para listas no WebClient

Contribuições de

Rodrigo Farias

Desenvolvedor Java focado em aplicações corporativas e microsserviços.

Mais sobre o autor

Compartilhe este tutorial