尚硅谷阳哥SpringCloud第二季学习笔记（二）

一、Ribbon负载均衡服务调用

1.1 概述

1.1.1 是什么

Spring Cloud Ribbon是基于Netfix Ribbon实现的一套客户端负载均衡的工具。

简单的说，Ribbon是Netfix发布的开源项目，主要功能是提供客户端的软件负载均衡算法和服务调用。Ribbon客户端组件提供一系列完善的配置项如连接超时，重试等。简单的说，就是在配置文件中列出Load Balancer（简称LB）后面所有的机器，Ribbon会自动的帮助你基于某种规则（如简单轮询，随机选择等）去连接这些机器。我们很容易使用Ribbon实现自定义的负载均衡算法。

1.1.2 能干吗

LB（负载均衡）

LB负载均衡（Load Balance）是什么

简单的说就是将用户的请求平摊的分配到多个服务上，从而达到系统的HA。

常见的负载均衡软件有Nginx，LVS，硬件有F5等。

Ribbon本地负载均衡客户端 VS Nginx服务端负载均衡区别

Nginx是服务器负载均衡，客户端所有请求都会交给Nginx，然后由Nginx实现转发请求。即负载均衡是由服务端实现的。

Ribbon本地负载均衡，在调用微服务接口时候，会在注册中心上获取注册信息服务列表之后缓存到JVM本地，从而在本地实现RPC远程服务调用技术。

集中式LB

即在服务的消费方和提供方之间使用独立的LB设施（可以是硬件，如F5，也可以是软件，如Nginx），由该设施负责把访问请求通过某种策略转发至服务的提供方。

进程内LB

将LB逻辑集成到消费方，消费方从服务注册中心获知有哪些地址可用，然后自己再从这些地址中选择一个合适的服务器。

Ribbon就属于进程内LB，它只是一个类库，集成与消费方进程，消费方通过它来获取到服务提供方的地址。

1.2 Ribbon的简单架构

Ribbon在工作的时候分成两步：

1. 先选择EurekaServer，它优先选择在同一个区域内负载较少的server
2. 再根据用户指定的策略，再从server去到服务注册列表中选择一个地址。

1.3 RestTemplate的使用

postForObject/postForEntity方法类似

1.4 Ribbon核心组件IRule

IRule：根据特定算法从服务列表中选取一个要访问的服务。

IRule接口的一些实现类

这些实现类分别定义了Ribbon以何种策略进行负载均衡

1. RoundRobinRule：轮询
2. RandomRule：随机
3. RetryRule：先按照RoundRobinRule的策略获取服务，如果获取服务失败则在指定时间内会进行重试
4. WeightedResponseTimeRule：对RoundRobinRule的扩展，响应速度越快的实例选择权重越大，越容易被选择
5. BestAvailableRule：会先过滤掉由于多次访问故障而处于断路器跳闸状态的服务，然后选择一个并发量最小的服务
6. AvailabilityFilteringRule：先过滤掉故障实例，再选择并发较小的实例
7. ZoneAvoidanceRule：默认规则，复合判断server所在区域的性能和server的可用性选择服务器。

1.4.1 如何替换

@SpringBootApplication注解会包含@ComponentScan（会扫描当前包以及子包）注解，官网明确给出，自定义的负载均衡策略配置类不能放在主函数的当前包以及子包下，所以我们需要新建一个包。

目录结构

修改启动类

@SpringBootApplication
@EnableEurekaClient
//为要访问的服务指明特定的负载均衡策略，其中name指定要进行轮询的提供服务的别名，configuration指明的是自定义策略配置类
@RibbonClient(name = "CLOUD-PAYMENT-SERVICE",configuration = MySelfRule.class)
public class OrderMain80 {
    public static void main(String[] args) {
        SpringApplication.run(OrderMain80.class,args);
    }
}

配置类

@Configuration
public class MySelfRule {
    @Bean
    public IRule myRule(){
        //把默认的轮询策略改为随机策略。
        return new RandomRule();
    }
}

1.5 Ribbon负载均衡算法

