五分钟带你玩转springcloudNetflix（七）使用Feign调用时添加验证信息token到请求头

1、这是最简单的一个方法，但是需要对每个调用都一一添加，就是使用@RequestHeader注解添加参数到请求头中去

  

   

    

     

    
    

     

      @FeignClient(name = "capability-register", fallback = ApiServiceClientFallBack.class )
     
    
   

    

     

    
    

     

      public interface ApiServiceClient {
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    @GetMapping("/apiDebug/")
     
    
   

    

     

    
    

     

          Result debug(@RequestParam("url") String path,
     
    
   

    

     

    
    

     
                 @RequestParam("param") String param,
     
    
   

    

     

    
    

     
                 @RequestParam("method") String method,
     
    
   

    

     

    
    

     
                 @RequestParam("appKey") String appKey,
     
    
   

    

     

    
    

     
                 @RequestHeader(name = "Token",required = true) String Token);
     
    
   

    

     

    
    

     

      }
     
    
  
 

这里需要注意，其他几个参数都是调用debug接口需要的参数，使用此接口时，直接获取验证信息放进token中，就可以了

2、这个方法是网上大多数人的用法，但是我看到一个大神的博客，说是这种方法有点不好，然后大神自定义了一个Hystrix的策略，这个第三种方法再讲

这种方法是对所有的feign调用统一设置请求头

  

   

    

     

    
    

     

      package com.hiynn.provider.configuration;
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      import feign.RequestInterceptor;
     
    
   

    

     

    
    

     

      import feign.RequestTemplate;
     
    
   

    

     

    
    

     

      import org.springframework.context.annotation.Configuration;
     
    
   

    

     

    
    

     

      import org.springframework.web.context.request.RequestContextHolder;
     
    
   

    

     

    
    

     

      import org.springframework.web.context.request.ServletRequestAttributes;
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      import javax.servlet.http.HttpServletRequest;
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      /**
     
    
   

    

     

    
    

     

       * @author lidai
     
    
   

    

     

    
    

     

       * @date 2019/2/27 16:14
     
    
   

    

     

    
    

     

       * <p>
     
    
   

    

     

    
    

     

       * Feign调用的时候添加请求头Token
     
    
   

    

     

    
    

     

       */
     
    
   

    

     

    
    

     

      @Configuration
     
    
   

    

     

    
    

     

      public class FeignConfiguration implements RequestInterceptor {
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    @Override
     
    
   

    

     

    
    

     
    public void apply(RequestTemplate requestTemplate) {
     
    
   

    

     

    
    

     

              ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
     
    
   

    

     

    
    

     

              HttpServletRequest request = attributes.getRequest();
     
    
   

    

     

    
    

     

              requestTemplate.header("Token", request.getHeader("Token"));
     
    
   

    

     

    
    

     

          }
     
    
   

    

     

    
    

     

      }
     
    
  
 

有了configuration之后还需要再feign添加configuration属性

  

   

    

     

    
    

     

      @FeignClient(name = "capability-register", fallback = ApiServiceClientFallBack.class ,configuration = FeignConfiguration.class)
     
    
   

    

     

    
    

     

      public interface ApiServiceClient {
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    @GetMapping("/apiDebug/")
     
    
   

    

     

    
    

     

          Result debug(@RequestParam("url") String path,
     
    
   

    

     

    
    

     
                 @RequestParam("param") String param,
     
    
   

    

     

    
    

     
                 @RequestParam("method") String method,
     
    
   

    

     

    
    

     
                 @RequestParam("appKey") String appKey);
     
    
   

    

     

    
    

     

      }
     
    
  
 

到这里的时候，如果你debug的话，会发现FeignConfiguration中的attributes获取不到，需要再配置文件中添加如下配置就可以了

3、第三种方法就是大神的方法了，和第二种方法的区别就是不需要添加配置文件，但是FeignConfiguration这个还是要的，不需要加配置文件就加一个自定义策略

  

   

    

     

    
    

     

      package com.hiynn.provider.configuration;
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      import com.netflix.hystrix.HystrixThreadPoolKey;
     
    
   

    

     

    
    

     

      import com.netflix.hystrix.HystrixThreadPoolProperties;
     
    
   

    

     

    
    

     

      import com.netflix.hystrix.strategy.HystrixPlugins;
     
    
   

    

     

    
    

     

      import com.netflix.hystrix.strategy.concurrency.HystrixConcurrencyStrategy;
     
    
   

    

     

    
    

     

      import com.netflix.hystrix.strategy.concurrency.HystrixRequestVariable;
     
    
   

    

     

    
    

     

      import com.netflix.hystrix.strategy.concurrency.HystrixRequestVariableLifecycle;
     
    
   

    

     

    
    

     

      import com.netflix.hystrix.strategy.eventnotifier.HystrixEventNotifier;
     
    
   

    

     

    
    

     

      import com.netflix.hystrix.strategy.executionhook.HystrixCommandExecutionHook;
     
    
   

    

     

    
    

     

      import com.netflix.hystrix.strategy.metrics.HystrixMetricsPublisher;
     
    
   

    

     

    
    

     

      import com.netflix.hystrix.strategy.properties.HystrixPropertiesStrategy;
     
    
   

    

     

    
    

     

      import com.netflix.hystrix.strategy.properties.HystrixProperty;
     
    
   

    

     

    
    

     

      import lombok.extern.slf4j.Slf4j;
     
    
   

    

     

    
    

     

      import org.springframework.context.annotation.Configuration;
     
    
   

    

     

    
    

     

      import org.springframework.web.context.request.RequestAttributes;
     
    
   

    

     

    
    

     

      import org.springframework.web.context.request.RequestContextHolder;
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      import java.util.concurrent.BlockingQueue;
     
    
   

    

     

    
    

     

      import java.util.concurrent.Callable;
     
    
   

    

     

    
    

     

      import java.util.concurrent.ThreadPoolExecutor;
     
    
   

    

     

    
    

     

      import java.util.concurrent.TimeUnit;
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      /**
     
    
   

    

     

    
    

     

       * @author lidai
     
    
   

    

     

    
    

     

       * @date 2019/3/18 10:09
     
    
   

    

     

    
    

     

       */
     
    
   

    

     

    
    

     

      @Slf4j
     
    
   

    

     

    
    

     

      @Configuration
     
    
   

    

     

    
    

     

      public class FeignHystrixConcurrencyStrategy extends HystrixConcurrencyStrategy {
     
    
   

    

     

    
    

     
    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.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();
     
    
   

    

     

    
    

     

                  }
     
    
   

    

     

    
    

     

              }
     
    
   

    

     

    
    

     

          }
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      }
     
    
  
 

文章来源: baocl.blog.csdn.net，作者：小黄鸡1992，版权归原作者所有，如需转载，请联系作者。

原文链接：baocl.blog.csdn.net/article/details/107996832