SpringCloud 服务降级

最新推荐文章于 2024-01-22 13:36:27 发布
最新推荐文章于 2024-01-22 13:36:27 发布
阅读量404 收藏
点赞数
分类专栏： SpringCloud
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45738810/article/details/109134845
版权

博客参考学习视频： https://www.bilibili.com/video/BV18E411x7eT?from=search&seid=4388336378730572330

上一篇：SpringCloud服务调用：https://blog.csdn.net/qq_45738810/article/details/109116078

一、Hystrix 断路器

① 概述

1.分布式系统面临的问题

image-20201016002519013

image-20201016002530999

2.是什么

image-20201016002559663

3.能干嘛
  • 服务降级
  • 服务熔断
  • 接近实时的监控
4.官 网 资 料

​ https://github.com/Netflix/Hystrix/wiki/How-To-Use

5.Hystrix 官宣，停更进维

​ https://github.com/Netflix/Hystrix

image-20201016003154348

  • 不在修复Bug
  • 不在接收合并请求
  • 不在发布新版本

② Hystrix 重要概念

1.服务降级

服务器忙， 请稍候再试， 不让客户端等待并立刻返回一个友好提示， fallback

哪些情况会触发降级： 1 程序运行异常、 2 超时、 3 服务熔断触发服务降级 、4 线程池/信号量打满也会导致服务降级

2.服务熔断

​ 类比保险丝达到最大服务访问后， 直接拒绝访问， 拉闸限电， 然后调用服务降级的方法并返回友好提示，就是保险丝。

​ 服务的降级->进而熔断->恢复调用链路

3.服务限流

​ 秒杀高并发等操作， 严禁一窝蜂的过来拥挤， 大家排队， 一秒钟 N 个， 有序进行

③ hystrix 案例

1.构建

新建 cloud-provider-hystrix-payment8001

POM

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>clould</artifactId>
        <groupId>com.oy</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>cloud-provider-hystrix-payment8001</artifactId>

    <dependencies>
        <!--新增 hystrix-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <dependency>
            <groupId>com.oy</groupId>
            <artifactId>cloud-api-commons</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <dependency><groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

YML

server:
  port: 8001
eureka:
  client:
    register-with-eureka: true #表示不向注册中心注册自己
    fetch-registry: true #表名自己就是注册中心，职责维护服务实例，并不需要去检索服务
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka

主启动类

@SpringBootApplication
@EnableEurekaClient
public class PaymentHystrixMain8001 {
     public static void main(String[] args) {
           SpringApplication.run(PaymentHystrixMain8001.class, args);
      }
}

业务类

​ Service

@Service
public class PaymentService {

    // 成功
    public String paymentInfo_OK(Integer id){
        return "线程池：" + Thread.currentThread().getName() + "paymentInfo_OK,id:"+id+"\t"+"O(∩_∩)O哈哈~";
    }


    // 失败
    public String paymentInfo_TimeOut(Integer id){
        int timeNumber  = 3;
        try {
            TimeUnit.SECONDS.sleep(timeNumber);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        return "线程池：" + Thread.currentThread().getName()+ "paymentInfo_TimeOut,id:" + id +"\t" +"┭┮﹏┭┮"+"耗时(秒)" + timeNumber;
    }
}

Controller

@RestController
@Slf4j
public class PaymentController {

    @Resource
    private PaymentService  paymentService;

    @Value("${server.port}")
    private String serverPort;

    @GetMapping(value = "/payment/hystrix/ok/{id}")
    public String paymentInfo_OK(@PathVariable("id") Integer id){
        String result = paymentService.paymentInfo_OK(id);
        log.info("*************result:" + result);

        return result;
    }

    @GetMapping(value = "/payment/hystrix/timeout/{id}")
    public String paymentInfo_TimeOut(@PathVariable("id") Integer id){
        String result = paymentService.paymentInfo_TimeOut(id);
        log.info("******result:" + result);
        return result;
    }
}

测试：

  • 先启动 eureka 7001, 启动 cloud-provider-hystrix-payment8001

  • 访问：

    http://localhost:8001/payment/hystrix/ok/1

    image-20201016152409512

  • 在测试访问：http://localhost:8001/payment/hystrix/timeout/1，每 次 调 用 耗 费 3 秒 钟

image-20201016152506946

