springcloud使用hystrix组件实现微服务集群降级、熔断、限流

已于 2023-08-24 21:15:41 修改
阅读量618 收藏
点赞数
文章标签： spring cloud 微服务 java
于 2022-06-22 09:55:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/QingChunBuSanChang/article/details/125403681
版权

spring-cloud-hystrix实现微服务集群降级、熔断、限流

参考：https://windmt.com/2018/04/15/spring-cloud-4-hystrix/

https://blog.csdn.net/varyall/article/details/99722594?spm=1001.2014.3001.5502

https://www.cnblogs.com/sword-successful/p/13548233.html

注意：springcloud使用Hystrix在springcloud整合ribbon和feign的基础上

一、Hystrix实现降级和隔离

服务降级场景：

  • A服务调用B服务的一些接口，现在为了防止B服务的接口出现因为服务宕机造成的问题，需要对B服务的接口增加降级处理
  • B服务的接口调用方式
    • 采用@FeignClient注解的方式进行调用
    • 采用RestTemplate的方式
  • 因此服务的降级和服务的隔离，都是建立在A服务调用B服务的接口处理上。
1、Hystrix快速引入
（1）添加依赖
<dependency>
	<groupId>org.springframework.cloud</groupId>
	<artifactId>spring-cloud-starter-hystrix</artifactId>
	<version>1.4.7.RELEASE</version> 
</dependency>
（2）启动类开启Hystrix
  • @EnableCircuitBreaker 启用开启断路器熔断命令
  • @EnableHystrix 开启断路器组件
@EnableHystrix
@EnableCircuitBreaker
@SpringBootApplication
public class ConsumerMovieFeignApplication {
   public static void main(String[] args) {
      SpringApplication.run(ConsumerMovieFeignApplication.class, args);
   }
}
（3）常用配置
# 开启熔断机制
feign:
  hystrix:
    enabled: true
# ribbon配置
ribbon:
  # 开启eureka与ribbon的集成
  eureka:
    enabled: true
  # 暂不开启熔断机制
  hystrix:
    enabled: false
  # 配置ribbon默认的超时时间
  ConnectTimeout: 20000
  ReadTimeout: 20000
  # 是否开启重试
  OkToRetryOnAllOperations: true
  # 重试的时候实例切换次数
  MaxAutoRetriesNextServer: 3
  # 每个实例重试次数
  MaxAutoRetries: 2
  
## hystrix相关配置
## hystrix默认会读取classpath下的config.properties文件，application会覆盖config.properties中的属性
hystrix:
  threadpool:
    # 指定服务的配置
    user-service:
      coreSize: 20
      maxQueueSize: 200
      queueSizeRejectionThreshold: 3
    # userThreadPool是UserTimeOutCommand中配置的threadPoolKey
    userThreadPool:
      coreSize: 20
      maxQueueSize: 20
      queueSizeRejectionThreshold: 3
    # 这是默认的配置
    default:
      coreSize: 10
      maxQueueSize: 200
      queueSizeRejectionThreshold: 2
  command:
    # 指定feign客户端中具体的方法
    UserService#timeout():
      execution:
        isolation:
          thread:
            timeoutInMilliseconds: 20000
    userCommandKey:
      execution:
        isolation:
          thread:
            timeoutInMilliseconds: 15000
    # 这是默认的配置
    default:
      execution:
        timeout:
          enabled: true
         # 隔离配置
        isolation:
          strategy: THREAD 
          thread:
            timeoutInMilliseconds: 15000
            interruptOnTimeout: true
            interruptOnFutureCancel: false
          semaphore:
            maxConcurrentRequests: 2
      # 降级配置
      fallback:
        enabled: true
        isolation:
          semaphore:
            maxConcurrentRequests: 10
      # 断路器配置
      circuitBreaker:
        enabled: true
        forceOpen: false
        forceClosed: false
        requestVolumeThreshold: 4
        errorThresholdPercentage: 50
        sleepWindowInMilliseconds: 10000
      metrics:
        rollingStats:
          timeInMilliseconds: 5000
          numBuckets: 10
        rollingPercentile:
          enabled: true
          timeInMilliseconds: 60000
          numBuckets: 6
          bucketSize: 100
        healthSnapshot:
          intervalInMilliseconds: 500
