spring cloud 熔断重试时间 spring cloud 熔断的作用

转载

mob64ca1400133b 2024-02-26 07:14:32

文章标签 spring cloud 熔断重试时间 java spring 微服务 ci 文章分类 架构后端开发

一、微服务架构中为什么要有熔断器？

在微服务架构中，每个服务单元都是独立部署的，服务之间通过远程调用来实现信息交互，那么当某个服务的响应太慢、发生故障或者网络波动，则会造成调用者延迟或调用失败，当大量请求到达，就会造成请求的堆积，导致调用者的线程挂起，从而引发调用者也无法响应，调用者也发生故障。为了解决此问题，微服务架构中引入了一种叫熔断器的服务保护机制。

二、微服务架构中的熔断器是什么？

微服务架构中的熔断器，就是当被调用方没有响应，调用方直接返回一个错误响应，而不是长时间的等待，这样避免调用时因为等待而线程一直得不到释放，避免故障在分布式系统间蔓延。服务熔断类比保险丝达到最大服务访问后，直接拒绝访问，拉闸限电，然后调用服务降级的方法并返回友好提示。

三、Spring Cloud Hystrix是什么？

Spring Cloud Hystrix是基于 Netflix 的开源框架 Hystrix 实现的，它实现了熔断器、线程隔离等一系列服务保护功能。具备服务降级、服务熔断、线程和信号隔离、请求缓存、请求合并以及服务监控等强大功能。该框架的目标在于通过控制那些访问远程系统、服务和第三方库的节点，从而对延迟和故障提供更强大的容错能力。

四、Hystrix服务熔断的快速使用

（要使用Hystrix 仪表盘监控可以看第七，异常处理可以看第六）
（1）、在消费者springboot项目中添加下面依赖

<!--Spring Cloud 熔断器起步依赖 -->
 <dependency>
      <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-starter-hystrix</artifactId>
      <version>1.4.4.RELEASE</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>

（2）、在消费者springboot项目的启动类中使用@EnableCircuitBreaker 注解开启断路器功能（也可以使用@SpringCloudApplication 代替下面主类上的三个注解）

@SpringBootApplication//开启支持springboot的注解
@EnableEurekaClient//开启eureka客户端的支持
@EnableCircuitBreaker//开启断路器功能
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

（3）、在调用远程服务的方法上添加下面注解：

@HystrixCommand(fallbackMethod="error")

如下图：

@RestController
public class WebController {
    @Autowired
    RestTemplate restTemplate;
    
    @RequestMapping("/web/hello")
    @HystrixCommand(fallbackMethod = "error",/*指定善后方法名*/commandProperties = {
            @HystrixProperty(name="execution.isolation.thread.timeoutInMilliseconds",value="3000")
    })//表示发生故障时调用error方法，error方法需要自定义
    public String hello(){
        return  restTemplate.getForEntity("http://02-SPRINGCLOUD-SERVICE-PROVIDER/service/hello", String.class).getBody();;
    }
    public String error(){
        return "error";//远程访问失败，可以在这里进行业务处理
    }
}

五、 Hystrix的服务降级

服务降级，就是当某个服务熔断之后，服务端提供的服务将不再被调用，此时由客户端自己准备一个本地的fallback 回调，返回一个默认值来代表服务端的返回；如：服务器忙，请稍后再试。这种做法，虽然不能得到正确的返回结果，但至少保证了服务的可用，比直接抛出错误或服务不可用要好很多，当然这需要根据具体的业务场景来选择，如常见的使用场景有

程序运行导常
超时
服务熔断触发服务降级
线程池/信号量打满也会导致服务降级
补充：服务限流
秒杀高并发等操作，严禁一窝蜂的过来拥挤，大家排队，一秒钟N个，有序进行。
服务的降级 -> 进而熔断 -> 恢复调用链路

六、 Hystrix 的异常处理

1.方法一：通配服务降级FeignFallback
（1）在消费者工程业务层添加fallback = PaymentFallbackService.class

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;
@Component
@FeignClient(value = "CLOUD-PROVIDER-HYSTRIX-PAYMENT" ,//
             fallback = PaymentFallbackService.class)//指定PaymentFallbackService类