  • 上述 module 均 OK，以上述为根基平台，从正确->错误->降级熔断->恢复
2.高并发测试

Jmeter 压测测试

​ 开 启 Jmeter ， 来 20000 个 并 发 压 死 8001 ， 20000 个 请 求 都 去 访 问paymentInfo_TimeOut 服务。

image-20201016154613777

  • 再来一个访问：http://localhost:8001/payment/hystrix/ok/1， http://localhost:8001/payment/hystrix/timeout/1

    看演示结果： 两个都在自己转圈圈

  • 为什么会被卡死： tomcat 的默认的工作线程数被打满了。没有多余的线程来分解压力和处理

3.Jmeter 压测结论

​ 上面还是服务提供者 8001 自己测试， 假如此时外部的消费者 80 也来访问，那消费者只能干等， 最终导致消费端 80 不满意， 服务端 8001 直接被拖死

4.看热闹不嫌弃事大， 80 新建加入

新建 cloud-consumer-feign-hystrix-order80

image-20201016155321248

POM

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>clould</artifactId>
        <groupId>com.oy</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>cloud-consumer-feign-hystrix-order80</artifactId>

    <dependencies>
        <!--新增 hystrix-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <dependency>
            <groupId>com.oy</groupId>
            <artifactId>cloud-api-commons</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency><dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

YML

server:
  port: 80
eureka:
  client:
    register-with-eureka: true
    fetch-registry: true
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka

主启动类

@SpringBootApplication
@EnableEurekaClient
public class PaymentHystrixMain8001 {
     public static void main(String[] args) {
           SpringApplication.run(PaymentHystrixMain8001.class, args);
      }
}

业务类

PaymentHystrixService

package com.oy.springcloud.service;

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;

/**
 * @Author OY
 * @Date 2020/10/16
 */
@Component
@FeignClient(value = "CLOUD-PROVIDER-HYSTRIX-PAYMENT")
public interface PaymentHystrixService {

    /**
     * 正常访问
     *
     * @param id
     * @return
     */
    @GetMapping("/payment/hystrix/ok/{id}")
    public String paymentInfo_OK(@PathVariable("id") Integer id);

    /**
     * 超时访问
     *
     * @param id
     * @return
     */
    @GetMapping("/payment/hystrix/timeout/{id}")
    public String paymentInfo_TimeOut(@PathVariable("id") Integer id);
}

Controller

@RestController
@Slf4j
public class OrderHyrixController {

    @Resource
    private PaymentHystrixService paymentHystrixService;

    /**
     * 正常访问
     *
     * @param id
     * @return
     */
    @GetMapping("/consumer/payment/hystrix/ok/{id}")
    public String paymentInfo_OK(@PathVariable("id") Integer id) {
        String result = paymentHystrixService.paymentInfo_OK(id);
        log.info("*****result:" + result);
        return result;
    }

    /**
     * 超时访问
     *
     * @param id
     * @return
     */
    @GetMapping("/consumer/payment/hystrix/timeout/{id}")
    public String paymentInfo_TimeOut(@PathVariable("id") Integer id) {
        String result = paymentHystrixService.paymentInfo_TimeOut(id);
        log.info("*****result:" + result);
        return result;

    }
}

正常测试

  • http://localhost/consumer/payment/hystrix/ok/1

image-20201016163217022

  • http://localhost/consumer/payment/hystrix/timeout/1

image-20201016163241381

注意：测试这个时有可能会报超时错误，如果出现错误只需要在配置文件中配置

ribbon:
  # 指的是建立连接所用的时间,适用于网络状态正常的情况下,两端连接所用的时间
  ReadTimeout: 5000
  # 指的是建立连接后从服务器读取到可用资源所用的时间
  ConnectTimeout: 5000

image-20201016163421515

高并发测试

  • 2W 个线程压 8001，消费端 80 微服务再去访问正常的 OK 微服务 8001 地址

    http://localhost/consumer/payment/hystrix/timeout/1

image-20201016163648968

​ 消费者 80， 要么转圈圈等待、 要么消费端报超时错误

5.故障现象和导致原因
  • 8001 同一层次的接口服务被困死，因为tomcat 线程里面的工作线程已经被挤占完毕
  • 80此时调用 8001，客户端访问的响应缓慢，转圈圈
6.上诉结论

​ 正因为有上述故障或不佳表现， 才有我们的降级/容错/限流等技术诞生

7.如何解决？解决的要求

