SpringCloud(二)

2020-11-04

1. 服务调用Feign入门

前面我们使用的RestTemplate实现REST API调用，代码大致如下：

@RequestMapping(value = "/buy/{id}", method = RequestMethod.GET)
public Product findById(@PathVariable Long id) {
    Product product = null;
    product = restTemplate.getForObject("http://service-product/product/1", Product.class);
    return product;
}

由代码可知，我们是使用拼接字符串的方式构造URL的，该URL只有一个参数。但是，在现实中，URL中往往含有多个参数。这时候我们如果还用这种方式构造URL，那么就会非常痛苦。那应该如何解决？我们带着这样的问题进入到本章的学习。

1.1 Feign简介

Feign是Netflix开发的声明式，模板化的HTTP客户端，其灵感来自Retrofit,JAXRS-2.0以及WebSocket.

Feign可帮助我们更加便捷，优雅的调用HTTP API。
在SpringCloud中，使用Feign非常简单——创建一个接口，并在接口上添加一些注解，代码就完成了。
Feign支持多种注解，例如Feign自带的注解或者JAX-RS注解等。
SpringCloud对Feign进行了增强，使Feign支持了SpringMVC注解，并整合了Ribbon和Eureka，从而让Feign的使用更加方便。

1.2 基于Feign的服务调用

1.2.1 引入依赖

在服务消费者 shop_service_order 添加Fegin依赖

<!--springcloud整合的openFeign-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

1.2.2 配置调用接口

/**
 * 声明需要调用的微服务名称
 *
 * @author wgy
 * @FeignClient
 *      name : 服务提供者的名称
 */
@FeignClient(name = "service-product")
public interface ProductFeignClient {

    /**
     * 配置需要调用的微服务接口
     *
     * @param id
     * @return
     */
    @RequestMapping(value = "/product/{id}", method = RequestMethod.GET)
    public Product findById(@PathVariable("id") Long id);
}

定义各参数绑定时， @PathVariable、@RequestParam、@RequestHeader等可以指定参数属性，在Feign中绑定参数必须通过value属性来指明具体的参数名，不然会抛出异常
@FeignClient ：注解通过name指定需要调用的微服务的名称，用于创建Ribbon的负载均衡器。会通过动态代理的形式创建ProductFeignClient接口的实现类。

1.2.3 启动类激活Feign

/**
 * 启动类
 *
 * @author wgy
 */
@SpringBootApplication
//激活Feign
@EnableFeignClients
public class OrderApplication {

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

通过@EnableFeignClients注解开启Spring Cloud Feign的支持功能

1.2.4 通过自动的接口调用远程微服务

修改 OrderController ，添加ProductFeginClient的自动注入，并在order方法中使用ProductFeginClient 完成微服务调用

/**
 * @author wgy
 */
@RestController
@RequestMapping("/order")
public class OrderController {

    @Autowired
    private ProductFeignClient productFeignClient;

