{"id":472,"date":"2024-06-28T21:59:40","date_gmt":"2024-06-28T20:59:40","guid":{"rendered":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/?p=472"},"modified":"2024-07-04T22:09:04","modified_gmt":"2024-07-04T21:09:04","slug":"circuit-breaker-mit-resilience4j-in-java","status":"publish","type":"post","link":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/?p=472","title":{"rendered":"Circuit Breaker mit Resilience4j in Java"},"content":{"rendered":"\n

Einf\u00fchrung<\/h3>\n\n\n\n

In der modernen Softwareentwicklung ist die Zuverl\u00e4ssigkeit von Anwendungen von entscheidender Bedeutung. Mikroservices-Architekturen und verteilte Systeme sind sehr popul\u00e4r geworden, was jedoch auch Herausforderungen mit sich bringt, insbesondere bei der Handhabung von Fehlern und der Resilienz von Anwendungen. Eine der Techniken zur Verbesserung der Resilienz ist das Circuit Breaker Muster. Resilience4j ist eine leichtgewichtige, auf Funktionen basierende Java-Bibliothek, die verschiedene Resilienz-Muster unterst\u00fctzt, darunter auch Circuit Breaker. In diesem Artikel werden wir detailliert erl\u00e4utern, wie man mit Resilience4j einen Circuit Breaker in Java implementiert und die verschiedenen Konfigurationsoptionen erkl\u00e4rt.<\/p>\n\n\n\n

Was ist ein Circuit Breaker?<\/h3>\n\n\n\n

Ein Circuit Breaker ist ein Designmuster, das dazu dient, den Ausfall eines Services zu verhindern, indem Anfragen an einen fehlerhaften Service unterbrochen werden. Es arbeitet \u00e4hnlich wie ein elektrischer Sicherungsautomat und hat drei Zust\u00e4nde:<\/p>\n\n\n\n

    \n
  1. Closed<\/strong>: Der Circuit Breaker leitet die Anfragen weiter.<\/li>\n\n\n\n
  2. Open<\/strong>: Der Circuit Breaker blockiert alle Anfragen und l\u00e4sst keine weiteren Versuche zu, bis eine festgelegte Wartezeit abgelaufen ist.<\/li>\n\n\n\n
  3. Half-Open<\/strong>: Der Circuit Breaker l\u00e4sst eine begrenzte Anzahl von Anfragen durch, um zu testen, ob der Service wieder funktionsf\u00e4hig ist.<\/li>\n<\/ol>\n\n\n\n

    Einrichtung von Resilience4j<\/h3>\n\n\n\n

    Bevor wir mit der Implementierung beginnen, m\u00fcssen wir die notwendigen Abh\u00e4ngigkeiten zu unserem Projekt hinzuf\u00fcgen. F\u00fcr ein Maven-Projekt f\u00fcgen wir folgende Abh\u00e4ngigkeit in der pom.xml<\/code> hinzu:<\/p>\n\n\n

    <dependency<\/span>><\/span>\n    <groupId<\/span>><\/span>io.github.resilience4j<\/groupId<\/span>><\/span>\n    <artifactId<\/span>><\/span>resilience4j-circuitbreaker<\/artifactId<\/span>><\/span>\n    <version<\/span>><\/span>1.7.1<\/version<\/span>><\/span>\n<\/dependency<\/span>><\/span><\/code><\/span>Code-Sprache:<\/span> HTML, XML<\/span> (<\/span>xml<\/span>)<\/span><\/small><\/pre>\n\n\n
    F\u00fcr Gradle-Projekte f\u00fcgen wir folgende Zeile in der build.gradle<\/code> Datei hinzu:<\/p>\n\n\n
    implementation 'io.github.resilience4j:resilience4j-circuitbreaker:1.7.1'<\/span><\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
    Grundlegende Implementierung<\/h3>\n\n\n\n
    Nun, da die Abh\u00e4ngigkeiten hinzugef\u00fcgt sind, k\u00f6nnen wir mit der Implementierung eines einfachen Circuit Breakers beginnen. Zuerst m\u00fcssen wir eine Instanz des Circuit Breakers erstellen und konfigurieren.<\/p>\n\n\n
    import<\/span> io.github.resilience4j.circuitbreaker.CircuitBreaker;\nimport<\/span> io.github.resilience4j.circuitbreaker.CircuitBreakerConfig;\nimport<\/span> io.github.resilience4j.circuitbreaker.CircuitBreakerRegistry;\n\nimport<\/span> java.time.Duration;\n\npublic class<\/span> CircuitBreakerExample<\/span> <\/span>{\n    public static<\/span> void<\/span> main(String<\/span>[] args) {\n        \/\/ Konfiguration des Circuit Breakers<\/span>\n        CircuitBreakerConfig config = CircuitBreakerConfig.custom()\n                .failureRateThreshold(50<\/span>) \/\/ 50% Fehlerrate<\/span>\n                .waitDurationInOpenState(Duration.ofSeconds(10<\/span>)) \/\/ 10 Sekunden im Open-Zustand<\/span>\n                .slidingWindowSize(20<\/span>) \/\/ Gr\u00f6\u00dfe des Sliding Window<\/span>\n                .build();\n\n        \/\/ Registrierung des Circuit Breakers<\/span>\n        CircuitBreakerRegistry registry = CircuitBreakerRegistry.of(config);\n\n        \/\/ Erstellen des Circuit Breakers<\/span>\n        CircuitBreaker circuitBreaker = registry.circuitBreaker(\"exampleCircuitBreaker\"<\/span>);\n\n        \/\/ Anwendung des Circuit Breakers<\/span>\n        Supplier<String<\/span>> decoratedSupplier = CircuitBreaker\n                .decorateSupplier(circuitBreaker, CircuitBreakerExample<\/span>::remoteServiceCall);\n\n        \/\/ Ausf\u00fchren des dekorierten Suppliers<\/span>\n        String<\/span> result = Try.ofSupplier(decoratedSupplier)\n                .recover(throwable -> \"Fallback\"<\/span>).get();\n\n        System.out.println(result);\n    }\n\n    \/\/ Beispiel f\u00fcr einen Remote Service Call, der fehlschl\u00e4gt<\/span>\n    public static<\/span> String<\/span> remoteServiceCall() {\n        throw<\/span> new<\/span> RuntimeException(\"Service not available\"<\/span>);\n    }\n}<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
    In diesem Beispiel konfigurieren wir einen Circuit Breaker mit einer Fehlerrate von 50%, einer Wartezeit von 10 Sekunden im offenen Zustand und einem Sliding Window von 20 Anfragen. Wir dekorieren dann einen Supplier, der einen Remote Service Call simuliert. Wenn der Remote Service Call fehlschl\u00e4gt, greift der Circuit Breaker ein und der Fallback-Mechanismus liefert einen Standardwert zur\u00fcck.<\/p>\n\n\n\n
    Erweiterte Konfigurationsoptionen<\/h3>\n\n\n\n
    Die grundlegende Implementierung kann durch verschiedene Konfigurationsoptionen erweitert werden, um spezifischeren Anforderungen gerecht zu werden. Hier sind einige erweiterte Konfigurationsoptionen:<\/p>\n\n\n\n
    Fehlerrate (failureRateThreshold)<\/h4>\n\n\n\n
    Die Fehlerrate definiert den Prozentsatz der fehlgeschlagenen Anfragen, bei dem der Circuit Breaker in den Open-Zustand wechselt. In unserem Beispiel bedeutet eine Fehlerrate von 50%, dass der Circuit Breaker in den Open-Zustand wechselt, wenn mindestens die H\u00e4lfte der Anfragen innerhalb des Sliding Windows fehlschlagen.<\/p>\n\n\n
    .failureRateThreshold(50<\/span>) \/\/ 50% Fehlerrate<\/span><\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
    Wartezeit im offenen Zustand (waitDurationInOpenState)<\/h4>\n\n\n\n
    Die Wartezeit definiert, wie lange der Circuit Breaker im Open-Zustand bleibt, bevor er in den Half-Open-Zustand wechselt. In unserem Beispiel betr\u00e4gt diese Wartezeit 10 Sekunden.<\/p>\n\n\n
    .waitDurationInOpenState(Duration.ofSeconds(10<\/span>)) \/\/ 10 Sekunden im Open-Zustand<\/span><\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
    Sliding Window (slidingWindowSize)<\/h4>\n\n\n\n
    Das Sliding Window definiert die Anzahl der Anfragen, die zur Berechnung der Fehlerrate herangezogen werden. In unserem Beispiel umfasst das Sliding Window 20 Anfragen. Es gibt zwei Modi f\u00fcr das Sliding Window:<\/p>\n\n\n\n
      \n
    1. Count-based sliding window<\/strong>: Das Fenster basiert auf einer festen Anzahl von Anfragen.<\/li>\n\n\n\n
    2. Time-based sliding window<\/strong>: Das Fenster basiert auf einem festen Zeitintervall.<\/li>\n<\/ol>\n\n\n\n
      In unserem Beispiel verwenden wir ein Count-based sliding window.<\/p>\n\n\n
      .slidingWindowSize(20<\/span>) \/\/ Gr\u00f6\u00dfe des Sliding Window<\/span><\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
      Ausnahmen (recordExceptions und ignoreExceptions)<\/h4>\n\n\n\n
      Wir k\u00f6nnen spezifische Ausnahmen definieren, die vom Circuit Breaker als Fehler gez\u00e4hlt oder ignoriert werden sollen.<\/p>\n\n\n
      .recordExceptions(RuntimeException.class, TimeoutException.class) \/\/ Ausnahmen, die gez\u00e4hlt werden<\/span>\n.ignoreExceptions(IgnoredException.class) \/\/ Ausnahmen, die ignoriert werden<\/span><\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
      Ereignis\u00fcberwachung<\/h3>\n\n\n\n
      Resilience4j bietet auch die M\u00f6glichkeit, Ereignisse zu \u00fcberwachen und zu protokollieren, die vom Circuit Breaker ausgel\u00f6st werden. Dies ist n\u00fctzlich, um Einblicke in das Verhalten des Circuit Breakers zu erhalten.<\/p>\n\n\n
      circuitBreaker<\/span>.getEventPublisher<\/span>()\n        .onSuccess<\/span>(event<\/span> -<\/span>> System<\/span>.out<\/span>.println<\/span>(\"Call<\/span> succeeded<\/span>\"))\n        .onError<\/span>(event<\/span> -<\/span>> System<\/span>.out<\/span>.println<\/span>(\"Call<\/span> failed<\/span>\"))\n        .onStateTransition<\/span>(event<\/span> -<\/span>> System<\/span>.out<\/span>.println<\/span>(\"State<\/span> transitioned<\/span> to<\/span> \" + event<\/span>.getStateTransition<\/span>()));<\/code><\/span>Code-Sprache:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
      Integration mit Spring Boot<\/h3>\n\n\n\n
      Resilience4j l\u00e4sst sich auch nahtlos in Spring Boot Anwendungen integrieren. Hier ist ein einfaches Beispiel:<\/p>\n\n\n
      import<\/span> io.github.resilience4j.circuitbreaker.annotation.CircuitBreaker;\nimport<\/span> org.springframework.stereotype.Service;\nimport<\/span> org.springframework.web.client.RestTemplate;\n\n@Service\npublic class<\/span> MyService<\/span> <\/span>{\n    private final RestTemplate restTemplate;\n\n    public MyService(RestTemplate restTemplate) {\n        this<\/span>.restTemplate = restTemplate;\n    }\n\n    @CircuitBreaker(name = \"myServiceCircuitBreaker\"<\/span>, fallbackMethod = \"fallback\"<\/span>)\n    public String<\/span> callExternalService() {\n        return<\/span> restTemplate.getForObject(\"http:\/\/example.com\/api\"<\/span>, String<\/span>.class);\n    }\n\n    public String<\/span> fallback(Throwable throwable) {\n        return<\/span> \"Fallback response\"<\/span>;\n    }\n}<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
      In diesem Beispiel wird ein REST-Aufruf mit einem Circuit Breaker gesch\u00fctzt. Wenn der Aufruf fehlschl\u00e4gt, wird die fallback<\/code> Methode aufgerufen.<\/p>\n\n\n\n
      Fazit<\/h3>\n\n\n\n
      Die Resilience4j-Bibliothek bietet eine leistungsf\u00e4hige und flexible M\u00f6glichkeit, das Circuit Breaker Muster in Java-Anwendungen zu implementieren. Durch die Verwendung von Resilience4j k\u00f6nnen Entwickler die Resilienz ihrer Anwendungen erheblich verbessern und die Auswirkungen von Fehlern und Ausf\u00e4llen minimieren. Mit einer Vielzahl von Konfigurationsm\u00f6glichkeiten und der einfachen Integration in Spring Boot ist Resilience4j eine ausgezeichnete Wahl f\u00fcr die Implementierung von Resilienzmustern in modernen Java-Anwendungen.<\/p>\n","protected":false},"excerpt":{"rendered":"
      Einf\u00fchrung In der modernen Softwareentwicklung ist die Zuverl\u00e4ssigkeit von Anwendungen von entscheidender Bedeutung. Mikroservices-Architekturen und verteilte Systeme sind sehr popul\u00e4r geworden, was jedoch auch Herausforderungen mit sich bringt, insbesondere bei der Handhabung von Fehlern und der Resilienz von Anwendungen. Eine der Techniken zur Verbesserung der Resilienz ist das Circuit Breaker Muster. Resilience4j ist eine leichtgewichtige, […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[4,5],"tags":[],"class_list":["post-472","post","type-post","status-publish","format-standard","hentry","category-plain_java","category-spring"],"_links":{"self":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/472","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=472"}],"version-history":[{"count":1,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/472\/revisions"}],"predecessor-version":[{"id":473,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/472\/revisions\/473"}],"wp:attachment":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=472"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=472"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=472"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}