2022-08-20 09:49 湖南师范大学 Java 发布于湖南

关注

Sentinel限流降级如何优雅的返回？

前言

我们访问接口进行限流或者降级后，直接返回500错误，或者提示 flow limit 之类的东西：

这样显得很不优雅，透漏着不专业，那么进行限流或者降级后该如何进行优雅的返回呢？

从 Sentinel 的热点参数限流着手，使用注解 @SentinelResource 的 blockHandler 和 fallback 来实现限流后优雅的返回。

Sentinel的热点参数限流

看到限流名字热点参数，顾名思义，就能想到是针对请求资源的参数进行限流的。如果参数是热点参数，并且符合设置的热点参数限流规则，那么 Sentinel 也对其进行限流。

何为热点参数呢？联想一下娱乐圈的那些明星，粉丝越多的明星，他的热度就越高。同理，一个系统，访问的数据越频繁，这个数据的热度就越高。这种经常访问的数据就是热点。

有些时候，需要采取一些措施对热点数据进行限制，比如：

统计一段时间内最常访问的某个商品 ID （参数为商品 ID ），那么对该商品 ID 进行限制；
请求资源参数用户 ID ，针对一段时间内频繁访问的用户 ID 进行限制；
等等

热点参数限流会统计传入参数中的热点参数，并根据配置的限流阈值与模式，对包含热点参数的资源调用进行限流。

热点参数限流可以看做是一种特殊的流量控制，仅对包含热点参数的资源调用生效。

下面我们就开始创建包含热点参数的接口资源，并配置热点参数限流规则进行验证 Sentinel 的热点参数限流功能。

还是用之前的微服务项目 sentinel-service ，新增一个接口资源如下：

@RestController @Slf4j public class UserController { @GetMapping("/getProduct") @SentinelResource("getProduct") public String getProduct(@RequestParam(value = "userId", required = false) Long userId,
                             @RequestParam(value = "productId", required = false) Long productId,
                             @RequestParam(value = "categoryId", required = false) Integer categoryId) {
        log.info("getProduct param userId={},productId={},categoryId={}", userId, productId, categoryId); return "getProduct success";
    }
}

下面开始通过 Sentinel 控制台和 Nacos 配置中心两种方式进行规则配置。

通过 Sentinel 控制台进行热点参数限流规则配置

在控制台，在簇点链路上找到对应的资源，进行热点规则配置：

打开热点操作：

如图所示的就是对资源 getProduct 的第一个参数 userId 进行限流，如果配置单机阈值为1，窗口统计时长1秒，那么其含义就是：在1秒内访问 getProduct 资源超过1次，如果传入了热点参数 userId，那么将对该资源进行限流，如果没有传入 userId，那么该资源不被限流。

现在我们来访问接口验证一下，先传入不是热点的参数 categoryId ：

可以看到，无论QPS是多少，接口都正常返回，没有进行限流，现在我们加上热点参数 userId 试一下：

1秒内快速刷新几下，QPS只要大于1了，接口访问就芭比Q了，说明 Sentinel 的热点参数限流生效了。

Sentinel 热点参数限流规则持久化到 Nacos

在 Nacos 设置 Data ID 及规则内容

在 Sentinel 控制台配置的规则，当服务重启后，规则将消失，这并不是我们想要的结果，上一篇文章中，我们已经完成了 Sentinel 的规则持久化到 Nacos 中，本小节我们配置一下热点参数的限流规则。

热点参数的限流规则主要有以下几个字段：

resource ：资源名，必填项；
count ：限流阈值，必填项；
grade ：限流模式，只能是 QPS ；
paramIdx ：热点参数的索引，必填项，索引从 0 开始；
durationInSec ：统计窗口时间长度（单位为秒），默认为 1 s；
controlBehavior ：流控效果（支持快速失败和匀速排队模式），默认为快速失败；
maxQueueingTimeMs ：最大排队等待时长（仅在匀速排队模式生效），默认 0 ms；
paramFlowItemList ：参数例外项，可以针对指定的参数值单独设置限流阈值，不受前面 count 阈值的限制。仅支持基本类型和字符串类型。
clusterMode ：是否是集群参数流控规则，默认为 false ；
clusterConfig ：集群流控相关配置。