    /**
     * 通过订单系统,调用商品服务根据id查询商品信息
     *
     * @param id
     * @return
     */
    @RequestMapping(value = "/buy/{id}", method = RequestMethod.GET)
    public Product findById(@PathVariable Long id) {
        Product product = null;
        product = productFeignClient.findById(id);
        return product;
    }
}

1.2.5 测试效果

1.3 Feign 和Ribbon的联系

Ribbon是一个基于 HTTP 和 TCP客户端的负载均衡的工具。它可以在客户端配置RibbonServerList（服务端列表），使用 HttpClient 或 RestTemplate 模拟http请求，步骤相当繁琐。

Feign是在 Ribbon的基础上进行了一次改进，是一个使用起来更加方便的 HTTP 客户端。采用接口的方式，只需要创建一个接口，然后在上面添加注解即可，将需要调用的其他服务的方法定义成抽象方法即可，不需要自己构建http请求。然后就像是调用自身工程的方法调用，而感觉不到是调用远程方法，使得编写客户端变得非常容易

1.4 负载均衡

Feign 中本身已经集成了Ribbon依赖和自动配置，因此我们不需要额外引入依赖，也不需要再注册RestTemplate 对象。另外，我们可以像上节课中讲的那样去配置Ribbon，可以通过 ribbon.xx 来进行全局配置。也可以通过 服务名.ribbon.xx 来对指定服务配置。

#修改ribbon的负载均衡策略   服务名 -  ribbon - NFLoadBalancerRuleClassName : 策略
service-product:
  ribbon:
    NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule

2. 服务调用Feign高级

2.1 Feign的配置

从Spring Cloud Edgware开始，Feign支持使用属性自定义Feign。对于一个指定名称的Feign Client（例如该Feign Client的名称为 feignName ），Feign支持如下配置项：

feign:
  client:
    config:
      feignName:  #定义FeginClient的名称
        connectTimeout: 5000  #建立链接的超时时长 相当于Request.Options
        readTimeout: 5000   #读取超时时长 相当于Request.Options
        loggerLevel: full   # 配置Feign的日志级别，相当于代码配置方式中的Logger
        errorDecoder: com.example.SimpleErrorDecoder  # Feign的错误解码器，相当于代码配置方式中的ErrorDecoder
        retryer: com.example.SimpleRetryer    # 配置重试，相当于代码配置方式中的Retryer
        requestInterceptors:  # 配置请求拦截器，相当于代码配置方式中的RequestInterceptor
          - com.example.FooRequestInterceptor
          - com.example.BarRequestInterceptor
        decode404: false  # 配置熔断不处理404异常

2.2 请求压缩

Spring Cloud Feign 支持对请求和响应进行GZIP压缩，以减少通信过程中的性能损耗。通过下面的参数即可开启请求与响应的压缩功能：

feign:
  compression:
    request:
      enabled: true # 开启请求压缩
    response:
      enabled: true # 开启响应压缩

同时，我们也可以对请求的数据类型，以及触发压缩的大小下限进行设置：

feign:
  compression:
    request:
      enabled: true # 开启请求压缩
      mime-types: text/html,application/xml,application/json # 设置压缩的数据类型
      min-request-size: 2048 # 设置触发压缩的大小下限

注：上面的数据类型、压缩大小下限均为默认值。

2.3 日志级别

在开发或者运行阶段往往希望看到Feign请求过程的日志记录，默认情况下Feign的日志是没有开启的。要想用属性配置方式来达到日志效果，只需在 application.yml 中添加如下内容即可：

#配置feign日志的输出
#日志配置  NONE : 不输出日志(高)   BASIC: 适用于生产环境追踪问题
#HEADERS : 在BASIC的基础上,记录请求和响应头信息   FULL : 记录所有
feign:
  client:
    config:
      service-product:  #需要调用的服务名称
        loggerLevel: FULL
logging:
  level:
    com.wgy.order.feign.ProductFeignClient: debug	#Feign日志只会对日志级别为debug的做出响应

2.4 源码分析

3. 微服务架构的高并发问题

通过注册中心已经实现了微服务的服务注册和服务发现，并且通过Ribbon实现了负载均衡，已经借助Feign可以优雅的进行微服务调用。那么我们编写的微服务的性能怎么样呢，是否存在问题呢？

3.1 性能工具Jmetter

Apache JMeter 是Apache组织开发的基于Java的压力测试工具。用于对软件做压力测试，它最初被设计用于Web应用测试，但后来扩展到其他测试领域。它可以用于测试静态和动态资源，例如静态文件、Java 小服务程序、CGI 脚本、Java 对象、数据库、FTP 服务器，等等。JMeter 可以用于对服务器、网络或对象模拟巨大的负载，来自不同压力类别下测试它们的强度和分析整体性能。另外JMeter能够对应用程序做功能/回归测试，通过创建带有断言的脚本来验证你的程序返回了你期望的结果。为了最大限度的灵活性，JMeter允许使用正则表达式创建断言。

3.1.1 安装Jmetter

Jmetter安装十分简单，将 apache -jmeter-2.13.zip 完整压缩包解压，找到安装目录下bin/jmeter.bat 已管理员身份启动即可

3.1.2 配置Jmetter

3.1.2.1 创建新的测试计划

3.1.2.2 测试计划下创建发起请求的线程组

可以配置请求的线程数
以及每个请求发送的请求次数

3.1.2.3 创建http请求模板

3.1.2.4 配置测试的接口信息

3.2 系统负载过高存在的问题

3.2.1 问题分析

在微服务架构中，我们将业务拆分成一个个的服务，服务与服务之间可以相互调用，由于网络原因或者自身的原因，服务并不能保证服务的100%可用，如果单个服务出现问题，调用这个服务就会出现网络延迟，此时若有大量的网络涌入，会形成任务累计，导致服务瘫痪。

在SpringBoot程序中，默认使用内置tomcat作为web服务器。单tomcat支持最大的并发请求是有限的，如果某一接口阻塞，待执行的任务积压越来越多，那么势必会影响其他接口的调用。

3.2.2 线程池的形式实现服务隔离

3.2.2.1 配置坐标

为了方便实现线以线程池的形式完成资源隔离，需要引入如下依赖

<dependency>
    <groupId>com.netflix.hystrix</groupId>
    <artifactId>hystrix-metrics-event-stream</artifactId>
    <version>1.5.12</version>
</dependency>
<dependency>
    <groupId>com.netflix.hystrix</groupId>
    <artifactId>hystrix-javanica</artifactId>
    <version>1.5.12</version>
</dependency>

3.2.2.2 配置线程池

配置HystrixCommand接口的实现类，再实现类中可以对线程池进行配置

/**
 * @author wgy
 */
public class OrderCommand extends HystrixCommand<Product> {

    private RestTemplate restTemplate;

    private Long id;

    public OrderCommand(RestTemplate restTemplate, Long id) {
        super(setter());
        this.restTemplate = restTemplate;
        this.id = id;
    }

    private static Setter setter() {

        // 服务分组
        HystrixCommandGroupKey groupKey = HystrixCommandGroupKey.Factory.asKey("order_product");
        // 服务标识
        HystrixCommandKey commandKey = HystrixCommandKey.Factory.asKey("product");
        // 线程池名称
        HystrixThreadPoolKey threadPoolKey = HystrixThreadPoolKey.Factory.asKey("order_product_pool");
        /**
         * 线程池配置
         *     withCoreSize :  线程池大小为10
         *     withKeepAliveTimeMinutes:  线程存活时间15秒
         *     withQueueSizeRejectionThreshold  :队列等待的阈值为100,超过100执行拒绝策略
         */
        HystrixThreadPoolProperties.Setter threadPoolProperties = HystrixThreadPoolProperties.Setter().withCoreSize(50)
                .withKeepAliveTimeMinutes(15).withQueueSizeRejectionThreshold(100);

        // 命令属性配置Hystrix 开启超时
        HystrixCommandProperties.Setter commandProperties = HystrixCommandProperties.Setter()
                // 采用线程池方式实现服务隔离
                .withExecutionIsolationStrategy(HystrixCommandProperties.ExecutionIsolationStrategy.THREAD)
                // 禁止
                .withExecutionTimeoutEnabled(false);
        return Setter.withGroupKey(groupKey).andCommandKey(commandKey).andThreadPoolKey(threadPoolKey)
                .andThreadPoolPropertiesDefaults(threadPoolProperties).andCommandPropertiesDefaults(commandProperties);

    }

