sentinel中如何使用@SentinelResource和openFeign来进行服务熔断和降级的操作

前言：认识Sentinel

• ① 超时处理（服务故障处理）

• ② 舱壁模式（服务故障处理）

• ③ 熔断降级（服务故障处理）

• ④ 流量控制（瞬间高并发预防）

Sentinel 后台安装 , github

下载源码并运行

java -Dserver.port=8080 -Dcsp.sentinel.dashboard.server=localhost:8080 -Dproject.name=sentinel-dashboard -jar sentinel-dashboard.jar#访问： http://localhost:8080/ #密码：用户名和密码都是sentinel

Client 端连接 Sentinel 后台

# 修改payment-service 项目的配置文件，添加如下配置spring.cloud.sentinel.transport.dashboard=localhost:8080

sentinel中如何使用@SentinelResource和openFeign来进行服务熔断和降级的操作

SentinelResource

【@SentinelResource：】
    @SentinelResource 注解用于定义资源，并提供了可选的异常处理 以及 fallback 配置项。
value：资源名称，必须项（不能为空）。
    blockHandler：
    指定限流异常（BlockException）发生后，应该执行的方法。
    注意事项：
        方法访问权限修饰符为 public。
        返回值类型 与 原方法返回值类型一致。
        参数类型 与 原方法一致，并追加一个 额外参数，参数类型为 BlockException。
        blockHandler 指定的函数默认需要与 原方法在同一个类中。
blockHandlerClass：
    指定限流异常（BlockException）发生后，应该执行的方法（此方法可以位于 其他类）。
    注意事项：
        方法访问权限修饰符为 public。
        方法必须是 static 函数，否则无法解析。
fallback：
    指定异常（除了 exceptionsToIgnore 指定的异常外的异常）发生后，应该执行的方法。
    注意事项：
        返回值类型 与 原方法返回值类型一致。
        参数类型 与 原方法一致，可以额外增加一个 Throwable 类型的参数用于接收对应的异常。
        fallback 指定的函数默认需要与 原方法在同一个类中。
        fallbackClass：
    指定异常发生后，应该执行的方法（此方法可以位于 其他类）。
    注意事项：
        方法访问权限修饰符为 public。
        方法必须是 static 函数，否则无法解析。 
defaultFallback:
    指定异常发生后，执行默认的逻辑（即 通用处理逻辑）。
    与 fallback 类似，但 其指定的方法参数为空，可以额外增加一个 Throwable 类型的参数用于接收对应的异常。
   当 fallback 与 defaultFallback 同时存在时，只有 fallback 会生效。
exceptionsToIgnore:
    用于指定哪些异常被排除掉，不会计入异常统计中，也不会进入 fallback 逻辑中（直接对外抛出原异常）。
【@SentinelResource 使用注意事项：】
    若 blockHandler 和 fallback 都配置了，当限流降级异常发生时(即 抛出 BlockException)，只会执行 blockHandler 指定的方法。
   若未配置 fallback、blockHandler 时，则限流降级时，则可能直接抛出 BlockException 异常，若方法本身没定义 throws BlockException，则异常将会被 JVM 包装为 UndeclaredThrowableException 异常。
可以简单的理解为： 
    blockHandler 用于指定 限流、降级 等异常(BlockException)发生后应该执行的规则。
    fallback 用于指定 其他异常（比如： RuntimeException）发生后应该执行的规则。

默认限流

编写一个新的控制器类型，这里使用cloud-alibaba-sentinel-8006项目进行操作

@SentinelResource既可以配置资源名称，也可以配置URL，当我们配置了blockHandler属性时，如果达到阈值时，会调用对应的方法提示限流信息，如果没有配置blockHandler属性，系统会走默认的限流信息（Blocked by Sentinel (flow limiting)）

首先我们使用默认的@SentinelResource注解，系统会针对对应的地址调用默认的异常处理方法。

    @GetMapping("/restUrl")
    @SentinelResource(value = "restUrl")
    public String restUrl(){
        return " restUrl";
    }