下面我们在 Nacos 控制台中对资源 getProduct 添加热点参数限流规则：

这里的设置和前文在 Sentinel 控制台设置的含义一致。

配置 application.yml

Nacos 中持久化了限流规则，那么在微服务项目中，可以在 application.yml 配置文件中这样配置：

spring:
  application:
    name: sentinel-service

  cloud:
    nacos:
      discovery: # Nacos 集群 server-addr: 192.168.242.112:81
    sentinel:
      transport:
        dashboard: localhost:8080
        port: 8719 # https://github.com/alibaba/Sentinel/issues/1213 web-context-unify: false # Sentinel 规则持久化到 Nacos datasource:
        rule1:
          nacos:
            serverAddr: 192.168.242.112:81
            groupId: DEFAULT_GROUP
            dataId: sentinelFlowRule.json
            ruleType: flow
        rule2:
          nacos:
            serverAddr: 192.168.242.112:81
            groupId: DEFAULT_GROUP
            dataId: hotKeyRule.json
            ruleType: param-flow

其中 ruleType 为 param-flow 的就是热点参数限流的规则，一定要把 dataId 配置正确。

然后启动服务，重新验证限流规则，依然生效：

接口统一返回和统一异常处理

前面接口 getProduct 调用成功返回字符串 getProduct success ,调用失败返回了一个 500 Internal Server Error ，这种返回格式没有一个统一的格式，这在前后端分离项目中并不是很好的实践。前后端应该约定好每个接口的统一返回格式。

本文在 SpringCloudAlibabaDemo 父工程模块下增加一个子模块 internal-common 作为公共模块，其他子模块可以引入该模块使用。

internal-common 子模块中定义了接口返回格式，在包 cn.chendapeng.springcloud.common.response 下定义两个类：

枚举 ResponseCode：

public enum ResponseCode { /**
     * 操作成功
     */ SUCCESS("00000", "操作成功"), /**
     * 系统内部异常
     */ INTERNAL_ERROR("B0001", "系统执行出错"); /**
     * 状态码
     */ private final String code; /**
     * 提示信息
     */ private final String message;

    ResponseCode(String code, String message) { this.code = code; this.message = message;
    } public String getCode() { return code;
    } public String getMessage() { return message;
    }
}

该枚举类可以定义很多其他业务上的异常代码和异常信息。

统一返回类 ResponseResult：

package cn.chendapeng.springcloud.common.response; import lombok.Data; /**
 * 统一返回结果
 *
 * 
 *
 * @author 行百里者
 * @date 2022-08-16 16:49
 */ @Data public class ResponseResult<T> { /**
     * 状态码
     */ private String code; /**
     * 提示信息
     */ private String message; /**
     * 返回数据
     */ private T data; public ResponseResult() {
    } public ResponseResult(String code, String message) { this.code = code; this.message = message;
    } /**
     * 操作成功的返回
     * @param data 返回结果数据
     * @param <T> 数据类型泛型
     * @return 相应结果
     */ public static <T> ResponseResult<T> success(T data) {
        ResponseResult<T> result = new ResponseResult<>();
        result.setCode(ResponseCode.SUCCESS.getCode());
        result.setMessage(ResponseCode.SUCCESS.getMessage());
        result.setData(data); return result;
    } /**
     * 操作失败的返回
     * @param code 状态码
     * @param message 提示信息
     * @param <T> 数据类型泛型
     * @return 失败操作的返回结果
     */ public static <T> ResponseResult<T> fail(String code, String message) { return new ResponseResult<>(code, message);
    }
}

父工程定义子模块：

<modules> <module>internal-common</module> <module>nacos-provider</module> <module>nacos-consumer</module> <module>nacos-config</module> <module>sentinel-service</module> </modules>

在本篇文章demo的子工程 sentinel-service 中引入 internal-common ：

<!-- 引入二方库 --> <dependency> <groupId>cn.chendapeng.springcloud</groupId> <artifactId>internal-common</artifactId> <version>0.0.1-SNAPSHOT</version> </dependency>

