Microservices Communication Patterns (Saga, Circuit Breaker) · Lekcja

Integracja z wywołaniami usług

Proszę zintegrować mechanizmy circuit breaker z mikrousługami, aby opakować wywołania zewnętrznych usług i chronić system przed awariami.

Lekcja 3 z 411 kroki

Integracja z wywołaniami usług to bezpłatna lekcja Microservices Communication Patterns (Saga, Circuit Breaker) na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Microservices Communication Patterns (Saga, Circuit Breaker), a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Microservices Communication Patterns (Saga, Circuit Breaker) zawiera 4 lekcji w sumie.

Części tej lekcji nie zostały jeszcze przetłumaczone i są wyświetlane po angielsku.

Wrap Up Your Calls!

Welcome to the final lesson on implementing Circuit Breakers! Today, we'll get hands-on and learn how to integrate a circuit breaker directly into your microservice's external calls.

Protecting these calls is crucial for building resilient systems that can gracefully handle failures and maintain responsiveness, even when dependencies are struggling.

Direct Service Calls

Imagine your service needs data from another microservice. A common way to do this is a direct method call or HTTP request. But what happens if that external service is slow or down?

Let's look at a basic setup without any protection.

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

Simulating Service Failure

In the real world, external services aren't always perfect. They can fail due to network issues, overload, or bugs. Let's update our ExternalService to simulate these failures randomly.

Run the code a few times. You'll see how a single failure can break our Main application.

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

The Circuit Breaker Wrapper

This is where the Circuit Breaker comes in! Instead of calling the external service directly, we 'wrap' the call with our circuit breaker.

The circuit breaker then manages the call, decides if it should even be attempted (if the circuit is open), and handles failures. Here's a very simplified version of how such a wrapper might look:

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

Basic CB Integration

Now let's use our basic MyCircuitBreaker to wrap the calls to our unreliable ExternalService. Notice how the Main method now uses the circuit breaker's execute method.

Run this code. While it still shows errors, the circuit breaker is now involved in mediating the calls.

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

Graceful Failure: Fallbacks

Catching errors is good, but what if we could provide a default or alternative response when the primary service call fails or the circuit is open? This is where fallbacks come in.

A fallback is a predefined action or value that gets returned when the main operation cannot complete successfully.
It helps maintain a good user experience by preventing total outages and providing partial functionality.
Think of it as a 'plan B' for your service calls.

Implementing Fallback Logic

We'll enhance our MyCircuitBreaker to accept a second Callable: the fallback operation. If the primaryCall fails, the fallbackCall will be executed instead.

This makes our circuit breaker much more useful for handling failures gracefully.

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

Putting It All Together

Now, let's see the full picture. We'll use our updated MyCircuitBreaker with both the primary service call and a simple fallback message.

Run this code multiple times. When the ExternalService fails, you'll now get the fallback message instead of an error in your Main application!

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

Strategic Integration Points

Where exactly should you place circuit breakers in your architecture?

Service Clients: Wrap all calls made from your service to other external services. This is the most common place.
API Gateways: If you use an an API Gateway, it's an excellent place to implement circuit breakers for calls to downstream microservices, protecting your frontend from direct service failures.
Dedicated Proxy Layers: For very complex systems, a dedicated proxy or sidecar pattern can manage circuit breakers transparently for all outbound calls.

Integrating Circuit Breakers

You've learned how to wrap external service calls with a Circuit Breaker. Let's check your understanding.

Odpowiedz w interaktywnej lekcji

Lesson Summary

Great job! In this lesson, you've learned the practical steps of integrating a circuit breaker into your microservice calls. We covered:

The risks of unprotected external service calls.
How to 'wrap' a service call using a circuit breaker's execute method.
The importance and implementation of fallback operations for graceful degradation.
Common strategic points in your architecture for integrating circuit breakers.

By applying these techniques, you can significantly enhance the resilience and stability of your distributed systems. Keep practicing!

Bezpłatny start

Ucz się Microservices Communication Patterns (Saga, Circuit Breaker) dzięki korepetycjom AI — za darmo

Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.

Kursy: 12
Lekcje: 48

Zacznij naukę bezpłatnie Wyświetl pełny kurs

Często zadawane pytania

Czy lekcja „Integracja z wywołaniami usług” jest bezpłatna?

Tak — pełny tekst „Integracja z wywołaniami usług” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Microservices Communication Patterns (Saga, Circuit Breaker), przejdź na CoddyKit PRO. Kurs Microservices Communication Patterns (Saga, Circuit Breaker) zawiera 4 lekcji w sumie.

Co nauczysz się w „Integracja z wywołaniami usług”?

Proszę zintegrować mechanizmy circuit breaker z mikrousługami, aby opakować wywołania zewnętrznych usług i chronić system przed awariami. Ćwiczysz Microservices Communication Patterns (Saga, Circuit Breaker) z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Microservices Communication Patterns (Saga, Circuit Breaker)?

Nie wymagamy żadnego doświadczenia. Microservices Communication Patterns (Saga, Circuit Breaker) w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.

Ile czasu zajmuje lekcja „Integracja z wywołaniami usług”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Microservices Communication Patterns (Saga, Circuit Breaker)?

Tak. Każda lekcja Microservices Communication Patterns (Saga, Circuit Breaker) zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

Wybór biblioteki circuit breaker
Konfigurowanie instancji circuit breaker
Integracja z wywołaniami usług
Dodawanie mechanizmów fallback do circuit breakerów

← Powrót do Microservices Communication Patterns (Saga, Circuit Breaker)