2、常用基于FeignClient注解实现
（1）@FeignClient+回调工厂方式
  • @FeignClient的fallbackFactory使用工厂方式
@FeignClient(name = "microservice-provider-user",
             fallbackFactory = HelloRollBackFactory.class)
public interface UserFeignClient {

  @RequestMapping(value = "/simple/{id}", method = RequestMethod.GET)
  public User findById(@PathVariable("id") Long id);
}

@Slf4j
@Component
public class HelloRollBackFactory implements FallbackFactory<HelloService> {

    @Override
    public HelloService create(Throwable throwable) {
        //可以抓取异常
        log.info("fallback; reason was: {}", throwable.getMessage());
        //返回实现的一个回调接口
        return new HelloService(){
            @Override
            public User findById(String name) {
                log.info("UserFeignClient#findById#id={}服务降级了",id);
                User user = new User();
                user.setId(0L);
                return user;
            }
        }
    }
}
（2）、@FeignClient+继承接口方式
@FeignClient(name = "microservice-provider-user", fallback = HystrixClientFallback.class)
public interface UserFeignClient {
  @GetMapping("/simple/{id}")
  public User findById(@PathVariable("id") Long id);
}

@Slf4j
@Component
public class HystrixClientFallback implements UserFeignClient {
  //回调类，返回一个默认的user，防止调用出现空指针的问题
  @Override
  public User findById(Long id) {
    log.info("UserFeignClient#findById#id={}服务降级了",id);
    User user = new User();
    user.setId(0L);
    return user;
  }
}
（3）通过@HystrixCommand+RestTemplate

https://www.cnblogs.com/zou-rong/p/12589390.html

  • 实现接口隔离（线程隔离和信号量隔离）
  • 实现调用的负载均衡
  • 实现调用过程中降级
#设置线程隔离超时时间为5S
hystrix.command.default.execution.isolation.thread.timeoutInMilliseconds=5000

//在配置类中引入RestTemplate并使用Ribbon的@LoadBalanced注解
@Bean
@LoadBalanced
public RestTemplate restTemplate() {
    return new RestTemplate();
}

@RestController
public class MovieController {
    
    @Autowired
    private RestTemplate restTemplate;

   //==========================线程隔离，缺点比较费资源=========================
    @GetMapping("/user/{id}")
    @HystrixCommand(groupKey="UserGroup", 
                    commandKey = "GetUserByIdCommand"，
                    fallbackMethod = "findByIdFallback",
                    commandProperties = {
                        //超时时间，单位毫秒。超时进fallback
                        @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "100"),
                        //判断熔断的最少请求数，默认是10；只有在一定时间内请求数量达到该值，才会进行成功率的计算
                        @HystrixProperty(name = "circuitBreaker.requestVolumeThreshold", value = "10"),
                        //熔断的阈值默认值50，表示在一定时间内有50%的请求处理失败，会触发熔断
                        @HystrixProperty(name = "circuitBreaker.errorThresholdPercentage", value = "10"),
                    },
                    //线程池参数配置
                    threadPoolProperties = {
                        @HystrixProperty(name = "coreSize", value = "30"),
                        @HystrixProperty(name = "maxQueueSize", value = "101"),
                        @HystrixProperty(name = "keepAliveTimeMinutes", value = "2"),
                        @HystrixProperty(name = "queueSizeRejectionThreshold", value = "15"),
                        @HystrixProperty(name = "metrics.rollingStats.numBuckets", value = "12"),
                        @HystrixProperty(name = "metrics.rollingStats.timeInMilliseconds", value = "1440")
                    })
    public User findById(@PathVariable Long id) {
        //通过restTemplate进行调用
        return this.restTemplate
            .getForObject("http://microservice-provider-user/simple/" + id,
                          User.class);
    }
    public User findByIdFallback(Long id) {
        log.info("UserFeignClient#findById#id={}服务降级了",id);
        User user = new User();
        user.setId(0L);
        return user;
    }
    
    //========================信号量隔离,建议使用========================
    //注意下面这一个注解里面的内容，这样配置更加详细一点
    @GetMapping("/user2/{id}")
    @HystrixCommand(fallbackMethod = "findByIdFallback", 
         commandProperties = @HystrixProperty(
             		name = "execution.isolation.strategy", 
                    value = "SEMAPHORE"))
    public User findById(@PathVariable Long id) {
        return this.restTemplate
            .getForObject("http://microservice-provider-user/simple/" + id, 
                          User.class);
    }
	//服务降级出口
    public User findByIdFallback(Long id) {
        log.info("UserFeignClient#findById#id={}服务降级了",id);
        User user = new User();
        user.setId(0L);
        return user;
    }
    
}
//=========================可以配置统一的服务降级的处理==============//
@RestController
@RequestMapping("/consumer")
@Slf4j
@DefaultProperties(defaultFallback = "getUserByIdFallBack")//指定默认降级函数
public class ConsumerController {