1.5.1 原理

负载均衡算法：rest接口第几次请求数 % 服务器集群总数量 = 实际调用服务器位置下标，每次服务重启动后rest接口计数从1开始。

1.5.2 自己实现轮询策略算法

接口

public interface LoadBalancer {
    //用于获取服务列表
    ServiceInstance instances(List<ServiceInstance> serviceInstances);
}

实现

@Component
public class MyLoadBalancer implements LoadBalancer {
    private AtomicInteger atomicInteger = new AtomicInteger(0);

    public final int getAndIncrement() {
        int current;
        int next;
        do {
            current = this.atomicInteger.get();
            next = current >= Integer.MAX_VALUE ? 0 : current + 1;
        }while(!this.atomicInteger.compareAndSet(current,next));
        System.out.println("****第几次访问，次数next："+next);
        return next;
    }

    @Override
    public ServiceInstance instances(List<ServiceInstance> serviceInstances) {
        int index = getAndIncrement() % serviceInstances.size();
        return serviceInstances.get(index);
    }
}

针对于do–while中自旋锁的解释：current为原子整型类的初始值0，根据三目运算符，current小于Integer.MAX_VALUE，所以next为1，atomicInteger.xompareAndSet(current,next)，当前值为0，期望值也为0，所以atomicInteger的新值为更新值1，所以this.atomicInteger.compareAndSet(current,next)为true，因为整体取反，所以while条件为false，跳出这个do–while。

二、OpenFeign服务接口调用

2.1 概述

2.1.1 是什么

官方文档

中文文档

Feign是一个声明式WebService客户端。使用Feign能让编写Web Service客户端更加简单。它的使用方法是定义一个服务接口然后在上面添加注解。Feign也支持可拔插式的编码器和解码器。Spring Cloud对Feign进行了封装，使其支持了Spring MVC标准注解和HttpMessageConverters。Feign可以与Eureka和Ribbon组合使用以支持负载均衡。

2.1.2 Feign能干什么

前面在使用Ribbon+RestTemplate时，利用RestTemplate对http请求的封装处理，形成了一套模板化的调用方法。但是在实际开发中，由于对服务依赖的调用可能不止一处，往往一个接口会被多处调用，所以通常都会针对每个微服务自行封装一些客户端类来包装这些依赖服务的调用。所以，Feign在此基础上做了进一步封装，由他来帮助我们定义和实现依赖服务接口的定义。在Feign的实现下，我们只需创建一个接口并使用注解的方式来配置它（以前是Dao接口上面标注Mapper注解，现在是一个微服务接口上面标注一个Feign注解即可），即可完成对服务提供方的接口绑定，简化了使用Spring Cloud Ribbon时，自动封装服务调用客户端的开发量。

Feign集成了Ribbon

利用Ribbon维护了Payment的服务列表信息，并且通过轮询实现了客户端的负载均衡。而与Ribbon不同的是，通过Feign只需要定义服务绑定接口且以声明式的方法，优雅而简单的实现了服务调用。

2.2 OpenFeign使用步骤

应该注意的是OpenFeign是在消费端使用的

2.2.1 新建module–>cloud-consumer-feign-order80

2.2.2 导入依赖

<dependencies>
    
    <dependency>
        <groupId>org.springframework.cloudgroupId>
        <artifactId>spring-cloud-starter-openfeignartifactId>
    dependency>
    
    <dependency>
        <groupId>org.springframework.cloudgroupId>
        <artifactId>spring-cloud-starter-netflix-eureka-clientartifactId>
    dependency>
    
    <dependency>
        <groupId>com.jg.springcloudgroupId>
        <artifactId>cloud-api-commonsartifactId>
        <version>1.0-SNAPSHOTversion>
    dependency>
    
    <dependency>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-webartifactId>
    dependency>
    <dependency>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-actuatorartifactId>
    dependency>
    
    <dependency>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-devtoolsartifactId>
        <scope>runtimescope>
        <optional>trueoptional>
    dependency>
    <dependency>
        <groupId>org.projectlombokgroupId>
        <artifactId>lombokartifactId>
        <optional>trueoptional>
    dependency>
    <dependency>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-testartifactId>
        <scope>testscope>
    dependency>
