SpringCloud（Hystrix(服务降级_服务熔断)，Feign(声明式服务调用)，Zuul(网关，过滤器)）

最新推荐文章于 2024-08-11 22:45:54 发布

飞奔的嗨少

最新推荐文章于 2024-08-11 22:45:54 发布

阅读量929

点赞数

分类专栏： Java修仙之路

本文链接：https://blog.csdn.net/weixin_43908333/article/details/107123652

版权

Java修仙之路专栏收录该内容

91 篇文章 9 订阅

订阅专栏

一、Hystrix

`1.1 Hystrix简介`

Hystrix,英文意思是豪猪，全身是刺，看起来就不好惹，是一种保护机制。Hystrix也是Netflix公司的一款组件。
主页：https://github.com/Netflix/Hystrix/

那么Hystix的作用是什么呢？具体要保护什么呢？
Hystix是Netflix开源的一个延迟和容错库，用于隔离访问远程服务、第三方库，防止出现级联失败。

`1.2 雪崩效应`

微服务中，服务间调用关系错综复杂，一个请求，可能需要调用多个微服务接口才能实现，会形成非常复杂的调用链路：

如图，一次业务请求，需要调用A、P、H、I四个服务，这四个服务又可能调用其它服务。如果此时，某个服务出现异常：

例如微服务I发生异常，请求阻塞，用户不会得到响应，则tomcat的这个线程不会释放，于是越来越多的用户请求到来，越来越多的线程会阻塞：

服务器支持的线程和并发数有限，请求一直阻塞，会导致服务器资源耗尽，从而导致所有其它服务都不可用，形成雪崩效应。
这就好比，一个汽车生产线，生产不同的汽车，需要使用不同的零件，如果某个零件因为种种原因无法使用，那么就会造成整台车无法装配，陷入等待零件的状态，直到零件到位，才能继续组装。此时如果有很多个车型都需要这个零件，那么整个工厂都将陷入等待的状态，导致所有生产都陷入瘫痪。一个零件的波及范围不断扩大。
Hystix解决雪崩问题的手段有两个：线程隔离，服务熔断

`1.3 线程隔离，服务降级`

线程隔离示意图：

解读：

Hystrix为每个依赖服务调用分配一个小的线程池，如果线程池已满调用将被立即拒绝，默认不采用排队.加速失败判定时间。用户的请求将不再直接访问服务，而是通过线程池中的空闲线程来访问服务，如果线程池已满，或者请求超时，则会进行降级处理，什么是服务降级？
服务降级：优先保证核心服务，而非核心服务不可用或弱可用。
用户的请求故障时，不会被阻塞，更不会无休止的等待或者看到系统崩溃，至少可以看到一个执行结果（例如返回友好的提示信息）。服务降级虽然会导致请求失败，但是不会导致阻塞，而且最多会影响这个依赖服务对应的线程池中的资源，对其它服务没有响应。
触发Hystix服务降级的情况：线程池已满，请求超时

`1.4 动手实践`

在消费方提供Hystrix依赖

<!--引入Hystrix依赖：-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
    <version>2.0.2.RELEASE</version>
</dependency>

开启熔断

注意:
可以看到，我们类上的注解越来越多，在微服务中，经常会引入上面的三个注解，于是Spring就提供了一个组合注解：@SpringCloudApplication

编写服务降级逻辑
我们改造springclouddemo1_consumer，当目标服务的调用出现故障，我们希望快速失败，给用户一个友好提示。因此需要提前编写好失败时的降级处理逻辑，要使用HystixCommond来完成：

1.4.1 声明局部的服务降级方法

注意:局部的服务降级方法，方法的返回值和参数必须和需要被熔断的方法保持一致

测试: 将服务提供方停止，即可模拟效果。再次请求: http://localhost:8085/consumer/findAccountById/2

2.声明全局的服务降级方法

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

@DefaultProperties(defaultFallback = “defaultFallBack”)：在类上指明统一的失败降级方法
defaultFallback：默认降级方法，不用任何参数，以匹配更多方法，但是返回值一定一致
@HystrixCommand：在方法上直接使用该注解，使用默认的降级方法。

