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

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

目录Feign调用添加验证信息token到请求头1、这是最简单的一个方法2、这个方法是网上大多数人的用法3、第三种方法就是大神的方法了Feign中增加请求头最近遇到项目在调用

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

*

* 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获取不到，需要再配置文件中添加如下配置就可以了

hystrix:

command:

default:

execution:

isolation:

strategy: SEMAPHORE

3、第三种方法就是大神的方法了

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

package com.hiynn.provider.configuration;

import com-flix.hystrix.HystrixThreadPoolKey;

import com-flix.hystrix.HystrixThreadPoolProperties;

import com-flix.hystrix.strategy.HystrixPlugins;

import com-flix.hystrix.strategy.concurrency.HystrixConcurrencyStrategy;

import com-flix.hystrix.strategy.concurrency.HystrixRequestVariable;

import com-flix.hystrix.strategy.concurrency.HystrixRequestVariableLifecycle;

import com-flix.hystrix.strategy.eventnotifier.HystrixEventNotifier;

import com-flix.hystrix.strategy.executionhook.HystrixCommandExecutionHook;

import com-flix.hystrix.strategy.metrics.HystrixMetricsPublisher;

import com-flix.hystrix.strategy.properties.HystrixPropertiesStrategy;

import com-flix.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);

}

}kGxkQhXNms

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 Callable wrapCallable(Callable callable) {

RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();

return new WrappedCallable<>(callable, requestAttributes);

}

@Override

public ThreadPoolExecutor getThreadPool(HystrixThreadPoolKey threadPoolKey,

HystrixProperty corePoolSize, HystrixProperty maximumPoolSize,

HystrixProperty keepAliveTime, TimeUnit unit, BlockingQueue 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 getBlockingQueue(int maxQueueSize) {

return this.delegate.getBlockingQueue(maxQueueSize);

}

@Override

public HystrixRequestVariable getRequestVariable(HystrixRequestVariableLifecycle rv) {

return this.delegate.getRequestVariable(rv);

}

static class WrappedCallable implements Callable<T> {

private final Callable target;

private final RequestAttributes requestAttributes;

public WrappedCallable(Callable 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中增加请求头

最近遇到项目在调用

实现RequestInterceptor 接口，然后可以根据feignClient中的值加到请求头中，使用时候在feignClient中配置，这样就可以把参数传入feign中

import com.alibaba.fastjson.JSONObject;

import com.google.common.collect.Lists;

import feign.RequestInterceptor;

import feign.RequestTemplate;

import org.apache.commons.collections4.CollectionUtils;

import java.util.ArrayList;

import java.util.Collection;

import java.util.List;

import java.util.Map;

public class FeignConfiguration implementhttp://s RequestInterceptor {

@Override

public void apply(RequestTemplate template) {

List list = new ArrayList<>();

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

Map> queries = template.queries();

list = (List) queries.get("key");

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

byte[] body = template.body();

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

}

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。