    @Override
    protected Product run() throws Exception {
        System.out.println(Thread.currentThread().getName());
        return restTemplate.getForObject("http://127.0.0.1/product/" + id, Product.class);
    }

    /**
     * 降级方法
     */
    @Override
    protected Product getFallback() {
        Product product = new Product();
        product.setProductName("不好意思,出错了");
        return product;
    }
}

3.2.2.3 配置调用

修改 OrderController ，使用自定义的OrderCommand完成调用

/**
 * @author wgy
 */
@RestController
@RequestMapping("/order")
public class OrderController {

    //注入restTemplate对象
    @Autowired
    private RestTemplate restTemplate;

    /**
     * 使用OrderCommand调用远程服务
     */
    @RequestMapping(value = "/buy/{id}", method = RequestMethod.GET)
    public Product findById(@PathVariable Long id) {
        return new OrderCommand(restTemplate, id).execute();
    }

    @RequestMapping(value = "/{id}", method = RequestMethod.GET)
    public String findOrder(@PathVariable Long id) {
        System.out.println(Thread.currentThread().getName());
        return "根据id查询订单";
    }
}

4. 服务熔断Hystrix入门

4.1 服务容错的核心知识

4.1.1 雪崩效应

在微服务架构中，一个请求需要调用多个服务是非常常见的。如客户端访问A服务，而A服务需要调用B服务，B服务需要调用C服务，由于网络原因或者自身的原因，如果B服务或者C服务不能及时响应，A服务将处于阻塞状态，直到B服务C服务响应。此时若有大量的请求涌入，容器的线程资源会被消耗完毕，导致服务瘫痪。服务与服务之间的依赖性，故障会传播，造成连锁反应，会对整个微服务系统造成灾难性的严重后果，这就是服务故障的“雪崩”效应。

雪崩是系统中的蝴蝶效应导致其发生的原因多种多样，有不合理的容量设计，或者是高并发下某一个方法响应变慢，亦或是某台机器的资源耗尽。从源头上我们无法完全杜绝雪崩源头的发生，但是雪崩的根本原因来源于服务之间的强依赖，所以我们可以提前评估，做好熔断，隔离，限流。

4.1.2 服务隔离

顾名思义，它是指将系统按照一定的原则划分为若干个服务模块，各个模块之间相对独立，无强依赖。当有故障发生时，能将问题和影响隔离在某个模块内部，而不扩散风险，不波及其它模块，不影响整体的系统服务。

4.1.3 熔断降级

熔断这一概念来源于电子工程中的断路器（Circuit Breaker）。在互联网系统中，当下游服务因访问压力过大而响应变慢或失败，上游服务为了保护系统整体的可用性，可以暂时切断对下游服务的调用。这种牺牲局部，保全整体的措施就叫做熔断。

所谓降级，就是当某个服务熔断之后，服务器将不再被调用，此时客户端可以自己准备一个本地的fallback回调，返回一个缺省值。也可以理解为兜底

4.1.4 服务限流

限流可以认为服务降级的一种，限流就是限制系统的输入和输出流量已达到保护系统的目的。一般来说系统的吞吐量是可以被测算的，为了保证系统的稳固运行，一旦达到的需要限制的阈值，就需要限制流量并采取少量措施以完成限制流量的目的。比方：推迟解决，拒绝解决，或者者部分拒绝解决等等。

4.2 Hystrix介绍

Hystrix 是由Netflix开源的一个延迟和容错库，用于隔离访问远程系统、服务或者第三方库，防止级联失败，从而提升系统的可用性与容错性。Hystrix主要通过以下几点实现延迟和容错。

包裹请求：使用 HystrixCommand包裹对依赖的调用逻辑，每个命令在独立线程中执行。这使用了设计模式中的“命令模式”。
跳闸机制：当某服务的错误率超过一定的阈值时， Hystrix可以自动或手动跳闸，停止请求该服务一段时间。
资源隔离： Hystrix为每个依赖都维护了一个小型的线程池（或者信号量）。如果该线程池已满，发往该依赖的请求就被立即拒绝，而不是排队等待，从而加速失败判定。
监控： Hystrix可以近乎实时地监控运行指标和配置的变化，例如成功、失败、超时、以及被拒绝的请求等。
回退机制：当请求失败、超时、被拒绝，或当断路器打开时，执行回退逻辑。回退逻辑由开发人员自行提供，例如返回一个缺省值。
自我修复：断路器打开一段时间后，会自动进入 “半开”状态。

4.3 Rest实现服务熔断

4.3.1 引入Hystrix的依赖

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

4.3.2 启动类激活Hystrix

/**
 * 启动类
 *
 * @author wgy
 */
@SpringBootApplication
//激活hystrix
@EnableCircuitBreaker
public class OrderApplication {

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

    /**
     * 使用spring提供的RestTemplate发送http请求到商品服务
     *      1.创建RestTemplate对象交给容器管理
     *      2.在使用的时候,调用其方法完成操作 (getXX,postxxx)
     *
     * @return restTemplate
     * @LoadBalanced : 是ribbon提供的负载均衡的注解
     */
    @LoadBalanced
    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

4.3.3 配置熔断触发的降级逻辑

/**
 * @author wgy
 */
@RestController
@RequestMapping("/order")
public class OrderController {

    //注入restTemplate对象
    @Autowired
    private RestTemplate restTemplate;