`1.5 设置超时(了解)`

在之前的案例中，请求在超过1秒后都会返回错误信息，这是因为Hystix的默认超时时长为1，我们可以通过配置修改这个值：我们可以通过hystrix.command.default.execution.isolation.thread.timeoutInMilliseconds来设置Hystrix超时时间。该配置没有提示。(一般用于生产环境。开发环境不建议使用)

在服务消费方的配置文件中配置:

server:
  port: 8085
spring:
  application:
    name: springclouddemo1_consumer
eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:10086/eureka
#hystrix熔断策略配置
hystrix:
  command:
    default:
      execution:
        thread:
          timeoutInMilliseconds: 3000 #默认的连接超时时间1秒,若1秒没有返回数据,自动的触发降级逻辑

`1.6 服务熔断`

熔断器，也叫断路器，其英文单词为：Circuit Breaker

熔断状态机3个状态：

Closed：关闭状态，所有请求都正常访问。
Open：打开状态，所有请求都会被降级。Hystix会对请求情况计数，当一定时间内失败请求百分比达到阈值，则触发熔断，断路器会完全打开。默认失败比例的阈值是50%，请求次数最少不低于20次。
Half Open：半开状态，open状态不是永久的，打开后会进入休眠时间（默认是5S）。随后断路器会自动进入半开状态。此时会释放部分请求通过，若这些请求都是健康的，则会完全关闭断路器，否则继续保持打开，再次进行休眠计时

示例:
为了能够精确控制请求的成功或失败，我们在consumer的调用业务中加入一段逻辑：
当请求的id不为1的时候，都视为失败的请求

@GetMapping("/findAccountById/{id}")
@HystrixCommand
public Account findAccountById(@PathVariable("id") Integer id){
    if(id!=1){
        throw new RuntimeException();
    }
    String url = "http://springclouddemo1-provider/account/findAccountById/"+id;
    return restTemplate.getForObject(url,Account.class);
}

我们准备两个请求路径:
http://localhost:8085/consumer/findAccountById/1 一定请求成功
http://localhost:8085/consumer/findAccountById/2 一定请求失败

当我们疯狂访问id为2的请求时（超过20次），就会触发熔断。断路器会断开，一切请求都会被降级处理。
此时你访问id为1的请求，会发现返回的也是失败，而且失败时间很短，只有几毫秒左右：
不过，默认的熔断触发要求较高，休眠时间窗较短，为了测试方便，我们可以通过配置修改熔断策略：

server:
  port: 8085
spring:
  application:
    name: springclouddemo1_consumer
eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:10086/eureka
#hystrix熔断策略配置
hystrix:
  command:
    default:
      execution:
        thread:
          timeoutInMilliseconds: 3000 #默认的连接超时时间1秒,若1秒没有返回数据,自动的触发降级逻辑
      circuitBreaker:
        requestVolumeThreshold: 5 #触发熔断的最小请求次数10秒5次，默认10秒20次
        sleepWindowInMilliseconds: 10000 #熔断多少秒后去尝试请求 默认5s打开状态的时间
        errorThresholdPercentage: 50 #触发熔断的失败请求最小占比，默认50%

解读：
requestVolumeThreshold：触发熔断的最小请求次数，默认20
errorThresholdPercentage：触发熔断的失败请求最小占比，默认50%
sleepWindowInMilliseconds：休眠时长，默认是5000毫秒

当我们请求失败5次之后触发服务熔断，此时id=1的请求也会失败（服务降级，返回错误信息），5s后，断路器处于半开状态，此时如果请求能够正确响应之后，断路器自动关闭，服务正常运行，如果请求还是失败，再次触发熔断，断路器打开，所有服务全部降级。

二、Feign

`2.1 Feign简介`

`2.2 Feign的快速入门`

在服务消费方引入feign的依赖

<!--引入feign依赖：-->
<dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring-cloud-starter-openfeign</artifactId>
  <version>2.2.1.RELEASE</version>
</dependency>