  • 超时导致服务器变慢（转圈） ： 超时不再等待

  • 出错（宕机或程序运行出错） ： 出错要有兜底

解决：

  1. 对方服务（8001） 超时了， 调用者（80） 不能一直卡死等待，必须有服务降级。
  2. 对方服务（8001） down 机了， 调用者（80） 不能一直卡死等待， 必须有服务降级。
  3. 对方服务（8001） OK， 调用者（80） 自己出故障或有自我要求（自己的等待时间小于服务提供者） ， 自己处理降级

④ 服务降级

1.降低配置： @HystrixCommand
2.8001先从自身找问题

​ 置自身调用超时时间的峰值，峰值内可以正常运行，超过了需要有兜底的方法处理，做服务降级 fallback

3.8001fallback

业务类启用

image-20201016212902803

@Service
public class PaymentService {

    // 成功
    public String paymentInfo_OK(Integer id){
        return "线程池：" + Thread.currentThread().getName() + "paymentInfo_OK,id:"+id+"\t"+"O(∩_∩)O哈哈~";
    }

    /**
     * 超时访问，演示降级
     * @param id
     * @return
     */
    @HystrixCommand(fallbackMethod = "paymentInfo_TimeOutHandler", commandProperties = {
            @HystrixProperty(name ="execution.isolation.thread.timeoutInMilliseconds",value="3000")
    })
    public String paymentInfo_TimeOut(Integer id){
        int timeNumber  = 5;
        try {
            TimeUnit.SECONDS.sleep(timeNumber);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        return "线程池：" + Thread.currentThread().getName()+ "paymentInfo_TimeOut,id:" + id +"\t" +"┭┮﹏┭┮"+"耗时(秒)" + timeNumber;
    }

    public String paymentInfo_TimeOutHandler(Integer id){
        return "o(╥﹏╥)o 调用支付接口超时异常：\t" + "\t当前线程池名字：" + Thread.currentThread().getName();
    }
}

image-20201016213119295

@HystrixCommand报异常后如何处理

一旦调用服务方法失败并抛出了错误信息后,会自动调用@HystrixCommand标注好的fallbckMethod调用类中的指定方法

图示：

image-20201016214851342

主启动类激活： 添加新注解**@EnableCircuitBreaker**

@SpringBootApplication
@EnableEurekaClient
@EnableCircuitBreaker
public class PaymentHystrixMain8001 {
     public static void main(String[] args) {
           SpringApplication.run(PaymentHystrixMain8001.class, args);
      }
}
4.80fallback
80 订单微服务， 也可以更好的保护自己， 自己也依样画葫芦进行客户端降级保护。

题外话

切记我 们 自 己 配 置 过 的 热 部 署 方 式 对 java 代 码 的 改 动 明 显 ， 但对@HystrixCommand 内属性的修改建议重启微服务

YML

feign:
  hystrix:
    enabled: true # 如果处理自身的容错就开启。开启方式与生产端不一样。

image-20201016215256041

主启动： @EnableHystrix

@SpringBootApplication
@EnableEurekaClient
@EnableFeignClients
@EnableHystrix
public class OrderHystrixMain80 {
     public static void main(String[] args) {
           SpringApplication.run(OrderHystrixMain80.class, args);
      }
}

业务类

@GetMapping("/consumer/payment/hystrix/timeout/{id}")
@HystrixCommand(fallbackMethod = "paymentTimeOutFallbackMethod",commandProperties = {
    @HystrixProperty(name="execution.isolation.thread.timeoutInMilliseconds",value = "15000")
})
public String paymentInfo_TimeOut(@PathVariable("id") Integer id) {
    String result = paymentHystrixService.paymentInfo_TimeOut(id);
    log.info("*****result:" + result);
    return result;
}

public String paymentTimeOutFallbackMethod(@PathVariable("id") Integer id){
    return "我是消费者80,对方支付系统繁忙请10秒钟后再试或者自己运行出错请检查自己，o(╥﹏╥)o";
}
5.目前方法
  • 每个业务方法对应一个兜底的方法，代码膨胀
  • 统一和自定义的需要分开
6.解决问题

每个方法配置一个？ ？ ？ 膨胀

