Spring Cloud Hystrix est simple et pratique

Annuaire d'articles

1. Introduction

Veuillez ajouter une description de l'image

Hystrix, qui signifie porc-épic en anglais, a des épines sur tout le corps, et les épines sont un mécanisme de protection. Hystrix est également un composant de Netflix.

Qu'est-ce qu'Hystrix ?

Dans un environnement distribué, il existe une certaine probabilité que certains services parmi de nombreuses dépendances de services échouent. Hystrix est une bibliothèque qui vous aide à contrôler les interactions entre ces services distribués en ajoutant une logique de latence et de tolérance aux pannes. Hystrix empêche les défaillances en cascade en isolant les points d'accès entre les services et prévient les erreurs en cascade en fournissant des options de secours. Améliore la résilience globale du système. Avec Ribbon, il existe également dans presque tous les microservices et infrastructures construits par Spring Cloud.

Hystrix est conçu pour :

Protection et contrôle de la latence et des défaillances des dépendances accessibles via des bibliothèques clientes tierces, généralement sur le réseau.
Arrêtez l'effet d'avalanche dans les systèmes distribués complexes.
Échouez vite, récupérez vite.
Se replier, se dégrader le plus gracieusement possible.

2. Démarrage rapide

1. dépendance pom

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
</dependency>

2. Démarrer l'annotation de classe

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.SpringCloudApplication;
import org.springframework.cloud.client.circuitbreaker.EnableCircuitBreaker;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.cloud.netflix.hystrix.EnableHystrix;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

//注解简化写法：微服务中，注解往往引入多个，简化注解可以使用组合注解。
// @SpringCloudApplication =等同于
// @SpringBootApplication+@EnableDiscoveryClient+@EnableCircuitBreaker
@SpringBootApplication
@EnableDiscoveryClient
@EnableCircuitBreaker   //开启熔断
public class DemoHystrixApplication {
    
    

    public static void main(String[] args) {
    
    
        SpringApplication.run(DemoHystrixApplication.class, args);
    }

    @Bean
    @LoadBalanced
    //开启负载均衡
    public RestTemplate restTemplate() {
    
    
        return new RestTemplate();
    }
}

3. Configuration de la rétrogradation du service`@HystrixCommand`

Définissez la méthode de secours à l'aide de @HystrixCommand

import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/test")
public class TestHystrixController {
    
    

    @RequestMapping("/hystrix")
    @HystrixCommand(fallbackMethod = "queryByIdFallBack")
    public String queryById() {
    
    
        System.out.println("testBystrix");
        return "testBystrix";
    }

    public String queryByIdFallBack() {
    
    
        return "对不起，网络太过拥挤";
    }
}

4. Configurez la politique de fusible

Configuration commune de la politique de disjoncteur
Temps de veille après la fusion : sleepWindowInMilliseconds
Le nombre minimum de demandes de déclenchement de fusible : requestVolumeThreshold
Seuil du taux d'erreur de déclenchement du fusible : errorThresholdPercentage
Délai d'expiration du fusible : timeoutInMilliseconds

Adresse officielle du fichier de configuration

https://github.com/Netflix/Hystrix/wiki/Configuration#circuitBreaker.forceOpen

# 配置熔断策略：
# 强制打开熔断器 默认false关闭的。测试配置是否生效
hystrix.command.default.circuitBreaker.forceOpen: false
# 触发熔断错误比例阈值，默认值50%
hystrix.command.default.circuitBreaker.errorThresholdPercentage: 20
# 熔断后休眠时长，默认值5秒
hystrix.command.default.circuitBreaker.sleepWindowInMilliseconds: 60000
# 熔断触发最小请求次数，默认值是20
hystrix.command.default.circuitBreaker.requestVolumeThreshold: 5
# 熔断超时设置，默认为1秒
hystrix.command.default.execution.isolation.thread.timeoutInMilliseconds: 2000

5. Testez

3. Analyse de principe

Le principe du fusible est comme un protecteur de surcharge électrique.

La machine d'état du fusible a 3 états :

État fermé, toutes les demandes d'accès normal
Lorsqu'il est activé, toutes les demandes seront rétrogradées.
- Hystrix comptera l'état de la demande. Lorsque le pourcentage de demandes échouées atteint le seuil dans un certain laps de temps, le fusible se déclenchera et le disjoncteur sera complètement fermé.
- Le seuil de taux d'échec par défaut est de 50 % et le nombre minimum de demandes n'est pas inférieur à 20
à moitié ouvert
- L'état ouvert n'est pas permanent et il entrera dans le temps de veille (5 secondes par défaut) après s'être ouvert pendant un certain temps. Après le temps de sommeil, il entrera dans l'état semi-ouvert.
- État semi-ouvert : le fusible évaluera l'état de retour de la prochaine demande et, en cas de succès, le fusible reviendra à l'état fermé. En cas de défaillance, le fusible repasse à l'état ouvert.

La solution de base du disjoncteur : isolation des fils et dégradation du service.

Isolement des threads.
Rétrogradation de service (méthode de poche)

Après l'isolement du thread et la dégradation du service, lorsqu'un utilisateur demande une erreur, le thread ne sera pas bloqué, encore moins attendre sans fin ou voir le système planter, au moins vous pouvez voir le résultat de l'exécution (mécanisme de fusible).

Quand fusionner :

délai d'accès
service indisponible (mort)
Le service a lancé une exception (bien qu'il ait une exception mais qu'il soit actif)
D'autres demandes font que les exceptions de service atteignent le seuil et tous les services seront rétrogradés

4. Utilisation réelle

**Remarque :** La méthode dégradée du service de coupure de circuit doit garantir la même liste de paramètres et la même valeur de retour que la méthode dégradée

Il existe deux manières d'écrire : écrire sur la classe et écrire sur la méthode. Toutes les méthodes de la classe sont valides en haut de la classe. Sur la méthode, valable uniquement pour la méthode en cours.

En terme de méthode : la méthode de repli en cas de dégradation de service

À l'aide de l'annotation HystrixCommon, définissez
@HystrixCommand(fallbackMethod="queryByIdFallBack")fallbackUne méthode de repli pour déclarer une logique de repli .

Sur la classe : la méthode de secours pour la rétrogradation du service par défaut

Je viens d'écrire le repli sur une certaine méthode métier. S'il existe de nombreuses méthodes, vous pouvez ajouter la configuration FallBack à la classe pour implémenter le FallBack par défaut
@DefaultProperties(defaultFallback=”defaultFallBack“), sur la classe, spécifiez une méthode unifiée de dégradation des défaillances ;

import com.netflix.hystrix.contrib.javanica.annotation.DefaultProperties;
import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

@RestController
@RequestMapping("/consumer")
@DefaultProperties(defaultFallback = "defaultFallback")
//开启默认的 FallBack，统一失败降级方法(兜底) 
public class ConsumerController {
    
    
    @Autowired
    private RestTemplate restTemplate;

    @GetMapping("{id}")
    @HystrixCommand
    public String queryById(@PathVariable Long id) {
    
    
        //如果参数为1抛出异常，否则 执行REST请求返回user对象 
        if (id == 1) {
    
    
            throw new RuntimeException("too busy!!!");
        }
        String url = String.format("http://user-service/user/%d", id);
        return restTemplate.getForObject(url, String.class);
    }

    /**
     * queryById的降级方法
     */
    public String queryByIdFallback(Long id) {
    
    
        return "对不起，网络太拥挤了！";
    }

    /**
     * 默认降级方法
     */
    public String defaultFallback() {
    
    
        return "默认提示：对不起，网络太拥挤了！";
    }
}