dependencies>

2.2.3 写yml

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

2.2.4 主启动

@SpringBootApplication
@EnableDiscoveryClient
//激活并开启Feign
@EnableFeignClients
public class OrderFeignMain80 {
    public static void main(String[] args) {
        SpringApplication.run(OrderFeignMain80.class,args);
    }
}

2.2.5 写接口

@Component
//使用这个注解绑定要调用服务的服务名称
@FeignClient(value = "CLOUD-PAYMENT-SERVICE")
public interface PaymentFeignService {
    @GetMapping(value = "/payment/get/{id}")
    CommonResult<Payment> getPaymentById(@PathVariable("id") Long id);
}

2.2.6 controller

@RestController
@Slf4j
public class OrderFeignController {
    //装配PaymentFeignService
    @Autowired
    private PaymentFeignService paymentFeignService;

    @GetMapping(value = "/consumer/payment/get/{id}")
    public CommonResult<Payment> getPaymentById(@PathVariable("id") Long id){
        return paymentFeignService.getPaymentById(id);
    }
}

Feign自己集成了Ribbon，所以天生就自带负载均衡的能力

2.3 OpenFeign的超时控制

OpenFeign默认等待时间是1秒钟，超时即报错。如果服务提供方因为某种原因出现网络延迟，超时时间超过1秒钟，那么在用OpenFeign调用服务的时候就会出现超时报错。

解决方法是在yml中配置OpenFeign的超时时间

#设置feign客户端超时时间(OpenFeign默认支持ribbon)
ribbon:
  #指的是建立连接后从服务器读取到可用资源所用的时间
  ReadTimeout: 5000
  #指的是建立连接所用的时间，适用于网络状况正常的情况下,两端连接所用的时间
  ConnectTimeout: 5000

2.4 OpenFeign日志打印功能

2.4.1 是什么

Feign提供了日志打印功能，我们可以通过配置来调整日志级别，从而了解Feign中Http请求的细节。

2.4.2 日志级别

1. NONE：默认的，不显示任何日志；
2. BASIC：仅记录请求方法、URL、响应状态码及执行时间；
3. HEADERS：除了BASIC中定义的信息之外，还有请求和响应的头信息；
4. FULL：除了HEADERS中定义的信息之外，还有请求和响应的正文及元数据。

2.4.3 使用步骤

1. 写配置类

   @Configuration
   public class FeignConfig {
       @Bean
       Logger.Level feignLoggerLevel(){
           return Logger.Level.FULL;
       }
   }
   

2. 修改yml文件

   添加以下内容

   logging:
     level:
       #feign日志以什么级别监控哪个接口
       com.jg.springcloud.service.PaymentFeignService: debug
   

三、Hystrix熔断器

3.1 概述

3.1.1 分布式系统面临的问题

复杂分布式体系结构中的应用程序有数十个依赖关系，每个依赖关系在某些时候将不可能避免的失败。

所以，通常当你发现一个模块下的某个实例失败后，这时候这个模块依然还会接收流量，然后这个有问题的模块还调用了其他的模块，这样就会发生级联故障，或叫雪崩。

3.1.2 Hystrix是什么

Hystrix是一个用于处理分布式系统的延迟和容错的开源库，在分布式系统里，许多依赖不可避免的会调用失败，比如超时、异常等，Hystrix能够保证在一个依赖出问题的情况下，不会导致整体服务失败，避免级联故障，以提高分布式系统的弹性。

“断路器”本身是一种开关装置，当某个服务单元发生故障之后，通过断路器的故障监控（类似熔断保险丝），向调用方返回一个符合预期的、可处理的备选响应（FallBack），而不是长时间的等待或者抛出调用方无法处理的异常，这样就保证了服务调用方的线程不会被长时间、不必要的占用，从而避免了故障在分布式系统中的蔓延，乃至雪崩。