public interface PaymentHystrixService
{
    @GetMapping("/payment/hystrix/ok/{id}")
    public String paymentInfo_OK(@PathVariable("id") Integer id);

    @GetMapping("/payment/hystrix/timeout/{id}")
    public String paymentInfo_TimeOut(@PathVariable("id") Integer id);
}

（2）新建一个类(AaymentFallbackService)实现消费者业务层接口

import org.springframework.stereotype.Component;
@Component
public class PaymentFallbackService implements PaymentHystrixService
{
    @Override
    public String paymentInfo_OK(Integer id)
    {
        return "-----PaymentFallbackService fall back-paymentInfo_OK ,o(╥﹏╥)o";
    }

    @Override
    public String paymentInfo_TimeOut(Integer id)
    {
        return "-----PaymentFallbackService fall back-paymentInfo_TimeOut ,o(╥﹏╥)o";
    }
}

2、方法二：使用全局服务降级，按照下面3个步骤逐一进行，有标1、2、3。除了个别重要核心业务有专属，其它普通的可以通过@DefaultProperties(defaultFallback = “”)统一跳转到统一处理结果页面

@RestController//1、使用全局配置
@DefaultProperties(defaultFallback = "payment_Global_FallbackMethod")
public class OrderHystirxController {
    @Resource
    private PaymentHystrixService paymentHystrixService;
    
    @GetMapping("/consumer/payment/hystrix/timeout/{id}")
    @HystrixCommand//2、用全局的fallback方法
    public String paymentInfo_TimeOut(@PathVariable("id") Integer id) {
        //int age = 10/0;
        String result = paymentHystrixService.paymentInfo_TimeOut(id);
        return result;
    }
    public String paymentTimeOutFallbackMethod(@PathVariable("id") Integer id)
    {
        return "我是消费者80,对方支付系统繁忙请10秒钟后再试或者自己运行出错请检查自己,o(╥﹏╥)o";
    }

    //3、下面是全局fallback方法
    public String payment_Global_FallbackMethod()
    {
        return "Global异常处理信息，请稍后再试，/(ㄒoㄒ)/~~";
    }
}

3、方法三：在调用服务提供者时，消费者也可能会抛异常，默认情况下方法抛了异常会自动进行服务降级，交给服务降级中的方法去处理；
第一步：加上@HystrixCommand(fallbackMethod = “error”)注解，表示发生故障时调用error方法

@RequestMapping("/web/hello")
@HystrixCommand(fallbackMethod = "error")//表示发生故障时调用error方法，error方法需要自定义
    public String hello(){
        int i = 0/0;
        return  restTemplate.getForEntity("http://02-SPRINGCLOUD-SERVICE-PROVIDER/service/hello", String.class).getBody();
    }

第二步：当我们自己发生异常后，只需要在服务降级方法中添加一个Throwable 类型的参数就能够获取到抛出的异常的类型

//熔断的回调方法，也就是服务降级的方法
    public String error(Throwable throwable){
        //远程调用失败，可以在此进行处理
        System.out.println("异常信息："+throwable.getMessage());
        return "error";
    }

（2）这步可忽略，如果我们希望将异常直接抛给用户，那么我们可以在@HystrixCommand 注解中添加忽略异常，如下：

@HystrixCommand(fallbackMethod="error", ignoreExceptions = Exception.class)

4、方法四
第一步：自定义类继承自 HystrixCommand 来实现自定义的 Hystrix 请求在 getFallback 方法中调用 getExecutionException 方法来获取服务抛出的异常

package com.chang.springcloud.hystrix;

import com.netflix.hystrix.HystrixCommand;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.client.RestTemplate;
//自定义Hystrix请求
public class MyHystrixCommand extends HystrixCommand<String> {
    @Autowired
    RestTemplate restTemplate;

    public MyHystrixCommand(Setter setter,RestTemplate restTemplate){
        super(setter);
        this.restTemplate=restTemplate;
    }

