Como Usar RestTemplate e WebClient para Consultar CPF via API em Java

import org.springframework.boot.web.client.RestTemplateBuilder;
import org.springframework.http.*;
import org.springframework.stereotype.Service;
import org.springframework.web.client.HttpClientErrorException;
import org.springframework.web.client.RestTemplate;

import java.time.Duration;

@Service
public class CpfRestTemplateService {

    private final RestTemplate restTemplate;
    private final String apiKey;

    public CpfRestTemplateService(
    RestTemplateBuilder builder,
    @Value("${cpfhub.api-key}") String apiKey) {
    this.restTemplate = builder
    .setConnectTimeout(Duration.ofSeconds(5))
    .setReadTimeout(Duration.ofSeconds(10))
    .build();
    this.apiKey = apiKey;
    }

    public CpfData consultar(String cpf) {
    String cpfLimpo = cpf.replaceAll("\\D", "");

    HttpHeaders headers = new HttpHeaders();
    headers.set("x-api-key", apiKey);
    headers.setContentType(MediaType.APPLICATION_JSON);

    HttpEntity<Void> entity = new HttpEntity<>(headers);

    try {
    ResponseEntity<CpfResponse> response =
    restTemplate.exchange(
    "https://api.cpfhub.io/cpf/" + cpfLimpo,
    HttpMethod.GET,
    entity,
    CpfResponse.class
    );

    CpfResponse body = response.getBody();
    if (body != null && body.isSuccess()) {
    return body.getData();
    }
    throw new CpfNaoEncontradoException(
    "CPF nao encontrado"
    );

    } catch (HttpClientErrorException.Unauthorized e) {
    throw new ApiException("API key invalida");
    } catch (HttpClientErrorException e) {
    throw new ApiException(
    "Erro HTTP: " + e.getStatusCode()
    );
    }
    }

    public List<CpfData> consultarLote(List<String> cpfs) {
    return cpfs.stream()
    .map(this::consultar)
    .toList();
    }
}

import org.springframework.stereotype.Service;
import org.springframework.web.reactive.function.client.WebClient;
import org.springframework.web.reactive.function.client.WebClientResponseException;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

import java.time.Duration;

@Service
public class CpfWebClientService {

    private final WebClient webClient;

    public CpfWebClientService(
    @Value("${cpfhub.api-key}") String apiKey) {
    this.webClient = WebClient.builder()
    .baseUrl("https://api.cpfhub.io")
    .defaultHeader("x-api-key", apiKey)
    .defaultHeader("Content-Type", "application/json")
    .build();
    }

    public Mono<CpfData> consultar(String cpf) {
    String cpfLimpo = cpf.replaceAll("\\D", "");

    return webClient.get()
    .uri("/cpf/{cpf}", cpfLimpo)
    .retrieve()
    .bodyToMono(CpfResponse.class)
    .timeout(Duration.ofSeconds(10))
    .flatMap(response -> {
    if (response.isSuccess()) {
    return Mono.just(response.getData());
    }
    return Mono.error(
    new CpfNaoEncontradoException(
    "CPF nao encontrado"
    )
    );
    })
    .onErrorResume(
    WebClientResponseException.Unauthorized.class,
    e -> Mono.error(
    new ApiException("API key invalida")
    )
    );
    }

    public Flux<CpfData> consultarLote(List<String> cpfs) {
    return Flux.fromIterable(cpfs)
    .flatMap(this::consultar, 10) // 10 em paralelo
    .onErrorContinue((erro, cpf) ->
    System.err.println(
    "Erro no CPF " + cpf + ": " + erro.getMessage()
    )
    );
    }

    // Versão bloqueante para uso em contextos síncronos
    public CpfData consultarSync(String cpf) {
    return consultar(cpf).block();
    }
}

// RestTemplate: sequencial (bloqueante)
public List<CpfData> loteSincrono(List<String> cpfs) {
    return cpfs.stream()
    .map(this::consultar)
    .toList();
}

// WebClient: paralelo (não-bloqueante)
public List<CpfData> loteReativo(List<String> cpfs) {
    return Flux.fromIterable(cpfs)
    .flatMap(
    cpf -> consultar(cpf)
    .onErrorResume(e -> Mono.empty()),
    10 // concorrência máxima
    )
    .collectList()
    .block();
}

// Retry com RestTemplate (usando Spring Retry)
@Retryable(
    retryFor = {ApiException.class},
    maxAttempts = 3,
    backoff = @Backoff(delay = 1000, multiplier = 2)
)
public CpfData consultarComRetry(String cpf) {
    return consultar(cpf);
}

// Retry com WebClient (nativo Reactor)
public Mono<CpfData> consultarComRetryReativo(String cpf) {
    return consultar(cpf)
    .retryWhen(
    Retry.backoff(3, Duration.ofSeconds(1))
    .maxBackoff(Duration.ofSeconds(10))
    .filter(throwable ->
    throwable instanceof ApiException
    )
    .doBeforeRetry(signal ->
    System.out.println(
    "Retentativa " + signal.totalRetries()
    )
    )
    );
}