    @Autowired
    private RestTemplate template;


    @GetMapping("/{id}")
    @HystrixCommand //启用熔断降级
    public String getUserById(@PathVariable("id")Long id){
        String url="http://user-service/user/"+id;
        long start=System.currentTimeMillis();
        String user = template.getForObject(url, String.class);
        long end=System.currentTimeMillis();
        log.debug("调用时长：{}",end-start);
        return user;
    }

　　//注意此时的返回值没有限制，不能写参数，因为这是当前类通用的降级方法
    public String getUserByIdFallBack(){
        return "很抱歉，服务器正忙，请稍后再试。";
    }

}
（4）HystrixCommand注解源码
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface HystrixCommand {
    //配置全局唯一标识服务的名称
    String groupKey() default "";
    
    //配置全局唯一标识服务分组的名称，比如，库存系统、订单系统、系统用户就是一个单独的服务分组
    String commandKey() default "";

    //对线程池进行设定，细粒度的配置，相当于对单个服务的线程池信息进行设置，也可多个服务设置同一个threadPoolKey构成线程组
    String threadPoolKey() default "";

    //执行快速失败的回调函数，@HystrixCommand修饰的函数必须和这个回调函数定义在同一个类中，因为定义在了同一个类中，所以fackback method可以是public/private均可
    String fallbackMethod() default "";

    //配置该命令的一些参数，如executionIsolationStrategy配置执行隔离策略，默认是使用线程隔离
    HystrixProperty[] commandProperties() default {};

    //线程池相关参数设置，具体可以设置哪些参数请见：com.netflix.hystrix.HystrixThreadPoolProperties
    HystrixProperty[] threadPoolProperties() default {};

    //调用服务时，除了HystrixBadRequestException之外，其他@HystrixCommand修饰的函数抛出的异常均会被Hystrix认为命令执行失败而触发服务降级的处理逻辑（调用fallbackMethod指定的回调函数），所以当需要在命令执行中抛出不触发降级的异常时来使用它，通过这个参数指定，哪些异常抛出时不触发降级（不去调用fallbackMethod），而是将异常向上抛出
    Class<? extends Throwable>[] ignoreExceptions() default {};

    //定义hystrix observable command的模式
    ObservableExecutionMode observableExecutionMode() default ObservableExecutionMode.EAGER;

    //任何不可忽略的异常都包含在HystrixRuntimeException中
    HystrixException[] raiseHystrixExceptions() default {};

    //默认的回调函数，该函数的函数体不能有入参，返回值类型与@HystrixCommand修饰的函数体的返回值一致。如果指定了fallbackMethod，则fallbackMethod优先级更高
    String defaultFallback() default "";
}
（5）通过OrderHystrixCommand编码实现
//线程池隔离
@Slf4j
public class OrderHystrixCommand extends HystrixCommand<String> {
    //这种方式可以调用Feign的接口
    OrderService orderService;
    
