Skip to content

Capitulo 04

Jairo Nascimento edited this page Sep 10, 2025 · 1 revision

Consumindo uma API de tradução

Contextualizando o projeto

O projeto CodeChella é uma plataforma grande que provavelmente será acessada por pessoas de todo o mundo para a compra de ingressos para eventos. Frequentemente, turistas ou residentes estrangeiros preferem ler as descrições dos shows, eventos e do próprio site no idioma que utilizam. No entanto, os navegadores e seus plugins muitas vezes não conseguem realizar essa tarefa de forma eficiente. Portanto, podemos integrar ao nosso projeto uma API de tradução que execute essa função para nós.

Como estamos trabalhando com um projeto que utiliza programação reativa, precisamos realizar essa tradução ou pesquisa em outro idioma de forma assíncrona, para que não seja bloqueante e não prejudique o fluxo da nossa aplicação.

Utilizando a API DeepL Translator Para isso, utilizaremos a API DeepL Translator. Ao acessar o site, https://www.deepl.com, ele já aparece em português e pode traduzir textos para 33 idiomas, além de arquivos.

Por exemplo, no nosso Postman, temos uma descrição de um evento da banda The Cure, voltado para pessoas que apreciam rock. Copiamos esse texto, "Um evento para pessoas que curtem rock", colamos na DeepL e solicitamos a tradução para o inglês.

A API oferece uma tradução e algumas alternativas. Podemos traduzir para outros 32 idiomas, como francês ou indonésio. Esse recurso pode agregar muito valor à nossa aplicação, permitindo descrever eventos de forma eficiente. Se não quisermos descrever o site inteiro, podemos ao menos descrever cada evento, como uma peça teatral, um show, recomendações, faixa etária, o que pode ou não ser levado, e orientações gerais.

Cadastrando e configurando a API

Para realizar o cadastro, acessamos a opção "API", no menu superior, que possui uma versão gratuita. Ao clicar em "Experimentar grátis", poderemos fazer uma assinatura que dará acesso às funcionalidades. Basta clicar em "Assine grátis", inserir o e-mail e continuar para liberar alguns recursos.

Após o cadastro, será necessário preencher informações como endereço, nome, sobrenome e realizar uma verificação de cartão de crédito, que não será cobrada, apenas para verificar a identidade. Com isso, será possível utilizar até 500 mil caracteres por mês na conta gratuita. Após preencher todas as informações, teremos acesso à documentação.

Ao informar o cartão de crédito e seguir com o cadastro, a assinatura estará no modo gratuito, exibindo dados da conta, e-mail e fornecendo chaves. Então, é necessário criar uma chave para conectar e realizar buscas e traduções no idioma desejado.

Aqui, já temos uma chave cadastrada e um consumo registrado, por exemplo, 2 mil caracteres testados. Não há fatura, pois a conta continua gratuita, mas há a opção de fazer um upgrade para uma versão Pro.

Disponibilizaremos o link para a documentação, explicando como consumir a API e o formato dos dados a serem enviados. Então, cadastre sua conta gratuita, informe o cartão de crédito e mantenha a conta no modo gratuito para podermos fazer essa conexão.

Conclusão e próximos passos

Existem outras alternativas de APIs de tradução, que serão mencionadas no material, mas recomendamos a DeepL. Há planos e preços, incluindo versões gratuitas e Pro com mais dados, além de suporte e documentação. Após realizar todo o processo, basta clicar na opção "API" e em "Ler documentação" para entender como realizar a conexão.

Resumo

Neste capitulo, aprendemos sobre a API DeepL Translator e como podemos integrá-la ao nosso projeto CodeChella para traduzir descrições de eventos para diversos idiomas, o que é crucial considerando que a plataforma será acessada por pessoas de todo o mundo.

Você viu como criar uma conta gratuita na DeepL, obter a chave de acesso à API e consultou a documentação para entender como realizar a conexão. A ideia é que, no futuro, possamos consumir essa API de forma assíncrona para não bloquear o fluxo da nossa aplicação reativa.

Para saber mais: documentação da API DeepL

A DeepL oferece uma API de tradução completa e flexível, permitindo que pessoas desenvolvedoras integrem traduções de alta qualidade diretamente em suas aplicações. Para utilizar a API, é importante conhecer sua documentação, que fornece informações detalhadas sobre funcionalidades, endpoints, autenticação e muito mais.

Documentação