    /**
     * 使用注解配置熔断保护
     *      fallbackmethod : 配置熔断之后的降级方法
     *
     * @param id
     * @return
     */
    @HystrixCommand(fallbackMethod = "orderFallBack")
    @RequestMapping(value = "/product/{id}", method = RequestMethod.GET)
    public Product findById(@PathVariable Long id) {
        return restTemplate.getForObject("http://service-product/product/1", Product.class);
    }

    /**
     * 降级方法
     *      和需要收到保护的方法的返回值一致
     *      方法参数一致
     *
     * @param id
     * @return
     */
    public Product orderFallBack(Long id) {
        Product product = new Product();
        product.setProductName("熔断:触发降级方法");
        return product;
    }

}

有代码可知，为 findById 方法编写一个回退方法orderFallBack，该方法与 findById 方法具有相同的参数与返回值类型，该方法返回一个默认的错误信息。

在 findById方法上，使用注解@HystrixCommand的fallbackMethod属性，指定熔断触发的降级方法是orderFallBack。

因为熔断的降级逻辑方法必须跟正常逻辑方法保证： 相同的参数列表和返回值声明。
在 findById 方法上 HystrixCommand(fallbackMethod = “orderFallBack”) 用来声明一个降级逻辑的方法

当 shop -service-product 微服务正常时，浏览器访问 http://localhost:9001/order/product/1

可以正常调用服务提供者获取数据。当将商品微服务停止时继续访问

此时 Hystrix配置已经生效进入熔断降级方法。

4.3.3.1 默认的Fallback

我们刚才把fallback写在了某个业务方法上，如果这样的方法很多，那岂不是要写很多。所以我们可以把Fallback配置加在类上，实现默认fallback：

/**
 * @author wgy
 */
@RestController
@RequestMapping("/order")
/**
 * @DefaultProperties : 指定此接口中公共的熔断设置
 *      如果过在@DefaultProperties指定了公共的降级方法
 *      在@HystrixCommand不需要单独指定了
 */
@DefaultProperties(defaultFallback = "defaultFallBack")
public class OrderController {

    //注入restTemplate对象
    @Autowired
    private RestTemplate restTemplate;

    /**
     * 使用注解配置熔断保护
     *
     * @param id
     * @return
     */
    @HystrixCommand
    @RequestMapping(value = "/buy/{id}", method = RequestMethod.GET)
    public Product findById(@PathVariable Long id) {
        return restTemplate.getForObject("http://service-product/product/1", Product.class);
    }

    /**
     * 指定统一的降级方法
     *      参数 : 没有参数
     *
     * @return
     */
    public Product defaultFallBack() {
        Product product = new Product();
        product.setProductName("触发统一的降级方法");
        return product;
    }
}

4.3.3.2 超时设置

在之前的案例中，请求在超过1秒后都会返回错误信息，这是因为Hystix的默认超时时长为1，我们可以通过配置修改这个值：

hystrix:
  command:
    default:
      execution:
        isolation:
          thread:
            timeoutInMilliseconds: 2000 #默认的连接超时时间1秒,若1秒没有返回数据,自动的触发降级逻辑

4.4 Feign 实现服务熔断

SpringCloud Fegin默认已为Feign整合了hystrix，所以添加Feign依赖后就不用在添加hystrix，那么怎么才能让Feign的熔断机制生效呢，只要按以下步骤开发：

4.4.1 在Feign中配置开启Hystrix

在Feign中已经内置了hystrix，但是默认是关闭的需要在工程的 application.yml 中开启对hystrix的支持

feign:
  #开启对hystrix的支持
  hystrix:
    enabled: true

4.4.2 配置FeignClient接口的实现类

基于Feign实现熔断降级，那么降级方法需要配置到FeignClient接口的实现类中

/**
 * 实现自定义的ProductFeginClient接口
 *      在接口实现类中编写熔断降级方法
 *
 * @author wgy
 */
@Component
public class ProductFeignClientCallBack implements ProductFeignClient {

    @Override
    /**
     * 熔断降级的方法
     */
    public Product findById(Long id) {
        Product product = new Product();
        product.setProductName("feign调用触发熔断降级方法");
        return product;
    }
}

4.4.3 修改FeignClient添加hystrix熔断

@FeignClient 注解中以fallback声明降级方法

/**
 * 声明需要调用的微服务名称
 *
 * @author wgy
 * @FeignClient
 *      name : 服务提供者的名称
 *      fallback : 配置熔断发生降级方法实现类
 */
@FeignClient(name = "service-product", fallback = ProductFeignClientCallBack.class)
public interface ProductFeignClient {