3.1.3 能干嘛

1. 服务降级
2. 服务熔断
3. 接近实时的监控
4. 限流
5. 隔离

3.1.4 官网

地址

3.2 Hystrix重要概念

3.2.1 服务降级

所谓服务降级，简单来说就是当服务器忙或者服务不可用的时候，不让客户端等待并立刻返回一个友好提示，fallback。此时并不是说服务就直接挂掉了。

哪些情况会触发降级

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

3.2.2 服务熔断

当达到某个服务的最大访问量的时候，为了保证自己不会挂掉，会直接拒绝访问，然后调用服务降级的方法并返回友好提示。

3.2.3 服务限流

当有秒杀高并发等操作，可能会导致一瞬间或者一段时间内访问流量暴增，为了防止所有的流量都一起打过来，会进行一个排队机制，规定一定时间内放行几个，这就是服务限流。

3.3 Hystrix案例

3.3.1 构建服务提供方

创建module–>cloud-provier-hystrix-payment8001

导入依赖

<dependencies>
    
    <dependency>
        <groupId>org.springframework.cloudgroupId>
        <artifactId>spring-cloud-starter-netflix-hystrixartifactId>
    dependency>
    
    <dependency>
        <groupId>org.springframework.cloudgroupId>
        <artifactId>spring-cloud-starter-netflix-eureka-clientartifactId>
    dependency>
    
    <dependency>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-webartifactId>
    dependency>
    <dependency>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-actuatorartifactId>
    dependency>
    <dependency>
        <groupId>com.jg.springcloudgroupId>
        <artifactId>cloud-api-commonsartifactId>
        <version>${project.version}version>
    dependency>
    <dependency>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-devtoolsartifactId>
        <scope>runtimescope>
        <optional>trueoptional>
    dependency>
    <dependency>
        <groupId>org.projectlombokgroupId>
        <artifactId>lombokartifactId>
        <optional>trueoptional>
    dependency>
    <dependency>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-testartifactId>
        <scope>testscope>
    dependency>
dependencies>

yml

server:
  port: 8001
spring:
  application:
    name: cloud-provider-hystrix-payment

eureka:
  client:
    register-with-eureka: true
    fetch-registry: true
    service-url:
#      集群环境
#      defaultZone: http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka
      defaultZone: http://eureka7001.com:7001/eureka

主启动

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

业务

@RestController
@Slf4j
public class PaymentController {
    @Resource
    private PaymentService paymentService;

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

    @GetMapping("/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("/payment/hystrix/timeout/{id}")
    public String paymentInfo_TimeOut(@PathVariable("id") Integer id){
        String result = paymentService.paymentInfo_TimeOut(id);
        log.info("*****result"+result);
        return result;
    }
}

说明：这里业务类有一个是正常的，另一个是采用线程等待的方式模拟网络卡顿。

3.3.2 构建服务调用方

module

创建子模块---->cloud-consumer-feign-hystrix-order80

pom

<dependencies>
    
    <dependency>
        <groupId>org.springframework.cloudgroupId>
        <artifactId>spring-cloud-starter-openfeignartifactId>
    dependency>
    
    <dependency>
        <groupId>org.springframework.cloudgroupId>
        <artifactId>spring-cloud-starter-netflix-hystrixartifactId>
    dependency>
    
    <dependency>
        <groupId>org.springframework.cloudgroupId>
        <artifactId>spring-cloud-starter-netflix-eureka-clientartifactId>
    dependency>
    
    <dependency>
        <groupId>com.jg.springcloudgroupId>
        <artifactId>cloud-api-commonsartifactId>
        <version>1.0-SNAPSHOTversion>
    dependency>
    
    <dependency>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-webartifactId>
    dependency>
    <dependency>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-actuatorartifactId>
    dependency>
    
