hystrix断路器

Hystrix特性
　　1.请求熔断： 当Hystrix Command请求后端服务失败数量超过一定比例(默认50%), 断路器会切换到开路状态(Open). 这时所有请求会直接失败而不会发送到后端服务. 断路器保持在开路状态一段时间后(默认5秒), 自动切换到半开路状态(HALF-OPEN).

这时会判断下一次请求的返回情况, 如果请求成功, 断路器切回闭路状态(CLOSED), 否则重新切换到开路状态(OPEN). Hystrix的断路器就像我们家庭电路中的保险丝, 一旦后端服务不可用, 断路器会直接切断请求链, 避免发送大量无效请求影响系统吞吐量, 并且断路器有自我检测并恢复的能力.

2.服务降级：Fallback相当于是降级操作. 对于查询操作, 我们可以实现一个fallback方法, 当请求后端服务出现异常的时候, 可以使用fallback方法返回的值. fallback方法的返回值一般是设置的默认值或者来自缓存.告知后面的请求服务不可用了，不要再来了。

3.依赖隔离(采用舱壁模式，Docker就是舱壁模式的一种)：在Hystrix中, 主要通过线程池来实现资源隔离. 通常在使用的时候我们会根据调用的远程服务划分出多个线程池.比如说，一个服务调用两外两个服务，你如果调用两个服务都用一个线程池，那么如果一个服务卡在哪里，资源没被释放

后面的请求又来了，导致后面的请求都卡在哪里等待，导致你依赖的A服务把你卡在哪里，耗尽了资源，也导致了你另外一个B服务也不可用了。这时如果依赖隔离，某一个服务调用A B两个服务，如果这时我有100个线程可用，我给A服务分配50个，给B服务分配50个，这样就算A服务挂了，

我的B服务依然可以用。

4.请求缓存：比如一个请求过来请求我userId=1的数据，你后面的请求也过来请求同样的数据，这时我不会继续走原来的那条请求链路了，而是把第一次请求缓存过了，把第一次的请求结果返回给后面的请求。

5.请求合并：我依赖于某一个服务，我要调用N次，比如说查数据库的时候，我发了N条请求发了N条SQL然后拿到一堆结果，这时候我们可以把多个请求合并成一个请求，发送一个查询多条数据的SQL的请求，这样我们只需查询一次数据库，提升了效率。
　　
Hystrix流程说明:

1:每次调用创建一个新的HystrixCommand,把依赖调用封装在run()方法中.
　　2:执行execute()/queue做同步或异步调用.
　　3:判断熔断器(circuit-breaker)是否打开,如果打开跳到步骤8,进行降级策略,如果关闭进入步骤.
　　4:判断线程池/队列/信号量是否跑满，如果跑满进入降级步骤8,否则继续后续步骤.
　　5:调用HystrixCommand的run方法.运行依赖逻辑
　　5a:依赖逻辑调用超时,进入步骤8.
　　6:判断逻辑是否调用成功
　　6a:返回成功调用结果
　　6b:调用出错，进入步骤8.
　　7:计算熔断器状态,所有的运行状态(成功, 失败, 拒绝,超时)上报给熔断器，用于统计从而判断熔断器状态.
　　8:getFallback()降级逻辑.以下四种情况将触发getFallback调用：
　　　　(1):run()方法抛出非HystrixBadRequestException异常。
　　　　(2):run()方法调用超时
　　　　(3):熔断器开启拦截调用
　　　　(4):线程池/队列/信号量是否跑满
　　8a:没有实现getFallback的Command将直接抛出异常
　　8b:fallback降级逻辑调用成功直接返回
　　8c:降级逻辑调用失败抛出异常
　　9:返回执行成功结果

---

集成hystrix

---

---

请求熔断，服务降级一起

---

在服务的调用者上进行处理，即在order-demo上进行处理
在pom.xml上添加依赖

 <!--hystrix断路器-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
        </dependency>

在app启动类上加上打开断路器的注解@EnableHystrix

@SpringBootApplication
@EnableEurekaClient
@EnableFeignClients
@EnableHystrix
public class  orderApp {

    public static void main(String[] args) {

        SpringApplication.run(orderApp.class,args);
    }


