Kommunikationsmönster för mikrotjänster (Saga, Circuit Breaker) · Lektion

Integrering i tjänsteanrop

Integrera circuit breakers i Era mikrotjänster för att kapsla in anrop till externa tjänster och skydda mot fel.

Lektion 3 av 411 steg

Integrering i tjänsteanrop är en gratis lektion i Kommunikationsmönster för mikrotjänster (Saga, Circuit Breaker) på CoddyKit. Detta är lektion 3 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Kommunikationsmönster för mikrotjänster (Saga, Circuit Breaker), och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Kommunikationsmönster för mikrotjänster (Saga, Circuit Breaker) innehåller totalt 4 lektioner.

Skydda era anrop!

Välkomna till den sista lektionen om att implementera kretsbrytare! I dag får ni arbeta praktiskt och lära er hur ni integrerar en kretsbrytare direkt i en mikrotjänsts externa anrop.

Det är avgörande att skydda dessa anrop för att bygga motståndskraftiga system som kan hantera fel på ett kontrollerat sätt och förbli responsiva, även när beroenden har problem.

Direkta tjänsteanrop

Föreställ er att er tjänst behöver data från en annan mikrotjänst. Ett vanligt sätt att göra detta är genom ett direkt metodanrop eller en HTTP-begäran. Men vad händer om den externa tjänsten är långsam eller nere?

Vi tittar på en grundläggande konfiguration utan något skydd.

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());
    }
  }
}

Simulera tjänstefel

I verkligheten är externa tjänster inte alltid felfria. De kan sluta fungera på grund av nätverksproblem, överbelastning eller buggar. Vi uppdaterar vår ExternalService så att den simulerar dessa fel slumpmässigt.

Kör koden några gånger. Ni kommer att se hur ett enda fel kan få vår Main-applikation att sluta fungera.

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(); }
    }
  }
}

Kretsbrytarens omslag

Det är här kretsbrytaren kommer in! I stället för att anropa den externa tjänsten direkt "omsluter" vi anropet med vår kretsbrytare.

Kretsbrytaren hanterar sedan anropet, avgör om det ens ska försöka genomföras (om kretsen är öppen) och hanterar fel. Här är en mycket förenklad version av hur ett sådant omslag kan se ut:

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
    }
  }
}

Grundläggande CB-integrering

Nu använder vi vår grundläggande MyCircuitBreaker för att omsluta anropen till vår opålitliga ExternalService. Observera hur Main-metoden nu använder kretsbrytarens execute-metod.

Kör koden. Även om den fortfarande visar fel är kretsbrytaren nu med och förmedlar anropen.

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(); }
    }
  }
}

Kontrollerad felhantering: fallbacks

Det är bra att fånga fel, men tänk om vi kunde tillhandahålla ett standardiserat eller alternativt svar när det primära tjänsteanropet misslyckas eller kretsen är öppen? Det är här fallbacks kommer in.

En fallback är en fördefinierad åtgärd eller ett värde som returneras när huvudåtgärden inte kan slutföras korrekt.
Den bidrar till en bättre användarupplevelse genom att förhindra totala avbrott och tillhandahålla begränsad funktionalitet.
Se det som en "plan B" för era tjänsteanrop.

Implementera fallback-logik

Vi förbättrar vår MyCircuitBreaker så att den accepterar en andra Callable: fallback-åtgärden. Om primaryCall misslyckas körs fallbackCall i stället.

Detta gör vår kretsbrytare betydligt mer användbar för att hantera fel på ett kontrollerat sätt.

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
      }
    }
  }
}

Sätt ihop allt

Nu tittar vi på helheten. Vi använder vår uppdaterade MyCircuitBreaker med både det primära tjänsteanropet och ett enkelt fallback-meddelande.

Kör koden flera gånger. När ExternalService misslyckas får ni nu fallback-meddelandet i stället för ett fel i er Main-applikation!

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(); }
    }
  }
}

Strategiska integreringspunkter

Var i arkitekturen bör ni placera kretsbrytare?

Tjänsteklienter: Omslut alla anrop som er tjänst gör till andra externa tjänster. Detta är den vanligaste placeringen.
API-gatewayer: Om ni använder en API-gateway är den en utmärkt plats för att implementera kretsbrytare för anrop till underordnade mikrotjänster och skydda frontend från direkta tjänstefel.
Dedikerade proxylager: I mycket komplexa system kan ett dedikerat proxy- eller sidecar-mönster hantera kretsbrytare transparent för alla utgående anrop.

Integrera kretsbrytare

Ni har lärt er hur externa tjänsteanrop omsluts med en kretsbrytare. Nu kontrollerar vi era kunskaper.

Besvara frågan i den interaktiva lektionen

Lektionssammanfattning

Bra gjort! I den här lektionen har ni lärt er de praktiska stegen för att integrera en kretsbrytare i era mikrotjänstanrop. Vi gick igenom:

Riskerna med oskyddade anrop till externa tjänster.
Hur ett tjänsteanrop "omsluts" med kretsbrytarens execute-metod.
Vikten av och implementeringen av fallback-åtgärder för kontrollerad degradering.
Vanliga strategiska punkter i arkitekturen där kretsbrytare kan integreras.

Genom att använda dessa tekniker kan ni avsevärt förbättra motståndskraften och stabiliteten i era distribuerade system. Fortsätt öva!

Gratis att börja

Lär dig Kommunikationsmönster för mikrotjänster (Saga, Circuit Breaker) med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 12
Lektioner: 48

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Integrering i tjänsteanrop” gratis?

Ja – hela texten till ”Integrering i tjänsteanrop” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Kommunikationsmönster för mikrotjänster (Saga, Circuit Breaker), kan Ni uppgradera till CoddyKit PRO. Kursen i Kommunikationsmönster för mikrotjänster (Saga, Circuit Breaker) innehåller totalt 4 lektioner.

Vad lär jag mig i ”Integrering i tjänsteanrop”?

Integrera circuit breakers i Era mikrotjänster för att kapsla in anrop till externa tjänster och skydda mot fel. Ni övar på Kommunikationsmönster för mikrotjänster (Saga, Circuit Breaker) med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Kommunikationsmönster för mikrotjänster (Saga, Circuit Breaker)?

Du behöver inga förkunskaper. Utbildningen i Kommunikationsmönster för mikrotjänster (Saga, Circuit Breaker) på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.

Hur lång tid tar lektionen ”Integrering i tjänsteanrop”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Kommunikationsmönster för mikrotjänster (Saga, Circuit Breaker)-lektionen?

Ja. Varje Kommunikationsmönster för mikrotjänster (Saga, Circuit Breaker)-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Kommunikationsmönster för mikrotjänster (Saga, Circuit Breaker)