开启Feign的功能，在启动类上添加Feign的注解，开启Feign的功能

删除RestTemplate：feign已经自动集成了Ribbon负载均衡的RestTemplate。所以，此处不需要再注册RestTemplate

定义Feign客户端
1.在springclouddemo1_consumer工程中添加AccoutClient接口

package com.bianyiit.client;

import com.bianyiit.pojo.Account;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;

@FeignClient(value = "springclouddemo1-provider") //标注这是一个feign接口
@Component
public interface AccoutClient {

    @GetMapping("/account/findAccountById/{id}")
    public Account getAccountById(@PathVariable("id") Integer id);

}

解读:

首先这是一个接口，Feign会通过动态代理，帮我们生成实现类。这点跟mybatis的mapper很像
@FeignClient，声明这是一个Feign客户端，类似@Mapper注解。同时通过value属性指定服务名称
接口中的定义方法，完全采用SpringMVC的注解，Feign会根据注解帮我们生成URL，并访问获取结果

2.改造原来的调用逻辑，调用UserClient接口：
改造springclouddemo1_consumer工程中的AccountController

package com.bianyiit.controller;

import com.bianyiit.client.AccoutClient;
import com.bianyiit.pojo.Account;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/consumer")
public class AccountController {
    @Autowired
    AccoutClient accoutClient;

    @GetMapping("/findAccountById/{id}")
    public Account findAccountById(@PathVariable("id") Integer id){
        return accoutClient.getAccountById(id);
    }
}

启动测:http://localhost:8085/consumer/findAccountById/2

`2.3 Feign对负载均衡的支持`

Feign中本身已经集成了Ribbon依赖和自动配置：

因此我们不需要额外引入依赖，也不需要再注册RestTemplate对象。

`2.4 Feign对Hystrix的支持`

Feign默认也有对Hystrix的集成：

只不过，默认情况下是关闭的。我们需要通过下面的参数来开启：(在springclouddemo1_consumer工程添加配置内容)

server:
  port: 8085
spring:
  application:
    name: springclouddemo1_consumer
eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:10086/eureka
feign:
  hystrix:
    enabled: true # 开启Feign的熔断功能

我们要定义一个类AccountClientFallback，实现刚才编写的AccoutClient，作为fallback的处理类

package com.bianyiit.client;

import com.bianyiit.pojo.Account;
import org.springframework.stereotype.Component;

@Component
public class AccountClientFallback implements AccoutClient {
    @Override
    public Account getAccountById(Integer id) {
        Account account=new Account();
        account.setName("服务器内部资源错误....");
        return account;
    }
}

挂掉服务提供方，启动测试:http://localhost:8085/consumer/findAccountById/2

三、Zuul网关

`3.1 Zuul的简介`

Zuul：维基百科,电影《捉鬼敢死队》中的怪兽，Zuul，在纽约引发了巨大骚乱。
事实上，在微服务架构中，Zuul就是守门的大Boss！一夫当关，万夫莫开！

Zuul加入之后的架构

`3.2 Zuul快速入门`

导入依赖

<parent>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-parent</artifactId>
  <version>2.2.5.RELEASE</version>
  <relativePath/>
</parent>

<properties>
  <spring-cloud.version>Hoxton.SR1</spring-cloud.version>
</properties>

<dependencies>
  <dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
  </dependency>
  <dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-zuul</artifactId>
  </dependency>
</dependencies>

<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-dependencies</artifactId>
      <version>${spring-cloud.version}</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
  </dependencies>
</dependencyManagement>

<build>
  <plugins>
    <plugin>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-maven-plugin</artifactId>
    </plugin>
  </plugins>
</build>

在springclouddemo1_zuul模块里面编写配置

server:
  port: 10010  #端口号
spring:
  application:
    name: springclouddemo1-zuul #注册到Eureka的服务名称
eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:10086/eureka   #连接eureka的地址
zuul:
  routes:
    springclouddemo1-provider:
      path: /springclouddemo1-provider/**   # 这里是映射路径
      url: http://127.0.0.1:8081  # 这里是映射路径映射的实际地址

在启动类上开启网关组件

package com.bianyiit;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.zuul.EnableZuulProxy;

@SpringBootApplication
@EnableZuulProxy //开启网关组件  动态路由
public class SpringCloudZuulApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringCloudZuulApplication.class, args);
    }
}

启动测试
访问的路径中需要加上配置规则的映射路径，我们访问：
http://localhost:10010/springclouddemo1-provider/account/findAccountById/1

`3.3 面向服务路由`

在刚才的路由规则中，我们把路径对应的服务地址写死了！如果同一服务有多个实例的话，这样做显然就不合理了。我们应该根据服务的名称，去Eureka注册中心查找服务对应的所有实例列表，然后进行动态路由才对！
改造springclouddemo1_zuul工程:
添加Eureka客户端依赖

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

将网关服务注册到Eureka容器

在引导类上开启Eureka客户端

修改映射配置
因为已经有了Eureka客户端，我们可以从Eureka获取服务的地址信息，因此映射时无需指定IP地址，而是通过服务名称来访问，而且Zuul已经集成了Ribbon的负载均衡功能。

server:
  port: 10010  #端口号
spring:
  application:
    name: springclouddemo1-zuul #注册到Eureka的服务名称
eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:10086/eureka   #连接eureka的地址
zuul:
  routes:
    springclouddemo1-provider:
      path: /springclouddemo1-provider/**   # 这里是映射路径  
      serviceId: springclouddemo1-provider  #指定服务名称
      # url: http://127.0.0.1:8081  # 这里是映射路径映射的实际地址

启动测试
再次启动，这次Zuul进行代理时，会利用Ribbon进行负载均衡访问：
http://localhost:10010/springclouddemo1-provider/account/findAccountById/1

`3.4 简化路由配置`

在刚才的配置中，我们的规则是这样的：
zuul.routes.<route>.path=/xxx/**：来指定映射路径。<route>是自定义的路由名
zuul.routes.<route>.serviceId=springclouddemo1-provider：来指定服务名。

而大多数情况下，我们的路由名称往往和服务名会写成一样的。
因此Zuul就提供了一种简化的配置语法：zuul.routes.<serviceId>=<path>
比方说上面我们关于service-provider的配置可以简化为一条：

zuul:
  routes:
    server-provider: /springclouddemo1-provider/**
    #  path: /server-provider/**   # 这里是映射路径
    #  url: http://127.0.0.1:8081  # 这里是映射路径映射的实际地址
    #  serviceId: server-provider  #指定服务名称

`3.5 默认的路由规则`

在使用Zuul的过程中，上面讲述的规则已经大大的简化了配置项。但是当服务较多时，配置也是比较繁琐的。因此Zuul就指定了默认的路由规则：默认情况下，一切服务的映射路径就是服务名本身。例如服务名为：service-provider，则默认的映射路径就是：/service-provider/**
也就是说，刚才的映射规则我们完全不配置也是OK的，不信就试试看。

server:
  port: 10010  #端口号
spring:
  application:
    name: springclouddemo1-zuul #注册到Eureka的服务名称
eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:10086/eureka   #连接eureka的地址
zuul:
  routes:
    springclouddemo1-provider: /springclouddemo1-provider/**
    springclouddemo1-consumer: /springclouddemo1-consumer/**

`3.6 添加路由前缀`

server:
  port: 10010  #端口号
spring:
  application:
    name: springclouddemo1-zuul #注册到Eureka的服务名称
eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:10086/eureka   #连接eureka的地址
zuul:
  routes:
    springclouddemo1-provider: /springclouddemo1-provider/**
    springclouddemo1-consumer: /springclouddemo1-consumer/**
  prefix: /api  #添加路由前缀 如果带前缀，说明该请求时经过网关的，如果没有带api则说明绕过了网关

千万注意这里的服务名用-,而不是用下划线_
服务提供方:http://localhost:10010/api/springclouddemo1-provider/account/findAccountById/2
服务消费方: http://localhost:10010/api/springclouddemo1_consumer/consumer/findAccountById/1

四、zuul过滤器

Zuul作为网关的其中一个重要功能，就是实现请求的鉴权。而这个动作我们往往是通过Zuul提供的过滤器来实现的。

`4.1 ZuulFilter`

ZuulFilter是过滤器的顶级父类。在这里我们看一下其中定义的4个最重要的方法：

public abstract class ZuulFilter implements IZuulFilter, Comparable<ZuulFilter> {
public abstract String filterType();
public abstract int filterOrder();
boolean shouldFilter();
Object run() throws ZuulException;
}

shouldFilter：返回一个Boolean值，判断该过滤器是否需要执行。返回true执行，返回false不执行。
run：过滤器的具体业务逻辑。
filterType：返回字符串，代表过滤器的类型。包含以下4种：
pre：请求在被路由之前执行
route：在路由请求时调用
post：在route和errror过滤器之后调用
error：处理请求时发生错误调用
filterOrder：通过返回的int值来定义过滤器的执行顺序，数字越小优先级越高。

`4.2 过滤器的生命周期`

这张是Zuul官网提供的请求生命周期图，清晰的表现了一个请求在各个过滤器的执行顺序

正常流程：

请求到达首先会经过pre类型过滤器，而后到达route类型，进行路由，请求就到达真正的服务提供者，执行请求，返回结果后，会到达post过滤器。而后返回响应。

异常流程：

整个过程中，pre或者route过滤器出现异常，都会直接进入error过滤器，在error处理完毕后，会将请求交给POST过滤器，最后返回给用户。
如果是error过滤器自己出现异常，最终也会进入POST过滤器，将最终结果返回给请求客户端。
如果是POST过滤器出现异常，会跳转到error过滤器，但是与pre和route不同的是，请求不会再到达POST过滤器。

`4.3 使用场景`

场景非常多：

请求鉴权：一般放在pre类型，如果发现没有访问权限，直接就拦截了
异常处理：一般会在error类型和post类型过滤器中结合来处理。
服务调用时长统计：pre和post结合使用

`4.4 自定义过滤器`

接下来自定义一个过滤器，模拟一个登录的校验。基本逻辑：如果请求中有access-token参数，则认为请求有效，放行。

内容:注意，springboot的启动类一定要放在com.bianyiit下面

package com.bianyiit.filter;

import com.netflix.zuul.ZuulFilter;
import com.netflix.zuul.context.RequestContext;
import com.netflix.zuul.exception.ZuulException;
import org.apache.commons.lang.StringUtils;
import org.apache.http.HttpStatus;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;

@Component
public class LoginFilter extends ZuulFilter {
    /**
     * 过滤器类型  pre  前置过滤器
     * @return
     */
    @Override
    public String filterType() {
        return "pre";
    }

    /**
     * 过滤器执行顺序  数值越小 优先级越高
     * @return
     */
    @Override
    public int filterOrder() {
        return 1;
    }

    /**
     * 过滤器是否生效
     * true生效,false 不生效
     * @return
     */
    @Override
    public boolean shouldFilter() {
        return true;
    }

    /**
     * 编写过滤器的基本逻辑
     * @return
     * @throws ZuulException
     */
    @Override
    public Object run() throws ZuulException {
        //获取Zuul上下文对象
        RequestContext context = RequestContext.getCurrentContext();
        //从上下文获取
        HttpServletRequest request = context.getRequest();
        //获取token信息
        String token = request.getParameter("token");
        //System.out.println("123456789"+token);
        //判断
        if(StringUtils.isBlank(token)) { //如果token为空
            //过滤该请求，不对其进行路由
            context.setSendZuulResponse(false);
            //设置响应状态码
            context.setResponseStatusCode(HttpStatus.SC_UNAUTHORIZED);
            //设置响应信息
            context.setResponseBody("{'status':'401','text':'request error!'}");
        }
        return null;
    }
}

测试:
不带token参数: http://localhost:10010/api/springclouddemo1-provider/account/findAccountById/2

带token参数: http://localhost:10010/api/springclouddemo1-provider/account/findAccountById/2?token=123