精华内容
下载资源
问答
  • hystrix降级

    2019-07-03 09:49:33
    服务降级是在消费者的接口层面设置,当提供者关闭或者异常时,返回错误提示信息,以避免拖死服务提供者,要在feign格式下设置 1.编写服务降级类,实现所需降级的接口 @Component // 不要忘记添加 public class ...

    服务降级是在消费者的接口层面设置,当提供者关闭或者异常时,返回错误提示信息,以避免拖死服务提供者,要在feign格式下设置

    1.编写服务降级类,实现所需降级的接口

    @Component // 不要忘记添加
    public class OrderServiceFallbackFactory implements FallbackFactory<UserFeignClient> {
        @Override
        public UserFeignClient create(Throwable throwable) {
            return new UserFeignClient() {
                @Override
                public String placeOrder() {
                    return "服务降级熔断。";
                }
            };
        }
    }
    

    2.为接口设置降级类

    @FeignClient(name = "eureka-provide",fallbackFactory = OrderServiceFallbackFactory.class)
    public interface UserFeignClient {
        @RequestMapping("/placeOrder")
        public String placeOrder();
    }
    

    3.配置文件开启服务降级支持

    feign.hystrix.enabled=true
    

    4.提供者正常的情况
    在这里插入图片描述

    5.关闭提供者,模拟异常
    在这里插入图片描述

    展开全文
  • Hystrix降级

    2019-03-28 16:16:13
    要使用@HystrixCommand注解来开启降级服务,需要引入 <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-netflix-hystrix</artifact...

    要使用@HystrixCommand注解来开启降级服务,需要引入

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

    feign的熔断服务是不需要这个依赖的,因为feign已经有Hystrix的依赖了,只是没有@HystrixCommand,
    所以要使用@HystrixCommand 需要单独引入hystrix依赖。

       @GetMapping("/server")
        @HystrixCommand(fallbackMethod = "serverFallBack")
        public String server(){
            String test = feignClient1.test();
            if (test.equals("熔断了")){
                throw new RuntimeException();
            }
            return  test;
        }
    

    使用注解,并且指定回调方法:
    @HystrixCommand(fallbackMethod = “serverFallBack”)

    具体方法如下:

    **---------------fallback------------*/
    public String serverFallBack(){
    
        //降级的话进行警报,发送短信给维护人员
        //使用redis,防止短时间按内多次重复发送。
        String s = redisTemplate.opsForValue().get(alarm);
        //短信比较耗时,可以单独start一个线程进行发送,当然也可以使用消息队列。
       new Thread( ()->{
           if (s==null||s.equals("")){
               System.out.println("服务出了问题,快来解决");
               redisTemplate.opsForValue().set(alarm,"发送了短信",120,TimeUnit.SECONDS);
           }else {
               System.out.println("已经发送过");
           }
       }).start();
    
        return  "降级了";
    }
    

    如果test2方法中检测到异常,就会降级处理,进入fallback,进行返回。这也可以直接放在controller层上,这样就不会直接返回异常给客户了。

    而且在fallback中可以设置进入回调函数,就会出发短信发送,实现服务异常报警机制。但是最好对短信发送进行缓存,防止连续发送短信,比如发送过一次,就在redis中存入个数据,设置过期时间,每次打算发信,都去reids检查一下,有对应数据,就不发送。

    展开全文
  • Hystrix降级配置

    2020-07-27 22:24:17
    Hystrix降级配置服务端降级a.新的注解b.设置自身峰值c.激活客户端降级a.fegin开启Hystrixb.启动c.客户端的controller上加注解 服务端降级 a.新的注解 @HystrixCommand 向调用方返回一个符合可预期的、可处理的备选...

    服务端降级

    a.新的注解

    @HystrixCommand
    向调用方返回一个符合可预期的、可处理的备选响应(Fallback)

    1.主类上加上注解(被调用的业务类

    @Service
    public class PaymentService {
        //延迟访问
        @HystrixCommand(fallbackMethod = "paymentInfo_timeOutHandler")
        public String paymentInfo_timeout(Integer id) {
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "线程池:耗时3秒" + Thread.currentThread().getName() + "paymentOk, id" + id;
        }
    	//处理类
        public String paymentInfo_timeOutHandler(Integer id) {
            return "服务器超时! 请稍后再试";
        }
    }
    

    b.设置自身峰值

    还可以指定多长时间内是正常的

    上面注解换成这个

    @HystrixCommand(fallbackMethod = "paymentInfo_timeOutHandler", commandProperties = {
                @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "3000")
        })
    

    设置自身调用超时时间的峰值。峰值内可以正常运行,超时了则需要兜底的方法处理,作为服务降级fallback (代码里出错也会到兜底函数)

    c.激活

    主启动类上加上注解 @EnableCircuitBreaker

    客户端降级

    a.fegin开启Hystrix

    feign:
      hystrix:
        enabled: true
    

    b.启动

    主启动类上加@EnableHystrix

    c.客户端的controller上加注解

    和上面一样

    @HystrixCommand(fallbackMethod = "paymentInfo_timeOutHandler", commandProperties = {
                @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "3000")
        })
    

    再写个兜底函数 和上面一样

    展开全文
  • hystrix降级预热问题

    万次阅读 2020-04-12 17:36:15
    hystrix降级预热问题1、问题描述2、问题分析3、问题解决4、总结 1、问题描述   模拟hystrix在高并发条件下流量降级处理。设计使用多级降级策略。但是在使用测试时发现第一次直接就不断的降级一直到最低级策略。当...

    1、问题描述

      模拟hystrix在高并发条件下流量降级处理。设计使用多级降级策略。但是在使用测试时发现第一次直接就不断的降级一直到最低级策略。当使用httpclient客户端模拟请求时,一直在降级。

    2、问题分析

      这是由于java程序在初次服务时效率总是很低。对用户发送的请求需要花很长时间处理。所以服务就自动降级了。

    3、问题解决

      如果是使用浏览器访问,则再访问一次就可以了。在java分布式开发过程中,有很多时候明明代码写的都是正确的,但是实验的结果总是和预期不符。这里很大一部分是这个原因,尤其是在使用httpclient客户端模拟请求时。这里我们还是需要使用浏览器测试。

    首先模拟一个服务。返回产品信息。

    package com.njust.eshop.product.ha.controller;
    
    
    import com.alibaba.fastjson.JSONArray;
    import com.alibaba.fastjson.JSONObject;
    import com.njust.eshop.product.ha.utils.HttpClientUtils;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.ResponseBody;
    import org.springframework.web.bind.annotation.RestController;
    
    /**
     * 缓存服务的接口
     *
     * @author Administrator
     */
    @RestController
    public class ProductController {
    
        @RequestMapping("/getProductInfo")
        public String getProductInfo(Long productId) {
            return "{\"id\": " + productId + ", \"name\": \"iphone7手机1\", \"price\": 5599, \"pictureList\":\"a.jpg,b.jpg\", \"specification\": \"iphone7的规格\", \"service\": \"iphone7的售后服务\", \"color\": \"红色,白色,黑色\", \"size\": \"5.5\", \"shopId\": 1, \"modifiedTime\": \"2017-01-01 12:00:00\", \"cityId\": 1, \"brandId\": 1}";
        }
    
    
    }
    

    接着定义hystrix降级策略。这里假设用户的productId为-1的时候采用一级降级,当productId为-2的时候采用二级降级。

    package com.njust.eshop.cache.ha.hystrix.command;
    
    
    import com.alibaba.fastjson.JSONObject;
    import com.netflix.hystrix.*;
    import com.netflix.hystrix.strategy.concurrency.HystrixConcurrencyStrategyDefault;
    import com.njust.eshop.cache.ha.cache.local.BrandCache;
    import com.njust.eshop.cache.ha.cache.local.LocationCache;
    import com.njust.eshop.cache.ha.entity.ProductInfo;
    import com.njust.eshop.cache.ha.utils.HttpClientUtils;
    
    import java.text.SimpleDateFormat;
    import java.util.Date;
    
    /**
     * 获取商品信息
     *
     * @author Administrator
     */
    public class GetProductInfoCommand extends HystrixCommand<ProductInfo> {
    
        public static final HystrixCommandKey KEY = HystrixCommandKey.Factory.asKey("GetProductInfoCommand");
    
        private Long productId;
    
        public GetProductInfoCommand(Long productId) {
    		super(Setter.withGroupKey(HystrixCommandGroupKey.Factory.asKey("ProductInfoService"))
    				.andCommandKey(KEY)
    				.andThreadPoolKey(HystrixThreadPoolKey.Factory.asKey("GetProductInfoPool"))
    				.andThreadPoolPropertiesDefaults(HystrixThreadPoolProperties.Setter()
    						.withCoreSize(10)
    						.withMaxQueueSize(12)
    						.withQueueSizeRejectionThreshold(15))
    				.andCommandPropertiesDefaults(HystrixCommandProperties.Setter()
    						.withCircuitBreakerRequestVolumeThreshold(30)
    						.withCircuitBreakerErrorThresholdPercentage(40)
    						.withCircuitBreakerSleepWindowInMilliseconds(3000)
    						.withExecutionTimeoutInMilliseconds(500)
    						.withFallbackIsolationSemaphoreMaxConcurrentRequests(30))
    				);
    //        super(HystrixCommandGroupKey.Factory.asKey("ProductInfoService"));
            this.productId = productId;
        }
    
        @Override
        protected ProductInfo run() throws Exception {
    //		System.out.println("调用接口,查询商品数据,productId=" + productId);
    //
            if (productId.equals(-1L)) {
                throw new Exception();
            }
            if (productId.equals(-2L)) {
                throw new Exception();
            }
    //
    //		if(productId.equals(-2L)) {
    //			Thread.sleep(3000);
    //		}
    //
    //		if(productId.equals(-3L)) {
    			Thread.sleep(250);
    //		}
    
            String url = "http://127.0.0.1:8084/getProductInfo?productId=" + productId;
            String response = HttpClientUtils.sendGetRequest(url);
            return JSONObject.parseObject(response, ProductInfo.class);
        }
    
    //	@Override
    //	protected String getCacheKey() {
    //		return "product_info_" + productId;
    //	}
    
        @Override
        protected ProductInfo getFallback() {
            System.out.println("--------getFallback-------------------");
            return new FirstLevelFallbackCommand(productId).execute();
        }
    
        private static class FirstLevelFallbackCommand extends HystrixCommand<ProductInfo> {
    
            private Long productId;
    
            public FirstLevelFallbackCommand(Long productId) {
                // 第一级的降级策略,因为这个command是运行在fallback中的
                // 所以至关重要的一点是,在做多级降级的时候,要将降级command的线程池单独做一个出来
                // 如果主流程的command都失败了,可能线程池都已经被占满了
                // 降级command必须用自己的独立的线程池
                super(Setter.withGroupKey(HystrixCommandGroupKey.Factory.asKey("ProductInfoService"))
                        .andCommandKey(HystrixCommandKey.Factory.asKey("FirstLevelFallbackCommand"))
                        .andThreadPoolKey(HystrixThreadPoolKey.Factory.asKey("FirstLevelFallbackPool")));
                this.productId = productId;
            }
    
            @Override
            protected ProductInfo run() throws Exception {
                // 这里,因为是第一级降级的策略,所以说呢,其实是要从备用机房的机器去调用接口
                // 但是,我们这里没有所谓的备用机房,所以说还是调用同一个服务来模拟
                System.out.println("-------------------response-------------------: ");
                if (productId.equals(-2L)) {
                    throw new Exception();
                }
                System.out.println("-------------------response-------------------: ");
                String url = "http://127.0.0.1:8084/getProductInfo?productId=" + productId;
                String response = HttpClientUtils.sendGetRequest(url);
                System.out.println("response: " + response);
                return JSONObject.parseObject(response, ProductInfo.class);
            }
    
            @Override
            protected ProductInfo getFallback() {
                System.out.println("-------------------response---getFallback----------------: ");
                // 第二级降级策略,第一级降级策略,都失败了
                ProductInfo productInfo = new ProductInfo();
                // 从请求参数中获取到的唯一条数据
                productInfo.setId(productId);
                // 从本地缓存中获取一些数据
                productInfo.setBrandId(BrandCache.getBrandId(productId));
                productInfo.setBrandName(BrandCache.getBrandName(productInfo.getBrandId()));
                productInfo.setCityId(LocationCache.getCityId(productId));
                productInfo.setCityName(LocationCache.getCityName(productInfo.getCityId()));
                // 手动填充一些默认的数据
                productInfo.setColor("默认颜色 第二级降级策略");
                productInfo.setModifiedTime(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
                productInfo.setName("默认商品");
                productInfo.setPictureList("default.jpg");
                productInfo.setPrice(0.0);
                productInfo.setService("默认售后服务");
                productInfo.setShopId(-1L);
                productInfo.setSize("默认大小");
                productInfo.setSpecification("默认规格");
                return productInfo;
            }
    
        }
    
        public static void flushCache(Long productId) {
            HystrixRequestCache.getInstance(KEY,
                    HystrixConcurrencyStrategyDefault.getInstance()).clear("product_info_" + productId);
        }
    
    }
    
    

    定义浏览器测试类,测试该降级策略。这里模拟使用一级降级策略。

    package com.njust.eshop.cache.ha.controller;
    
    import com.njust.eshop.cache.ha.hystrix.command.GetProductInfoCommand;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    /**
     * @author Chen
     * @version 1.0
     * @date 2020/4/12 16:52
     * @description:
     */
    @RestController
    public class TestController {
    
        @RequestMapping("testMutil")
        public String testMutil() {
            GetProductInfoCommand getProductInfoCommand1 = new GetProductInfoCommand(-1L);
    //        Thread.sleep(3000);
    //        System.out.println(getProductInfoCommand1.execute());
    //        GetProductInfoCommand getProductInfoCommand2 = new GetProductInfoCommand(-2L);
    //        System.out.println(getProductInfoCommand2.execute());
    //        Thread.sleep(5000);
            return getProductInfoCommand1.execute().toString();
        }
    }
    
    

    运行两个服务器,输出结果为:

    在这里插入图片描述
    第一次直接输出二级降级数据,明显不符合预期。再次刷新浏览器。我们发现可以获取到正常结果。

    在这里插入图片描述

    控制台输出结果如下;

    --------getFallback-------------------
    -------------------response-------------------: 
    -------------------response-------------------: 
    -------------------response---getFallback----------------: 
    response: {"id": -1, "name": "iphone7手机", "price": 5599, "pictureList":"a.jpg,b.jpg", "specification": "iphone7的规格", "service": "iphone7的售后服务", "color": "红色,白色,黑色", "size": "5.5", "shopId": 1, "modifiedTime": "2017-01-01 12:00:00", "cityId": 1, "brandId": 1}
    
    --------getFallback-------------------
    -------------------response-------------------: 
    -------------------response-------------------: 
    response: {"id": -1, "name": "iphone7手机", "price": 5599, "pictureList":"a.jpg,b.jpg", "specification": "iphone7的规格", "service": "iphone7的售后服务", "color": "红色,白色,黑色", "size": "5.5", "shopId": 1, "modifiedTime": "2017-01-01 12:00:00", "cityId": 1, "brandId": 1}
    
    --------getFallback-------------------
    -------------------response-------------------: 
    -------------------response-------------------: 
    response: {"id": -1, "name": "iphone7手机1", "price": 5599, "pictureList":"a.jpg,b.jpg", "specification": "iphone7的规格", "service": "iphone7的售后服务", "color": "红色,白色,黑色", "size": "5.5", "shopId": 1, "modifiedTime": "2017-01-01 12:00:00", "cityId": 1, "brandId": 1}
    
    
    

    其实我们发现第一次请求的时候已经获取到http的请求结果,但是由于超时的原因直接降级了。

    下面来直接编写测试类。测试类的好处就是不需要启动服务器,测试便捷。

    package com.njust.eshop.cache.ha;
    
    import com.njust.eshop.cache.ha.hystrix.command.GetProductInfoCommand;
    
    /**
     * @author Chen
     * @version 1.0
     * @date 2020/4/11 19:44
     * @description:
     */
    public class MultiLevelFallbackTest {
        public static void main(String[] args) throws Exception {
            GetProductInfoCommand getProductInfoCommand1 = new GetProductInfoCommand(-1L);
    //        Thread.sleep(3000);
            System.out.println(getProductInfoCommand1.execute());
    //        GetProductInfoCommand getProductInfoCommand2 = new GetProductInfoCommand(-2L);
    //        System.out.println(getProductInfoCommand2.execute());
    //        Thread.sleep(5000);
        }
    }
    
    

    这里的逻辑和上面的一样。直接运行测试类。输出结果如下:

    -------------------response-------------------: 
    -------------------response-------------------: 
    -------------------response---getFallback----------------: 
    ProductInfo(id=-1, name=默认商品, price=0.0, pictureList=default.jpg, specification=默认规格, service=默认售后服务, color=默认颜色 第二级降级策略, size=默认大小, shopId=-1, modifiedTime=2020-04-12 17:14:15, cityId=1, cityName=北京, brandId=1, brandName=iphone)
    
    

    这里我们发现无论我们运行多少次,都是直接使用的二级降级的策略。因为每次我们测试只是相当于第一次。控制台输出结果:

    -------------------response-------------------: 
    -------------------response-------------------: 
    -------------------response---getFallback----------------: 
    ProductInfo(id=-1, name=默认商品, price=0.0, pictureList=default.jpg, specification=默认规格, service=默认售后服务, color=默认颜色 第二级降级策略, size=默认大小, shopId=-1, modifiedTime=2020-04-12 17:30:26, cityId=1, cityName=北京, brandId=1, brandName=iphone)
    
    

    4、总结

      由于java有编译优化的功能,所以当测试类不行的时候,直接走正常测试吧。

    点个赞再走呗!欢迎留言哦!

    展开全文
  • Hystrix降级和熔断实验

    2019-11-01 14:54:04
    代码实验Hystrix降级和熔断 1.Hystrix 滑动窗口配置 2.熔断状态切换(CLOSE,OPNE,HALF_OPEN) 3.线程池打满服务降级和熔断 4.某个时间窗口内的buket时间内服务请求书和错误率导致降级和熔断 5.hystrix.stream 或者...
  • Hystrix降级和熔断

    2018-10-29 18:29:43
    Hystrix 熔断,降级
  • 主要介绍了详解springcloud 基于feign的服务接口的统一hystrix降级处理,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • hystrix降级不完全删除后产生的系统异常hystrix降级不完全删除后产生的系统异常问题现象原因分析总结 hystrix降级不完全删除后产生的系统异常 问题现象 在压测情况下抛出异常 ...
  • - 文档地址 - ...- 源码分析Hystrix降级策略和调整 - 查看默认讲解策略: HystrixCommandProperties - 通过查找配置类可以按需修改默认配置文件(小技巧, 不要去背默认配置) - execution.iso...
  • Hystrix 降级、熔断、限流简介自己写一个Hystrix的思路 简介 在项目上线后,微服务之间相互调用,不可能一点问题都不出。如果出了问题,请求超时,应该怎么去解决? 首先请求超时可能会发生在两个阶段: 在客户端...
  • 1.hystrix的局部降级逻辑的处理方式 2.全局降级处理方式 3.什么是熔断? 熔断有哪几种状态 断路器的工作原理 4.如何开启熔断? 5.什么是网关? gateway 的核心概念 6.如何简单使用gateway 学习内容: 1.hystrix的局部...
  • 降级有三种清空 1.下游服务宕机 2.下游服务抛出异常 3.下游服务超时 可以代码控制超时和异常测试,如果... //如果是testHystrix,睡眠10s,用于测试hystrix超时降级。 try { Thread.sleep(10000); } catch (Interru
  • Hystrix降级与熔断

    2019-05-21 00:26:25
    Hystrix 即熔断器,一种保护机制
  • 微服务中使用 Feign 实现服务间通信,Hystrix 针对服务间容错。本文主要讲hystrix中的 超时,熔断 ,隔离策略,适合对Hystrix 功能有基本了解的读者。 1 准备工作 三个服务: 服务提供者provider,服务消费者consumer...
  • pom文件 ...-- hystrix --> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-netflix-hystrix</artifactId> &l
  • 所谓降级,就是指在在Hystrix执行非核心链路功能失败的情况下,我们如何处理,比如我们返回默认值等。如果我们要回退或者降级处理,代码上需要实现HystrixCommand.getFallback()方法或者是HystrixObservableCommand....
  • Hystrix降级策略和调整

    2021-04-22 10:11:31

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 21,775
精华内容 8,710
关键字:

hystrix降级