HTTP Clients: RestTemplate vs WebClient vs RestClient

RestTemplate restTemplate = new RestTemplate();

// GET — returns body directly
String result = restTemplate.getForObject(
    "https://api.example.com/users/{id}", String.class, 1);

// GET — returns ResponseEntity (headers + status + body)
ResponseEntity<User> response = restTemplate.getForEntity(
    "https://api.example.com/users/{id}", User.class, 1);

// POST — returns created resource location
URI location = restTemplate.postForLocation(
    "https://api.example.com/users", newUser);

// POST — returns the created object
User created = restTemplate.postForObject(
    "https://api.example.com/users", newUser, User.class);

// Generic exchange — full control over method, headers, body
ResponseEntity<User> entity = restTemplate.exchange(
    "https://api.example.com/users/{id}",
    HttpMethod.GET,
    new HttpEntity<>(headers),
    User.class,
    1
);

// Execute — lowest level, full control with callbacks
restTemplate.execute(url, HttpMethod.GET, 
    requestCallback, responseExtractor);

// Custom error handler
restTemplate.setErrorHandler(new ResponseErrorHandler() {
    @Override
    public boolean hasError(ClientHttpResponse response) throws IOException {
        return response.getStatusCode().isError();
    }

    @Override
    public void handleError(ClientHttpResponse response) throws IOException {
        if (response.getStatusCode() == HttpStatus.NOT_FOUND) {
            throw new ResourceNotFoundException("Resource not found");
        }
        if (response.getStatusCode().is5xxServerError()) {
            throw new ExternalServiceException("Downstream service failed");
        }
    }
});

@Bean
public RestTemplate restTemplate() {
    // Connection pool configuration
    PoolingHttpClientConnectionManager connManager = 
        new PoolingHttpClientConnectionManager();
    connManager.setMaxTotal(100);           // max total connections
    connManager.setDefaultMaxPerRoute(20);  // max per host

    CloseableHttpClient httpClient = HttpClients.custom()
        .setConnectionManager(connManager)
        .setDefaultRequestConfig(RequestConfig.custom()
            .setConnectTimeout(Timeout.ofSeconds(3))
            .setResponseTimeout(Timeout.ofSeconds(5))
            .build())
        .build();

    HttpComponentsClientHttpRequestFactory factory = 
        new HttpComponentsClientHttpRequestFactory(httpClient);

    return new RestTemplate(factory);
}

// Logging interceptor
public class LoggingInterceptor implements ClientHttpRequestInterceptor {
    @Override
    public ClientHttpResponse intercept(HttpRequest request, byte[] body,
            ClientHttpRequestExecution execution) throws IOException {
        log.info("Request: {} {}", request.getMethod(), request.getURI());
        long start = System.currentTimeMillis();

        ClientHttpResponse response = execution.execute(request, body);

        log.info("Response: {} in {}ms", 
            response.getStatusCode(), System.currentTimeMillis() - start);
        return response;
    }
}

restTemplate.setInterceptors(List.of(
    new LoggingInterceptor(),
    new AuthTokenInterceptor()
));

@Bean
public WebClient webClient() {
    // Connection provider with pooling
    ConnectionProvider provider = ConnectionProvider.builder("custom")
        .maxConnections(100)
        .maxIdleTime(Duration.ofSeconds(20))
        .maxLifeTime(Duration.ofSeconds(60))
        .pendingAcquireTimeout(Duration.ofSeconds(5))
        .evictInBackground(Duration.ofSeconds(30))
        .build();

    // HTTP client with timeouts
    HttpClient httpClient = HttpClient.create(provider)
        .option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 3000)
        .responseTimeout(Duration.ofSeconds(5))
        .doOnConnected(conn -> conn
            .addHandlerLast(new ReadTimeoutHandler(5))
            .addHandlerLast(new WriteTimeoutHandler(5)));

    return WebClient.builder()
        .baseUrl("https://api.example.com")
        .clientConnector(new ReactorClientHttpConnector(httpClient))
        .defaultHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE)
        .defaultHeader(HttpHeaders.ACCEPT, MediaType.APPLICATION_JSON_VALUE)
        .filter(logRequest())
        .filter(logResponse())
        .codecs(configurer -> configurer
            .defaultCodecs()
            .maxInMemorySize(16 * 1024 * 1024)) // 16MB buffer
        .build();
}

// GET single item — returns Mono<User>
Mono<User> userMono = webClient.get()
    .uri("/users/{id}", 1)
    .retrieve()
    .bodyToMono(User.class);

// GET collection — returns Flux<User>
Flux<User> usersFlux = webClient.get()
    .uri("/users")
    .retrieve()
    .bodyToFlux(User.class);

// POST with body
Mono<User> created = webClient.post()
    .uri("/users")
    .bodyValue(newUser)
    .retrieve()
    .bodyToMono(User.class);

// Subscribe to trigger execution (reactive)
userMono.subscribe(
    user -> log.info("Got user: {}", user),
    error -> log.error("Failed: {}", error.getMessage()),
    () -> log.info("Completed")
);

