SpringCloud Alibaba微服务实战之远程Feign请求头丢失
原创 一安 一安未来 2023-05-06 08:08 发表于北京
收录于合集#SpringCloud专栏11个
大家好，我是一安~
导读：在上一篇文章中我们讲解了如何利用Spring Security OAuth2实现微服务统一认证，今天继续讲解Feign远程调用和异步调用请求头丢失问题。
简介
之前演示只是测试了调用用户微服务下查询接口，并没有在用户服务再调用其他微服务接口，调测看着一切都很正常，但今天测试了用户微服务调用商品微服务，出现了异常：
Debug跟踪，发现用户微服务正常接收到token，而远程调用商品微服务token消失不见了：
原因
源码：ReflectiveFeign.class：
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
if (!"equals".equals(method.getName())) {
if ("hashCode".equals(method.getName())) {
return this.hashCode();
} else {
return "toString".equals(method.getName()) ? this.toString() : ((InvocationHandlerFactory.MethodHandler)this.dispatch.get(method)).invoke(args);
}
} else {
try {
Object otherHandler = args.length > 0 && args[0] != null ? Proxy.getInvocationHandler(args[0]) : null;
return this.equals(otherHandler);
} catch (IllegalArgumentException var5) {
return false;
}
}
}
进入((InvocationHandlerFactory.MethodHandler)this.dispatch.get(method)).invoke(args)：
public Object invoke(Object[] argv) throws Throwable {
//就是在这 构建了一个新的RequestTemplate ，而浏览器带给我们的请求头都会丢失
RequestTemplate template = this.buildTemplateFromArgs.create(argv);
Request.Options options = this.findOptions(argv);
Retryer retryer = this.retryer.clone();
while(true) {
try {
// 在这即将执行该方法
return this.executeAndDecode(template, options);
} catch (RetryableException var9) {
RetryableException e = var9;
try {
retryer.continueOrPropagate(e);
} catch (RetryableException var8) {
Throwable cause = var8.getCause();
if (this.propagationPolicy == ExceptionPropagationPolicy.UNWRAP && cause != null) {
throw cause;
}
throw var8;
}
if (this.logLevel != Level.NONE) {
this.logger.logRetry(this.metadata.configKey(), this.logLevel);
}
}
}
}
进入this.executeAndDecode(template, options)：
Object executeAndDecode(RequestTemplate template, Request.Options options) throws Throwable {
//这里 它会对我们的请求进行一些包装
Request request = this.targetRequest(template);
if (this.logLevel != Level.NONE) {
this.logger.logRequest(this.metadata.configKey(), this.logLevel, request);
}
long start = System.nanoTime();
Response response;
try {
response = this.client.execute(request, options);
response = response.toBuilder().request(request).requestTemplate(template).build();
} catch (IOException var12) {
if (this.logLevel != Level.NONE) {
this.logger.logIOException(this.metadata.configKey(), this.logLevel, var12, this.elapsedTime(start));
}
throw FeignException.errorExecuting(request, var12);
}
.......
}
进入this.targetRequest(template)：
Request targetRequest(RequestTemplate template) {
//拿到对应的所有请求拦截器的迭代器
Iterator var2 = this.requestInterceptors.iterator();
//遍历所有的请求拦截器
while(var2.hasNext()) {
RequestInterceptor interceptor = (RequestInterceptor)var2.next();
//这里是每个请求拦截器 依次对该方法进行包装
interceptor.apply(template);
}
return this.target.apply(template);
}
进入interceptor.apply(template)：
public interface RequestInterceptor {
void apply(RequestTemplate var1);
}
发现它是一个接口，所以可以重写一下这个方法对我们的请求做一些包装，借鉴一下别的实现方法：
方案
/**
* 微服务之间feign调用请求头丢失的问题
* @author yian
* @since 2023-04-05
*/
@Configuration
@Slf4j
public class FeignRequestInterceptor implements RequestInterceptor {
@Override
public void apply(RequestTemplate template) {
HttpServletRequest httpServletRequest = getHttpServletRequest();
if(httpServletRequest!=null){
Map headers = getHeaders(httpServletRequest);
// 传递所有请求头,防止部分丢失
//此处也可以只传递认证的header
//requestTemplate.header("json-token", request.getHeader("json-token"));
for (Map.Entry entry : headers.entrySet()) {
template.header(entry.getKey(), entry.getValue());
}
log.debug("FeignRequestInterceptor:{}", template.toString());
}
}
private HttpServletRequest getHttpServletRequest() {
try {
return ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
} catch (Exception e) {
return null;
}
}
/**
* 获取原请求头
*/
private Map getHeaders(HttpServletRequest request) {
Map map = new LinkedHashMap<>();
Enumeration enumeration = request.getHeaderNames();
if(enumeration!=null){
while (enumeration.hasMoreElements()) {
String key = enumeration.nextElement();
String value = request.getHeader(key);
map.put(key, value);
}
}
return map;
}
}
补充说明
实际开发中，在业务复杂情况下难免使用异步编排的方式实现，这个时候你会发现请求头又丢失了。
源码：RequestContextHolder.class：
@Nullable
public static RequestAttributes getRequestAttributes() {
RequestAttributes attributes = (RequestAttributes)requestAttributesHolder.get();
if (attributes == null) {
attributes = (RequestAttributes)inheritableRequestAttributesHolder.get();
}
return attributes;
}
查看requestAttributesHolder变量：
private static final ThreadLocal requestAttributesHolder = new NamedThreadLocal("Request attributes");
查看NamedThreadLocal：
public class NamedThreadLocal extends ThreadLocal {
private final String name;
public NamedThreadLocal(String name) {
Assert.hasText(name, "Name must not be empty");
this.name = name;
}
public String toString() {
return this.name;
}
}
ThreadLocal是一个线程局部变量，在不同线程之间是独立的所以我们获取不到原先主线程的请求属性。
方案
//获取之前的请求
RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
CompletableFuture getAddress = CompletableFuture.runAsync(() -> {
System.out.println(Thread.currentThread().getId());
//每一个线程都来共享之前请求的数据
RequestContextHolder.setRequestAttributes(requestAttributes);
List address = memberFeignService.getAddress(memberRespVo.getId());
confirmVo.setAddress(address);
}, executor);
至此我们已经解决了Feign远程以及异步编排下导致的请求头丢失问题。
一安未来
致力于Java，大数据；心得交流，技术分享；
91篇原创内容
公众号