17-Sentinel主流框架适配

使用Sentinel需要用try-catch-finally将需要保护的资源（方法或者代码块）包装起来，在目标方法或者代码块执行之前，调用ContextUtil#enter方法以及SphU#entry方法，在抛出异常时，如果非BlockException异常需要调用Tracer#trace记录异常，修改异常指标数据，在finally中需要调用Entry#exit方法，以及ContextUtil#exit方法。

为了节省这些步骤，Sentinel提供了对主流框架的适配，如适配Spring MVC、Webflux、Dubbo、Api Gateway等框架。当然，对于Sentinel未适配的框架，我们也可以自己实现适配器。在Sentinel源码之外，alibaba的spring-cloud-starter-alibaba-sentinel也为Sentinel提供与OpenFeign框架整合的支持。

Spring MVC适配器

Sentinel借助Spring MVC框架的HandlerInterceptor适配Spring MVC，但也需要我们借助WebMvcConfigurer将SentinelWebInterceptor注册到Spring MVC框架。

使用步骤

第一步：在项目中添加spring mvc适配模块的依赖。

<dependency>
    <groupId>com.alibaba.csp</groupId>
    <artifactId>sentinel-spring-webmvc-adapter</artifactId>
    <version>${version}</version>
</dependency>

第二步：编写WebMvcConfigurer，在addInterceptors方法中注入SentinelWebInterceptor。

@Configuration
public class InterceptorConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        SentinelWebMvcConfig config = new SentinelWebMvcConfig();
        config.setBlockExceptionHandler(new DefaultBlockExceptionHandler());
        config.setHttpMethodSpecify(true);
        config.setOriginParser(request -> request.getHeader("S-user"));
        // SentinelWebInterceptor拦截所有接口（"/**"）
        registry.addInterceptor(new SentinelWebInterceptor(config)).addPathPatterns("/**");
    }
}

在创建SentinelWebInterceptor时，可为SentinelWebInterceptor添加配置，使用SentinelWebMvcConfig封装这些配置：

• setBlockExceptionHandler：配置BlockException异常处理器，如果不想配置BlockException异常处理器，也可在Spring MVC的全局异常处理器中处理BlockException异常；
• setOriginParser：注册调用来源（origin）解析器，例如从请求头中获取“S-user”参数的值作为调用来源名称，上游服务在发起请求时就可在请求头写入“S-user”参数告知自己的身份；
• setHttpMethodSpecify：是否需要给资源名称加上HttpMethod前缀，例如GET接口“/hello”，如果httpMethodSpecify配置为false，则资源名称为“/hello”，否则资源名称为“GET:/hell”；

适配原理

Spring MVC框架的方法拦截器（HandlerInterceptor）的定义如下。

public interface HandlerInterceptor {
    default boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        return true;
    }
    default void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable ModelAndView modelAndView) throws Exception {
    }
    default void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable Exception ex) throws Exception {
    }
}

HandlerInterceptor在DispatcherServlet#doDispatch方法中被调用，每个方法的调用时机如下：

• preHandle：在调用接口方法之前调用
• postHandle：在接口方法执行完成返回ModelAndView时被调用；
• afterCompletion：在接口方法执行完成时被调用，无论成功或异常都会被调用；

因此，Sentinel可借助HandlerInterceptor与Spring MVC框架整合，在HandlerInterceptor#preHandle方法中调用ContextUtil#enter方法以及SphU#entry方法，在afterCompletion方法中根据方法参数ex是否为空处理异常情况，并且完成Entry#exit方法、ContextUtil#exit方法的调用。