    //设置线程池隔离
    public OrderHystrixCommand(OrderService orderService) {
        super(Setter
           //服务分组
           .withGroupKey(HystrixCommandGroupKey.Factory.asKey("orderGroup")) 
           //命令分组
           .andCommandKey(HystrixCommandKey.Factory.asKey("orderCommandKey"))
           //线程池配置
           .andThreadPoolKey(HystrixThreadPoolKey.Factory.asKey("OrderPool"))
           .andThreadPoolPropertiesDefaults(HystrixThreadPoolProperties.Setter()
               .withCoreSize(10).withKeepAliveTimeMinutes(5)
               .withMaxQueueSize(10).withQueueSizeRejectionThreshold(10000))
            //断路器配置
            .andCommandPropertiesDefaults(
                //设置线程池隔离
                HystrixCommandProperties.Setter().withExecutionIsolationStrategy(
                    	HystrixCommandProperties.ExecutionIsolationStrategy.THREAD))
        );
        //设置Service
        this.orderService = orderService;
    }
    
	// 方式一：通过线程池的run方法执行getOrderList 最后得到结果
    @Override
    protected List run() throws Exception {
        return orderService.getOrderList();
    }
    
    /***  方式二：采用Rest调用的方式 直接采用父类的实现
     public OrderHystrixCommand() {
        super(HystrixCommandGroupKey.Factory.asKey("orderGroup"));
    }
	
    //这里也可以使用RestTemplate进行调用
    @Override
    protected String run() throws Exception {
        LOGGER.info("start query timeout endpoint");
        URL url = new URL("http://localhost:8002/user/timeout");
        byte[] result = new byte[1024];
        url.openStream().read(result);
        return new String(result);
    }
 
    @Override
    protected String getFallback() {
        // 执行超时、出错或者开启熔断之后，使用这个方法返回
        // 这种策略称为服务降级
        // 这里可以是一个固定返回值，查询缓存等
        return "服务降级，暂时不可用";
    }
   ***/     
}

//测试采用命令方式调用
public  class UnitTest {
    @Test
    public void testGetOrder(){
        Future<List> future =new GetOrderCommand("hystrix-order").queue();
    }
}


//信号量隔离
public class QueryUserIdCommand extends HystrixCommand<Integer> {
    private final static Logger logger = LoggerFactory.getLogger(QueryUserIdCommand.class);
    //调用Feign的接口
    private UserServiceProvider userServiceProvider;
	public QueryUserAgeCommand(UserServiceProvider userServiceProvider) {
    	super(Setter.withGroupKey(HystrixCommandGroupKey.Factory.asKey("userService"))
            	.andCommandKey(HystrixCommandKey.Factory.asKey("queryByUserId"))
	            .andCommandPropertiesDefaults(HystrixCommandProperties.Setter()
                         //至少有10个请求，熔断器才会开始进行错误率计算
    	                .withCircuitBreakerRequestVolumeThreshold(10)
                         //熔断器中断请求，5秒后会进入一个半打开状态,放开部分请求去进行重试
        	            .withCircuitBreakerSleepWindowInMilliseconds(5000)
                         错误率达到50%就开启熔断保护   
            	        .withCircuitBreakerErrorThresholdPercentage(50)  
                         //设置为信号量隔离
                	    .withExecutionIsolationStrategy(HystrixCommandProperties.ExecutionIsolationStrategy.SEMAPHORE) 
                    	.withExecutionTimeoutEnabled(true))
	            .andThreadPoolPropertiesDefaults(HystrixThreadPoolProperties
    	                .Setter().withCoreSize(10)));
    	this.userServiceProvider = userServiceProvider;
	}
 
	@Override
	protected Integer run() {
    	return userServiceProvider.queryByUserId();
	}
 
	@Override
	protected Integer getFallback() {
    	   return -1;
	}
}


//异步的方式调用
Future<List> future =new QueryUserIdCommand("hystrix-order").queue();
//同步的方式调用
new UserExceptionCommand().execute();

