Sentinel导航

简介

最近都在弄微服务的东西，现在来记录下收获。我从一知半解到现在能从0搭建使用最大的感触有两点

1.微服务各大组件的版本很多，网上很多博客内容不一定适合你的版本，很多时候苦苦琢磨都是无用功

2.网上博客参差不齐，有些甚至错误的。更离谱的是，好的文章阅读量除非高出天际，不然就都很低，比那些复制粘贴，随便应付的都低（这个搜索推荐算法不知道基于什么的）

通过这段时间学习，我觉得最重要是从好的博客入手，先不要着急怎么组件怎么使用，而是先了解组件的作用，大概的原理，然后才是使用，这样搭建和尝试的过程中才能更好的定位问题，最后再次回到原理和一些实际问题的处理（不知道实际问题怎样的，直接搜那个组件的面试题往往效果最好）

接下来的内容，都以导航的形式展现给大家（毕竟优秀的轮子很多，直接看大佬写的不香嘛），再顺带提些自己的理解

传送门

更多微服务的介绍可点击下方链接

微服务介绍、Nginx导航、Nacos导航、Gateway导航、Ribbon导航、Feign导航、Sentinel导航

博主微服务git练手项目：https://github.com/NiceJason/SpringCloudDemo

Sentinel简介

1.限流相关

1.1限流点

在聊Sentinel之前，先简单梳理下微服务限流的几个地方：

1.Nginx限流，系统的最外层限流地点

2.Gateway网关限流，Gateway可以用内置的限流Filter（RequestRateLimiterGatewayFilterFactory，依赖于redis），或者其他插件的限流Filter（如Redis的Redis RateLimiter），或者自定义Filter（自己实现限流算法），或者结合Sentinel或者Hystrix来限流。

参考：https://blog.csdn.net/qq_38380025/article/details/102968559（博客的第八点 请求限流）

3.微服务内部的限流，结合Sentinel或者Hystrix

4.消息队列的限流，通过控制生产者和消费者的速度

5.数据库连接池限流，一定时间内只能有一定数量的连接

当需要限流的时候可以从这5个点去思考

1.2限流算法

参考：https://blog.csdn.net/qq_38380025/article/details/102968559（博客的第八点 请求限流）

文章简述了常用的限流算法，如令牌桶算法、漏桶算法，可以大致了解一下，以后万一有场景需要手动实现的时候就能有个思路

2.Sentinel相关

Sentinel十分友好的中文安装使用文档：https://github.com/alibaba/Sentinel/wiki/%E6%96%B0%E6%89%8B%E6%8C%87%E5%8D%97

里面介绍了基础的安装与使用（十分简单易上手），因为同是阿里系的组件，所以和Nacos结合的特别好，熔断限流等配置直接在Nacos上写即可，具体使用看文档(重点了解“资源”这个概念)，这里讲下文档没有或者被忽视的地方

2.1Json参数配置

参考（规则种类）：https://github.com/alibaba/Sentinel/wiki/%E5%A6%82%E4%BD%95%E4%BD%BF%E7%94%A8#%E8%A7%84%E5%88%99%E7%9A%84%E7%A7%8D%E7%B1%BB

可以看到一些参数说明，具体参数值如果还不明白的，看该规则的类，里面会有默认参数及注释，一般都是使用RuleConst里的值，而里面的值代表什么意思可以看具体的Rule类

 

如：限流规则 FlowRule

 

2.2Sentinel和SpringCloud结合

有一点比较重要，就是Sentinel和SpringCloud结合开始的地方在哪，在AbstractSentinelInterceptor开始

public abstract class AbstractSentinelInterceptor implements HandlerInterceptor {
     ...
}

所以Sentinel可以把控程序的入口和出口，而掌握不了里面业务的处理（这点单这样听好像没卵用，但在实际功能开发和BUG查找中还是挺有用的，了解来龙去脉）

2.2.1Sentinel熔断失效，不起作用

比如：Sentinel设置了熔断，但是@FeignClient设置了Fallback方法对异常进行了处理，那么熔断是不生效的，以Sentinel的视角来看，没抛出异常就是正常执行。

还有项目中往往@ExceptionHandle进行全局异常处理，这要也会导致熔断失效，下面简单的分析分析

Sentinel与SpringCloud结合，是从AbstractSentinelInterceptor开始的

 

public abstract class AbstractSentinelInterceptor implements HandlerInterceptor {
     @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
        throws Exception {
        try {
            String resourceName = getResourceName(request);

            if (StringUtil.isNotEmpty(resourceName)) {
                // Parse the request origin using registered origin parser.
                String origin = parseOrigin(request);
                ContextUtil.enter(SENTINEL_SPRING_WEB_CONTEXT_NAME, origin);
                Entry entry = SphU.entry(resourceName, ResourceTypeConstants.COMMON_WEB, EntryType.IN);

                setEntryInRequest(request, baseWebMvcConfig.getRequestAttributeName(), entry);
            }
            return true;
        } catch (BlockException e) {
            handleBlockException(request, response, e);
            return false;
        }
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response,
                                Object handler, Exception ex) throws Exception {
        Entry entry = getEntryInRequest(request, baseWebMvcConfig.getRequestAttributeName());
        if (entry != null) {
            //跟踪记录异常
            traceExceptionAndExit(entry, ex);
            removeEntryInRequest(request);
        }
        ContextUtil.exit();
    }
    