SentinelWebInterceptor是AbstractSentinelInterceptor的子类，preHandle与afterCompletion方法在父类中实现，自身只实现父类定义的一个获取资源名称的抽象方法，其源码如下。

    @Override
    protected String getResourceName(HttpServletRequest request) {
        // （1）
        Object resourceNameObject = request.getAttribute(HandlerMapping.BEST_MATCHING_PATTERN_ATTRIBUTE);
        if (resourceNameObject == null || !(resourceNameObject instanceof String)) {
            return null;
        }
        String resourceName = (String) resourceNameObject;
        // （2）
        UrlCleaner urlCleaner = config.getUrlCleaner();
        if (urlCleaner != null) {
            resourceName = urlCleaner.clean(resourceName);
        }
        // （3）
        if (StringUtil.isNotEmpty(resourceName) && config.isHttpMethodSpecify()) {
            resourceName = request.getMethod().toUpperCase() + ":" + resourceName;
        }
        return resourceName;
    }

资源名称生成过程如下：

• （1）、从HttpServletRequest的属性中获取HandlerMapping匹配的URL；

因为有些接口是这样的：“/hello/{name}”，如果直接从HttpServletRequest获取请求路径，那么每个请求获取到的URL就可能会不同。

• （2）、如果UrlCleaner不为空，则调用UrlCleaner的clean方法；

