Utilisez Resilience4J pour obtenir le mode disjoncteur, qui est léger et complet en fonction; 2. Configurer YAML pour définir le seuil de défaillance, la taille de la fenêtre et le temps de récupération; 3. Annoter la méthode de marquage avec @CircuitBreaker et spécifier la logique de secours; 4. La mise en ?uvre manuelle est uniquement utilisée pour l'apprentissage et l'environnement de production doit utiliser des bibliothèques matures pour éviter les problèmes de sécurité des threads; 5. Combinaison de surveillance, d'ajustement des paramètres raisonnables et de stratégies de secours pour améliorer la résilience du système, assurez-vous qu'aucun plantage n'est causé lorsqu'il s'appuie sur les défaillances et, finalement, maintenir l'application en cours d'exécution de manière stable.

Lors de la construction d'applications Java résilientes - en particulier dans des systèmes distribués comme les microservices - la maintenance des échecs est essentiellement critique. L'un des modèles les plus efficaces pour cela est le modèle de disjoncteur de circuit . Il empêche un système d'essayer à plusieurs reprises d'exécuter une opération susceptible d'échouer, comme appeler un service à distance lent ou à distance.

Voici comment vous pouvez implémenter efficacement le modèle de disjoncteur dans une application Java.

Pourquoi utiliser le motif du disjoncteur?

Sans disjoncteur de circuit, les appels ratés répétés (par exemple, à une API de repos défaillant) peuvent:

• Ressources de déchets (threads, mémoire)
• Provoquer des échecs en cascade
• Conduire à des délais d'attente et à une mauvaise expérience utilisateur

Le disjoncteur agit comme un proxy qui surveille les échecs. Après un certain seuil, il ?trébuche? et cesse de transférer les demandes temporairement, permettant à l'heure de la récupération de récupérer.

Il y a généralement trois états:

1. Fermé : les demandes passent normalement.
2. Ouvert : les demandes ont échoué immédiatement sans invocation.
3. Half-Open : Un nombre limité de demandes de test est autorisé à vérifier si le service s'est rétabli.

Option 1: Utilisation de Resilience4J (recommandée)

Resilience4j est une bibliothèque fonctionnelle légère con?ue pour Java 8 et la programmation fonctionnelle. C'est une alternative moderne à Hystrix (qui est maintenant en mode de maintenance).

étape 1: Ajouter des dépendances (maven)

 <dépendance>
    <bandrandId> io.github.resilience4j </pr?dId>
    <ArtefactId> Resilience4j-Spring-Boot2 </ Arfactive>
    <version> 2.0.2 </ version>
</Dependance>

étape 2: Configurer le disjoncteur

Dans application.yml :

 Resilience4J.Circuitbreaker:
  Instances:
    BackendService:
      FailourateRaTheReshold: 50
      minimunmbumberofcalls: 10
      waitDurationInOpenState: 5s
      SlidingWindowType: Time_based
      SlidingWindowSize: 10

Cela signifie:

• Si plus de 50% des 10 derniers appels échouent, déclenchez le circuit.
• Restez ouvert pendant 5 secondes avant de passer à la moitié ouverte.
• Dans l'état à moitié ouvert, permettez à certains appels de tester la récupération.

étape 3: Appliquer à une méthode de service

 import io.github.resilience4j.circuitbreaker.annotation.CircuitBreaker;
import org.springframework.sterreotype.service;

@Service
classe publique externalapiservice {

    @CircuitBreaker (name = "backendService", FallbackMethod = "Fallback")
    cha?ne publique callexternalapi () {
        // Simuler appelez une API de repos à distance
        Retour RiskRemoteCall ();
    }

    Fallback de cha?ne publique (exception e) {
        Retour "Réponse de secours en raison de l'indisponibilité du service";
    }

    cha?ne privée RiskRemoteCall () {
        // Simuler un appel réseau qui peut échouer
        lancer un nouveau RuntimeException ("Service indisponible");
    }
}

Maintenant, lorsque callExternalApi() échoue à plusieurs reprises, le circuit s'ouvre et fallback() est appelé à la place.

Option 2: mise en ?uvre manuelle (objectif éducatif)

Bien que l'utilisation de bibliothèques soit recommandée, la compréhension de la logique de base aide.

 classe publique SimpleCircuitBreaker {
    état de l'énumération publique {fermé, ouvert, half_open}

    état d'état privé = State.Closed;
    private int FailUreCount = 0;
    private final int FailUrerethReshold;
    final privé long tempsoutinmillis;
    privé long lastfailuretime;

    public SimplecircuitBreaker (int nefreurethreshold, long timeUtinmillis) {
        this.failureThReshold = faillureThReshold;
        this.timeoutinmillis = timeoutinmilis;
    }

    public <T> T EXECUTER (Fournisseur <T> Call) lance une exception {
        if (state == state.open) {
            if (System.currentTimemillis () - LastFailuRetime> timeoutInmillis) {
                state = state.half_open;
            } autre {
                Jetez une nouvelle exception ("Le circuit est ouvert. Demande rejetée.");
            }
        }

        essayer {
            T result = call.get ();
            onSuccess ();
            Résultat de retour;
        } catch (exception e) {
            onFailure ();
            jeter e;
        }
    }

    void privé onSuccess () {
        failureCount = 0;
        state = state.Closed;
    }

    private void onfailure () {
        FailureCount;
        LastFailuRetime = System.CurrentTimemillis ();
        if (failUreCount> = faillureThReshold) {
            state = state.open;
        }
    }
}

Exemple d'utilisation:

 SimpleCircuitBreaker CB = nouveau SimpleCircuitBreaker (3, 5000); // 3 échecs, délai d'expiration de 5 secondes

essayer {
    Résultat de la cha?ne = CB.Execute (() -> externalService.getData ());
    System.out.println (résultat);
} catch (exception e) {
    System.out.println ("La demande a échoué:" e.getMessage ());
}

Remarque: Cette version de base manque de sécurité de fil et de fonctionnalités avancées telles que des métriques ou des écouteurs d'événements. Pour la production, utilisez Resilience4J ou similaire.

Meilleures pratiques

• Utilisez des méthodes de secours pour renvoyer des données en cache, des paramètres par défaut ou des messages d'erreur gracieux.
• Survenez l'état du circuit via la journalisation ou les mesures (Resilience4J s'intègre au micromètre).
• Assurez les seuils soigneusement en fonction de la charge et des SLA attendus.
• Combinez avec des tentatives (mais soyez prudent - les tempêtes de la rétraction peuvent aggraver les choses).

Résumé

La mise en ?uvre du modèle de disjoncteur en Java est essentielle pour construire des systèmes tolérants aux pannes. Bien que vous puissiez écrire le v?tre, tirant parti des bibliothèques matures comme Resilience4j est beaucoup plus fiable et riche en fonctionnalités. Il gère les cas Edge, fournit des mesures et s'intègre parfaitement à Spring Boot.

Avec seulement quelques annotations et lignes de configuration, vous gagnez de la résilience contre les échecs transitoires, en gardant votre application stable même lorsque les dépendances ne le sont pas.

Fondamentalement, ne roulez pas le v?tre en production - utilisez Resilience4J.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!