/**响应式**/
//立即执行
Observable<String> ho = new UserExceptionCommand().observe();
//只有当被订阅的时候才会开始执行
Observable<String> co = new UserExceptionCommand().toObservable();
//阻塞的
ho.toBlockingObservable().single();
//非阻塞的
ho.subscribe(new Observer<String>() {
    @Override
    public void onCompleted() {
        // nothing needed here
    }
    @Override
    public void onError(Throwable e) {
        e.printStackTrace();
    }
    @Override
    public void onNext(String v) {
        System.out.println("onNext: " + v);
    }
});
// 非阻塞的
ho.subscribe(new Action1<String>() {
    @Override
    public void call(String v) {
        System.out.println("onNext: " + v);
    }
});

二、Hystrix实现熔断

@RestController
public class DeptController
{
    @Autowired
    private DeptService service;

    @RequestMapping(value = "/dept/add", method = RequestMethod.POST)
    public boolean add(@RequestBody Dept dept)
    {
        return service.add(dept);
    }

    @RequestMapping(value = "/dept/get/{id}", method = RequestMethod.GET)    //一旦调用服务方法失败抛出“错误信息后，胡自动范湖用@HystrixCommand标注好的fallbackMethod调用类中的指定方法”
    @HystrixCommand(fallbackMethod = "processHystrixGet")
    public Dept get(@PathVariable("id") Long id)
    {
        Dept dept = service.get(id);

        //模拟异常
        if(null == dept)
        {
            throw new RuntimeException("该id的信息不存在! id=" + id);
        }
        return service.get(id);
    }

    public Dept processHystrixGet(@PathVariable("id") Long id)
    {
        return new Dept().setDname("id没有对应的信息, null -- @HystrixCommand, id=" + id)
                .setDb_source("no this database in MySQL.");
    }
}

三、Hystrix实现限流

https://blog.csdn.net/qq_40990836/article/details/108500728

四、请求缓存功能@CacheResult

  • @CacheResult 该注解用来标记请求命令返回的结果应该被缓存，它必须与@HystrixCommand注解结合使用 cacheKeyMethod
  • @CacheRemove 该注解用来让请求命令的缓存失效，失效的缓存根据定义Key决定 commandKey, cacheKeyMethod
  • @CacheKey 该注解用来在请求命令的参数上标记，使其作为缓存的Key值，如果没有标注则会使用所有参数。如果同事还是使用了@CacheResult和@CacheRemove注解的cacheKeyMethod方法指定缓存Key的生成，那么该注解将不会起作用 value

附录、使用断路器监控

1、创建项目springcloud-hystrix-dashboard
(1)、添加依赖
<dependency>
	<groupId>org.springframework.cloud</groupId>
	<artifactId>spring-cloud-starter-hystrix-dashboard</artifactId>
</dependency>
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
(2)、新建项目 hstrix-dashboard

hstrix-dashboard支持的三种不同的集群监控

  1. 默认的集群监控：
    • 通过 URL：http://turbine-hostname:port/turbine.stream 开启，实现对默认集群的监控。
  2. 指定的集群监控：
    • 通过 URL：http://turbine-hostname:port/turbine.stream?cluster=[clusterName] 开启，实现对 clusterName 集群的监控。
  3. 单体应用的监控：
    • 通过 URL：http://hystrix-app:port/hystrix.stream 开启 ，实现对具体某个服务实例的监控。
    • 现在这里的 URL 应该为 http://hystrix-app:port/actuator/hystrix.stream，
    • Actuator 2.x 以后 endpoints 全部在 /actuator 下，可以通过 management.endpoints.web.base-path 修改）
  4. 前两者都对集群的监控，需要整合 Turbine 才能实现。这一部分我们先实现对单体应用的监控，这里的单体应用就用我们之前使用 Feign 和 Hystrix 实现的服务消费者
(3)、在已有项目上添加依赖
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix-dashboard</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
</dependency>
(4)、启动类
  • @EnableHystrixDashboard 开启DashBoard面板
@EnableHystrixDashboard
@SpringBootApplication
public class HystrixDashboardApplication {