A documentação completa da API DeepL está disponível no site oficial. Lá você encontrará:

  • Visão geral: Uma introdução à API DeepL, seus recursos e casos de uso;

  • Guia de início rápido: Instruções passo a passo para realizar sua primeira tradução usando a API;

  • Referência da API: Documentação detalhada de todos os endpoints, parâmetros e respostas da API;

  • Especificações OpenAPI: Definição formal da API usando o padrão OpenAPI (Swagger), útil para gerar clientes de API automaticamente;

  • SDKs: Bibliotecas de código aberto em várias linguagens de programação, como Python, Node.js e PHP, que facilitam a integração com a API.

Funcionalidades

  • Tradução de texto: Traduza textos entre os idiomas suportados pela DeepL com alta precisão e fluidez;

  • Detecção de idioma: Identifique automaticamente o idioma de um texto;

  • Glossários: Crie e utilize glossários personalizados para garantir traduções consistentes de termos específicos;

  • Controle de formalidade: Ajuste o nível de formalidade da tradução para se adequar ao contexto;

  • Gerenciamento de uso: Monitore o uso da API e visualize estatísticas de tradução.

Segurança

A API DeepL utiliza autenticação por chave de API. Para obter uma chave, é necessário criar uma conta DeepL Pro e ativá-la. As chaves de API devem ser mantidas em sigilo e protegidas para evitar o uso não autorizado.

Ao explorar a documentação completa da API DeepL, você poderá aproveitar ao máximo as suas funcionalidades de tradução, podendo integrá-las facilmente em suas aplicações.

Primeira Requisição para API DeepL

Para realizarmos nossa primeira tradução, vamos explorar a documentação!

Entendendo como fazer a primeira requisição à API

No menu à esquerda, clicamos em "Your First API Request" para acessar nossa primeira requisição à API. A documentação apresenta o endpoint e algumas opções de linguagens, como Python, PHP, C#, Node e Java.

Embora exista uma biblioteca para Java, não podemos garantir que ela funcione de forma assíncrona. Portanto, utilizaremos ferramentas e dependências que permitam o consumo de forma assíncrona. Não usaremos a biblioteca Java, mas sim a opção HTTP Request.

Criando a requisição no Postman

Na seção HTTP Request, a documentação informa qual é o endpoint e como configurar o cabeçalho. Precisamos incluir DeepL-Auth-Key [yourAuthKey] e nossa chave. Vamos copiá-lo e abrir uma nova aba no Postman. Faremos um GET e passaremos no header um cabeçalho de autorização, onde colocaremos DeepL-Auth-Key e nossa chave. Para obter a chave, basta copiar no Postman.

No body, o formato deve ser JSON, contendo o texto e a linguagem para a qual queremos traduzir: {"text":["Hello, world!"],"target_lang":"DE"}. Então, copiamos e colamos este trecho no body. Em seguida, precisamos incluir o endpoint.

Vamos definir o target_lang como PT para verificar se a tradução é feita para o português.

{"text":["Hello, world!"],"target_lang":"PT"}

Conforme indicado na documentação, se estivermos usando a API Free, devemos utilizar o endpoint https://api-free.deepl.com, seguido de /v2/translate, com o método POST, não GET. Portanto, copiamos e colamos esse endpoint no Postman e mudamos a requisição para POST.

https://api-free.deepl.com/v2/translate

Verificando a resposta

Ao enviar, verificamos a resposta:

"translations": [
    {
      "detected_source_language": "EN",
      "text": "Olá, mundo!"
    }

Ele detectou que enviamos um texto em inglês e nos devolveu a tradução, que é "Olá, mundo!". Precisamos representar essa resposta em nossa aplicação. O retorno será um JSON com um campo chamado translations, e dentro dele, haverá um array cujo primeiro item, text, conterá a tradução.

Testamos no Postman primeiro porque é uma boa prática. Muitas vezes, ao tentar consumir a API na aplicação, não sabemos se o erro está na API externa ou na aplicação. É sempre bom testar externamente e verificar se a tradução foi feita para saber o que esperar. Assim, sabemos qual JSON enviar e qual formato receber, pois representaremos isso na aplicação.

Implementando a representação

Para representar esse retorno, criaremos dois records dentro do pacote br.com.jnsdev.codechella. Clicamos em "Autoinserte", selecionamos "Java Class" e nomeamos a classe como Traducao. Ela será um record com um campo translations, que é uma lista de Texto. Para isso, também devemos importar o List.

package br.com.jnsdev.codechella;

public record Traducao(List<Texto> translations) {

}

O Texto será o que vimos no Postman. Onde a IDE marcou como vermelho, na palavra Texto, vamos em "More Actions" e criamos o record Texto, que estará no mesmo pacote e terá simplesmente o campo text, que será uma String.

package br.com.jnsdev.codechella;

public record Texto(String text) {
}

Em Traducao, importaremos a lista, que não havia sido importada, e criaremos um método para obter o texto. No retorno do Postman, recebemos um array, mas pedimos para traduzir apenas uma frase. Portanto, nos interessa apenas a primeira posição do array. Não sabemos se em algum momento chegarão vários itens nesse array, mas isso não nos interessa agora. Para que isso funcione, pegaremos a primeira posição do array e o texto.

Ao representar e mapear o que foi trazido para essa tradução, queremos pegar a primeira posição das translations. Criaremos um método que nos devolverá essa tradução. Dentro do record Traducao, criamos um public String chamado getTexto() que retornará translations.get(0).text.

package br.com.jnsdev.codechella;

import java.util.List;

public record Traducao(List<Texto> translations) {

    public String getTexto() {
        return translations.get(0).text();
    }
}

Para saber mais: WebClient

O WebClient é um componente do Spring WebFlux, introduzido no Spring 5, projetado para fazer requisições HTTP de forma reativa e não bloqueante. Ele substitui o RestTemplate para cenários reativos e é muito flexível. Permite uma ampla gama de operações, desde requisições simples até operações complexas, com suporte a WebSockets, multipart e streaming de dados. Com ele é possível construir aplicativos escaláveis e responsivos, aproveitando ao máximo os benefícios da programação reativa. Confira algumas implementações abaixo,

Criando instância

Você pode criar uma instância do WebClient usando seu builder estático ou injetando-o no seu contexto Spring.

Criação básica:

WebClient webClient = WebClient.create();

Configuração com o builder:

WebClient webClient = WebClient.builder()
        .baseUrl("http://example.com")
        .defaultHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE)
        .defaultUriVariables(Collections.singletonMap("url", "http://example.com"))
        .build();

Injeção com Spring:

@Configuration
public class WebClientConfig {
    @Bean
    public WebClient webClient() {
        return WebClient.builder().baseUrl("http://example.com").build();
    }
}

Requisições HTTP

O WebClient permite fazer requisições HTTP de forma simples e intuitiva.

Requisições GET:

Mono<String> response = webClient.get()
        .uri("/endpoint")
        .retrieve()
        .bodyToMono(String.class);

Requisições POST:

Mono<String> response = webClient.post()
        .uri("/endpoint")
        .contentType(MediaType.APPLICATION_JSON)
        .body(BodyInserters.fromValue(new MyRequestBody()))
        .retrieve()
        .bodyToMono(String.class);

Inclusão de Headers e Query Parameters:

Mono<String> response = webClient.get()
        .uri(uriBuilder -> uriBuilder
            .path("/endpoint")
            .queryParam("param", "value")
            .build())
        .header(HttpHeaders.AUTHORIZATION, "Bearer token")
        .retrieve()
        .bodyToMono(String.class);

Manipulação de respostas

O método retrieve é usado para recuperar o corpo da resposta e tratar automaticamente os erros.

Mono<String> response = webClient.get()
        .uri("/endpoint")
        .retrieve()
        .bodyToMono(String.class)
        .onStatus(HttpStatus::isError, clientResponse -> {
            return clientResponse.bodyToMono(String.class).flatMap(error -> {
                return Mono.error(new RuntimeException("Error response: " + error));
            });
        });

O método exchange oferece controle sobre a requisição e a resposta.

Mono<ClientResponse> response = webClient.get()
        .uri("/endpoint")
        .exchange();

response.flatMap(clientResponse -> {
    if (clientResponse.statusCode().is2xxSuccessful()) {
        return clientResponse.bodyToMono(String.class);
    } else {
        return clientResponse.bodyToMono(String.class)
                .flatMap(error -> Mono.error(new RuntimeException("Error response: " + error)));
    }
});

Nessa documentação oficial do Spring tem um guia com explicações e exemplos de uso do WebClient.

Utilizando o WebClient

Para realizar a tradução de forma não bloqueante e assíncrona, utilizaremos o WebClient, um cliente HTTP reativo fornecido pelo Spring WebFlux. Em vez de usar a biblioteca pronta fornecida pela API, utilizaremos o WebClient do próprio WebFlux, que já está preparado para realizar chamadas de forma não bloqueante.