OK，至此基础信息准备完毕，下面开始设置统一返回结果。

使用 Spring 的 ResponseBodyAdvice 类以及 @RestControllerAdvice 注解来完成接口的统一返回，在 sentinel-service 中新建一个全局返回的配置类：

package cn.chendapeng.springcloud.sentinelservice.response; import cn.chendapeng.springcloud.common.response.ResponseResult; import com.fasterxml.jackson.core.JsonProcessingException; import com.fasterxml.jackson.databind.ObjectMapper; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.core.MethodParameter; import org.springframework.http.MediaType; import org.springframework.http.converter.HttpMessageConverter; import org.springframework.http.server.ServerHttpRequest; import org.springframework.http.server.ServerHttpResponse; import org.springframework.web.bind.annotation.RestControllerAdvice; import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice; /**
 *
 * @author 行百里者
 * @since 2020-01-16 16:55
 */ @RestControllerAdvice public class ResponseAdvice implements ResponseBodyAdvice<Object> { private ObjectMapper objectMapper; /**
     * 是否开***能
     * @param methodParameter 方法的参数
     * @param aClass 类
     * @return true：开启，false：不开启
     */ @Override public boolean supports(MethodParameter methodParameter, Class<? extends HttpMessageConverter<?>> aClass) { return true;
    } /**
     * 处理返回结果
     * @param o 实例对象
     * @param methodParameter 方法参数
     * @param mediaType 媒体类别
     * @param aClass 类对象
     * @param request 请求
     * @param response 相应
     * @return 处理结果json
     */ @Override public Object beforeBodyWrite(Object o, MethodParameter methodParameter, MediaType mediaType, Class<? extends HttpMessageConverter<?>> aClass, ServerHttpRequest request, ServerHttpResponse response) { //处理字符串类型数据 if (o instanceof String) { try { return objectMapper.writeValueAsString(ResponseResult.success(o));
            } catch (JsonProcessingException e) {
                e.printStackTrace();
            }
        } //如果返回类型o已经封装成ResponseResult了，直接返回 if (o instanceof ResponseResult) { return o;
        } return ResponseResult.success(o);
    } @Autowired public void setObjectMapper(ObjectMapper objectMapper) { this.objectMapper = objectMapper;
    }
}

统一异常返回处理类 GlobalExceptionHandler ：

@RestControllerAdvice public class GlobalExceptionHandler { private static final Logger LOGGER = LoggerFactory.getLogger(GlobalExceptionHandler.class); /**
     * 未知的异常，统一处理
     * @param e 异常对象
     * @return ResponseResult全局异常响应
     */ @ExceptionHandler(Exception.class) public ResponseResult<String> exception(Exception e) {
        LOGGER.error("未知异常", e); return ResponseResult.fail(ResponseCode.INTERNAL_ERROR.getCode(), ResponseCode.INTERNAL_ERROR.getMessage());
    }
}

这个类里还可以增加其他自定义的业务异常处理。

此时，我们重启 sentinel-service 服务，调用 getProduct 测试：

这样接口就有了统一返回的格式了。

另外，我们可以注意到，资源被限流后返回的信息也被如下方法截获：

@ExceptionHandler(Exception.class)
public ResponseResult<String> exception(Exception e) { LOGGER.error("未知异常", e); return ResponseResult.fail(ResponseCode.INTERNAL_ERROR.getCode(), ResponseCode.INTERNAL_ERROR.getMessage());
}

这里定义的是所有的异常都返回：

{ "code": "B0001", "message": "系统执行出错", "data": null }

而资源被 Sentinel 限流就是返回一个 BlockException 异常，所以也就被我们定义的通用异常方法统一处理了。

@SentinelResource 注解之 blockHandler 和 fallback

blockHandler 和 blockHandlerClass

使用 blockHandler 处理限流逻辑

前面的返回：

{ "code": "B0001", "message": "系统执行出错", "data": null }

虽然格式上没有问题，但是返回的结果语义太过笼统，这里我们可以使用注解 @SentinelResource 的 blockHandler 属性来自定义限流后的处理逻辑。