    @Override
    protected String run() throws Exception {
         //调用远程的服务
        return restTemplate.getForEntity("http://02-SPRINGCLOUD-SERVICE-PROVIDER/service/hello", String.class).getBody();
    }
    //当远程服务超时、异常、不可用等情况时，会触发改熔断方法
    @Override
    public String getFallback() {
        //获取返回的异常信息是什么
        Throwable throwable = super.getExecutionException();
        System.out.println(throwable);
        //实现服务熔断/降级逻辑
        return "getFallback";
    }
}

第二步：可以用同步调用和异步调用，下面使用异步调用

@RequestMapping("/hystrix/hello")
 @HystrixCommand//(fallbackMethod = "error")
    public Future<String> hello02() throws ExecutionException, InterruptedException {
        int i = 0/0;
        MyHystrixCommand myHystrixCommand = new MyHystrixCommand(com.netflix.hystrix.HystrixCommand.Setter.withGroupKey(HystrixCommandGroupKey.Factory.asKey("")),restTemplate);
       //同步调用，拿到远程结果才会继续执行
       // String execute = myHystrixCommand.execute();
        //异步调用到返回值前都是
        Future<String> queue = myHystrixCommand.queue();

        //可以在此写一些业务逻辑

        //会阻塞
        String str = queue.get();

        //可以在此写一些业务逻辑
        return  queue;
    }

七. Hystrix 仪表盘监控

Hystrix 仪表盘主要用来监控 Hystrix 的实时运行状态，通过它我们可以看到 Hystrix 的各项指标信息，从而快速发现系统中存在的问题进而解决它。
搭建一个 Hystrix Dashboard 服务的步骤：
（1)、创建一个普通的 Spring Boot 工程
比如创建一个名为 springcloud-hystrix-dashboard 的 Spring Boot 工程，建立好基本的结构和配置，然后引入下面依赖

<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.0.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
 </parent>
 <dependencies>
   <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>
 <!--hystrix-dashboard仪表盘起步依赖-->
<dependency>
      <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-starter-netflix-hystrix-dashboard</artifactId>
</dependency>
   
 </dependencies>
          <!--依赖管理必须加，要不然spring-cloud-starter-netflix-eureka-server版本无法做到-->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Hoxton.SR10</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <!--在本地仓库找不到就到官网去找-->
    <repositories>
        <repository>
            <id>spring-milestones</id>
            <name>Spring Milestones</name>
            <url>https://repo.spring.io/libs-milestone</url>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </repository>
    </repositories>

（2）在入口类上添加@EnableHystrixDashboard 注解开启仪表盘
功能，如下：

@SpringBootApplication
@EnableHystrixDashboard//开启仪表盘的功能
public class MainApplication {

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

（3)、在配置文件application.properties 修改端口号

#Hystrix仪表盘的功能
server.port=2001

至此，我们的 Hystrix 监控环境就搭建好了；注意访问是: 主机名+端口号+/hystrix

spring cloud 熔断重试时间 spring cloud 熔断的作用_微服务

现在我们需要有一个服务，让这个服务提供一个路经为/actuator/hystrix.stream 接口，然后就可以使用 Hystrix 仪表盘来对该服务进行监控了；我们改造消费者服务，让其能提供/actuator/hystrix.stream 接口，步骤如下：
(1)、消费者项目需要有 hystrix 的依赖和一个 spring boot 的服务监控依赖：

<!--Spring Cloud 熔断器起步依赖,项目有可以忽略 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-hystrix</artifactId>
            <version>1.4.4.RELEASE</version>
        </dependency>
        <!--spring boot 的服务监控依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>

（2）配置文件需要配置 spring boot 监控端点的访问权限：

#spring boot 监控端点的访问权限,*表示可以访问所有的访问端点
management.endpoints.web.exposure.include=*