Criando a classe TraducaoDeTextos

Vamos criar uma nova classe para centralizar as informações do WebClient. Dentro do nosso pacote br.com.jnsdev.codechella, criaremos uma nova classe chamada TraducaoDeTextos.

package br.com.alura.codechella;

public class TraducaoDeTextos {

}

Para utilizar esta classe e chamar seus métodos dentro da nossa classe de serviço, criaremos um método que realizará a tradução. Para isso, criaremos o método de forma estática, que nos permitirá chamar a classe TraducaoDeTextos e o método que preparará toda essa tradução para nós.

Definindo o método obterTraducao

Criamos um método public static chamado obterTraducao. Assim, quando estivermos na nossa classe de serviço, chamaremos obterTraducao. Este método receberá o texto e o idioma para o qual queremos que seja traduzido. Passaremos, por exemplo, uma String texto e uma String idioma. Isso pode futuramente ser transformado em um enum, mas, por enquanto, manteremos como String.

package br.com.jnsdev.codechella;

public class TraducaoDeTextos {
     public static obterTraducao(String texto, String idioma) {
     
     }
}

Ainda não definimos qual será o retorno. Queremos devolver apenas a tradução da primeira posição do array translations que a API nos enviará, pois não sabemos como seria com muitos itens. No nosso caso, queremos traduzir apenas o texto que descreve o evento, que é algo pequeno. Indicaremos que o método devolverá um Mono<String>, pois será um texto traduzido. Além disso, importaremos o Mono.

package br.com.alura.codechella;

import reactor.core.publisher.Mono;

public class TraducaoDeTextos {
      public static Mono<String> obterTraducao(String texto, String idioma) {
     
     }
}

Configurando o WebClient

Para estruturar essa conexão com o WebClient, declararemos o WebClient e o criaremos com o próprio builder que ele fornece, passando a baseUrl. A baseUrl é a URL que usamos no Postman para conectar à API de tradução. Copiamos esse endereço do Postman e o colocamos na nossa aplicação dentro de baseUrl, entre aspas duplas:

public class TraducaoDeTextos {
    public static Mono<String> obterTraducao(String texto, String idioma) {
        WebClient webClient = WebClient.builder()
                .baseUrl("https://api-free.deepl.com/v2/translate")
                .build();
     }
}

Agora, precisamos enviar os valores que enviamos também no Postman: o texto e o idioma. Na seção "OpenAPI spec for text translation", na documentação da API, vemos como deve ser o corpo da requisição, os tipos de linguagens, as siglas e como é a resposta. Vamos estruturar para enviar essa informação.

Criaremos um MultiValueMap, com dois campos do tipo String, chamado req, em alusão à requisição. Em seguida, criaremos um LinkedMultiValueMap, onde colocaremos os itens que precisamos utilizando o método .add(). Os itens são: o texto e o idioma para o qual o texto deve ser traduzido (target_lang), que ficará armazenado na variável idioma.

Além disso, poderíamos definir o idioma original, que é o português, mas isso é opcional. Como não fizemos isso no exemplo prático no Postman, também não colocaremos aqui, mas poderíamos adicionar usando o parâmetro source_lang, conforme a documentação.

public class TraducaoDeTextos {

    public static Mono<String> obterTraducao(String texto, String idioma) {
        WebClient webClient = WebClient.builder()
                .baseUrl("https://api-free.deepl.com/v2/translate")
                .build();

        MultiValueMap<String, String> req = new LinkedMultiValueMap<>();

        req.add("text", texto);
        req.add("target_lang", idioma);
   }
}

Para fazer a requisição, utilizamos webClient.post(). Em seguida, passamos o header(), com o item de autorização e a chave com DeepL-Auth-Key. Usaremos uma variável de ambiente já cadastrada para que, ao subir para o Git, as pessoas não tenham acesso à nossa chave. Para isso, concatenamos "DeepL-Auth-Key " com System.getenv("DPL_APIKey").

webClient.post()
    .header("Authorization", "DeepL-Auth-Key " + System.getenv("DPL_APIKey"))

Após passar o header(), passamos o corpo da requisição, .body(), utilizando BodyInserters.fromFormData(req). Em seguida, chamamos .retrieve() para fazer a requisição e .bodyToMono(Traducao.class) para transformar a resposta em um Mono da classe Traducao. Por fim, mapeamos para chamar o método getText, pois nos interessa apenas o item text.