        protected void traceExceptionAndExit(Entry entry, Exception ex) {
        if (entry != null) {
            //要ex参数不为空才记录，但这个参数是可能为空的
            if (ex != null) {
                Tracer.traceEntry(ex, entry);
            }
            entry.exit();
        }
    }
}

可以看出，它就是一个Spring的拦截器，preHandle方法就进行资源绑定（然后进行Sentinel的一连串的Slot判断），通过后才能正常访问资源

而afterCompletion方法则进行收尾工作，如资源执行时抛出异常则记录，为熔断功能提供数据

失效的原因恰恰是这个afterCompletion，我们可以看到traceExceptionAndExit方法里，需要ex不为空才记录异常信息，但这个参数是有可能会空的

这就要到DispatcherServlet的doDispatch里面来，这里面负责调用interceptor，具体看里面的注释

protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
       ...

        try {
            ModelAndView mv = null;
            Exception dispatchException = null;

            try {
                ...
                
                HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());

                ...

                // 这里会调用intercepter过滤链，调用其preHandle方法
                mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

                ...
            }
            catch (Exception ex) {
                //这里捕获了所有异常
                dispatchException = ex;
            }
            catch (Throwable err) {
                //这里捕获了所有的Throwable
                dispatchException = new NestedServletException("Handler dispatch failed", err);
            }
            //这个方法很关键，它抛不抛异常，取决于后面的catch能不能执行！！
            processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
        }
        catch (Exception ex) {
            //调用interceptor的afterCompletion，有没熔断记录就看它有没执行了
            triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
        }
        catch (Throwable err) {
            //调用interceptor的afterCompletion，有没熔断记录就看它有没执行了
            triggerAfterCompletion(processedRequest, response, mappedHandler,
                    new NestedServletException("Handler processing failed", err));
        }
        finally {
            ...
        }
    }

我们首先来看看非常关键的processDispatchResult方法，这个方法只有两个地方抛出异常，如果这两个地方都没抛出异常，则doDispatch方法就不可能执行43或47行代码，意思是熔断信息将不会被记录，从而导致熔断失效

private void processDispatchResult(HttpServletRequest request, HttpServletResponse response,
            @Nullable HandlerExecutionChain mappedHandler, @Nullable ModelAndView mv,
            @Nullable Exception exception) throws Exception {

        boolean errorView = false;

        if (exception != null) {
            if (exception instanceof ModelAndViewDefiningException) {
                logger.debug("ModelAndViewDefiningException encountered", exception);
                mv = ((ModelAndViewDefiningException) exception).getModelAndView();
            }
            else {
                Object handler = (mappedHandler != null ? mappedHandler.getHandler() : null);
                //这里是执行异常处理器，如果用了@ExceptionHandler全局异常处理，就会被处理
                //这里是能够抛出异常的第一个地方，但我们全局异常处理的目的就是终止程序抛出的异常
                mv = processHandlerException(request, response, handler, exception);
                errorView = (mv != null);
            }
        }

        // Did the handler return a view to render?
        if (mv != null && !mv.wasCleared()) {
            //这里是能够抛出异常的第二个地方，读取视图抛异常
            //可是有大部分情况都是返回数据，并不需要查找视图，所以mv经常等于null
            //并不会进这个if里面来
            render(mv, request, response);
            if (errorView) {
                WebUtils.clearErrorRequestAttributes(request);
            }
        }
        else {
            if (logger.isTraceEnabled()) {
                logger.trace("No view rendering, null ModelAndView returned.");
            }
        }

        if (WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
            // Concurrent handling started during a forward
            return;
        }

        //这里注意第三个参数是null，即传入AbstractSentinelInterceptor类里的afterCompletion方法的ex参数为null
        //这样是做不了熔断记录的，所以上面的方法必须要抛出异常
        if (mappedHandler != null) {
            mappedHandler.triggerAfterCompletion(request, response, null);
        }
    }

从上述流程可以看出，当我们使用@ExceptionHandler进行全局异常处理的时候，Sentinel并不能成功记录熔断信息，因为代码执行到它这异常已经被处理了，所以视为此次业务逻辑被正确执行

2.2热点参数的限流原理

 参考：

https://mp.weixin.qq.com/s?__biz=MzAxMzY2MDYzMA%3D%3D&chksm=9b9e7eaface9f7b9ba70c6e07ba18bd150f07bc7097a27e78443f5c83d12bea0d40c94a5dbca&idx=1&mid=2247484950&scene=21&sn=c209d2c6948bddbe34b5d92dc3d61366#wechat_redirect

主要是要知道，相同参数是根据equal方法来比较是不是同一个对象，所以Object要重写此方法来符合自己的逻辑，不然的话热点参数设置无效

 2.3Sentinel统一降级处理

参考：https://blog.csdn.net/theOldCaptain/article/details/107756801