  1. feign 接口系列
  2. @DefaultProperties(defaultFallback = “”)

image-20201016221217405

说明：

image-20201016221245143

controller 配置

@RestController
@Slf4j
@DefaultProperties(defaultFallback = "payment_Global_FallbackMethod")
public class OrderHyrixController {

    @Resource
    private PaymentHystrixService paymentHystrixService;

    /**
     * 正常访问
     *
     * @param id
     * @return
     */
    @GetMapping("/consumer/payment/hystrix/ok/{id}")
    public String paymentInfo_OK(@PathVariable("id") Integer id) {
        String result = paymentHystrixService.paymentInfo_OK(id);
        log.info("*****result:" + result);
        return result;
    }

    /**
     * 超时访问
     *
     * @param id
     * @return
     */
    @GetMapping("/consumer/payment/hystrix/timeout/{id}")
    @HystrixCommand
    public String paymentInfo_TimeOut(@PathVariable("id") Integer id) {
        String result = paymentHystrixService.paymentInfo_TimeOut(id);
        log.info("*****result:" + result);
        return result;
    }

    // 兜底方法
    public String paymentTimeOutFallbackMethod(@PathVariable("id") Integer id){
        return "我是消费者80,对方支付系统繁忙请10秒钟后再试或者自己运行出错请检查自己，o(╥﹏╥)o";
    }

    /**
     * 全局fallback
     * @return
     */
    public String payment_Global_FallbackMethod() {
        return "Global异常处理信息,请稍后重试.o(╥﹏╥)o";
    }
}

**和业务逻辑混一起？ ？ ？ 混乱 **

  1. 服务降级，客户端去调用服务端，碰上服务器宕机或关闭

  2. 本次案例服务案例级处理是在客户端80 实现完成的，与服务端 8001 没有关系，只需要为 Feign 客户端定义的接口添加一个服务降级处理的实现类即可实现解耦。

  3. 未来我们要面对的异常

    运行、超时、宕机

  4. 再看我们的业务类 PaymentController

image-20201016230720317

  1. 修改 cloud-consumer-feign-hystrix-order80
  2. 根 据 cloud-consumer-feign-hystrix-order80 已 经 有 的PaymentHystrixService 接 口 ， 重 新 新 建 一 个 类
    （PaymentFallbackService） 实现该接口， 统一为接口里面的方法进行异常处理 。
  3. PaymentFallbackService 类 实 现PaymentFeignClientService 接口
@Component
public class PaymentFallbackService implements PaymentHystrixService{
    @Override
    public String paymentInfo_OK(Integer id) {
        return "-----PaymentFallbackService fall back-paymentInfo_OK , (┬＿┬)";
    }

    @Override
    public String paymentInfo_TimeOut(Integer id) {
        return "-----PaymentFallbackService fall back-paymentInfo_TimeOut , (┬ ＿┬)";
    }
}
  1. YML
feign:
  hystrix:
    enabled: true # 如果处理自身的容错就开启。开启方式与生产端不一样。
  1. PaymentFeignClientService 接口
@Component
@FeignClient(value = "CLOUD-PROVIDER-HYSTRIX-PAYMENT",fallback = PaymentFallbackService.class)
public interface PaymentHystrixService {

    /**
     * 正常访问
     *
     * @param id
     * @return
     */
    @GetMapping("/payment/hystrix/ok/{id}")
    public String paymentInfo_OK(@PathVariable("id") Integer id);

    /**
     * 超时访问
     *
     * @param id
     * @return
     */
    @GetMapping("/payment/hystrix/timeout/{id}")
    public String paymentInfo_TimeOut(@PathVariable("id") Integer id);
}
  1. 测试

  • 单个 eureka 先启动 7001，PaymentHystrixMain8001 启动

  • 正常测试： http://localhost/consumer/payment/hystrix/ok/1

image-20201016231719706

  • 故意关闭微服务 8001

image-20201016231758903

​ 客户端自己调用提升： 此时服务端 provider 已经 down 了， 但是我们做了服务降级处理， 让客户端在服务端不可用时也会获得提示信息而不会挂起耗死服务器 。

⑤ 服务熔断

1.断路器

​ 一句话就是家里保险丝

2.熔断是什么

image-20201016232022777

大神论文：https://martinfowler.com/bliki/CircuitBreaker.html

3.实操

修改 cloud-provider-hystrix-payment8001

PaymentService