    /**
     * 配置需要调用的微服务接口
     *
     * @param id
     * @return
     */
    @RequestMapping(value = "/product/{id}", method = RequestMethod.GET)
    public Product findById(@PathVariable("id") Long id);
}

5. 服务熔断Hystrix高级

我们知道，当请求失败，被拒绝，超时的时候，都会进入到降级方法中。但进入降级方法并不意味着断路器已经被打开。那么如何才能了解断路器中的状态呢？

5.1 Hystrix的监控平台

除了实现容错功能，Hystrix还提供了近乎实时的监控，HystrixCommand和HystrixObservableCommand在执行时，会生成执行结果和运行指标。比如每秒的请求数量，成功数量等。这些状态会暴露在Actuator提供的/health端点中。只需为项目添加 spring -boot-actuator 依赖，重启项目，访问 http://localhost:9001/actuator/hystrix.stream ,即可看到实时的监控数据。

#默认只有几个,配置暴露所有actuator监控的端点
management:
  endpoints:
    web:
      exposure:
        include: '*'

5.1.1 搭建Hystrix DashBoard监控

刚刚讨论了Hystrix的监控，但访问/hystrix.stream接口获取的都是已文字形式展示的信息。很难通过文字直观的展示系统的运行状态，所以Hystrix官方还提供了基于图形化的DashBoard（仪表板）监控平台。Hystrix仪表板可以显示每个断路器（被@HystrixCommand注解的方法）的状态。

5.1.1.1 导入依赖

<!--引入hystrix的监控信息-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix-dashboard</artifactId>
</dependency>

5.1.1.2 添加EnableHystrixDashboard 注解

在启动类使用@EnableHystrixDashboard注解激活仪表盘项目

/**
 * 启动类
 *
 * @author wgy
 */
@SpringBootApplication
//激活Feign
@EnableFeignClients
//激活hystrix
@EnableCircuitBreaker
//激活hytrix的web监控平台
@EnableHystrixDashboard
public class OrderApplication {

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

}

5.1.1.3 访问测试

http://localhost:9001/hystrix

输入监控断点展示监控的详细数据：http://localhost:9001/actuator/hystrix.stream

hystrix控制台面板说明：

5.1.2 断路器聚合监控Turbine

在微服务架构体系中，每个服务都需要配置Hystrix DashBoard监控。如果每次只能查看单个实例的监控数据，就需要不断切换监控地址，这显然很不方便。要想看这个系统的Hystrix Dashboard数据就需要用到Hystrix Turbine。Turbine是一个聚合Hystrix 监控数据的工具，他可以将所有相关微服务的Hystrix 监控数据聚合到一起，方便使用。引入Turbine后，整个监控系统架构如下：

5.1.2.1 搭建TurbineServer

创建工程 shop_hystrix_turbine 引入相关坐标

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

5.1.2.2 配置多个微服务的hystrix监控

在application.yml的配置文件中开启turbine并进行相关配置

server:
  port: 8031
spring:
  application:
    name: hystrix-turbine
eureka:
  client:
    service-url:
      defaultZone: http://localhost:9000/eureka/
  instance:
    prefer-ip-address: true
turbine:
  # 要监控的微服务列表，多个用,分隔
  appConfig: service-order
  clusterNameExpression: "'default'"

eureka 相关配置：指定注册中心地址
turbine 相关配置：指定需要监控的微服务列表

turbine会自动的从注册中心中获取需要监控的微服务，并聚合所有微服务中的 /hystrix.stream 数据

5.1.2.3 配置启动类

/**
 * 启动类
 *
 * @author wgy
 */
@SpringBootApplication
//trubin配置
@EnableTurbine
//激活hytrix的web监控平台
@EnableHystrixDashboard
public class TurbinAppliation {

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

作为一个独立的监控项目，需要配置启动类，开启 HystrixDashboard监控平台，并激活Turbine

5.1.2.4 测试

浏览器访问 http://localhost:8031/hystrix 展示HystrixDashboard。并在url位置输入 http://localhost:8031/turbine.stream ，动态根据turbine.stream数据展示多个微服务的监控数据

5.2 熔断器的状态

熔断器有三个状态 CLOSED 、 OPEN 、 HALF_OPEN 熔断器默认关闭状态，当触发熔断后状态变更为OPEN ,在等待到指定的时间，Hystrix会放请求检测服务是否开启，这期间熔断器会变为 HALF_OPEN 半开启状态，熔断探测服务可用则继续变更为 CLOSED 关闭熔断器。

Closed ：关闭状态（断路器关闭），所有请求都正常访问。代理类维护了最近调用失败的次数，如果某次调用失败，则使失败次数加1。如果最近失败次数超过了在给定时间内允许失败的阈值，则代理类切换到断开(Open)状态。此时代理开启了一个超时时钟，当该时钟超过了该时间，则切换到半断开（Half-Open）状态。该超时时间的设定是给了系统一次机会来修正导致调用失败的错误。
Open ：打开状态（断路器打开），所有请求都会被降级。Hystix会对请求情况计数，当一定时间内失败请求百分比达到阈值，则触发熔断，断路器会完全关闭。默认失败比例的阈值是50%，请求次数最少不低于20次。
Half Open ：半开状态，open状态不是永久的，打开后会进入休眠时间（默认是5S）。随后断路器会自动进入半开状态。此时会释放1次请求通过，若这个请求是健康的，则会关闭断路器，否则继续保持打开，再次进行5秒休眠计时。

为了能够精确控制请求的成功或失败，我们在 shop_service_order 的调用业务中加入一段逻辑：

/**
 * @author wgy
 */
@RestController
@RequestMapping("/order")
public class OrderController {

    //注入restTemplate对象
    @Autowired
    private RestTemplate restTemplate;

    /**
     * 使用注解配置熔断保护
     *      fallbackmethod : 配置熔断之后的降级方法
     *
     * @param id
     * @return
     */
    @HystrixCommand(fallbackMethod = "orderFallBack")
    @RequestMapping(value = "/product/{id}", method = RequestMethod.GET)
    public Product findById(@PathVariable Long id) {
        if (id != 1) {
            throw new RuntimeException("服务器异常");
        }
        return restTemplate.getForObject("http://service-product/product/1", Product.class);
    }