    <dependency>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-devtoolsartifactId>
        <scope>runtimescope>
        <optional>trueoptional>
    dependency>
    <dependency>
        <groupId>org.projectlombokgroupId>
        <artifactId>lombokartifactId>
        <optional>trueoptional>
    dependency>
    <dependency>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-testartifactId>
        <scope>testscope>
    dependency>
dependencies>

yml

server:
  port: 80

eureka:
  client:
    register-with-eureka: true
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka/

主启动

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

业务

这里采用的是OpenFeign实现的负载均衡和服务调用

service

@Component
@FeignClient(value = "CLOUD-PROVIDER-HYSTRIX-PAYMENT")
public interface PaymentHystrixService {
    @GetMapping("/payment/hystrix/ok/{id}")
    String paymentInfo_OK(@PathVariable("id") Integer id);

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

controller

@RestController
@Slf4j
public class OrderHystrixController {
    @Resource
    private PaymentHystrixService paymentHystrixService;

    @GetMapping("/consumer/payment/hystrix/ok/{id}")
    public String paymentInfo_OK(@PathVariable("id") Integer id){
        String result = paymentHystrixService.paymentInfo_OK(id);
        return result;
    }

    @GetMapping("/consumer/payment/hystrix/timeout/{id}")
    public String paymentInfo_TimeOut(@PathVariable("id") Integer id){
        String result = paymentHystrixService.paymentInfo_TimeOut(id);
        return result;
    }
}

3.3.3 解决的需求

1. 超时导致服务器变慢
2. 出错（宕机或程序运行出错）
3. 解决
   1. 被调用服务超时了，调用者不能一直卡死等待，必须有服务降级
   2. 被调用服务宕机了，调用者不能一直卡死等待，必须有服务降级
   3. 被调用服务是OK的，但是调用者自己出现故障或者有自我要求（自己的等待时间小于服务提供者），自己必须降级。

3.3.4 服务降级

3.3.4.1 服务提供方

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

在出现故障的方法上面声明方法出现故障要调用的兜底方法，以及设定调用兜底方法的时机。

定义一个兜底方法

主启动类上添加注解

3.3.4.2 服务调用方

服务提供方有自己的服务降级策略，那么服务调用方也应该有自己的降级策略，当服务调用方某个方法出错或是因为网络延迟的时候，我们也应该让它有个兜底的方法，而不是让它报错或是一直处在加载的状态，那样会影响整个微服务的调用链路。

启动类加上注解

yml文件开启客户端的Hystrix功能

#开启客户端Hystrix
feign:
  hystrix:
    enabled: true

业务方法加上兜底方法调用规则

3.3.5 当前存在的问题

每个业务方法对应一个兜底的方法，这样如果业务方法太多的话，会导致代码膨胀

解决思路：

使用@DefaultProperties(defaultFallback="")注解

1:1 每个方法配置一个服务降级方法，在技术上可以实现，但是也会让代码变得很繁琐

1:N 除了个别重要核心业务有专属，其它普通的可以通过统一跳转到统一处理结果页面。

在Controller方法上添加注解

定义全局FallbackMethod

public String payment_Global_FallbackMethod(){
        return "Global异常处理信息，请稍后再试";
    }

这样处理之后，一般的服务出现故障或是网络延迟都会去找全局的兜底方法，如果有个别的核心业务方法，还可以特别声明

3.3.6 新的问题

向上面那样做解决了代码膨胀的问题，但是同时的Fallback和业务方法耦合在了一起，所以，需要进一步优化，把Fallback method和业务方法解耦合。

解决方法

因为我们采用了OpenFeign实现负载均衡，我们在调用Controller层方法的时候都是去到对应的Service层方法，找到要调用服务的服务名然后去实现调用的，所以我们可以在声明一个类去继承service接口，然后这个类专门对service里面的方法实现Fallback。而且OpenFeign加在Service接口上的注解@FeignClient提供了对Fallback的支持

@Component
@FeignClient(value = "CLOUD-PROVIDER-HYSTRIX-PAYMENT",fallback = PaymentFallbackService.class)
public interface PaymentHystrixService {
    @GetMapping("/payment/hystrix/ok/{id}")
    String paymentInfo_OK(@PathVariable("id") Integer id);

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

3.3.7 服务熔断

3.3.7.1 熔断机制概述

熔断机制是应对雪崩效应的一种微服务链路保护机制。当扇出链路的某个微服务出错不可用或者响应时间太长时，会进行服务的降级，进而熔断该节点微服务的调用，快速返回错误的响应信息。

当检测到该节点微服务调用响应正常后，恢复调用链路

在SpringCloud框架里，熔断机制通过Hystrix实现。Hystrix会监控微服务间调用的状况，当失败的调用到一定阈值，缺省是5秒内调用失败20次，就会启动熔断机制。熔断机制的注解式@HystrixCommand

3.3.7.2 熔断是什么

相关文章地址

为一个业务方法设置服务熔断

//服务熔断
    //开启Hystrix的服务熔断功能，10秒内如果10次请求有60%（也就是6次）失败的话，就熔断该服务。
    @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;
    }

在10秒钟如果10次请求有超过6次（阈值）都是失败的话，熔断器的开关就会断开（open），触发熔断机制，这样一段时间内即使有正常的请求也不会返回结果。一段时间后，这个服务会逐渐恢复，可能是因为没有再继续收到错误的请求的原因，熔断器会由open进入half open，放一部分的请求进入。再过一段时间，如果这些请求没有返回错误结果的请求，那么熔断器就会由half open又进入close状态。

3.3.7.3 熔断类型

1. 熔断打开：请求不再进行调用当前的服务，内部设置时钟一般为MTTR（平均故障处理时间），当打开时长达到所设时钟则进入半熔断状态
2. 熔断关闭：熔断关闭不会对服务进行熔断
3. 熔断半开：部分请求根据规则调用当前服务，如果请求成功且符合规则则认为当前服务恢复正常，关闭熔断。（一段时间之后（默认是5秒），这个时候断路器是半开状态，会让其中一个请求进行转发。如果成功，断路器会关闭，若失败，断路器开启。重复4和5）
4. 

HystrixProperty通用配置项

3.4 Hystrix工作流程

3.5 服务监控hystrixDashboard

3.5.1 概述

除了隔离依赖服务的调用以外，Hystrix还提供了准实时的调用监控（Hystrix Dashboard），Hystrix会持续地记录所有通过Hystrix发起的请求的执行信息，并以统计报表和图形的形式展示给用户，包括每秒执行多少请求多少成功，多少失败等。Netflix通过hystrix-metrics-event-stream项目实现了对以上指标的监控。Spring Cloud也提供了Hystrix Dashboard的整合，对监控内容转化成可视化界面。

3.5.2 仪表盘9001

创建新模块

创建module—>cloud-consumer-hystrix-dashboard9001

导入pom

<dependencies>
	