    public static void main(String[] args) {
        SpringApplication.run(HystrixDashboardApplication.class, args);
    }
}
(5)、配置文件
spring:
  application:
    name: hystrix-dashboard
server:
  port: 11000
(6)、使用Hystrix的客户端，为服务实例添加 endpoint
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
2、使用Dashboard面板实现Hystrix监控
1、添加依赖
<dependency>
	<groupId>org.springframework.cloud</groupId>
	<artifactId>spring-cloud-starter-hystrix</artifactId>
</dependency>
<dependency>
	<groupId>org.springframework.cloud</groupId>
	<artifactId>spring-cloud-starter-hystrix-dashboard</artifactId>
</dependency>
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
3、修改配置
server:
  port: 8030
4、启动类
  • @EnableDiscoveryClient 开启服务注册和发现
  • @EnableFeignClients 开启远程调用
  • @EnableHystrixDashboard 开启DashBoard面板
  • @EnableCircuitBreaker 开启断路器
@SpringBootApplication
@EnableDiscoveryClient
@EnableFeignClients
@EnableHystrixDashboard
@EnableCircuitBreaker
public class ConsumerApplication {

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

打开http://localhost:9001/hystrix
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-93MLhG3Y-1655862891397)(…/…/typora-img/hystrix-dashboard-1.jpg)]
访问：http://localhost:9001/hystrix.stream
看到监控图形化显示
http://favorites.ren/assets/images/2017/springcloud/hystrix-dashboard-2.jpg

使用Turbine面板实现监控
添加依赖
<dependency>
	<groupId>org.springframework.cloud</groupId>
	<artifactId>spring-cloud-starter-turbine</artifactId>
</dependency>
<dependency>
	<groupId>org.springframework.cloud</groupId>
	<artifactId>spring-cloud-netflix-turbine</artifactId>
</dependency>
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<dependency>
	<groupId>org.springframework.cloud</groupId>
	<artifactId>spring-cloud-starter-hystrix-dashboard</artifactId>
</dependency>
添加配置
server:
  port: 8031
spring:
  application:
    name: microservice-hystrix-turbine
eureka:
  client:
    serviceUrl:
      defaultZone: http://user:password123@localhost:8761/eureka
  instance:
    prefer-ip-address: true
turbine:
  aggregator:
    clusterConfig: default
  appConfig: microservice-consumer-movie-ribbon-with-hystrix,microservice-consumer-movie-feign-with-hystrix
  clusterNameExpression: "'default'"
  • turbine.appConfig ：配置Eureka中的serviceId列表，表明监控哪些服务
  • turbine.aggregator.clusterConfig ：指定聚合哪些集群，多个使用”,”分割，默认为default。
  • turbine.clusterNameExpression ： 1. clusterNameExpression指定集群名称，默认表达式appName