    /*
    springcloud服务于服务之间的调用走的是restful风格的
    RestTemplate是springcloud提供的专门封装HTTP请求的
     */
    //@Bean 用在方法上，告诉Spring容器，你可以从下面这个方法中拿到一个Bean
    /*在使用springcloud ribbon客户端负载均衡的时候，可以给RestTemplate bean 加一个@LoadBalanced注解，
     就能让这个RestTemplate在请求时拥有客户端负载均衡的能力*/
    @Bean
    //自动装配
    @LoadBalanced
    RestTemplate restTemplate(){
        return new RestTemplate();
    }
}

如果用Feign做负载均衡的话，即用feign集成
创建一个MyFallback类实现FeignService类做降级用

//交给容器管理
@Component
public class MyFallback implements FeignService {

    //告诉他当前请求有问题
    @Override
    public String getUser(int id) {
        return "error getUser";
    }
}

在FeignService注解中添加fallback告诉他降级的方案有哪些
//调用服务的名字
@FeignClient(value = “6ms-user”,fallback = MyFallback.class)
public interface FeignService {

    //要去请求哪个地址，会什么方式，是什么参数
    @RequestMapping(value = "/user/{id}",method = RequestMethod.GET)
    String getUser(@PathVariable("id") int id);


}

在application.yml中开启hystrix功能

###开启hystrix功能
feign:
  hystrix:
    enabled: true

如果用restTemplate做负载均衡
直接在orderservice上添加

@Service
public class OrderService {

    @Autowired
    RestTemplate restTemplate;


	//告诉他降级的方法，即回调方法
    @HystrixCommand(fallbackMethod  = "userFallback")
    public String getUser(Integer id){

        //获取用户信息
        //6ms-user是user-demo在eureka上注册的服务名+访问路径
        String url = "http://6ms-user/user/{id}";

        //意义是请求返回一个对象，这个对象是一个String类型的
        String info = restTemplate.getForObject(url,String.class,id);

        return info;
    }



    //添加服务降级处理方法
    public String userFallback(Integer id){

        return "error user fallback";
    }
}

---

依赖隔离

---

---

请求缓存

---

基于注解的方式
cachaKey相同的话就会走缓存
在orderservice中

@CacheResult
@HystrixCommand(commandKey = "cache-user")//注解标识
public String getUser3(Integer id,@CacheKey Long cachaKey){

    String url = "http://6ms-user/user/{id}";
    String info = restTemplate.getForObject(url,String.class,id);

    return info;
}

//清空缓冲
@CacheRemove(commandKey = "cache-user")
@HystrixCommand
public void clearRequestCache(@CacheKey Long cachaKey){

}

在ordercontoller中

   @RequestMapping("/cache")
    public String cache2(){
    //缓存要放在上下文里面
        HystrixRequestContext context = HystrixRequestContext.initializeContext();

		//传入一个id，和cacheKey，12345L相同走缓存，不同查询两次
        String result1 = orderService.getUser3(1, 12345L);
        String result2 = orderService.getUser3(2,12345L);

        context.close();

        return "resulu1" + result1 + ", result2:" + result2;
    }

---

请求合并

---

在usercontroller中

 @RequestMapping("/getUserAll")
    public List<String> getUser(@RequestParam List<Integer> ids) {

        ArrayList<String> list = new ArrayList<>();
        for (Integer id :ids) {
            list.add("用户"+id);
        }

        return list;
    }

在orderservice中

请求不会走findone的方法会被合并到findAll去

   //获取单个的
    //被合并的请求
    //注解，batchMethod 告诉他请求合并需要调用的方法，collapserProperties规定时间内的请求合并到findAll中去
    @HystrixCollapser(batchMethod = "findAll",collapserProperties = {
            @HystrixProperty(name = "timeDelayInMilliseconds",value = "300")
    })
    public String findOne(Integer id){
        return null;
    }


    //合并的请求
    @HystrixCommand
    public List<String> findAll(List<Integer> ids){
        String url = "http://6ms-user/getUserAll?ids={1}/";
        return restTemplate.getForObject(url,List.class, StringUtils.join(ids,","));
    }

在ordercontroller中

 @RequestMapping("/findTest")
    public String findTest() throws ExecutionException, InterruptedException {

       HystrixRequestContext context = HystrixRequestContext.initializeContext();
    
    // Future异步的请求
    Future<String> f1 = orderService.findOne(1);
    Future<String> f2 = orderService.findOne(2);
    Future<String> f3 = orderService.findOne(3);

    String res = f1.get() + "," + f2.get() + "," + f3.get();

    context.close();

        return res;
    }