Fallbacks en time-outs implementeren
Configureer nette fallbacks en time-outs voor onbetrouwbare serviceaanroepen.
Fallbacks en time-outs implementeren is een gratis Spring Boot 4-microservices en REST-API's-les op CoddyKit. Dit is les 2 van 3. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Spring Boot 4-microservices en REST-API's. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Spring Boot 4-microservices en REST-API's bevat in totaal 3 lessen.
Robuuste services bouwen
In microservices zijn services vaak afhankelijk van elkaar. Wat gebeurt er als één service traag is of uitvalt?
In deze les verkennen we time-outs en terugvalmechanismen, cruciale patronen om je applicaties bestand te maken tegen zulke problemen.
Omgaan met onbetrouwbare aanroepen
Stel dat je gebruikersservice een productservice aanroept. Als de productservice blijft hangen, kan je gebruikersservice oneindig lang blijven wachten.
- Uitputting van resources: threads blijven hangen en verbruiken geheugen en CPU.
- Slechte gebruikerservaring: gebruikers moeten lang wachten of krijgen een app die niet reageert.
- Kettingreacties door fouten: één trage service kan ervoor zorgen dat andere services uitvallen.
Aanroep-time-outs begrijpen
Een time-out is de maximale tijd die een bewerking mag duren. Als de bewerking niet binnen deze tijd is voltooid, wordt ze afgebroken.
- Verbindingstime-out: hoe lang je wacht tot een verbinding tot stand komt.
- Lees-time-out: hoe lang je wacht op gegevens nadat een verbinding tot stand is gebracht.
Time-outs voorkomen dat je applicatie voor altijd op een niet-reagerende service blijft wachten.
Basis-time-outs configureren
Je kunt time-outs configureren voor HTTP-clients zoals Spring's RestTemplate of WebClient. Dit voorbeeld laat een eenvoudige configuratie van RestTemplate zien.
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;
import org.springframework.boot.web.client.RestTemplateBuilder;
import java.time.Duration;
@SpringBootApplication
public class TimeoutApp {
public static void main(String[] args) {
SpringApplication.run(TimeoutApp.class, args);
}
@Bean
public RestTemplate restTemplate(RestTemplateBuilder builder) {
return builder
.setConnectTimeout(Duration.ofSeconds(1)) // 1 second to connect
.setReadTimeout(Duration.ofSeconds(2)) // 2 seconds to read data
.build();
}
// In a real app, you'd inject and use this RestTemplate
// e.g., restTemplate.getForObject("http://localhost:8081/slow-service", String.class);
}Gecontroleerde degradatie met terugvalmechanismen
Zelfs met time-outs kan een serviceaanroep nog steeds mislukken, bijvoorbeeld door netwerkproblemen of doordat de service niet beschikbaar is. Een terugvalmechanisme biedt een alternatieve actie of standaardwaarde wanneer de primaire bewerking mislukt.
Zo kan je applicatie op een gecontroleerde manier blijven antwoorden, zelfs als de functionaliteit beperkt is.
Eenvoudige terugvallogica
Je kunt terugvalmechanismen handmatig implementeren met blokken try-catch. Zo kun je uitzonderingen afhandelen en een standaardantwoord teruggeven.
Bekijk een eenvoudige methode die gebruikersgegevens ophaalt:
public class UserService {
public String getUserName(int userId) {
try {
// Simulate a network call that might fail
if (userId == 101) {
throw new RuntimeException("Service unavailable!");
}
return "User " + userId + " Details";
} catch (Exception e) {
// This is our fallback logic!
System.out.println("Error fetching user " + userId + ". Returning default.");
return "Guest User"; // Fallback value
}
}
public static void main(String[] args) {
UserService service = new UserService();
System.out.println(service.getUserName(100)); // Works
System.out.println(service.getUserName(101)); // Fails, returns fallback
}
}Resilience4j voor terugvalmechanismen
Terugvalmechanismen handmatig beheren kan ingewikkeld worden. Bibliotheken zoals Resilience4j bieden declaratieve manieren om patronen voor veerkracht te implementeren, waaronder terugvalmechanismen.
Resilience4j integreert goed met Spring Boot en stelt je in staat een fallbackMethod op te geven die wordt aangeroepen wanneer de primaire methode mislukt.
Declaratieve terugvalmechanismen met Resilience4j
Met de annotatie @CircuitBreaker van Resilience4j kun je een fallbackMethod definiëren. Deze methode wordt aangeroepen als de hoofdmethode mislukt of als de circuit breaker open is.
Eerst heb je de afhankelijkheid van Resilience4j nodig. Daarna kun je deze toepassen:
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.stereotype.Service;
import org.springframework.beans.factory.annotation.Autowired;
import io.github.resilience4j.circuitbreaker.annotation.CircuitBreaker;
@SpringBootApplication
@RestController
public class ResilienceApp {
@Autowired
private ProductService productService;
public static void main(String[] args) {
SpringApplication.run(ResilienceApp.class, args);
}
@GetMapping("/product-info")
public String getProductDetails() {
return productService.getProduct();
}
}
@Service
class ProductService {
private int callCount = 0;
@CircuitBreaker(name = "productService", fallbackMethod = "fallbackGetProduct")
public String getProduct() {
callCount++;
if (callCount % 3 != 0) { // Simulate failure 2 out of 3 times
throw new RuntimeException("Product service is down!");
}
return "Product A Details";
}
// This is the fallback method
public String fallbackGetProduct(Throwable t) {
System.out.println("Fallback activated: " + t.getMessage());
return "Default Product (Fallback)";
}
}Pas je kennis toe
Je hebt een microservice die een externe betalingsgateway aanroept. Deze gateway is soms traag of valt uit.
Welke combinatie van patronen voor veerkracht zorgt er het best voor dat je service responsief blijft en een gebruiksvriendelijke ervaring biedt, zelfs als de betalingsgateway onbetrouwbaar is?
Samenvatting van de les
We hebben geleerd hoe time-outs en terugvalmechanismen essentieel zijn voor het bouwen van robuuste microservices:
- Time-outs voorkomen dat serviceaanroepen oneindig lang blijven wachten en besparen resources.
- Terugvalmechanismen bieden alternatieve antwoorden wanneer primaire bewerkingen mislukken en zorgen voor gecontroleerde degradatie.
Deze patronen verbeteren de gebruikerservaring en voorkomen kettingreacties door fouten in gedistribueerde systemen. Blijf oefenen om steeds robuustere applicaties te bouwen!
Leer Java met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 24
- Lessen
- 93
Veelgestelde vragen
Is de les “Fallbacks en time-outs implementeren” gratis?
Ja — de volledige tekst van “Fallbacks en time-outs implementeren” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Spring Boot 4-microservices en REST-API's wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Spring Boot 4-microservices en REST-API's bevat in totaal 3 lessen.
Wat leer ik in “Fallbacks en time-outs implementeren”?
Configureer nette fallbacks en time-outs voor onbetrouwbare serviceaanroepen. Je oefent met Spring Boot 4-microservices en REST-API's door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met Spring Boot 4-microservices en REST-API's te beginnen?
Ervaring vooraf is niet nodig. Spring Boot 4-microservices en REST-API's op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 3.
Hoe lang duurt de les “Fallbacks en time-outs implementeren”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over Spring Boot 4-microservices en REST-API's?
Ja. Elke les over Spring Boot 4-microservices en REST-API's bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Circuit breakers met Resilience4j
- Fallbacks en time-outs implementeren
- Gedistribueerde tracing met Zipkin