## 問題

在 Spring Cloud 中 微服務之間的呼叫會用到Feign，但是在預設情況下，Feign 呼叫遠端服務存在Header請求頭丟失問題。

## 解決方案

首先需要寫一個 Feign請求攔截器，透過實現RequestInterceptor介面,完成對所有的Feign請求,傳遞請求頭和請求引數。

### Feign 請求攔截器

```java
public class FeignBasicAuthRequestInterceptor implements RequestInterceptor {

private static final Logger logger = LoggerFactory.getLogger(FeignBasicAuthRequestInterceptor.class);

@Override
    public void apply(RequestTemplate requestTemplate) {
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder
                .getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();
        Enumeration<string> headerNames = request.getHeaderNames();
        if (headerNames != null) {
            while (headerNames.hasMoreElements()) {
                String name = headerNames.nextElement();
                String values = request.getHeader(name);
                requestTemplate.header(name, values);
            }
        }
        Enumeration<string> bodyNames = request.getParameterNames();
        StringBuffer body =new StringBuffer();
        if (bodyNames != null) {
            while (bodyNames.hasMoreElements()) {
                String name = bodyNames.nextElement();
                String values = request.getParameter(name);
                body.append(name).append("=").append(values).append("&");
            }
        }
        if(body.length()!=0) {
            body.deleteCharAt(body.length()-1);
            requestTemplate.body(body.toString());
            logger.info("feign interceptor body:{}",body.toString());
        }
    }
}
```

透過配置檔案配置 讓 所有 `FeignClient`，來使用 `FeignBasicAuthRequestInterceptor`

```yml
feign:
  client:
    config:
      default:
        connectTimeout: 5000
        readTimeout: 5000
        loggerLevel: basic
        requestInterceptors: com.leparts.config.FeignBasicAuthRequestInterceptor
```

也可以配置讓 某個 `FeignClient` 來使用這個 `FeignBasicAuthRequestInterceptor`

```yml
feign:
  client:
    config:
      xxxx: # 遠端服務名
        connectTimeout: 5000
        readTimeout: 5000
        loggerLevel: basic
        requestInterceptors: com.leparts.config.FeignBasicAuthRequestInterceptor
```

經過測試，上面的解決方案可以正常的使用；但是出現了新的問題。

在轉發Feign的請求頭的時候, 如果開啟了Hystrix, Hystrix的預設隔離策略是Thread(執行緒隔離策略), 因此轉發攔截器內是無法獲取到請求的請求頭資訊的。

可以修改預設隔離策略為訊號量模式：

```properties
hystrix.command.default.execution.isolation.strategy=SEMAPHORE
```

但訊號量模式不是官方推薦的隔離策略;另一個解決方法就是自定義Hystrix的隔離策略。

### 自定義策略

HystrixConcurrencyStrategy 是提供給開發者去自定義hystrix內部執行緒池及其佇列，還提供了包裝callable的方法，以及傳遞上下文變數的方法。所以可以繼承了HystrixConcurrencyStrategy，用來實現了自己的併發策略。

```java
@Component
public class FeignHystrixConcurrencyStrategy extends HystrixConcurrencyStrategy {

private static final Logger log = LoggerFactory.getLogger(FeignHystrixConcurrencyStrategy.class);

private HystrixConcurrencyStrategy delegate;

public FeignHystrixConcurrencyStrategy() {
        try {
            this.delegate = HystrixPlugins.getInstance().getConcurrencyStrategy();
            if (this.delegate instanceof FeignHystrixConcurrencyStrategy) {
                // 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 instance = HystrixPlugins.getInstance();
            instance.registerConcurrencyStrategy(this);
            instance.registerCommandExecutionHook(commandExecutionHook);
            instance.registerEventNotifier(eventNotifier);
            instance.registerMetricsPublisher(metricsPublisher);
            instance.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;

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();
            }
        }
    }
}
```

致此，Feign呼叫丟失請求頭的問題就解決的了 。

## 原始碼地址
https://github.com/gf-huanchupk/SpringCloudLearning

## 參考
https://blog.csdn.net/zl1zl2zl3/article/details/79084368
https://cloud.spring.io/spring-cloud-static/spring-cloud-openfeign/2.2.0.RC2/reference/html/</t></t></t></t></t></t></t></runnable></runnable></integer></integer></integer></t></t></t></string></string>

Feign 呼叫丟失Header的解決方案

相關文章