    @HystrixCommand(fallbackMethod =
            "paymentCircuitBreaker_fallback",commandProperties = {
            @HystrixProperty(name = "circuitBreaker.enabled",value = "true"), //是否开启断路器
            @HystrixProperty(name = "circuitBreaker.requestVolumeThreshold",value = "10"), //请求次数
            @HystrixProperty(name = "circuitBreaker.sleepWindowInMilliseconds",value = "10000"), //时间范围
            @HystrixProperty(name = "circuitBreaker.errorThresholdPercentage",value = "60"), //失败率达到多少后跳闸
    })
public String paymentCircuitBreaker(@PathVariable("id") Integer id){
    if (id < 0){
        throw new RuntimeException("*****id 不能负数");
     }
    String serialNumber = IdUtil.simpleUUID();
    return Thread.currentThread().getName()+"\t"+"调用成功,流水号： "+serialNumber;
}

public String paymentCircuitBreaker_fallback(@PathVariable("id") Integer id){
    return "id 不能负数， 请稍候再试,(┬＿┬)/~~ id: " +id;
}

why 配置这些参数：

image-20201016232453956

PaymentController

@GetMapping("/payment/circuit/{id}")
public String paymentCircuitBreaker(@PathVariable("id") Integer id){
    String result = paymentService.paymentCircuitBreaker(id);
    log.info("*******result:"+result);
    return result;
}

测试

  1. 自测 cloud-provider-hystrix-payment8001

image-20201016232734315

  1. 正确： http://localhost:8001/payment/circuit/1

    image-20201016233026906

  2. 错误： http://localhost:8001/payment/circuit/-1

image-20201016233053779

  1. 一次正确一次错误 trytry
  2. 重点测试： 多次错误,然后慢慢正确， 发现刚开始不满足条件，就算是正确的访问地址也不能进行访问， 需要慢慢的恢复链路
4.原理（小总结）

大神结论

image-20201016233342518

熔断类型

  1. 熔断打开

    请求不再进行调用当前服务， 内部设置时钟一般为 MTTR(平均故障处理时间)，当打开时长达到所设时钟则进入熔断状态 。

  2. 熔断关闭

    熔断关闭不会对服务进行熔断。

  3. 熔断半开

    部分请求根据规则调用当前服务， 如果请求成功且符合规则则认为当前服务恢复正常， 关闭熔断 。

官网断路器流程图

  1. 官网步骤

image-20201016233656920

  1. 断路器在什么情况下开始起作用

image-20201016233720377

  1. 断路器开启或者关闭的条件

  • 当满足一定阀值的时候（默认 10 秒内超过 20 个请求次数）

  • 当失败率达到一定的时候（默认 10 秒内超过 50%请求失败）

  • 到达以上阀值， 断路器将会开启

  • 当开启的时候， 所有请求都不会进行转发

  • 一段时间之后（默认是 5 秒）， 这个时候断路器是半开状态， 会让其中一个请求进行转发。 如果成功， 断路器会关闭， 若失败， 继续开启。 重复 4 和 5 。

  1. 断路器打开之后

    image-20201016234107457

  2. All 配置

image-20201016234250739

image-20201016234229443

image-20201016234319121

image-20201016234330093

⑥ 服务限流

参考我后面的关于高级篇的 alibaba 的 Sentinel 说明

⑦ hystrix 工作流程

1.hystrix 工作流程

​ https://github.com/Netflix/Hystrix/wiki/How-it-Works

2.hystrix 工作流程

**官网图例 : **

image-20201017152337133

步骤说明:

image-20201017152658751

⑧ 服务监控 hystrixDashboard

1.概述

image-20201017153028883

2.仪表盘 9001

新建 cloud-consumer-hystrix-dashboard9001

image-20201017153155398

POM

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>clould</artifactId>
        <groupId>com.oy</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>cloud-consumer-hystrix-dashboard9001</artifactId>

    <dependencies><!--新增 hystrix dashboard-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-hystrix-dashboard</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

YML

server:
  port: 9001

HystrixDashboardMain9001+新注解**@EnableHystrixDashboard**

@SpringBootApplication
@EnableHystrixDashboard
public class HystrixDashboardMain9001 {
     public static void main(String[] args) {
           SpringApplication.run(HystrixDashboardMain9001.class, args);
      }
}

所有 Provider 微服务提供类（8001/8002/8003） 都需要监控依赖配置

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

启动cloud-consumer-hystrix-dashboard9001该微服务后续将监控微服务8001

​ http://localhost:9001/hystrix

image-20201017155956437

3.断路器演示(服务监控hystrixDashboard)

修改cloud-provider-hystrix-payment8001

注意:新版本Hystrix需要在主启动PaymentHystrixMain8001中指定监控路径