这个是用来暴露 endpoints 的，由于 endpoints 中会包含很多敏感信息，除了 health 和 info 两个支持直接访问外，其他的默认不能直接访问，所以我们让它都能访问，或者指定：
management.endpoints.web.exposure.include=hystrix.stream
（3）注意：新版本Hystrix需要在主启动类PaymentHystrixMain8001中指定监控路径

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


    /**
     *此配置是为了服务监控而配置，与服务容错本身无关，springcloud升级后的坑
     *ServletRegistrationBean因为springboot的默认路径不是"/hystrix.stream"，
     *只要在自己的项目里配置上下面的servlet就可以了
     *否则，Unable to connect to Command Metric Stream 404
     */
    @Bean
    public ServletRegistrationBean getServlet() {
        HystrixMetricsStreamServlet streamServlet = new HystrixMetricsStreamServlet();
        ServletRegistrationBean registrationBean = new ServletRegistrationBean(streamServlet);
        registrationBean.setLoadOnStartup(1);
        registrationBean.addUrlMappings("/hystrix.stream");
        registrationBean.setName("HystrixMetricsStreamServlet");
        return registrationBean;
    }
}

（4）在浏览器直接输入 http://localhost:8081/actuator/hystrix.stream(端口号可能不同，其它都是一样的)

注意：先访问consumer 工程中的任意一个其他接口（有熔断器），再访问/hystrix.stream 接口即可。否则直接访问/hystrix.stream 接口时会输出出一连串的 ping: ping: …

（5）将上面地址http://localhost:8081/actuator/hystrix.stream复制到下面地址上进行监控 Hystrix 仪表盘监控数据的解读

spring cloud 熔断重试时间 spring cloud 熔断的作用_java_02

spring cloud 熔断重试时间 spring cloud 熔断的作用_spring_03

八、Hystrix服务熔断的使用

（1）服务熔断的使用

//=====服务熔断
@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) {
    ...
}
 public String paymentCircuitBreaker_fallback(@PathVariable("id") Integer id) {
         return "熔断器来了";
    }

（2）其它参数的使用