注意：我们重启项目之后，要先访问，才能去设置对应的限流规则

先访问http://localhost:8006/restUrl，在添加流控规则。此时如果没有自己定义限流处理方法，走系统默认。

blockHandler

使用@SentinelResource注解同时使用blockHandler属性

    @GetMapping("resourceTest")
    @SentinelResource(value = "resourceTest",blockHandler = "handler_resource")
    public String resourceTest(){
        return "resourceTest";
    }
    public String handler_resource(BlockException exception){
        return "系统繁忙，请稍后再试";
    }

先访问http://localhost:8006/resourceTest，在添加流控规则

再去快速的去访问http://localhost:8006/resourceTest就会出现代码中配置的限流异常处理信息，如下：

但是如果我们的业务逻辑比较复杂，熔断的业务场景比较多每个业务方法对添加一个对应的限流处理方法，会让代码显得臃肿，而且无法实现统一处理。

这里就需要提到另外一个属性—blockHandlerClass

blockHandlerClass

此属性中设置的方法必需为 static 函数，否则无法解析。

首先我们需要创建一个类用于专门处理自定义限流处理逻辑。

import com.alibaba.csp.sentinel.slots.block.BlockException;
/**
 * Sentinel限流自定义逻辑
 */
public class SentinelExptioinHandler {
    public static String handlerMethodError(BlockException exception){
        return "handlerMethodError：服务异常，请稍后重试！";
    }
    public static String handlerMethodNetwork(BlockException exception){
        return "handlerMethodNetwork：网络错误，连接超时，请稍后重试！";
    }
}

同时我们添加一个可访问的接口方法，设置@SentinelResource注解和blockHandlerClass属性对应的类型和这个类型中对应的处理方法

    /**
     * 此方法用到了自定义限流处理类型CustomerBlockHandler
     * 中的handlerException1方法来处理限流逻辑。
     */
    @GetMapping("/buildExption")
    @SentinelResource(value = "buildExption",
            blockHandlerClass = SentinelExptioinHandler.class,blockHandler = "handlerMethodError")
    public String buildExption(){
        return "hello buildExption";
    }

我们先访问http://localhost:8006/buildExption后，来给它添加限流规则。

再次访问http://localhost:8006/buildExption后，如果超过阈值之后使用的处理方法是否是我们的SentinelExptioinHandler.handlerMethodError()，频繁的访问地址，就会看到出现了我们在异常处理类中设置的方法。

如果我们想要网络异常的操作，我们只需要替换blockHandler中的handlerMethodError改为handlerMethodNetwork，重启项目，重复上面的步骤：

使用 JMeter 模拟超时故障发生

【JMeter】    Apache 的一款基于 Java 的压力测试工具。注：    有兴趣的自行研究，此处不过多赘述。
【官网下载地址：】    http://jmeter.apache.org/download_jmeter.cgi
【JMeter 简单使用：】    https://www.cnblogs.com/stulzq/p/8971531.html

服务熔断

服务熔断是应对微服务雪崩的一种链路保护机制

我们需要整合Ribbon+openFeign，来模拟真实的应用场景。首先我们需要利用Ribbon进行负载均衡的调用，先创建消费者(cloud-alibab-consumer-8083)和两个服务提供者(cloud-alibaba-provider-9003/9004)

我们先来搭建服务提供者

服务提供者

pom.xml

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>
<dependency>
    <groupId>com.muxiaonong</groupId>
    <artifactId>cloud-alibaba-commons</artifactId>
    <version>0.0.1-SNAPSHOT</version>
</dependency>

yml文件

server:
  port: 9003
spring:
  application:
    name: nacos-provider
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848 #配置Nacos地址
management:
  endpoints:
    web:
      exposure:
        include: '*'

主启动类添加@EnableDiscoveryClient注解

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

添加商品信息请求类

