使用Feign调用时添加验证信息token到请求头方式

@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);

}

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" ));

    }

}

@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);

}

hystrix:

   command:

    default:

      execution:

        isolation:

          strategy: SEMAPHORE

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

            }

        }

    }  

}

import com.alibaba.fastjson.JSONObject;

import com.google测试数据mon.collect.Lists;

import feign.RequestInterceptor;

import feign.RequestTemplate;

import org.apache测试数据mons.collections4.CollectionUtils; 

import java.util.ArrayList;

import java.util.Collection;

import java.util.List;

import java.util.Map;

public class FeignConfiguration implements RequestInterceptor {  

    @Override

    public void apply(RequestTemplate template) {

        List<String> list = new ArrayList<>();

        if ( "get" .equalsIgnoreCase(template.method())){

            Map<String, Collection<String>> queries = template.queries();

            list = (List<String>) queries.get( "key" );

        } else if ( "post" .equalsIgnoreCase(template.method())){

            byte [] body = template.body();

            Map<String, Object> map = JSONObject.parseObject(body, Map. class );

            Object key = map.get( "key" );

            if (key != null ){

                list.add(key.toString());

            }

        }

        if (CollectionUtils.isNotEmpty(list)) {

            template.header( "head" , list);

        }

    } 

}

import com.hbasesoft.vcc.sgp.integral.goods.config.FeignConfiguration;

import org.springframework.cloud.openfeign.FeignClient;

import org.springframework.web.bind.annotation.GetMapping;

import org.springframework.web.bind.annotation.RequestParam; 

@FeignClient (name = "test" , path = "/test" , configuration = FeignConfiguration. class )

public interface ErpGoodsCouponsExternalClient {

    @GetMapping ( "/url" )

    Object getData( @RequestParam ( "key" ) String key);    

}