@HystrixCommand(fallbackMethod = "fallbackMethod", 
                groupKey = "strGroupCommand", 
                commandKey = "strCommand", 
                threadPoolKey = "strThreadPool",
                
                commandProperties = {
                    // 设置隔离策略，THREAD 表示线程池 SEMAPHORE：信号池隔离
                    @HystrixProperty(name = "execution.isolation.strategy", value = "THREAD"),
                    // 当隔离策略选择信号池隔离的时候，用来设置信号池的大小（最大并发数）
                    @HystrixProperty(name = "execution.isolation.semaphore.maxConcurrentRequests", value = "10"),
                    // 配置命令执行的超时时间
                    @HystrixProperty(name = "execution.isolation.thread.timeoutinMilliseconds", value = "10"),
                    // 是否启用超时时间
                    @HystrixProperty(name = "execution.timeout.enabled", value = "true"),
                    // 执行超时的时候是否中断
                    @HystrixProperty(name = "execution.isolation.thread.interruptOnTimeout", value = "true"),
                    
                    // 执行被取消的时候是否中断
                    @HystrixProperty(name = "execution.isolation.thread.interruptOnCancel", value = "true"),
                    // 允许回调方法执行的最大并发数
                    @HystrixProperty(name = "fallback.isolation.semaphore.maxConcurrentRequests", value = "10"),
                    // 服务降级是否启用，是否执行回调函数
                    @HystrixProperty(name = "fallback.enabled", value = "true"),
                    // 是否启用断路器
                    @HystrixProperty(name = "circuitBreaker.enabled", value = "true"),
                    // 该属性用来设置在滚动时间窗中，断路器熔断的最小请求数。例如，默认该值为 20 的时候，如果滚动时间窗（默认10秒）内仅收到了19个请求， 即使这19个请求都失败了，断路器也不会打开。
                    @HystrixProperty(name = "circuitBreaker.requestVolumeThreshold", value = "20"),
                    
                    // 该属性用来设置在滚动时间窗中，表示在滚动时间窗中，在请求数量超过 circuitBreaker.requestVolumeThreshold 的情况下，如果错误请求数的百分比超过50, 就把断路器设置为 "打开" 状态，否则就设置为 "关闭" 状态。
                    @HystrixProperty(name = "circuitBreaker.errorThresholdPercentage", value = "50"),
                    // 该属性用来设置当断路器打开之后的休眠时间窗。 休眠时间窗结束之后，会将断路器置为 "半开" 状态，尝试熔断的请求命令，如果依然失败就将断路器继续设置为 "打开" 状态，如果成功就设置为 "关闭" 状态。
                    @HystrixProperty(name = "circuitBreaker.sleepWindowinMilliseconds", value = "5000"),
                    // 断路器强制打开
                    @HystrixProperty(name = "circuitBreaker.forceOpen", value = "false"),
                    // 断路器强制关闭
                    @HystrixProperty(name = "circuitBreaker.forceClosed", value = "false"),
                    // 滚动时间窗设置，该时间用于断路器判断健康度时需要收集信息的持续时间
                    @HystrixProperty(name = "metrics.rollingStats.timeinMilliseconds", value = "10000"),
                    
                    // 该属性用来设置滚动时间窗统计指标信息时划分"桶"的数量，断路器在收集指标信息的时候会根据设置的时间窗长度拆分成多个 "桶" 来累计各度量值，每个"桶"记录了一段时间内的采集指标。
                    // 比如 10 秒内拆分成 10 个"桶"收集这样，所以 timeinMilliseconds 必须能被 numBuckets 整除。否则会抛异常
                    @HystrixProperty(name = "metrics.rollingStats.numBuckets", value = "10"),
                    // 该属性用来设置对命令执行的延迟是否使用百分位数来跟踪和计算。如果设置为 false, 那么所有的概要统计都将返回 -1。
                    @HystrixProperty(name = "metrics.rollingPercentile.enabled", value = "false"),
                    // 该属性用来设置百分位统计的滚动窗口的持续时间，单位为毫秒。
                    @HystrixProperty(name = "metrics.rollingPercentile.timeInMilliseconds", value = "60000"),
                    // 该属性用来设置百分位统计滚动窗口中使用 “ 桶 ”的数量。
                    @HystrixProperty(name = "metrics.rollingPercentile.numBuckets", value = "60000"),
                    // 该属性用来设置在执行过程中每个 “桶” 中保留的最大执行次数。如果在滚动时间窗内发生超过该设定值的执行次数，
                    // 就从最初的位置开始重写。例如，将该值设置为100, 滚动窗口为10秒，若在10秒内一个 “桶 ”中发生了500次执行，
                    // 那么该 “桶” 中只保留 最后的100次执行的统计。另外，增加该值的大小将会增加内存量的消耗，并增加排序百分位数所需的计算时间。
                    @HystrixProperty(name = "metrics.rollingPercentile.bucketSize", value = "100"),
                    
                    // 该属性用来设置采集影响断路器状态的健康快照（请求的成功、 错误百分比）的间隔等待时间。
                    @HystrixProperty(name = "metrics.healthSnapshot.intervalinMilliseconds", value = "500"),
                    // 是否开启请求缓存
                    @HystrixProperty(name = "requestCache.enabled", value = "true"),
                    // HystrixCommand的执行和事件是否打印日志到 HystrixRequestLog 中
                    @HystrixProperty(name = "requestLog.enabled", value = "true"),

                },
                threadPoolProperties = {
                    // 该参数用来设置执行命令线程池的核心线程数，该值也就是命令执行的最大并发量
                    @HystrixProperty(name = "coreSize", value = "10"),
                    // 该参数用来设置线程池的最大队列大小。当设置为 -1 时，线程池将使用 SynchronousQueue 实现的队列，否则将使用 LinkedBlockingQueue 实现的队列。
                    @HystrixProperty(name = "maxQueueSize", value = "-1"),
                    // 该参数用来为队列设置拒绝阈值。 通过该参数， 即使队列没有达到最大值也能拒绝请求。
                    // 该参数主要是对 LinkedBlockingQueue 队列的补充,因为 LinkedBlockingQueue 队列不能动态修改它的对象大小，而通过该属性就可以调整拒绝请求的队列大小了。
                    @HystrixProperty(name = "queueSizeRejectionThreshold", value = "5"),
                }
               )
public String doSomething() {
	...
}

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：Python爬虫中的select python爬虫列表搜索

下一篇：kafka序列化集合异常 kafka消息序列化

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