    /**
     * 此配置是为了服务监控而配置，与服务容错本身无观，springCloud 升级之后的坑
     * ServletRegistrationBean因为springboot的默认路径不是/hystrix.stream
     * 只要在自己的项目中配置上下面的servlet即可
     * @return
     */
    @Bean
    public ServletRegistrationBean getServlet(){
        HystrixMetricsStreamServlet streamServlet = new HystrixMetricsStreamServlet();
        ServletRegistrationBean<HystrixMetricsStreamServlet> registrationBean = new ServletRegistrationBean<>(streamServlet);
        registrationBean.setLoadOnStartup(1);
        registrationBean.addUrlMappings("/hystrix.stream");
        registrationBean.setName("HystrixMetricsStreamServlet");
        return registrationBean;
    }

image-20201017161411381

  • Unable to connect to Command Metric Stream.
  • 404

监控测试

  • 启动 1 个 eureka 或者 3 个 eureka 集群均可
  • 观察监控窗口

9001 监控 8001

image-20201017162106329

  • 填写监控地址： http://localhost:8001/hystrix.stream

  • 测试地址： http://localhost:8001/payment/circuit/1、http://localhost:8001/payment/circuit/1

  • 上述测试通过： ok

  • 先访问正确地址， 再访问错误地址， 再正确地址， 会发现图示断路器都，是慢慢放开的 。

监控结果，成功

image-20201017162411201

监控结果， 失败

image-20201017162501189