    /**
     * 降级方法
     *      和需要收到保护的方法的返回值一致
     *      方法参数一致
     *
     * @param id
     * @return
     */
    public Product orderFallBack(Long id) {
        Product product = new Product();
        product.setProductName("熔断:触发降级方法");
        return product;
    }

}

这样如果参数是 id为1，一定失败，其它情况都成功。

我们准备两个请求窗口：

一个请求：http://localhost:9001/order/product/2，注定失败
一个请求：http://localhost:9001/order/product/1，肯定成功

熔断器的默认触发阈值是20次请求，不好触发。休眠时间时5秒，时间太短，不易观察，为了测试方便，我们可以通过配置修改熔断策略：

hystrix:
  command:
    default:
      circuitBreaker:
        requestVolumeThreshold: 5 #触发熔断的最小请求次数，默认20 /10秒
        sleepWindowInMilliseconds: 10000 #熔断多少秒后去尝试请求 默认 5   打开状态的时间
        errorThresholdPercentage: 50 #触发熔断的失败请求最小占比，默认50%

当我们疯狂访问id为2的请求时（超过10次），就会触发熔断。断路器会打开，一切请求都会被降级处理。

此时你访问id为1的请求，会发现返回的也是失败，而且失败时间很短，只有20毫秒左右：

5.3 熔断器的隔离策略

微服务使用Hystrix熔断器实现了服务的自动降级，让微服务具备自我保护的能力，提升了系统的稳定性，也较好的解决雪崩效应。其使用方式目前支持两种策略：

线程池隔离策略：使用一个线程池来存储当前的请求，线程池对请求作处理，设置任务返回处理超时时间，堆积的请求堆积入线程池队列。这种方式需要为每个依赖的服务申请线程池，有一定的资源消耗，好处是可以应对突发流量（流量洪峰来临时，处理不完可将数据存储到线程池队里慢慢处理）
信号量隔离策略：使用一个原子计数器（或信号量）来记录当前有多少个线程在运行，请求来先判断计数器的数值，若超过设置的最大线程个数则丢弃改类型的新请求，若不超过则执行计数操作请求来计数器+1，请求返回计数器-1。这种方式是严格的控制线程且立即返回模式，无法应对突发流量（流量洪峰来临时，处理的线程超过数量，其他的请求会直接返回，不继续去请求依赖的服务）

线程池和型号量两种策略功能支持对比如下：

hystrix:
  command:
    default:
      execution:
        isolation:
          strategy: ExecutionIsolationStrategy.SEMAPHORE #信号量隔离
          #strategy: # ExecutionIsolationStrategy.THREAD 线程池隔离
          maxConcurrentRequests:  30  #最大信号量上限

5.4 Hystrix的核心源码

Hystrix 底层基于 RxJava，RxJava 是响应式编程开发库，因此Hystrix的整个实现策略简单说即：把一个HystrixCommand封装成一个Observable（待观察者），针对自身要实现的核心功能，对Observable进行各种装饰，并在订阅各步装饰的Observable，以便在指定事件到达时，添加自己的业务。

6. 服务熔断Hystrix的替换方案

18年底Netflix官方宣布Hystrix 已经足够稳定，不再积极开发 Hystrix，该项目将处于维护模式。就目前来看Hystrix是比较稳定的，并且Hystrix只是停止开发新的版本，并不是完全停止维护，Bug什么的依然会维护的。因此短期内，Hystrix依然是继续使用的。但从长远来看，Hystrix总会达到它的生命周期，那么Spring Cloud生态中是否有替代产品呢？

6.1 替换方案介绍

6.1.1 Alibaba Sentinel

Sentinel 是阿里巴巴开源的一款断路器实现，目前在Spring Cloud的孵化器项目 Spring Cloud Alibaba中的一员Sentinel本身在阿里内部已经被大规模采用，非常稳定。因此可以作为一个较好的替代品。

6.1.2 Resilience4J

Resilicence4J 一款非常轻量、简单，并且文档非常清晰、丰富的熔断工具，这也是Hystrix官方推荐的替代产品。不仅如此，Resilicence4j还原生支持Spring Boot 1.x/2.x，而且监控也不像Hystrix一样弄Dashboard/Hystrix等一堆轮子，而是支持和Micrometer（Pivotal开源的监控门面，Spring Boot 2.x中的Actuator就是基于Micrometer的）、prometheus（开源监控系统，来自谷歌的论文）、以及Dropwizard metrics（Spring Boot曾经的模仿对象，类似于Spring Boot）进行整合。

6.2 Sentinel概述

6.2.1 Sentinel简介

随着微服务的流行，服务和服务之间的稳定性变得越来越重要。 Sentinel 以流量为切入点，从流量控制、熔断降级、系统负载保护等多个维度保护服务的稳定性。

Sentinel 具有以下特征:

丰富的应用场景 ：Sentinel 承接了阿里巴巴近 10 年的双十一大促流量的核心场景，例如秒杀（即突发流量控制在系统容量可以承受的范围）、消息削峰填谷、集群流量控制、实时熔断下游不可用应用等。
完备的实时监控 ：Sentinel 同时提供实时的监控功能。您可以在控制台中看到接入应用的单台机器秒级数据，甚至 500 台以下规模的集群的汇总运行情况。
广泛的开源生态 ：Sentinel 提供开箱即用的与其它开源框架/库的整合模块，例如与 Spring Cloud、Dubbo、gRPC 的整合。您只需要引入相应的依赖并进行简单的配置即可快速地接入Sentinel。
完善的 SPI 扩展点：Sentinel 提供简单易用、完善的 SPI 扩展接口。您可以通过实现扩展接口来快速地定制逻辑。例如定制规则管理、适配动态数据源等。

Sentinel 的主要特性：

6.2.2 Sentinel 与Hystrix的区别

