11. API Clients & External Calls

RU | EN | DE

1. RestTemplate (Synchronous Client)

📌 Old, but still used. Considered deprecated in Spring 6, but it’s important to know. 📄 Bean configuration:

@Configuration
public class RestTemplateConfig {
    @Bean
    public RestTemplate restTemplate(RestTemplateBuilder builder) {
        return builder
                .setConnectTimeout(Duration.ofSeconds(3))
                .setReadTimeout(Duration.ofSeconds(5))
                .build();
    }
}

📄 Usage examples:

@Service
@RequiredArgsConstructor
public class WeatherService {
    private final RestTemplate restTemplate;
    public WeatherDto getWeather(String city) {
        String url = "https://api.weather.com/city/" + city;
        return restTemplate.getForObject(url, WeatherDto.class);
    }
    public void createUser(UserDto user) {
        restTemplate.postForEntity("http://localhost:8080/api/users", user, Void.class);
    }
}

2. WebClient (Reactive Client)

📌 Modern alternative to RestTemplate. Supports asynchronicity and reactivity.

📄 Bean configuration:

@Configuration
public class WebClientConfig {
    @Bean
    public WebClient webClient(WebClient.Builder builder) {
        return builder.baseUrl("https://api.weather.com")
                       .defaultHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE)
                       .build();
    }
}

📄 Usage:

@Service
@RequiredArgsConstructor
public class WeatherService {
    private final WebClient webClient;
    public Mono<WeatherDto> getWeather(String city) {
        return webClient.get()
                       .uri("/city/{city}", city)
                       .retrieve()
                       .bodyToMono(WeatherDto.class);
    }
 
    public Flux<UserDto> getUsers() {
        return webClient.get()
                       .uri("/api/users")
                       .retrieve()
                       .bodyToFlux(UserDto.class);
    }
}
 
📌 Mono<T> = a single object (analogous to Optional),
Flux<T> = a stream of objects (like List).

3. OpenFeign (Declarative Client)

📌 If you have microservices → the best choice. No need to manually write RestTemplate or WebClient.

📄 Dependency:

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

📄 Integration:

@SpringBootApplication
@EnableFeignClients
public class DemoApplication {}

📄 Interface client:

@FeignClient(name = "userClient", url = "http://localhost:8080/api/users")
public interface UserClient {
    @GetMapping("/{id}")
    UserDto getUser(@PathVariable Long id);
    @PostMapping
    UserDto createUser(@RequestBody UserDto dto);
}

📄 Usage:

@Service
@RequiredArgsConstructor
public class UserService {
    private final UserClient client;
    public UserDto get(Long id) {
        return client.getUser(id);
    }
}

4. Retry & Timeout (Resilience4j)

📌 Sometimes an external API fails → you need to retry or limit the waiting time.

📄 Dependency:

<dependency>
    <groupId>io.github.resilience4j</groupId>
    <artifactId>resilience4j-spring-boot3</artifactId>
</dependency>

📄 Configuration:

resilience4j.retry:
    instances:
        apiRetry:
            maxAttempts: 3
            waitDuration: 2s

📄 Usage:

@Service
public class ExternalService {
    @Retry(name = "apiRetry")
    public String callApi() {
        if (Math.random() > 0.7) {
            return "Success!";
        }
        throw new RuntimeException("API failed");
    }
}

5. Circuit Breaker (Fuse)

📌 To prevent overloading the service with constant requests if it’s already failing.

📄 Configuration:

resilience4j.circuitbreaker:
    instances:
        apiBreaker:
            failureRateThreshold: 50
            waitDurationInOpenState: 10s
            slidingWindowSize: 10

📄 Usage:

@Service
public class ExternalService {
    @CircuitBreaker(name = "apiBreaker", fallbackMethod = "fallback")
    public String callApi() {
        throw new RuntimeException("API error");
    }
    public String fallback(Throwable t) {
        return "Fallback response";
    }
}

6. Async API calls (Parallel requests)

CompletableFuture:

@Async
public CompletableFuture<UserDto> fetchUser(Long id) {
    return CompletableFuture.supplyAsync(() -> client.getUser(id));
}

WebClient:

Flux<UserDto> users = webClient.get()
    .uri("/api/users")
    .retrieve()
    .bodyToFlux(UserDto.class);

7. Best Practices

• ✅ For synchronous APIs → RestTemplate (deprecated, but still encountered).
• ✅ For asynchronous/reactive services → WebClient.
• ✅ For microservices → Feign.
• ✅ Add retry, timeout, circuit breaker using Resilience4j.
• ✅ Never make external calls without timeouts.
• ✅ Log all requests/responses (Spring Boot Sleuth or custom LoggingInterceptor).