  • 如何看：

7 色 1 圈

image-20201017162751506

image-20201017162643326

1 线

image-20201017162702560

整图说明

image-20201017162830940

整图说明 2

image-20201017162858611
搞懂一个才能看懂复杂的

image-20201017163035515

OY..
关注
专栏目录
SpringCloud十七、服务降级。
lbh19630726的博客
02-07 265
①服务降级。 什么是服务降级： 整体资源快不够了，忍痛将某些服务先关掉，待渡过难关，再开启回来。 服务降级处理是在客户端（服务消费者、服务调用方）实现完成的，与服务端（服务提供者）没有关系。 服务熔断的坏处：容易方法膨胀。增加一个方法，就要增加一个fallbackMethod方法。而且出现高耦合现象。这时，我们需要解耦： microservicecloud-prov...
大白话详解Spring Cloud服务降级与熔断
m0_55613022的博客
07-13 2087
复杂分布式体系结构中的应用程序有数十个依赖关系，每个依赖关系在某些时候将不可避免地失败。这就造成有可能会发生 服务雪崩 。那么什么是服务雪崩呢？多个微服务之间调用的时候，假设微服务A调用微服务B和微服务C，微服务B和微服务C又调用其他的微服务，这就是所谓的“ 扇出 ”（像一把打开的折扇）。如果扇出的链路上某个微服务的调用响应时间过长或者不可用，对微服务A的调用就会占用越来越多的系统资源，进而引起系统崩溃，这就是所谓的” 雪崩效应# 1. Hystrix断路器概述...
Spring Cloud构建微服务架构：服务容错保护（Hystrix服务降级）【Dalston版】
weixin_34261739的博客
07-12 130
前言 在微服务架构中，我们将系统拆分成了一个个的服务单元，各单元应用间通过服务注册与订阅的方式互相依赖。由于每个单元都在不同的进程中运行，依赖通过远程调用的方式执行，这样就有可能因为网络原因或是依赖服务自身问题出现调用故障或延迟，而这些问题会直接导致调用方的对外服务也出现延迟，若此时调用方的请求不断增加，最后就会出现因等待出现故障的依...
11-SpringCloud Hystrix
彼岸舞的博客
08-23 244
Hystrix简介 分布式系统面临的问题 复杂分布式体系结构中的应用程序有数十个依赖关系，每个依赖关系在某些时候将不可避免地失败。 服务雪崩 多个微服务之间调用的时候，假设微服务A调用微服务B和微服务C，微服务B和微服务C又调用其它的微服务，这就是所谓的“扇出”。如果扇出的链路上某个微服务的调用响应时间过长或者不可用，对微服务A的调用就会占用越来越多的系统资源，进而引起系统崩溃，所谓的“雪崩效...
SpringCloud服务降级
最新发布
蓝影铁哥的博客
01-22 1048
SpringCloud服务降级
Spring Cloud微服务如何实现熔断降级？
weixin_30819085的博客
04-23 637
熔断限流概述 在基于Spring Cloud的微服务架构体系下，按照系统功能边界的不同划分，原先大而全的系统会被拆分为多个不同的微服务，而相应的微服务会提供一组功能关联的服务接口，并向系统中的其他微服务提供服务。在正常情况下，各个微服务之间功能上相互解耦，从软件的设计上来讲会呈现出一个比较合理的状态，但是从调用链路上来看，这种拆分实际上也是拉长了外部服务请求的调用链路。 ...
Spring Cloud之Hystrix服务降级
zhouym_的博客
09-02 1418
Hystrix引入 在微服务场景中，由于大部分微服务采用同步接口调用，而且多个领域相关的微服务会部署在同一个进程中，很容易发生“雪崩效应”，即某个微服务提供者故障，导致调用该微服务的消费者、或者与故障微服务合设在同一个进程中的其它微服务发生级联故障，最终导致系统崩溃，在spring cloud中提供了一种机制，断路器即Hystrix Hystrix简介 Hystrix也是Netflix套件的一部分...
springcloud学习-服务降级
qq_44692851的博客
08-21 965
什么是服务降级？ 服务降级就是将某些服务停掉或者不进行业务处理，释放资源来维持主要服务的功能。 某电商网站在搞活动时，活动期间压力太大，如果再进行下去，整个系统有可能挂掉，这个时候可以释放掉一些资源，将一些不那么重要的服务采取降级措施，比如登录、注册。 登录服务停掉之后就不会有更多的用户抢购，同时释放了一些资源，登录、注册服务就算停掉了也不影响商品抢购。 服务降级有很多种方式，最好的方式就是利用 Docker 来实现。 当需要对某个服务进行降级时，直接将这个服务所有的容器停掉，需要恢复的时候重新启动就可以
Springcloud---feign--服务降级
10年IT大头兵
04-18 1440
客户端技术：整体网站负荷过大时，为了资源的更好利用 客户端微服务做一个异常处理机制 做一个FallbackFactory的实现类 package com.wang.springcloud.service; import com.wang.springcloud.pojo.Dept; import feign.hystrix.FallbackFactory; import or...
小白学SpringCloud(六)：服务降级（Hystrix）
catalinaLi的博客
08-06 6864
在微服务架构中，我们将系统拆分为很多个服务，各个服务之间通过注册与订阅的方式相互依赖，由于各个服务都是在各自的进程中运行，就有可能由于网络原因或者服务自身的问题导致调用故障或延迟，随着服务的积压，可能会导致服务崩溃。为了解决这一系列的问题，断路器等一系列服务保护机制出现了。 一、Hystrix简介 Netflix提供了一个叫Hystrix的类库，它实现了断路器模式。在微服务...
详解springcloud 基于feign的服务接口的统一hystrix降级处理
08-25
主要介绍了详解springcloud 基于feign的服务接口的统一hystrix降级处理，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
spring cloud学习（七）-Hystrix【Feign服务降级】
Big Data
05-26 242
Hystrix介绍 Hystrix是一个用于处理分布式系统的延迟和容错的开源库，在分布式系统里，许多依赖不可避免的会调用失败，比如超时、异常等；Hystrix能够保证在一个依赖处问题的情况下，不会导致整体服务失败，避免级联故障，以提高分布式系统的弹性； "断路器" 本身是一种开关装置，当某个服务单元发生故障之后，通过断路器的故障监控（类似熔断保险丝），向调用方向返回一个符合预期的、可处理的备选响应（fallback）,而不是长时间的等待或者抛出调用方无法处理的异常，这样就保证了服务调用方的线程不会被长时
Springcloud的服务调用-OpenFeign与服务降级-Hystrix
weixin_53059756的博客
01-19 766
文章目录前言一、OpenFeign1.创建feign模块2.超时控制3.日志打印二、Hystrix1.Hystrix的要点2.Hystrix案例演练3.模拟高并发总结 前言   服务调用,指的是注册到服务端上的客户端之间数据的相互调用问题。   spring-cloud调用服务有两种方式，一种是Ribbon+RestTemplate, 另外一种是Feign。   服务降级，指的是当服务器压力剧增时，根据当前业务情况及流量对一些服务和页面有策略的降级，以此释放服务器资源以保证核心任务的正常运行。 提示
SpringCloud的服务容错处理(一)之服务降级
Coder_Joker的博客 joke a joker
05-27 1507
什么是服务降级:    核心思想是区分业务,优先核心服务,相当于弃车保帅,,例如下单的时候,优先确保订单和支付服务,积分服务低优先级使用方法也很SpringBoot :  注意这是服务端的,非客户端(相对而言)    1.引入依赖    2.启动类上配置注解    3.编写具体逻辑   -&gt;通过核心注解@HystrixComm &lt;!-- 服务降级措施 的依赖--&gt; &lt;dep...
springcloud-降级
weixin_44012040的博客
10-10 295
一、降级概念 当服务的访问量剧增，服务就可能出想问题，所以就需要作出一些处理，比如服务降级。（例：某电商网站在搞活动时，活动期间压力太大，如果再进行下去，整个系统有可能挂掉， 这个时候可以释放掉一些资源，将一些不那么重要的服务采取降级措施， 比如登录、注册。登录服务停掉之后就不会有更多的用户抢购， 同时释放了一些资源，登录、注册服务就算停掉了也不影响商品抢购。） 二、实现方式 利用docker实...
SpringCloud-服务降级
weixin_44007740的博客
10-11 291
一，降级概念 当访问两剧增，服务出现问题时，需要做一些处理，比如服务降级。 服务降级就是将某些服务停掉或者不进行业务处理，释放资源来维持主要服务的功能。 举例：某电商网站在搞活动，活动期间压力太大，如果在进行下去，整个系统有可能挂掉， 这个时候可以释放掉一些资源，将一些不那么重要的服务采取降级措施，比如登录，注册。登录服务停掉之后就不会有更好的用户抢购，同时释放了一些资源，登录，注册服务就算停掉了...
springcloud——服务消费者通配服务降级
weixin_43925059的博客
07-31 200
注：通配服务降级通常在消费者端进行，在远程服务调用接口（service层）上进行，构建该接口的实现类来实现服务异常的兜底（服务降级fallback）。 1、服务接口 package com.springcloud.service; import org.springframework.cloud.netflix.eureka.EnableEurekaClient; import org.springframework.cloud.openfeign.FeignClient; import org.spri
SpringCloud-Hystrix当中的服务降级具体实现
qq_31850627的博客
09-09 141
Hystrix服务降级： 当系统的方法调用时，发生错误或系统宕机或网络卡顿调用失败时，系统可以使用其他方法来进行调用来防止直接将系统回传直接发给调用者。可以使代码更加健壮 调用方式 在系统服务提供端（provicer） 首先在pom端添加坐标 <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-c
spring cloud 自动降级
xuehentian的博客
07-12 1072
1、让greeting-service支持hystrix（1）pom.xml&lt;dependency&gt;    &lt;groupId&gt;org.springframework.cloud&lt;/groupId&gt;    &lt;artifactId&gt;spring-cloud-starter-hystrix&lt;/artifactId&gt;&lt;/dependency...
spring cloud服务降级
08-01
Spring Cloud中的服务降级是指将某些服务停掉或者不进行业务处理，以释放资源来维持主要服务的功能。[2]比如在某电商网站搞活动时，活动期间压力太大，为了避免整个系统崩溃，可以采取服务降级措施，停掉一些不那么重要的服务，比如登录、注册服务。这样可以释放资源，同时不影响主要的商品抢购服务。[2] 在Spring Cloud中，可以使用Hystrix来实现服务降级。首先，在服务调用方的pom文件中添加依赖： ```xml <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-hystrix</artifactId> </dependency> ``` 然后，在需要进行降级的服务上添加@HystrixCommand注解，指定降级处理的方法。当该服务出现故障或超时时，Hystrix会自动调用降级处理的方法，保证系统的稳定性。[3] 总结起来，Spring Cloud中的服务降级通过停掉或不处理某些服务来释放资源，以维持主要服务的功能。可以使用Hystrix来实现服务降级，并在需要降级的服务上添加@HystrixCommand注解。
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值