请求资源被 Sentinel 限流后，将会出现BlockException 异常， blockHandler 对应处理 BlockException 的函数名称。

blockHandler 函数访问范围需要是 public，返回类型需要与原方法相匹配，参数类型需要和原方法相匹配并且最后加一个额外的参数，类型为 BlockException。blockHandler 函数默认需要和原方法在同一个类中。

下面我们来增加一个 blockHandler 对应的处理方法：

@GetMapping("/getProduct") @SentinelResource(value = "getProduct", blockHandler = "getProductBlockHandler") public String getProduct(@RequestParam(value = "userId", required = false) Long userId,
                         @RequestParam(value = "productId", required = false) Long productId,
                         @RequestParam(value = "categoryId", required = false) Integer categoryId) {
    log.info("getProduct param userId={},productId={},categoryId={}", userId, productId, categoryId); return "getProduct success";
} public String getProductBlockHandler(Long userId,
                                     Long productId,
                                     Integer categoryId,
                                     BlockException blockException) { return "热点参数 userId=" + userId + " 限流！";
}

然后在测试调用资源，结果如下：

可以看到，将 getProductBlockHandler 处理结果返回了。

这样看还是感觉怪怪的，因为资源被限流了其实返回的是异常结果，这里希望最好给我返回个指定的 code 以及 message 。

再升级一下处理逻辑，首先定义限流返回码，在 internal-common 模块的 ResponseCode 枚举类增加：

/**
  * 热点参数限流
  */ HOT_KEY_BLOCKED("B0002", "热点参数限流");

然后，自定义一个异常 HotKeyBlockedException ：

public class HotKeyBlockedException extends RuntimeException { private Object hotKey; public HotKeyBlockedException(Object hotKey) { super("热点参数 [" + hotKey + "]限流！"); this.hotKey = hotKey;
    } public Object getHotKey() { return hotKey;
    }
}

在全局异常处理类 GlobalExceptionHandler 中增加：

/**
  * 热点参数限流异常
  * @param e 异常对象
  * @return ResponseResult 全局异常响应
  */ @ExceptionHandler(HotKeyBlockedException.class)
public ResponseResult<String> hotKeyBlockedException(Exception e) { LOGGER.error("热点参数限流", e); return ResponseResult.fail(ResponseCode.HOT_KEY_BLOCKED.getCode(), ResponseCode.HOT_KEY_BLOCKED.getMessage());
}

最后，修改一下 getProductBlockHandler 方法：

public String getProductBlockHandler(Long userId,
                                     Long productId,
                                     Integer categoryId,
                                     BlockException blockException) { throw new HotKeyBlockedException(userId);
}

这样就可以返回想要的结果：

使用 blockHandlerClass 将业务和限流处理方法解耦

通过前面的处理，其实我们可以发现，限流处理的方法和业务逻辑耦合在一起了，即处理方法就在业务逻辑本类中。

如果每个业务都增加一个自己的限流处理逻辑，那么类将会膨胀的难以维护，因此 @SentinelResource 除了 blockHandler 可以设置自定义限流处理逻辑方法以外，还提供另外一个属性来设置限流处理逻辑类型 blockHandlerClass 属性。

也就是说，如果我们希望使用其他类的函数来自定义限流处理，则可以指定 blockHandlerClass 为对应的类的 Class 对象。 Sentinel 规定对应的函数必需为 static 函数，否则无法解析。

继续上代码，只需将 getProductBlockHandler 移动到 HotKeyBlockedException 类中，并将其设为 static 的即可：

public class HotKeyBlockedException extends RuntimeException { private Object hotKey; public HotKeyBlockedException(Object hotKey) { super("热点参数 [" + hotKey + "]限流！"); this.hotKey = hotKey;
    } public static String getProductBlockHandler(Long userId,
                                                Long productId,
                                                Integer categoryId,
                                                BlockException blockException) { throw new HotKeyBlockedException(userId);
    } public Object getHotKey() { return hotKey;
    }
}

然后在资源上这样定义：

@SentinelResource(value = "getProduct",
            blockHandlerClass = HotKeyBlockedException.class,
            blockHandler = "getProductBlockHandler")