需要注意

统一降级处理的资源不能用@SentinelResources修饰，否则是不走这个路的，需要自己配置@SentinelResources里的blockHandler和fallback这些方法

在Sentinel2.0之后，统一降级处理这样写（实践过可行）

import com.alibaba.csp.sentinel.adapter.spring.webmvc.callback.BlockExceptionHandler;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import com.alibaba.csp.sentinel.slots.block.degrade.DegradeException;
import com.alibaba.csp.sentinel.slots.block.flow.FlowException;
import com.alibaba.csp.sentinel.slots.block.flow.param.ParamFlowException;
import com.alibaba.csp.sentinel.slots.system.SystemBlockException;
import com.alibaba.fastjson.JSONObject;
import com.syni.common.result.ResultJson;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.nio.charset.StandardCharsets;

/**
 * @Author DiaoJianBin
 * @Description 别看idea标着@Component未被使用，实际上是被使用了的
 *              去掉的话此类无法生效
 * @Date 2021/4/22 10:44
 */
@Component
@Slf4j
public class SystemBlockExceptionHandler implements BlockExceptionHandler {
    @Override
    public void handle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, BlockException blockException) throws Exception {
        StringBuilder errorMessage = new StringBuilder();
        errorMessage.append("资源名称=");
        String resourceName = blockException.getRule().getResource();

        if (blockException instanceof FlowException) {
            errorMessage.append(" 被限流了");
        }else if(blockException instanceof DegradeException){
            errorMessage.append(" 被熔断了");
        }else if(blockException instanceof SystemBlockException){
            SystemBlockException systemBlockException = (SystemBlockException)blockException;
            errorMessage.append(" 触发系统保护 limitType=").append(systemBlockException.getLimitType());
        }else if(blockException instanceof ParamFlowException){
            //具体异常有特殊的方法
            ParamFlowException paramFlowException = (ParamFlowException)blockException;
            errorMessage.append(" 触发热点参数限流 limitParam=").append(paramFlowException.getLimitParam());
        }
        errorMessage.insert(5,resourceName);
        //日志记录具体原因
        log.error(errorMessage.toString());

        //这里返回个前端，不能说明具体原因的
        ResultJson resultJson = new ResultJson("102","系统繁忙，稍后再试");

        httpServletResponse.setHeader("Content-type", "text/html;charset=UTF-8");
        ServletOutputStream outputStream = httpServletResponse.getOutputStream();
        try{
            outputStream.write(JSONObject.toJSONString(resultJson).getBytes(StandardCharsets.UTF_8));
        }finally {
            outputStream.close();
        }
    }
}

sentinel降级方式的顺序,源码贴出,代码通俗易懂.

(1).查看是否有自定义了BlockExceptionHandler异常处理器.

(2).查看是否配置了降级页面.

(3).以上都没有,则创建默认的BlockExceptionHandler异常处理器,也就是响应Blocked by Sentinel (flow limiting)的那个类.

SentinelWebAutoConfiguration.java

@Bean
@ConditionalOnProperty(name = "spring.cloud.sentinel.filter.enabled", matchIfMissing = true)
public SentinelWebMvcConfig sentinelWebMvcConfig() {
    SentinelWebMvcConfig sentinelWebMvcConfig = new SentinelWebMvcConfig();
    sentinelWebMvcConfig.setHttpMethodSpecify(properties.getHttpMethodSpecify());

    if (blockExceptionHandlerOptional.isPresent()) {
        blockExceptionHandlerOptional
                .ifPresent(sentinelWebMvcConfig::setBlockExceptionHandler);
    }
    else {
        if (StringUtils.hasText(properties.getBlockPage())) {
            sentinelWebMvcConfig.setBlockExceptionHandler(((request, response,
                    e) -> response.sendRedirect(properties.getBlockPage())));
        }
        else {
            sentinelWebMvcConfig
                    .setBlockExceptionHandler(new DefaultBlockExceptionHandler());
        }
    }

    urlCleanerOptional.ifPresent(sentinelWebMvcConfig::setUrlCleaner);
    requestOriginParserOptional.ifPresent(sentinelWebMvcConfig::setOriginParser);
    return sentinelWebMvcConfig;
}

 

在Sentinel 2.0以前，据说是这样处理（未实践过）

参考：https://zhuanlan.zhihu.com/p/150058613

2.4Sentinel与网关结合

参考：https://github.com/alibaba/Sentinel/wiki/%E7%BD%91%E5%85%B3%E9%99%90%E6%B5%81#spring-cloud-gateway

大体原理（以SpringCloudGateway为例）

由于SpringCloudGateway里有一系列的Filter组成

Sentinel会构造一个Filter放入其中，这样就能被Sentinel处理

同时，Sentinel将路由名称或者一组API定义成资源，用新的路由规则来控制这些资源（明面上是GatewayFlowRule实际就变成了ParamFlowRule），这样就回到了Sentinel本身的代码逻辑，从网关逻辑里分离出来

小结

本篇博客围绕着Sentinel的小知识点开始讲，把我在学习了解，使用碰到的知识点分享给大家，希望能帮到大家~