    <dependency>
        <groupId>org.springframework.cloudgroupId>
        <artifactId>spring-cloud-starter-netflix-hystrix-dashboardartifactId>
    dependency>
    <dependency>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-actuatorartifactId>
    dependency>

    <dependency>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-devtoolsartifactId>
        <scope>runtimescope>
        <optional>trueoptional>
    dependency>
    <dependency>
        <groupId>org.projectlombokgroupId>
        <artifactId>lombokartifactId>
        <optional>trueoptional>
    dependency>
    <dependency>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-testartifactId>
        <scope>testscope>
    dependency>
dependencies>

写yml

server:
	port: 9001

主启动

需要添加新的注解

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

对于需要监控的服务要添加的依赖

<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-actuatorartifactId>
dependency>

启动该监控微服务

启动成功之后，改微服务后续将监控配置的微服务，web页面

3.5.3 断路器演示

被监控的服务除了要添加以上的依赖之外，还需要在主启动中添加配置，否则会报错

/**
     *此配置是为了服务监控而配置，与服务容错本身无关，springcloud升级后的坑
     *ServletRegistrationBean因为springboot的默认路径不是"/hystrix.stream"，
     *只要在自己的项目里配置上下面的servlet就可以了
     */
    @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;
    }

把要监控的地址填到HystrixDashboard的web页面中

监控图形说明