UrlCleaner用于实现将多个接口合并为一个，例如接口：“/user/create”、“/user/del”、“/user/update”，借助UrlCleaner修改资源名称将这几个接口都改为“/user/**”即可实现三个接口使用同一个限流规则。

• （3）、根据SentinelWebMvcConfig配置对象判断是否需要添加HttpMethod前缀，如果需要则给资源名称拼接前缀；

一般来说，不建议使用，因为如果接口使用@RequestMapping声明，那么想对该接口限流就需要配置多个限流规则，而一般旧项目多是使用@RequestMapping声明接口方法。例如接口“/user/create”，你可能需要针对“GET:/user/create”、“POST:/user/create”等多个资源配置限流规则。

由于AbstractSentinelInterceptor的源码较多，我们分几个步骤分析。

AbstractSentinelInterceptor#preHandle方法源码如下：

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
        throws Exception {
        try {
            //（1）
            String resourceName = getResourceName(request);
            if (StringUtil.isNotEmpty(resourceName)) {
                //（2）
                String origin = parseOrigin(request);
                //（3）
                ContextUtil.enter(SENTINEL_SPRING_WEB_CONTEXT_NAME, origin);
                //（4）
                Entry entry = SphU.entry(resourceName, ResourceTypeConstants.COMMON_WEB, EntryType.IN);
                //（5）
                setEntryInRequest(request, baseWebMvcConfig.getRequestAttributeName(), entry);
            }
            return true;
        } catch (BlockException e) {
            // （6）
            handleBlockException(request, response, e);
            return false;
        }
    }

• （1）、获取资源名称；
• （2）、调用OriginParser#parseOrigin方法解析调用来源，例如从请求头获取”S-user”参数的值；
• （3）、调用ContextUtil#enter方法，Context名称为“sentinel_spring_web_context”；
• （4）、调用SphU#entry方法，资源类型为COMMON_WEB，流量类型为IN；
• （5）、将SphU#entry方法返回的Entry放入HttpServletRequest的属性表中，方便在afterCompletion中取出；
• （6）、如果抛出BlockException异常，说明当前请求被拒绝，需调用handleBlockException方法处理BlockException异常；

AbstractSentinelInterceptor#handleBlockException方法源码如下：

protected void handleBlockException(HttpServletRequest request, HttpServletResponse response, BlockException e)
        throws Exception {
        if (baseWebMvcConfig.getBlockExceptionHandler() != null) {
            baseWebMvcConfig.getBlockExceptionHandler().handle(request, response, e);
        } else {
            throw e;
        }
    }

如果我们给SentinelWebMvcConfig配置了BlockExceptionHandler，则调用BlockExceptionHandler#handle方法处理BlockException异常，否则将异常抛出，由全局处理器处理。

AbstractSentinelInterceptor#afterCompletion方法源码如下：

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response,
                                Object handler, Exception ex) throws Exception {
        //（1）
        Entry entry = getEntryInRequest(request, baseWebMvcConfig.getRequestAttributeName());
        if (entry != null) {
            //（2）
            traceExceptionAndExit(entry, ex);
            removeEntryInRequest(request);
        }
        //（3）
        ContextUtil.exit();
    }

• （1）、从HttpServletRequest的属性表中获取preHandle方法放入的Entry；
• （2）、调用traceExceptionAndExit方法，记录异常和调用Entry#exit方法；
• （3）、调用ContextUtil#exit方法，如果当前CtEntry为空，则从ThreadLocal中移除Context；

AbstractSentinelInterceptor#traceExceptionAndExit方法源码如下：

   protected void traceExceptionAndExit(Entry entry, Exception ex) {
        if (entry != null) {
            if (ex != null) {
                Tracer.traceEntry(ex, entry);
            }
            entry.exit();
        }
    }

当方法执行抛出异常时，调用Tracer#traceEntry方法记录异常，更新异常指标数据。

OpenFeign适配器

Sentinel整合OpenFeign主要用于实现熔断降级，因此，关于OpenFeign的Sentinel适配器的使用介绍基于服务消费端。

使用步骤

1、引入依赖

借助spring-cloud-starter-alibaba-sentinel实现与OpenFeign整合，添加依赖配置如下。

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

2、启用OpenFeign整合Sentinel的自动配置

在application.yaml配置文件中添加如下配置，启用Sentinel与OpenFeign整合适配器。

feign:
  sentinel:
    enabled: true

3、熔断降级规则配置

可基于动态数据源实现，也可直接调用DegradeRuleManager的loadRules API硬编码实现，可参考上一篇。

4、给@FeignClient注解配置异常回调

给接口上的@FeignClient注解配置fallback属性，实现请求被拒绝后的处理。

@FeignClient(
         //.....
        // 这里配置
        fallback = ServiceDegradeFallback.class)
public interface DemoService {

    @PostMapping("/services")
    ListGenericResponse<DemoDto> getServices();

}

fallback属性要求配置一个类，该类必须实现相同的接口，所以ServiceDegradeFallback必须实现DemoService接口。

public class ServiceDegradeFallback implements DemoService {
    @Override
    public ListGenericResponse<DemoDto> getServices() {
        ListGenericResponse response = new ListGenericResponse<DemoDto>();
        response.setCode(ResultCode.SERVICE_DEGRAD.getCode())
                .setMessage("服务降级");
        return response;
    }
}

ServiceDegradeFallback类中处理接口降级逻辑，例如，响应一个状态码告知消费端由于服务降级本次接口调用失败。

最后还需要将该ServiceDegradeFallback注册到Feign的Clinet环境隔离的容器中。

编写配置类SentinelFeignConfig，在SentinelFeignConfig中注册ServiceDegradeFallback。

public class SentinelFeignConfig {
    @Bean
    public ServiceDegradeFallback degradeMockYcpayService() {
        return new ServiceDegradeFallback();
    }
}

将SentinelFeignConfig配置类添加到@FeignClient注解的configuration属性，如下。

@FeignClient(
        // .....
        configuration = {
                // 这里配置
                SentinelFeignConfig.class
        },
        // 这里配置
        fallback = ServiceDegradeFallback.class)
public interface DemoService {

    @PostMapping("/services")
    ListGenericResponse<DemoDto> getServices();

}

当满足熔断条件时，Sentinel会抛出一个DegradeException异常，如果配置了fallback，那么Sentinel会从Bean工厂中根据fallback属性配置的类型取一个Bean并调用接口方法。

Sentinel与OpenFeign整合实现原理

当Sentinel与OpenFeign、Ribbon整合时，客户端向服务端发起一次请求的过程如下图所示。

• 1、当调用@FeignClient接口的方法时，由Sentinel提供的方法调用拦截器（SentinelInvocationHandler）拦截方法的执行，根据接口方法上注解的url生成资源名称，然后调用Sentinel的SphU#entry方法（完成所有ProcessorSlot#entry方法的调用），判断当前发起的请求是否需要熔断；
• 2、非熔断降级情况下，继续将请求交给OpenFeign的MethodHandler处理；
• 3、OpenFeign从Ribbon获取一个服务提供者节点；
• 4、OpenFeign使用HttpClient发起http请求；
• 5、OpenFeign请求成功或者异常（已经经过重试）时，调用Sentinel的Entry#exit方法（完成所有ProcessorSlot#exit方法的调用）更新当前时间窗口的请求成功总数、异常总数等指标数据；

可见，Sentinel处在接口调用的最前端，因此Sentinel统计的指标数据即不会受Ribbon的重试影响也不会受OpenFeign的重试影响。

Sentinel通过自己提供InvocationHandler替换OpenFeign的InvocationHandler实现请求拦截。SentinelInvocationHandler源码调试如下图所示。

InvocationHandler是OpenFeign为接口生成JDK动态代理类时所需要的，是接口的方法拦截处理器，Sentinel通过替换OpenFeign的InvocationHandler拦截方法的执行，在OpenFeign处理接口调用之前完成熔断降级的检查。

那么，Sentinel是如何将原本的FeignInvocationHandler替换为SentinelInvocationHandler的呢？

OpenFeign通过Feign.Builder类创建接口的代理类，所以Sentinel直接将Feign.Builder也替换成了SentinelFeign.Builder，由SentinelFeignAutoConfiguration自动配置类向Spring的Bean容器注入SentinelFeign.Builder，代码如下。

@Configuration(proxyBeanMethods = false)
@ConditionalOnClass({ SphU.class, Feign.class })
public class SentinelFeignAutoConfiguration {

	@Bean
	@Scope("prototype")
	@ConditionalOnMissingBean
	@ConditionalOnProperty(name = "feign.sentinel.enabled")
	public Feign.Builder feignSentinelBuilder() {
		return SentinelFeign.builder();
	}

}

SentinelFeign.Builder继承Feign.Builder并重写build方法，SentinelFeign.Builder#build方法源码如下。

public final class SentinelFeign {

	public static Builder builder() {
		return new Builder();
	}

	public static final class Builder extends Feign.Builder
			implements ApplicationContextAware {

	   // .....

		@Override
		public Feign build() {
			super.invocationHandlerFactory(new InvocationHandlerFactory() {
				@Override
				public InvocationHandler create(Target target,
						Map<Method, MethodHandler> dispatch) {
					// 创建SentinelInvocationHandler
				}
			});
			super.contract(new SentinelContractHolder(contract));
			return super.build();
		}
		// .....
	}

}

SentinelFeign.Builder#build偷天换日，替换了InvocationHandlerFactory，所以OpenFeign调用InvocationHandlerFactory#create方法创建的InvocationHandler就变成了SentinelInvocationHandler。

看InvocationHandlerFactory#create方法的返回值类型我们也能知道，该方法负责创建SentinelInvocationHandler。create方法部分源码如下：

Class fallback = (Class) getFieldValue(feignClientFactoryBean,
							"fallback");
Object fallbackInstance = getFromContext(beanName, "fallback", fallback,
								target.type());
return new SentinelInvocationHandler(target, dispatch,
								new FallbackFactory.Default(fallbackInstance));

在创建SentinelInvocationHandler之前，通过反射从FeignClientFactoryBean拿到@FeignClient注解的fallback属性值，然后根据fallback类型从Bean工厂取得fallback实例，将fallback实例传递给SentinelInvocationHandler。当触发熔断时，SentinelInvocationHandler就能取得fallback实例并调用。

总结

本篇我们分析了Sentinel适配Spring MVC框架的实现原理，以及Sentinel适配Spring Cloud OpenFeign框架的实现原理。适配各种主流框架，无非就是通过框架提供的方法拦截器注入Sentinel，或者通过拦截主流框架的入口方法注入Sentinel。了解原理之后，如果我们项目中使用的框架Sentinel并未适配，那么我们也可以自己实现适配器。