@RestController
public class GoodsController {
    @Value("${server.port}")
    private String serverPort;
    //模仿数据库存储数据
    public static HashMap<Long,String> hashMap = new HashMap<>();
    static {
        hashMap.put(1l,"面膜");
        hashMap.put(2l,"哈密瓜");
        hashMap.put(3l,"方便面");
    }
    @GetMapping("queryGoods/{id}")
    public Response<String> queryGoods(@PathVariable("id") Long id){
        Response<String> response = new Response(200,"成功请求："+serverPort,hashMap.get(id));
        return response;
    }
}

此时服务提供者就搭建完成了

注意：另外一个服务提供者只需要端口不一样即可

服务消费者

pom.xml

 <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
    <scope>runtime</scope>
    <optional>true</optional>
</dependency>
<dependency>
    <groupId>com.muxiaonong</groupId>
    <artifactId>cloud-alibaba-commons</artifactId>
    <version>0.0.1-SNAPSHOT</version>
</dependency>
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
    <version>2.2.6.RELEASE</version>
</dependency>

yml文件

server:
  port: 8083
spring:
  application:
    name: nacos-consumer
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848
    sentinel:
      transport:
        #配置Sentinel dashboard地址
        dashboard: localhost:8080
        #默认8719端口，假如被占用会自动从8719开始依次+1扫描,直至找到未被占用的端口
        port: 8719
#消费者将要去访问的微服务名称(注册成功进nacos的微服务提供者)
service-url:
  nacos-user-service: http://nacos-provider

主启动类添加@EnableDiscoveryClient

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

访问类

/**
 * @program: spring-cloud-alibaba
 * @ClassName DemoController
 * @description:
 * @author: amu
 * @create: 2022-06-04 23:10
 * @Version 1.0
 **/
@RestController
public class DemoController {
    @Autowired
    private RestTemplate restTemplate;
    /**
     * 消费者去访问具体服务，这种写法可以实现
     * 配置文件和代码的分离
     */
    @Value("${service-url.nacos-user-service}")
    private String serverURL;
    @GetMapping("/consumer/goods/{id}")
        public Response<String> fallback(@PathVariable Long id){
        //通过Ribbon发起远程访问，访问9003/9004
        if(id <= 3) {
            Response<String> result = restTemplate.getForObject(serverURL + "/queryGoods/" + id, Response.class);
            return result;
        }else {
            throw new NullPointerException("未查询到对应的数据");
        }
    }
}

我们先启动9003/9004,在启动8083，然后访问http://localhost:8083/consumer/goods/2，就可以看到在浏览器中，如果9003/9004相互切换，说明我们搭建成功。

fallback

SentinelResource的fallback属性，主要用于抛出异常的时候提供处理逻辑，该函数可以针对所有的异常类型（除了exceptionsToIgnore排除的异常类型）进行处理，对于fallback的函数签名和位置要求：

- 返回值需和原函数返回在一致
- 方法参数列表需要和原函数一致，可以额外多一个Throwbale类型的参数用来接收对应的异常
- fallback 函数默认需要和原方法在同一个类中，如果希望使用其他类的函数，则可以指定 fallbackClass 为对应的类的 Class 对象，注意对应的函数必需为 static 函数，否则无法解析
案例：

    @Autowired
    private RestTemplate restTemplate;
    @GetMapping("/consumer/goods/{id}")
    //如果不设置这个注解和fallback参数，异常会原样弹出
    //如果设置SentinelResource注解的fallback属性，会按照设置的方法处理Java异常
    @SentinelResource(value = "falllback",fallback = "fallbackHandler")//被标注的异常将会被 原样抛出
    public Response<String> fallback(@PathVariable Long id){
        //通过Ribbon发起远程访问，访问9003/9004
        if(id <= 3) {
            Response<String> result = restTemplate.getForObject(serverURL + "/queryGoods/" + id, Response.class);
            return result;
        }else {
            throw new NullPointerException("未查询到对应的数据");
        }
    }
        //保证方法签名基本保持一致，但是要添加异常类型参数
    public Response<String> fallbackHandler(Long id,Throwable e){
        Response<String> result = new Response<>(500,"出现未知商品id","商品不存在");
        return result;
    }

