【OpenFeign】 RequestInterceptor 获取不到 HttpServletRequest 问题解决方案

Metadata

title: 【OpenFeign】 RequestInterceptor 获取不到 HttpServletRequest 问题解决方案
date: 2023-01-02 19:47
tags:
  - 行动阶段/完成
  - 主题场景/组件
  - 笔记空间/KnowladgeSpace/ProgramSpace/ModuleSpace
  - 细化主题/Module/OpenFeign/问题
categories:
  - OpenFeign
keywords:
  - OpenFeign
description: 【OpenFeign】 RequestInterceptor 获取不到 HttpServletRequest 问题解决方案

【OpenFeign】 RequestInterceptor 获取不到 HttpServletRequest 问题解决方案

在使用 Hystrix 的情况下，使用RequestInterceptor获取 Oauth2 令牌并传递到下游服务时，发现从RequestContextHolder中获取到的HttpServletRequest为 NULL。

@Component
public class AAOauth2TokenRequestInterceptor implements RequestInterceptor {

    @Override
    public void apply(RequestTemplate requestTemplate) {
        // 1. 获取 HttpServletRequest
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
    }
}

RequestContextHolder

RequestContextHolder 请求上下文持有者，可以看到在其ThreadLocal中，保存了请求对象，我们可以在当前线程的任意位置，通过这个类来获取到当前请求的RequestAttributes。

Hystrix 隔离策略

Hystrix 提供了两个隔离策略：THREAD、SEMAPHORE。其默认的策略为THREAD（线程池）。

在执行请求的实际，可以看到其代理对象是通过HystrixInvocationHandler实现的，首先会创建一个HystrixCommand对象。

在其构造方法中，可以看到，会根据客户端名称，创建一个线程池，其最大线程数 10。

由以上可知，RequestContextHolder 中的RequestAttributes是保存在ThreadLocal中，而ThreadLocal，在子线程中（包括 new Thread 和 new 线程池）是无法获取到的，由此造成了获取到的HttpServletRequest为 null。

方案 1 修改隔离策略为 SEMAPHORE

线程池和信号量最大的区别在于:

线程池通过每次都开启一个单独线程运行，每个服务单独用线程池，可以是异步，当线程池到达maxSize后，再请求会触发fallback接口进行熔断。调用线程和hystrixCommand线程不是同一个线程。
通过信号量的计数器，当信号量达到maxConcurrentRequests后。再请求会触发fallback。调用线程和hystrixCommand线程是同一个线程。

所以在SEMAPHORE策略下，因为是同一个线程，所以可以获取到ThreadLocal中值。

通过以下配置修改隔离策略为 SEMAPHORE（信号量）:

hystrix:
  command:
    default:
      execution:
        isolation:
          strategy: SEMAPHORE

重启项目，发现成功获取到了HttpServletRequest。

但是信号量存在一个很大的问题，信号量的调用是同步的，每次调用都得阻塞调用方的线程，直到结果返回。这样就导致了无法对访问做超时（只能依靠调用协议超时，无法主动释放）。官网也不推荐使用这种模式！

方案 2 自定义隔离策略

参考文档
实现 HystrixConcurrencyStrategy 类，重写其wrapCallable方法，该方可以在执行前包装 / 修饰{@code Callable<T>}。

@Component
public class RequestAttributeHystrixConcurrencyStrategy extends HystrixConcurrencyStrategy {
    private static final Log log = LogFactory
            .getLog(RequestAttributeHystrixConcurrencyStrategy.class);

    private HystrixConcurrencyStrategy delegate;

    public RequestAttributeHystrixConcurrencyStrategy() {
        try {
            this.delegate = HystrixPlugins.getInstance().getConcurrencyStrategy();
            if (this.delegate instanceof RequestAttributeHystrixConcurrencyStrategy) {
                // Welcome to singleton hell...
                return;
            }
            HystrixCommandExecutionHook commandExecutionHook = HystrixPlugins
                    .getInstance().getCommandExecutionHook();
            HystrixEventNotifier eventNotifier = HystrixPlugins.getInstance()
                    .getEventNotifier();
            HystrixMetricsPublisher metricsPublisher = HystrixPlugins.getInstance()
                    .getMetricsPublisher();
            HystrixPropertiesStrategy propertiesStrategy = HystrixPlugins.getInstance()
                    .getPropertiesStrategy();
            this.logCurrentStateOfHystrixPlugins(eventNotifier, metricsPublisher,
                    propertiesStrategy);
            HystrixPlugins.reset();
            HystrixPlugins.getInstance().registerConcurrencyStrategy(this);
            HystrixPlugins.getInstance()
                    .registerCommandExecutionHook(commandExecutionHook);
            HystrixPlugins.getInstance().registerEventNotifier(eventNotifier);
            HystrixPlugins.getInstance().registerMetricsPublisher(metricsPublisher);
            HystrixPlugins.getInstance().registerPropertiesStrategy(propertiesStrategy);
        }
        catch (Exception e) {
            log.error("Failed to register Sleuth Hystrix Concurrency Strategy", e);
        }
    }

    private void logCurrentStateOfHystrixPlugins(HystrixEventNotifier eventNotifier,
                                                 HystrixMetricsPublisher metricsPublisher,
                                                 HystrixPropertiesStrategy propertiesStrategy) {
        if (log.isDebugEnabled()) {
            log.debug("Current Hystrix plugins configuration is ["
                    + "concurrencyStrategy [" + this.delegate + "]," + "eventNotifier ["
                    + eventNotifier + "]," + "metricPublisher [" + metricsPublisher + "],"
                    + "propertiesStrategy [" + propertiesStrategy + "]," + "]");
            log.debug("Registering Sleuth Hystrix Concurrency Strategy.");
        }
    }

    @Override
    public <T> Callable<T> wrapCallable(Callable<T> callable) {
        RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
        return new WrappedCallable<>(callable, requestAttributes);
    }

    @Override
    public ThreadPoolExecutor getThreadPool(HystrixThreadPoolKey threadPoolKey,
                                            HystrixProperty<Integer> corePoolSize,
                                            HystrixProperty<Integer> maximumPoolSize,
                                            HystrixProperty<Integer> keepAliveTime, TimeUnit unit,
                                            BlockingQueue<Runnable> workQueue) {
        return this.delegate.getThreadPool(threadPoolKey, corePoolSize, maximumPoolSize,
                keepAliveTime, unit, workQueue);
    }

    @Override
    public ThreadPoolExecutor getThreadPool(HystrixThreadPoolKey threadPoolKey,
                                            HystrixThreadPoolProperties threadPoolProperties) {
        return this.delegate.getThreadPool(threadPoolKey, threadPoolProperties);
    }

    @Override
    public BlockingQueue<Runnable> getBlockingQueue(int maxQueueSize) {
        return this.delegate.getBlockingQueue(maxQueueSize);
    }

    @Override
    public <T> HystrixRequestVariable<T> getRequestVariable(
            HystrixRequestVariableLifecycle<T> rv) {
        return this.delegate.getRequestVariable(rv);
    }

    static class WrappedCallable<T> implements Callable<T> {

        private final Callable<T> target;
        private final RequestAttributes requestAttributes;

        public WrappedCallable(Callable<T> target, RequestAttributes requestAttributes) {
            this.target = target;
            this.requestAttributes = requestAttributes;
        }

        @Override
        public T call() throws Exception {
            try {
                RequestContextHolder.setRequestAttributes(requestAttributes);
                return target.call();
            }
            finally {
                RequestContextHolder.resetRequestAttributes();
            }
        }
    }
}

测试，发现能正常获取到HttpServletRequest。