Este bloco de código será um retorno, então adicionamos return antes de webClient.post().

return webClient.post()
                .header("Authorization", "DeepL-Auth-Key " + System.getenv("DEEPL_APIKEY"))
                .body(BodyInserters.fromFormData(req))
                .retrieve()
                .bodyToMono(Traducao.class)
                .map(Traducao::getTexto);

O código completo ficará assim:

package br.com.jnsdev.codechella;

import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.web.reactive.function.BodyInserters;
import org.springframework.web.reactive.function.client.WebClient;
import reactor.core.publisher.Mono;

public class TraducaoDeTextos {

    public static Mono<String> obterTraducao(String texto, String idioma) {
        WebClient webClient = WebClient.builder()
                .baseUrl("https://api-free.deepl.com/v2/translate")
                .build();

        MultiValueMap<String, String> req = new LinkedMultiValueMap<>();

        req.add("text", texto);
        req.add("target_lang", idioma);

        return webClient.post()
                .header("Authorization", "DeepL-Auth-Key " + System.getenv("DEEPL_APIKEY"))
                .body(BodyInserters.fromFormData(req))
                .retrieve()
                .bodyToMono(Traducao.class)
                .map(Traducao::getTexto);

    }

}

Esta é a parte central do método, onde a requisição para a API de tradução é construída e enviada. Vamos analisar cada passo:

  • webClient.post(): Inicia a construção de uma requisição POST.

  • .header("Authorization", "DeepL-Auth-Key " + System.getenv("DEEPL_APIKEY")): Adiciona o header de autorização à requisição, utilizando a chave da API DeepL armazenada em uma variável de ambiente (DEEPL_APIKEY).

  • .body(BodyInserters.fromFormData(req)): Define o corpo da requisição como um formulário (FormData), utilizando os dados armazenados no MultiValueMap req.

  • .retrieve(): Envia a requisição para a API e obtém a resposta.

  • .bodyToMono(Traducao.class): Converte o corpo da resposta para um objeto da classe Traducao. Essa classe deve ter os atributos correspondentes à estrutura da resposta da API.

  • .map(Traducao::getTexto): Extrai o texto traduzido do objeto Traducao utilizando uma referência a método (Traducao::getTexto). Isso assume que a classe Traducao tem um método getTexto() que retorna o texto traduzido.

Em resumo: O código cria um cliente web (WebClient), prepara os dados para a requisição (texto e idioma), envia a requisição para a API de tradução, recebe a resposta, converte a resposta para um objeto Java e extrai o texto traduzido, retornando-o como um Mono<String>.

Resumo

Neste capítulo aula, aprendemos a utilizar o WebClient do Spring WebFlux para consumir uma API de tradução de textos de forma não bloqueante e assíncrona.

Principais pontos abordados:

  • Criação da classe TraducaoDeTextos: Centralizamos a lógica de comunicação com a API de tradução nesta classe.

  • Definição do método obterTraducao: Este método recebe o texto a ser traduzido e o idioma de destino, retornando um Mono<String> com o texto traduzido.

  • Configuração do WebClient: Configuramos o WebClient com a URL base da API e definimos os headers necessários, incluindo a chave de autenticação da API DeepL.

  • Envio da requisição: Construímos um MultiValueMap com os parâmetros text e target_lang (idioma de destino) e enviamos a requisição POST para a API.

  • Tratamento da resposta: Convertemos a resposta da API para um objeto Traducao e extraímos o texto traduzido.

Em resumo, nesse capítulo aprendemos a criar uma classe utilitária para realizar traduções de texto utilizando o WebClient de forma reativa, preparando o terreno para a integração com o restante da aplicação.

Conclusão e próximos passos

Criamos a classe TraducaoDeTextos e o método obterTraducao utilizando o WebClient, garantindo o consumo da API de forma assíncrona e não bloqueante.

Agora, precisamos modificar o serviço e criar um novo endpoint para realizar os testes.

Recebendo informações de forma não bloqueante

Já definimos nossa API de tradução, criamos nossa chave, a classe de resposta, os registros que representam a resposta e a classe de tradução de textos que fará o post para nossa API. Agora, falta apenas ajustarmos nosso controller e nosso serviço para efetivamente chamar essa tradução.

Ajustando o Controller