天道酬勤的博客
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
springCloud_hystrix(断路由服务降级)
12-01
在微服务架构中，我们将业务拆分成一个个的服务，服务与服务之间可以相互调用（RPC）。为了保证其高可用，单个服务又必须集群部署。由于网络原因或者自身的原因，服务并不能保证服务的100%可用，如果单个服务出现...
浅谈SpringCloud实现简单的微服务架构
08-28
通过Spring Cloud，我们可以快速地搭建起一套完整的微服务架构，而无需关注每个组件的底层实现细节。 1. **服务注册与发现**： 在微服务架构中，服务注册与发现是非常关键的一环。Spring Cloud提供了Eureka作为...
Hystrix是个什么玩意儿
weixin_33816946的博客
03-18 259
1. 什么是Hystrix Hystrix是Netflix的一个开源框架，地址如下：https://github.com/Netflix/Hystrix 中文名为“豪猪”，即平时很温顺，在感受到危险的时候，用刺保护自己；在危险过去后，还是一个温顺的肉球。 所以，整个框架的核心业务也就是这2点： 何时需要保护 如何保护 2....
Spring cloud - Hystrix服务限流、熔断及降级
weixin_44612246的博客
11-19 363
Hystrix的主要作用是在微服务环境下防止服务雪崩，确保服务弹性及可用性。
SpringCloud微服务（十）——Hystrix服务降级熔断限流
qq_43409401的博客
11-23 663
Hystrix是一个用于处理分布式系统延迟和容错的开源库
【微服务笔记21】微服务组件之Sentinel服务熔断、服务降级、流量控制介绍
04-25 2585
Sentinel是Spring Cloud Alibaba提供的一个专门用于服务容错、服务熔断、服务限流的微服务组件，它和hystrix组件的作用是类似的，但是Sentinel提供的功能比hystrix更加强大，Sentinel分为两部分，一部分是Sentinel核心库，另外一部分是Dashboard控制台，Dashboard控制台可以查看监控的信息，接口的调用情况等。第一种：引入Sentinel核心库依赖，然后通过Java代码的方式编写流控规则。第二种：通过Dashboard控制台直接添加流控规则。
Hystrix熔断限流
Java技术干货
10-23 106
4、如果run()方法在指定的超时时间内没有返回结果，或者抛出了异常，那么Hystrix Command对象会执行fallback()方法，表示异常或超时时的备选逻辑，该结果返回给服务，并释放线程资源，同时向Hystrix Circuit Breaker对象报告失败信息。3、如果run()方法在指定的超时时间内返回了正常的结果，那么Hystrix Command对象会将该结果返回给服务，并释放线程资源，并向Hystrix Circuit Breaker对象报告成功信息。
hystrix 限流_SpringCloud入门降级、熔断、限流 Hystrix断路器
weixin_39579483的博客
12-01 118
服务降级Hystrix断路器分布式系统面临的问题复杂分布式体系结构中的应用程序有数十个依赖关系，每个依赖关系在某些时候将不可避免地失数。服务雪崩多个微服务之间调用的时候，假设微服务A调用微服务B和微服务C，微服务B和微服务C又调用其它的微服务，这就是所谓的“扇出”。如果扇出的链路上某个微服务的调用响应时间过长或者不可用，对微服务A的调用就会占用越来越多的系统资源，进而引起系统崩溃，所谓的...
分布式限流之 - Spring Cloud Gateway层限流实现
it_lihongmin的博客
05-21 3638
写在前面的话 高兵发的三驾马车：缓存、降级、限流，这里仅仅说限流 常用的限流算法有：计数器算法、固定窗口算法、滑动窗口算法、漏桶算法、令牌桶算法；每种算法的特点和优缺点这里不展开，比较适用的限流算法基本都会选择令牌桶，并且这里基于Spring Cloud Gateway Redis本身默认就是基于令牌桶算法实现 限流按照类型分为：单机、分布式； 限流按照请求流量的路径分为：nginx、gateway、微服务 如果仅仅使用于单机环境：谷歌guava的RateLimiter、（AtomicIntege
基于SpringCloud-微服务系统设计方案.rar
03-20
5. **服务熔断与降级**：引入Hystrix组件，实现服务的熔断和降级策略，保护系统稳定性。 6. **配置管理**：使用Spring Cloud Config统一管理服务的配置，支持配置的动态更新。 7. **监控与日志**：集成Spring Boot ...
springcloud微服务实战视频教程
05-22
SpringCloud作为微服务的工具集，它简化了服务发现、配置、熔断、负载均衡等关键功能的实现。 1. **服务发现**：Spring Cloud Netflix Eureka是服务注册与发现的组件，服务提供者在启动时会向Eureka Server注册自身...
springcloud代码示例，包括erueka,hystrix,ribbon的使用
01-22
Spring Cloud 是一个基于 Spring Boot 实现的云应用开发工具集，它为开发者提供了在分布式系统（如配置管理、服务发现、断路器、智能路由、微代理、控制总线、一次性令牌、全局锁、领导选举、分布式会话、集群状态）...
Hystrix之服务熔断支付侧breaker
qq_45078781的博客
07-20 222
服务熔断 一、概念 类比保险丝达到最大服务访问后，直接拒绝访问，拉闻限电，然后调用服务降级的方法并返回友好提示就是保险丝 服务的降级->进而熔断->恢复调用链路 二、修改cloud-provider-hystrix-payment8001 Hystrix之服务降级支付侧fallbackcloud-provider-hystrix-payment8001：https://blog.csdn.net/qq_45078781/article/details/118854118 //=====服务熔
微服务架构中的 熔断和降级
浮尘笔记
11-20 573
微服务架构中，如果需要保障可用性，其中一个方式就是 熔断。熔断在微服务架构里面是指 当微服务本身出现问题的时候，它会拒绝新的请求，直到微服务恢复。通过熔断机制可以给服务端恢复的时间，比如 CPU 使用率已经超出负载了，此时服务端触发了熔断，那么新来的请求就会被拒绝，因此，服务端的 CPU 使用率就会在一段时间内降到100%以内。
Spring Cloud——Spring Cloud GateWay熔断、降级、限流
weixin_44945027的博客
08-15 2334
从某种意义上讲，令牌桶算法是对漏桶算法的一种改进，漏桶算法能够限制请求调用的速率，而令牌桶算法能够在限制调用的平均速率的同时还允许一定程度的突发调用。放令牌这个动作是持续不断的进行，如果桶中令牌数达到上限，就丢弃令牌，所以就存在这种情况，桶中一直有大量的可用令牌，这时进来的请求就可以直接拿到令牌执行，比如设置qps为100，那么限流器初始化完成一秒后，桶中就已经有100个令牌了，这时服务还没完全启动好，等启动完成对外提供服务时，该限流器可以抵挡瞬时的100个请求。paramItem：参数限流配置。
Hystrix服务熔断
gmjian203828的博客
03-18 954
在分布式架构中会有多个为你服务层级调用而形成的调用链路，例如：在这个链路中某个服务发生异常，请求阻塞，用户的请求就不会得到响应，则tomcat这个线程不会释放，于是越来越多的用户请求到来，越来越多的线程会阻塞。Hystrix是一个应用于处理分布式系统的延迟和容错的开源库，Hystrix可以保证在一个依赖出问题的情况下，不会导致整个体系服务失败，提高了分布式系统的弹性。否则，继续保持打开状态。②用户的请求将不直接访问服务，而是通过线程池中的空闲线程来访问服务，如果线程池已满，请求超时，则会进行降级处理。
服务熔断（Hystrix）
qq_24428851的博客
12-22 999
熔断简单来说就是在单个服务出现问题，不可用时，为了避免引发更严重的问题，导致整个服务链路不可用的情况下，可以采用熔断的方式来避免。熔断一般情况下意味着服务的降级，可以理解为是一种异常兜底策略，需要服务的上游调用方来实现。
微服务（八）——Hystrix服务降级、熔断、限流(上)
不愿意做鱼的小鲸鱼の博客
07-26 654
Hystrix是一个用于处理分布式系统的**延迟**和**容错**的开源库，在分布式系统里，许多依赖不可避免的会调用失败，比如超时、异常等，Hystrix能够保证在一个依赖出问题的情况下，不会导致整体服务失败，避免级联故障，以提高分布式系统的弹性。...
【微服务网关——服务发现】
最新发布
qq_45467608的博客
07-03 1104
Apache ZooKeeper 是一个用于分布式系统中的协调服务。它提供了一套高效、可靠的分布式协调工具，用于实现服务注册、配置管理、同步、领导者选举等功能。Zookeeper 的设计初衷是简化分布式应用中的协调任务，从而使应用开发更容易。是一个分布式数据库（程序协调服务），Hadoop子项目树状方式维护节点方数据的增、删、改、查监听通知机制：通过监听可以获取相应消息事件（内容，子节点）
springcloud微服务框架搭建 简书
09-16
可以使用Spring Cloud提供的Hystrix进行熔断和降级处理，保证系统的稳定性。 7. 配置服务监控与追踪：为了对微服务进行监控和追踪，可以使用Spring Cloud提供的Actuator和Sleuth。Actuator可以暴露微服务的运行指标...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值