在这里如果我们去访问id超过3的数字的时候请求时（http://localhost:8083/consumer/goods/6），如果我们没有设置fallback属性，会弹出NullPointerException的错误

现在当我们去访问设置了 fallback属性的时http://localhost:8083/consumer/goods/6会出现我们设置的参数。

fallback也可以设置fallbackClass属性，用来指定对应类型，来处理对应的异常类型，但是方法也是需要为静态方法，否则无法解析。

fallback属性和blockHandler都能进行限流，哪一个的优先级更高？

blockHandler属性是针对于Sentinel异常，blockHandler 对应处理 BlockException 的函数名称，而fallback属性针对于Java异常

 @GetMapping("/consumer/goods/{id}")
    //如果不设置这个注解和fallback参数，异常会原样弹出
    //如果设置SentinelResource注解的fallback属性，会按照设置的方法处理Java异常
    @SentinelResource(value = "falllback",fallback = "fallbackHandler",blockHandler = "blockHandler")
    public Response<String> fallback(@PathVariable Long id){
        //通过Ribbon发起远程访问，访问9003/9004
        if(id <= 3) {
            Response<String> result = restTemplate.getForObject(serverURL + "/queryGoods/" + id, Response.class);
            return result;
        }else {
            throw new NullPointerException("未查询到对应的数据");
        }
    }
    //保证方法签名基本保持一致，但是要添加异常类型参数
    public Response<String> fallbackHandler(Long id,Throwable e){
        Response<String> result = new Response<>(500,"出现未知商品id","商品不存在");
        return result;
    }
    //处理Sentinel限流
    public Response<String> blockHandler(Long id, BlockException e){
        Response<String> result = new Response<>(501,"sentinel限流操作","blockHandler 限流");
        return result;
    }

添加熔断规则，在一秒内最小请求次数为5，如果异常超过2个时，触发熔断规则。

这个时候我们再来访问http://localhost:8083/consumer/goods/6时，没有触发熔断之前出现异常，由fallback进行处理。

当我们快速点击触发熔断规则时，这是时候则由blockHandler进行处理。

关于sentinel的另外一个属性 exceptionsToIgnore

exceptionsToIgnore

用于指定哪些异常被排除，不会计入异常统计中，也不会进入 fallback属性处理的方法，会原样抛出

    @GetMapping("/consumer/goods/{id}")
    //添加SentinelResource注解的fallback属性，同时设置方法来解决Java异常
    @SentinelResource(value = "falllback",fallback = "fallbackHandler",blockHandler = "blockHandler",
            exceptionsToIgnore = {NullPointerException.class})//被标注的异常将会被 原样抛出
    public Response<String> fallback(@PathVariable Long id){
        //通过Ribbon发起远程访问，访问9003/9004
        if(id <= 3) {
            Response<String> result = restTemplate.getForObject(serverURL + "/queryGoods/" + id, Response.class);
            return result;
        }else {
            throw new NullPointerException("未查询到对应的数据");
        }
    }

启动项目，当我们再去访问http://localhost:8083/consumer/goods/6的时候，出现原有异常。

下面我们就来了解一下基于openFeign如何实现负载均衡和服务熔断。

openFeign

OpenFeign是一种声明式、模板化的HTTP客户端。用法其实就是编写一个接口，在接口上添加注解即可。

可以简单理解它是借鉴Ribbon的基础之上，封装的一套服务接口+注解的方式的远程调用器。由它来帮助我们定义和实现依赖服务接口的定义，只需创建一个接口并使用注解的方式进行配置。进一步简化我们的操作。

演示项目为：cloud-alibaba-openFeign-8009，调用服务为9003/9004

pom.xml

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
    <version>2.2.6.RELEASE</version>
</dependency>

yml文件