	Sentinel	Hystrix	resilience4j
隔离策略	信号量隔离（并发线程数限流）	线程池隔离/信号量隔离	信号量隔离
熔断降级策略	基于响应时间、异常比率、异常数	基于异常比率	基于异常比率、响应时间
实时统计实现	滑动窗口（LeapArray）	滑动窗口（基于 RxJava）	Ring Bit Buffer
动态规则配置	支持多种数据源	支持多种数据源	有限支持
扩展性	多个扩展点	插件的形式	接口的形式
基于注解的支持	支持	支持	支持
限流	基于 QPS，支持基于调用关系的限流	有限的支持	Rate Limiter
流量整形	支持预热模式、匀速器模式、预热排队模式	不支持	简单的 Rate Limiter模式
系统自适应保护	支持	不支持	不支持
控制台	提供开箱即用的控制台，可配置规则、查看秒级监控、机器发现等	简单的监控查看	不提供控制台，可对接其它监控系统

6.2.3 名词解释

Sentinel 可以简单的分为 Sentinel 核心库和 Dashboard。核心库不依赖 Dashboard，但是结合Dashboard 可以取得最好的效果。

使用 Sentinel 来进行熔断保护，主要分为几个步骤:

定义资源
定义规则
检验规则是否生效

资源：可以是任何东西，一个服务，服务里的方法，甚至是一段代码。

规则：Sentinel 支持以下几种规则：流量控制规则、熔断降级规则、系统保护规则、来源访问控制规则和热点参数规则。Sentinel 的所有规则都可以在内存态中动态地查询及修改，修改之后立即生效

先把可能需要保护的资源定义好，之后再配置规则。也可以理解为，只要有了资源，我们就可以在任何时候灵活地定义各种流量控制规则。在编码的时候，只需要考虑这个代码是否需要保护，如果需要保护，就将之定义为一个资源。

6.3 Sentinel中的管理控制台

6.3.1 下载启动控制台

6.3.1.1 获取 Sentinel 控制台

您可以从官方网站中下载最新版本的控制台 jar 包，下载地址如下：
https://github.com/alibaba/Sentinel/releases/download/1.6.3/sentinel-dashboard-1.6.3.jar

6.3.1.2 启动

使用如下命令启动控制台：

1	java -Dserver.port=8080 -Dcsp.sentinel.dashboard.server=localhost:8080 -Dproject.name=sentinel-dashboard -jar sentinel-dashboard-1.6.3.jar

其中 - Dserver.port=8080 用于指定 Sentinel 控制台端口为 8080 。

从 Sentinel 1.6.0 起，Sentinel 控制台引入基本的登录功能，默认用户名和密码都是 sentinel 。

启动 Sentinel 控制台需要 JDK 版本为 1.8 及以上版本。

6.3.2 客户端能接入控制台

控制台启动后，客户端需要按照以下步骤接入到控制台。

6.3.2.1 引入JAR包

客户端需要引入 Transport 模块来与 Sentinel 控制台进行通信。可以通过 pom.xml 引入 JAR 包:

<dependency>
    <groupId>com.alibaba.csp</groupId>
    <artifactId>sentinel-transport-simple-http</artifactId>
</dependency>

6.3.2.2 配置启动参数

在工程的application.yml中添加Sentinel 控制台配置信息

spring:
  cloud:
    sentinel:
      transport:
        dashboard: localhost:8080   #sentinel控制台的请求地址

6.3.3 查看机器列表以及健康情况

默认情况下Sentinel 会在客户端首次调用的时候进行初始化，开始向控制台发送心跳包。也可以配置sentinel.eager=true ,取消Sentinel控制台懒加载。

spring:
  cloud:
    sentinel:
      transport:
        dashboard: localhost:8081   #sentinel控制台的请求地址
      datasource:	#加载本地规则
        ds1:
          file:
            file: classpath:flowrule.json
            data-type: json
            rule-type: flow
      eager: true #立即加载

flowrule.json

[
  {
    "resource": "orderFindById",
    "controlBehavior": 0,
    "count": 1,
    "grade": 1,
    "limitApp": "default",
    "strategy": 0
  }
]

打开浏览器即可展示Sentinel的管理控制台

6.4 基于Sentinel的服务保护

6.4.1 通用资源保护

6.4.1.1 引入依赖

需要注意SpringCloud-Alibaba与SpringCloud的版本关系

父工程引入 alibaba实现的SpringCloud

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>Greenwich.RELEASE</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-alibaba-dependencies</artifactId>
            <version>2.1.0.RELEASE</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

子工程中引入 sentinel

<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
</dependency>

6.4.1.2 配置熔断降级方法

/**
 * @author wgy
 */
@RestController
@RequestMapping("/order")
public class OrderController {

    //注入restTemplate对象
    @Autowired
    private RestTemplate restTemplate;

    /**
     * @param id
     * @return
     *
     * @SentinelResource
     *      blockHandler : 声明熔断时调用的降级方法
     *      fallback : 抛出异常执行的降级方法
     *      value : 自定义的资源名称
     *          不设置:当前全类名.方法名
     */
    @SentinelResource(value = "orderFindById", blockHandler = "orderBlockHandler", fallback = "orderFallback")
    @RequestMapping(value = "/buy/{id}", method = RequestMethod.GET)
    public Product findById(@PathVariable Long id) {
        if (id != 1) {
            throw new RuntimeException("错误");
        }
        return restTemplate.getForObject("http://service-product/product/1", Product.class);
    }

    /**
     * 定义降级逻辑
     *  hystrix和sentinel
     *      熔断执行的降级方法
     *      抛出异常执行的降级方法
     */
    public Product orderBlockHandler(Long id) {
        Product product = new Product();
        product.setProductName("触发熔断的降级方法");
        return product;
    }