这样就完成了限流处理逻辑与业务逻辑的解耦。

fallback

fallback 同 blockHandler 的使用方法及其相似，只是他们的本质不同：

blockHandler：针对 Sentinel 配置的规则生效而产生 BlockException 异常时的对应处理；
fallback：可以针对所有类型的异常（除了 exceptionsToIgnore 里面排除掉的异常类型）进行处理。

若 blockHandler 和 fallback 都进行了配置，则被限流降级而抛出 BlockException 时只会进入 blockHandler 处理逻辑。若未配置 blockHandler、fallback ，则被限流降级时会将 BlockException 直接抛出。

由于 fallback 和 blockHandler 的用法是在太像了，这里就不列出代码了。

小结

可以通过 @SentinelResource 注解来定义资源，并使用其属性 blockHandler 和 fallback 自定义异常处理逻辑。
其中 blockHandler 是针对限流熔断异常而设置的属性，fallback 是针对所有异常的。
如果同时配置了 blockHandler 和 fallback 属性，则被限流降级而抛出 BlockException 时只会进入 blockHandler 处理逻辑。

#java#

全部评论

推荐最新楼层

linke达

电子科技大学项目经理

浙西知道怎么处理了，感谢楼主分享啊

点赞回复分享

发布于 2022-08-21 22:29 陕西

11-21 13:08

已编辑

中南大学 Java

论如何包装实习经历

实习经历很重要，如果实习的公司头衔够高的话可以降低面试的难度，如果实习经历包装的好的话可以诱导面试官提问相关的八股，硬控面试官几十分钟。如果你觉得你的项目不够出彩然后实习经历有很多话说的话，可以把实习经历放前面，来吸吸收面试官的伤害。那怎么包装你的实习经历呢？首先我觉得评判实习经历好坏的因素有这些：1.实习公司的头衔；2.实习的时候自己的思考，技术业务方面的都可以；3.简历上的实习亮点部分最好关联些常见的八股，这样你也能提前做好准备。下面是具体的包装方法。1.狠偷文档狠狠的偷组内的各种技术文档，狠狠的包装成自己的实习亮点，展现自己的思考。建议你也可以关注下架构方面的技术，这样可以更好的和面试官...

PE____：都说现在环境程序员不稳定要准备好副业，佬的副业是研究明白了

牛客创作赏金赛实习工作，你找得还顺利吗？

点赞评论收藏

11-22 00:40

美团_后端开发(准入职员工)

忙完了工作，又要毕业论文……

工作基本定了，比较满意。这深度学习真是难搞啊，论文看不懂，代码看不懂，不会改，创新点？？？ 还有一个月中期，怎么搞，已经抑郁了，没有小论文要求，我真是非常幸运了，不然就我这科研能力………… 感觉自己对自己失去信心，无时无刻不在否定自己取得一些成绩都是运气好罢了，真的能顺利毕业吗？严重内耗、无力感爆棚啊…………

AI牛可乐：哎呀，听起来你最近压力好大呀，毕业论文和工作的双重压力一定让你感觉像是背了两座山呢。深度学习确实挺复杂的，就像是要在一片迷雾中找到出路一样。但是，你已经很棒了，工作都定好了，这是很大的成就呢！论文的事情，别太担心。每个人都有看不懂代码和论文的时候，这是正常的。至于创新点嘛，有时候灵感就像小猫一样，需要一点一点地哄出来的。你可以先试试把你看过的资料整理一下，说不定就能找到新的思路呢。中期答辩前，你可以列个计划，一步一步来，把大问题分解成小问题，一点一点克服。记得，你不是一个人在战斗，你的导师、同学都是你的战友哦。至于信心嘛，别否定自己，每个人都会有低谷的时候。你已经取得的成绩，都是你实力的体现。毕业不是问题，只要你不放弃，就一定能顺利走过去的。加油哦，我相信你可以的！对了，如果你愿意的话，可以点击我的头像，我们私信聊，也许我能帮你出出主意，或者就是简单地聊聊天，分散一下你的注意力也好呀。🐮💪🌟

你们的毕业论文什么进度了牛客解忧铺

点赞评论收藏