server:
  port: 8009
spring:
  application:
    name: nacos-consumer-openFeign
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848
        management:
  endpoints:
    web:
      exposure:
        include: '*'

启动类添加 @EnableFeignClients

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

@FeignClient

@Service
@FeignClient("nacos-provider")
public interface GoodsFeign {
    @GetMapping("queryGoods/{id}")
    public Response<String> queryGoods(@PathVariable("id") Long id);
}

请求控制类

@RestController
public class FeignController {
    @Autowired
    private GoodsFeign goodsFeign;
    @GetMapping("query/{id}")
    public Response<String> query(@PathVariable("id") Long id){
        return goodsFeign.queryGoods(id);
    }
}

我们一次启动，9003/9004，以及我们的消费者服务cloud-alibaba-openFeign-8009，服务都启动成功后，访问http://localhost:8009/query/1，如果看到端口切换展示就表示成功了

OpenFeign 设置超时时间

OpenFeign 默认的超时时间为一秒钟，如果服务端业务超过这个时间，则会报错，为了避免这样的情况，我们可以设置feign客户端的超时控制。

先来看一下如果我们设置一个延时任务openFeign会提示怎么样的信息。我们需要在服务提供者(9003/9004)那里设置一个阻塞三秒的请求。

    @GetMapping("/readTimeOut")
    public String readTimeOut() {
        try {
            System.out.println(serverPort+"网络连接超时，延迟响应");
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return serverPort;
    }

然后通过feign进行调用

   @GetMapping("/readTimeOut")
    public String readTimeOut();

   @GetMapping("/query/readTimeOut")
    public String readTimeOut() {
        String str = goodsFeign.readTimeOut();
        return str;
    }

这个时候当访问http://localhost:8009/query/readTimeOut时，客户端会提示报错，提示连接超时

可以设置feign的超时时间进行控制，由于OpenFeign 底层是ribbon 。所以超时控制由ribbon来控制。在yml文件中配置，只需要在8009中的yml添加这样一段代码即可。

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

重新启动项目后，再来访问我们当前接口，成功返回正确信息

说起OpenFeign，可以通过配置调整日志级别，这样有利于我们从feign中了解请求和响应的细节，对接口的调用情况进行监控。

OpenFeign日志级别分类四种

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

启动类中通过@Bean注解注入日志功能

    @Bean
	Logger.Level feignLoggerLevel(){
		//开启全日志
		return Logger.Level.FULL;
	}

yml中添加日志开启功能

logging:
  level:
    # openfeign日志以什么级别监控哪个接口
    com.muxiaonong.feign.GoodsFeign: debug

这样可在请求调用以后看到日志的详细信息了

我们已经了解了openFeign的基本使用，那么我们要如何将Sentinel和OpenFeign进行整合呢

yml中添加Sentinel对OpenFeign的支持

# 激活Sentinel对OpenFeign的支持
feign:
  sentinel:
    enabled: true

在feign中添加对fallback的支持

@Service
@FeignClient(value = "nacos-provider",fallback = GoodsServiceImpl.class)
public interface GoodsFeign {
    @GetMapping("queryGoods/{id}")
    public Response<String> queryGoods(@PathVariable("id") Long id);
    @GetMapping("/readTimeOut")
    public String readTimeOut();
}

@Component
public class GoodsServiceImpl implements GoodsFeign {
    @Override
    public Response<String> queryGoods(Long id) {
        return new Response<>(501,"服务降级处理返回信息",null);
    }
    @Override
    public String readTimeOut() {
        return null;
    }
}

这个时候请求http://localhost:8009/query/1，是正常的，但是当我们关闭服务提供者(9003/9004)时，就出触发服务降级操作，提示下面信息

总结

熔断由服务不可用引起，降级由业务实际情况和系统资源负载设置等关系引起，不管是对于熔断还是降级都是从系统稳定性出发，保证系统的最大可用。

文：一只阿木木

欢迎转发、交流小数据。