    public Product orderFallback(Long id) {
        Product product = new Product();
        product.setProductName("抛出异常执行的降级方法");
        return product;
    }

}

在需要被保护的方法上使用 @SentinelResource注解进行熔断配置。与Hystrix不同的是，Sentinel对抛出异常和熔断降级做了更加细致的区分，通过 blockHandler 指定熔断降级方法，通过 fallback 指定触发异常执行的降级方法。

6.4.2 Rest实现熔断

Spring Cloud Alibaba Sentinel 支持对 RestTemplate 的服务调用使用 Sentinel 进行保护，在构造RestTemplate bean的时候需要加上 @SentinelRestTemplate 注解。

/**
 * 启动类
 *
 * @author wgy
 */
@SpringBootApplication
public class RestOrderApplication {

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

    /**
     * sentinel支持对restTemplate的服务调用使用sentinel方法.在构造
     * RestTemplate对象的时候,只需要加载@SentinelRestTemplate即可
     *
     * 资源名:
     *      httpmethod:schema://host:port/path ：协议、主机、端口和路径
     *      httpmethod:schema://host:port ：协议、主机和端口
     *
     * @SentinelRestTemplate:
     *  异常降级
     *      fallback      : 降级方法
     *      fallbackClass : 降级配置类
     *  限流熔断
     *      blockHandler
     *      blockHandlerClass
     *
     * @return restTemplate
     */
    @LoadBalanced
    @Bean
    @SentinelRestTemplate(fallbackClass = ExceptionUtils.class, fallback = "handleFallback",
            blockHandler = "handleBlock", blockHandlerClass = ExceptionUtils.class
    )
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

@SentinelRestTemplate 注解的属性支持限流( blockHandler , blockHandlerClass )和降级( fallback , fallbackClass )的处理。
其中 blockHandler 或 fallback 属性对应的方法必须是对应 blockHandlerClass 或fallbackClass 属性中的静态方法。
该方法的参数跟返回值跟org.springframework.http.client.ClientHttpRequestInterceptor#interceptor 方法一致，其中参数多出了一个 BlockException 参数用于获取 Sentinel 捕获的异常。

比如上述 @SentinelRestTemplate 注解中 ExceptionUtil 的 handleException 属性对应的方法声明如下：

/**
 * 熔断降级
 *
 * @author wgy
 */
public class ExceptionUtils {

    /**
     * 静态方法
     * 		返回值: SentinelClientHttpResponse
     * 		参数 : request , byte[] , clientRquestExcetion , blockException
     */
    //限流熔断业务逻辑
    public static SentinelClientHttpResponse handleBlock(HttpRequest request, byte[] body, ClientHttpRequestExecution execution, BlockException ex) {
		Product product = new Product();
		product.setProductName("block");
		return new SentinelClientHttpResponse(JSON.toJSONString(product));
    }

    //异常降级业务逻辑
    public static SentinelClientHttpResponse handleFallback(HttpRequest request, byte[] body,
                                                            ClientHttpRequestExecution execution, BlockException ex) {
		Product product = new Product();
		product.setProductName("Fallback");
        return new SentinelClientHttpResponse(JSON.toJSONString(product));
    }

}

Sentinel RestTemplate 限流的资源规则提供两种粒度：

httpmethod:schema://host:port/path ：协议、主机、端口和路径
httpmethod:schema://host:port ：协议、主机和端口

6.4.3 Feign实现熔断

Sentinel 适配了 Feign 组件。如果想使用，除了引入 sentinel -starter 的依赖外还需要 2 个步骤：

配置文件打开 sentinel 对 feign 的支持： feign.sentinel.enabled=true
加入 openfeign starter 依赖使 sentinel starter 中的自动化配置类生效：

6.4.3.1 引入依赖

<!--springcloud整合的openFeign-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
</dependency>

6.4.3.2 开启sentinel 支持

在工程的application.yml中添加sentinel 对 feign 的支持

feign:
  #激活sentinel的支持
  sentinel:
    enabled: true

6.4.3.3 配置FeignClient

和使用Hystrix的方式基本一致，需要配置FeignClient接口以及通过 fallback 指定熔断降级方法

/**
 * 声明需要调用的微服务名称
 *
 * @author wgy
 * @FeignClient
 *      name : 服务提供者的名称
 *      fallback : 配置熔断发生降级方法实现类
 */
@FeignClient(name = "service-product", fallback = ProductFeignClientCallBack.class)
public interface ProductFeignClient {

    /**
     * 配置需要调用的微服务接口
     *
     * @param id
     * @return
     */
    @RequestMapping(value = "/product/{id}", method = RequestMethod.GET)
    public Product findById(@PathVariable("id") Long id);
}

6.4.3.4 配置熔断方法

/**
 * 实现自定义的ProductFeginClient接口
 *      在接口实现类中编写熔断降级方法
 *
 * @author wgy
 */
@Component
public class ProductFeignClientCallBack implements ProductFeignClient {

    @Override
    /**
     * 熔断降级的方法
     */
    public Product findById(Long id) {
        Product product = new Product();
        product.setProductName("feign调用触发熔断降级方法");
        return product;
    }
}

Feign 对应的接口中的资源名策略定义：httpmethod:protocol://requesturl。 @FeignClient 注解中的所有属性，Sentinel 都做了兼容。

ProductFeginClient 接口中方法 findById 对应的资源名为 GET: http://shop-service-product/product/{str}。

-------------本文结束感谢您的阅读-------------

本文作者： Wgy
本文标题： SpringCloud(二)
本文链接： https://wgy1993.gitee.io/archives/6f583e1f.html
版权声明： 本作品采用 CC BY-NC-SA 4.0 进行许可。转载请注明出处！