Integreren in serviceaanroepen
Integreer circuit breakers in uw microservices om aanroepen van externe services te omhullen en tegen storingen te beschermen.
Integreren in serviceaanroepen is een gratis Communicatiepatronen voor microservices (Saga, Circuit Breaker)-les op CoddyKit. Dit is les 3 van 4. 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 Communicatiepatronen voor microservices (Saga, Circuit Breaker). Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Communicatiepatronen voor microservices (Saga, Circuit Breaker) bevat in totaal 4 lessen.
Bescherm je aanroepen!
Welkom bij de laatste les over het implementeren van circuitbreakers! Vandaag ga je praktisch aan de slag en leer je hoe je een circuitbreaker rechtstreeks in de externe aanroepen van je microservice integreert.
Het is cruciaal om deze aanroepen te beschermen voor het bouwen van veerkrachtige systemen die fouten netjes kunnen afhandelen en responsief blijven, zelfs wanneer afhankelijkheden problemen ondervinden.
Rechtstreekse serviceaanroepen
Stel je voor dat je service gegevens nodig heeft van een andere microservice. Een gebruikelijke manier om dit te doen is een rechtstreekse methodeaanroep of een HTTP-aanvraag. Maar wat gebeurt er als die externe service traag of niet beschikbaar is?
Laten we kijken naar een eenvoudige opstelling zonder enige bescherming.
import java.util.concurrent.ThreadLocalRandom;
class ExternalService {
public String getData() throws Exception {
System.out.println("ExternalService: Attempting to get data...");
// Simulate success for now
return "Data from external service";
}
}
public class Main {
public static void main(String[] args) {
ExternalService service = new ExternalService();
try {
String result = service.getData();
System.out.println("Result: " + result);
} catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
}Een servicefout simuleren
Externe services zijn in de praktijk niet altijd perfect. Ze kunnen uitvallen door netwerkproblemen, overbelasting of bugs. Laten we onze ExternalService aanpassen om deze fouten willekeurig te simuleren.
Voer de code een paar keer uit. Je ziet hoe één fout onze Main-applicatie kan laten vastlopen.
import java.util.concurrent.ThreadLocalRandom;
class ExternalService {
private int callCount = 0;
public String getData() throws Exception {
callCount++;
System.out.println("ExternalService: Call #" + callCount);
// Simulate failure 50% of the time
if (ThreadLocalRandom.current().nextDouble() < 0.5) {
throw new RuntimeException("Simulated External Service Failure!");
}
return "Data from external service (call #" + callCount + ")";
}
}
public class Main {
public static void main(String[] args) {
ExternalService service = new ExternalService();
for (int i = 0; i < 3; i++) {
System.out.println("--- Attempt " + (i + 1) + " ---");
try {
String result = service.getData();
System.out.println("Result: " + result);
} catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
System.out.println();
try { Thread.sleep(200); } catch (InterruptedException e) { Thread.currentThread().interrupt(); }
}
}
}De circuitbreaker-wrapper
Hier komt de circuitbreaker van pas! In plaats van de externe service rechtstreeks aan te roepen, wikkelen we de aanroep in met onze circuitbreaker.
De circuitbreaker beheert de aanroep vervolgens, bepaalt of deze überhaupt moet worden uitgevoerd (als het circuit open is) en handelt fouten af. Hier zie je een sterk vereenvoudigde versie van zo'n wrapper:
import java.util.concurrent.Callable;
class MyCircuitBreaker {
// In a real CB, this would manage state (open, closed, half-open)
// and apply thresholds. For this lesson, we focus on the integration.
public <T> T execute(Callable<T> primaryCall) throws Exception {
try {
System.out.println("CB: Executing primary call...");
return primaryCall.call(); // Attempt the actual service call
} catch (Exception e) {
// A real CB would update its state here (e.g., trip the circuit)
System.err.println("CB: Primary call failed: " + e.getMessage());
throw e; // Re-throw for now, we'll add fallback later
}
}
}Basisintegratie van de circuitbreaker
Nu gebruiken we onze eenvoudige MyCircuitBreaker om de aanroepen naar onze onbetrouwbare ExternalService in te wikkelen. Let erop dat de Main-methode nu de execute-methode van de circuitbreaker gebruikt.
Voer deze code uit. Hoewel er nog steeds fouten worden weergegeven, is de circuitbreaker nu betrokken bij het bemiddelen van de aanroepen.
import java.util.concurrent.Callable;
import java.util.concurrent.ThreadLocalRandom;
// --- MyCircuitBreaker (Simplified) ---
class MyCircuitBreaker {
public <T> T execute(Callable<T> primaryCall) throws Exception {
try {
System.out.println("CB: Executing primary call...");
return primaryCall.call();
} catch (Exception e) {
System.err.println("CB: Primary call failed: " + e.getMessage());
throw e;
}
}
}
// --- ExternalService (from previous scene) ---
class ExternalService {
private int callCount = 0;
public String getData() throws Exception {
callCount++;
System.out.println("ExternalService: Call #" + callCount);
if (ThreadLocalRandom.current().nextDouble() < 0.5) {
throw new RuntimeException("Simulated External Service Failure!");
}
return "Data from external service (call #" + callCount + ")";
}
}
// --- Main Application ---
public class Main {
public static void main(String[] args) {
ExternalService service = new ExternalService();
MyCircuitBreaker circuitBreaker = new MyCircuitBreaker();
for (int i = 0; i < 3; i++) {
System.out.println("--- Attempt " + (i + 1) + " ---");
try {
String result = circuitBreaker.execute(
() -> service.getData() // The operation to protect
);
System.out.println("Result: " + result);
} catch (Exception e) {
System.err.println("Main: Caught error after CB: " + e.getMessage());
}
System.out.println();
try { Thread.sleep(200); } catch (InterruptedException e) { Thread.currentThread().interrupt(); }
}
}
}Fouten netjes afhandelen: terugvalopties
Fouten opvangen is goed, maar wat als we een standaard of alternatief antwoord kunnen geven wanneer de primaire serviceaanroep mislukt of het circuit open is? Daar komen terugvalopties van pas.
- Een terugvaloptie is een vooraf gedefinieerde actie of waarde die wordt teruggegeven wanneer de hoofd bewerking niet succesvol kan worden voltooid.
- Dit helpt een goede gebruikerservaring te behouden door volledige uitval te voorkomen en gedeeltelijke functionaliteit te bieden.
- Zie het als een 'plan B' voor je serviceaanroepen.
Terugvallogica implementeren
We breiden onze MyCircuitBreaker uit zodat deze een tweede Callable accepteert: de terugvalbewerking. Als de primaryCall mislukt, wordt in plaats daarvan de fallbackCall uitgevoerd.
Hierdoor is onze circuitbreaker veel bruikbaarder voor het netjes afhandelen van fouten.
import java.util.concurrent.Callable;
class MyCircuitBreaker {
public <T> T execute(Callable<T> primaryCall, Callable<T> fallbackCall) {
try {
System.out.println("CB: Executing primary call...");
return primaryCall.call();
} catch (Exception e) {
System.err.println("CB: Primary call failed. Invoking fallback: " + e.getMessage());
try {
// If primary fails, invoke the fallback
return fallbackCall.call();
} catch (Exception fallbackE) {
System.err.println("CB: Fallback call also failed: " + fallbackE.getMessage());
return null; // Or throw a specific exception if fallback is critical
}
}
}
}Alles samenbrengen
Nu bekijken we het volledige plaatje. We gebruiken onze bijgewerkte MyCircuitBreaker met zowel de primaire serviceaanroep als een eenvoudig terugvalbericht.
Voer deze code meerdere keren uit. Wanneer de ExternalService mislukt, krijg je nu het terugvalbericht in plaats van een fout in je Main-applicatie!
import java.util.concurrent.Callable;
import java.util.concurrent.ThreadLocalRandom;
// --- MyCircuitBreaker (with Fallback) ---
class MyCircuitBreaker {
public <T> T execute(Callable<T> primaryCall, Callable<T> fallbackCall) {
try {
System.out.println("CB: Executing primary call...");
return primaryCall.call();
} catch (Exception e) {
System.err.println("CB: Primary call failed. Invoking fallback: " + e.getMessage());
try {
return fallbackCall.call();
} catch (Exception fallbackE) {
System.err.println("CB: Fallback call also failed: " + fallbackE.getMessage());
return null;
}
}
}
}
// --- ExternalService (with failures) ---
class ExternalService {
private int callCount = 0;
public String getData() throws Exception {
callCount++;
System.out.println("ExternalService: Call #" + callCount);
if (ThreadLocalRandom.current().nextDouble() < 0.5) {
throw new RuntimeException("Simulated External Service Failure!");
}
return "Data from external service (call #" + callCount + ")";
}
}
// --- Main Application ---
public class Main {
public static void main(String[] args) {
ExternalService service = new ExternalService();
MyCircuitBreaker circuitBreaker = new MyCircuitBreaker();
System.out.println("Attempting to fetch data with Circuit Breaker and Fallback:");
for (int i = 0; i < 5; i++) {
System.out.println("--- Attempt " + (i + 1) + " ---");
String result = circuitBreaker.execute(
() -> service.getData(), // Primary operation
() -> "Fallback: Service is currently unavailable." // Fallback operation
);
System.out.println("Result: " + result);
System.out.println();
try { Thread.sleep(200); } catch (InterruptedException e) { Thread.currentThread().interrupt(); }
}
}
}Strategische integratiepunten
Waar moet je precies circuitbreakers in je architectuur plaatsen?
- Serviceclients: wikkel alle aanroepen van je service naar andere externe services in. Dit is de meest gebruikelijke plek.
- API-gateways: als je een API-gateway gebruikt, is dit een uitstekende plek om circuitbreakers te implementeren voor aanroepen naar onderliggende microservices. Zo bescherm je je frontend tegen rechtstreekse servicefouten.
- Toegewijde proxylagen: bij zeer complexe systemen kan een toegewijde proxy of sidecarpatroon circuitbreakers transparant beheren voor alle uitgaande aanroepen.
Circuitbreakers integreren
Je hebt geleerd hoe je externe serviceaanroepen met een circuitbreaker kunt omwikkelen. Laten we controleren of je het begrijpt.
Samenvatting van de les
Goed gedaan! In deze les heb je geleerd hoe je praktisch een circuitbreaker in de aanroepen van je microservice integreert. We hebben behandeld:
- De risico's van onbeschermde externe serviceaanroepen.
- Hoe je een serviceaanroep omwikkelt met de
execute-methode van een circuitbreaker. - Het belang en de implementatie van terugvalbewerkingen voor nette degradatie.
- Veelvoorkomende strategische plekken in je architectuur voor het integreren van circuitbreakers.
Door deze technieken toe te passen kun je de veerkracht en stabiliteit van je gedistribueerde systemen aanzienlijk verbeteren. Blijf oefenen!
Leer Communicatiepatronen voor microservices (Saga, Circuit Breaker) 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
- 12
- Lessen
- 48
Veelgestelde vragen
Is de les “Integreren in serviceaanroepen” gratis?
Ja — de volledige tekst van “Integreren in serviceaanroepen” 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 Communicatiepatronen voor microservices (Saga, Circuit Breaker) wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Communicatiepatronen voor microservices (Saga, Circuit Breaker) bevat in totaal 4 lessen.
Wat leer ik in “Integreren in serviceaanroepen”?
Integreer circuit breakers in uw microservices om aanroepen van externe services te omhullen en tegen storingen te beschermen. Je oefent met Communicatiepatronen voor microservices (Saga, Circuit Breaker) 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 Communicatiepatronen voor microservices (Saga, Circuit Breaker) te beginnen?
Ervaring vooraf is niet nodig. Communicatiepatronen voor microservices (Saga, Circuit Breaker) 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 3 van 4.
Hoe lang duurt de les “Integreren in serviceaanroepen”?
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 Communicatiepatronen voor microservices (Saga, Circuit Breaker)?
Ja. Elke les over Communicatiepatronen voor microservices (Saga, Circuit Breaker) 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
- Een circuit breaker-bibliotheek kiezen
- Circuit breaker-instanties configureren
- Integreren in serviceaanroepen
- Fallbacks toevoegen aan circuit breakers