Vamos começar pelo controller. No arquivo EventoController, vamos copiar o método@GetMapping("/{id}"), colar logo abaixo e alterar a duplicata para chamar a tradução para o idioma desejado. Será um @GetMapping("/{id}/traduzir/{idioma}"), onde a pessoa usuária poderá escolher o idioma que desejar.

Ao devolver a resposta, esse método não chamará mais obterPorId. O novo método que copiamos e colamos se chamará obterTraducao e ele não devolverá um evento, mas sim uma string. Queremos que ele devolva apenas a tradução da descrição do evento, pois a data e o cantor permanecerão os mesmos, não necessitando de tradução.

Então, o obterTraducao devolverá um public Mono<String> e terá duas variáveis no nosso endpoint: duas@PathVariable, uma para o id e outra para o idioma.

No nosso serviço, teremos um método específico para fazer essa tradução. O retorno do nosso novo método será servico.obterTraducao, onde passaremos o id e o idioma.

@GetMapping("/{id}/traduzir/{idioma}")
    public Mono<String> obterTraducao(@PathVariable Long id, @PathVariable String idioma) {
        return servico.obterTraducao(id, idioma);
    }

Criando o método obterTraducao

Como esse método obterTraducao ainda não existe, usaremos a IDE para nos ajudar e o criaremos no arquivo EventoService. Assim, a IDE já criará o cabeçalho para nós.

public Mono<String> obterTraducao(Long id, String idioma) {

}

No método obterTraducao, o primeiro passo será localizar o evento pelo seu id (por exemplo, o show da banda Kiss). Após localizar o evento, chamaremos a nossa classe de tradução para traduzir a descrição.

No nosso return, utilizaremos repositorio.findById(), passando o id do evento. Depois de localizar o evento, faremos uma transformação para buscar a tradução e devolver um Mono<String>.

Utilizaremos um .flatMap() com um método lambda que chamaremos de e, em alusão à "evento". Com e, chamaremos TraducaoDeTextos.obterTraducao(), passando a descrição do evento localizado e o idioma desejado. Assim, utilizaremos e.getDescricao() e o idioma, que são os dois parâmetros definidos na nossa classe TraducaoDeTextos.

public Mono<String> obterTraducao(Long id, String idioma) {
        return repositorio.findById(id)
                .flatMap(e -> TraducaoDeTextos.obterTraducao(e.getDescricao(), idioma));
    }

Feito isso, podemos executar e verificar se nossa aplicação está funcionando corretamente.

Na documentação do DPL, há várias opções de idiomas disponíveis, então tentaremos traduzir para alguns idiomas e verificar se está atendendo à nossa proposta.

Testando a implementação

No Postman, buscaremos todos os eventos. Entre eles, temos a palestra, que é o evento 4. Usaremos o endpoint programado para tradução em Inglês, então fazemos um GET para localhost:8080/eventos/4/traduzir/en. Ao enviar, ele já nos trará a tradução: "An informative talk on the latest AI trends and tools".

Agora, vamos tentar em francês: localhost:8080/eventos/4/traduzir/fr. Ao fazer isso, ele traz a tradução em Francês. Qualquer sigla que colocarmos, como espanhol es, ele traduzirá. Isso é muito interessante, pois agrega ao nosso projeto recursos que facilitam a acessibilidade e proporcionam uma melhor experiência para as pessoas usuárias.

Conclusão e próximos passos

Utilizando o WebClient, garantimos que recebemos os dados de forma assíncrona, sem bloquear a aplicação, e que não estamos realizando chamadas inadequadas. O WebClient substitui o REST Template para aplicações reativas, sendo a recomendação do pacote WebFlux.

Concluímos nossa missão de consumir uma API externa de forma assíncrona e não bloqueante. No próximo capítulo, trabalharemos com testes também de forma assíncrona.

Ness e capítulo, você aprendeu a:

  1. Importância de integrar uma API de tradução para tornar o conteúdo acessível em múltiplos idiomas;

  2. Utilizar a API DeepL Translator e obter a chave de acesso;

  3. Consumir uma API externa de forma assíncrona e não bloqueante com Spring WebFlux;

  4. Configurar e utilizar o WebClient para realizar chamadas HTTP;

  5. Implementar métodos para enviar requisições de tradução e processar respostas JSON; Proteger informações sensíveis usando variáveis de ambiente;

  6. Desenvolver endpoints GET específicos no controlador para obter traduções;

  7. Validar a funcionalidade da API integrada utilizando ferramentas como Postman.

Clone this wiki locally