// When you MUST have the result synchronously (e.g., in a @Service)
User user = webClient.get()
    .uri("/users/{id}", 1)
    .retrieve()
    .bodyToMono(User.class)
    .block(Duration.ofSeconds(5)); // blocks current thread

// Collect Flux to List
List<User> users = webClient.get()
    .uri("/users")
    .retrieve()
    .bodyToFlux(User.class)
    .collectList()
    .block(Duration.ofSeconds(10));

// Logging filter
private ExchangeFilterFunction logRequest() {
    return ExchangeFilterFunction.ofRequestProcessor(request -> {
        log.info("Request: {} {}", request.method(), request.url());
        return Mono.just(request);
    });
}

// Auth token injection filter
private ExchangeFilterFunction authFilter() {
    return (request, next) -> {
        ClientRequest newRequest = ClientRequest.from(request)
            .header("Authorization", "Bearer " + tokenService.getToken())
            .build();
        return next.exchange(newRequest);
    };
}

// Retry filter with exponential backoff
private ExchangeFilterFunction retryFilter() {
    return (request, next) -> next.exchange(request)
        .flatMap(response -> {
            if (response.statusCode().is5xxServerError()) {
                return Mono.error(new ServerException("Server error"));
            }
            return Mono.just(response);
        })
        .retryWhen(Retry.backoff(3, Duration.ofMillis(500))
            .filter(ex -> ex instanceof ServerException));
}

// Using onStatus (preferred)
Mono<User> user = webClient.get()
    .uri("/users/{id}", 1)
    .retrieve()
    .onStatus(HttpStatusCode::is4xxClientError, response ->
        response.bodyToMono(ErrorResponse.class)
            .flatMap(error -> Mono.error(
                new ResourceNotFoundException(error.getMessage()))))
    .onStatus(HttpStatusCode::is5xxServerError, response ->
        Mono.error(new ExternalServiceException("Downstream failed")))
    .bodyToMono(User.class);

// Using exchangeToMono (full response access)
Mono<User> user = webClient.get()
    .uri("/users/{id}", 1)
    .exchangeToMono(response -> {
        if (response.statusCode().is2xxSuccessful()) {
            return response.bodyToMono(User.class);
        } else if (response.statusCode() == HttpStatus.NOT_FOUND) {
            return Mono.empty();
        } else {
            return response.createError();
        }
    });

@Bean
public RestClient restClient() {
    return RestClient.builder()
        .baseUrl("https://api.example.com")
        .defaultHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE)
        .requestFactory(new HttpComponentsClientHttpRequestFactory(httpClient))
        .requestInterceptor(new LoggingInterceptor())
        .build();
}

// GET single item — returns the object directly (no Mono/Flux)
User user = restClient.get()
    .uri("/users/{id}", 1)
    .retrieve()
    .body(User.class);

// GET with ResponseEntity
ResponseEntity<User> response = restClient.get()
    .uri("/users/{id}", 1)
    .retrieve()
    .toEntity(User.class);

// POST with body
User created = restClient.post()
    .uri("/users")
    .contentType(MediaType.APPLICATION_JSON)
    .body(newUser)
    .retrieve()
    .body(User.class);

// DELETE
restClient.delete()
    .uri("/users/{id}", 1)
    .retrieve()
    .toBodilessEntity();

// Exchange — for complex response handling
User user = restClient.get()
    .uri("/users/{id}", 1)
    .exchange((request, response) -> {
        if (response.getStatusCode().is4xxClientError()) {
            throw new ResourceNotFoundException("User not found");
        }
        return objectMapper.readValue(
            response.getBody(), User.class);
    });

User user = restClient.get()
    .uri("/users/{id}", 1)
    .retrieve()
    .onStatus(HttpStatusCode::is4xxClientError, (request, response) -> {
        throw new ResourceNotFoundException(
            "User not found: " + response.getStatusCode());
    })
    .onStatus(HttpStatusCode::is5xxServerError, (request, response) -> {
        throw new ExternalServiceException(
            "Service unavailable: " + response.getStatusCode());
    })
    .body(User.class);

// Define the client as an interface
@FeignClient(name = "user-service", url = "${user-service.url}",
    configuration = FeignConfig.class,
    fallback = UserClientFallback.class)
public interface UserClient {

    @GetMapping("/users/{id}")
    User getUser(@PathVariable Long id);

    @PostMapping("/users")
    User createUser(@RequestBody User user);

    @GetMapping("/users")
    List<User> getAllUsers(@RequestParam("page") int page);
}

// Use it like any Spring bean
@Service
public class UserService {
    private final UserClient userClient;

    public User getUser(Long id) {
        return userClient.getUser(id); // Just call the method!
    }
}

@Configuration
public class FeignConfig {
    @Bean
    public RequestInterceptor authInterceptor() {
        return template -> template.header(
            "Authorization", "Bearer " + tokenService.getToken());
    }

    @Bean
    public ErrorDecoder errorDecoder() {
        return new CustomErrorDecoder();
    }

    @Bean
    public Retryer retryer() {
        return new Retryer.Default(100, 1000, 3);
    }
}