SpringCloud Alibaba微服务实战之远程Feign请求头丢失问题解决方案

    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;
            }
        }
    }

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

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

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

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<String, String> headers = getHeaders(httpServletRequest);
            // 传递所有请求头,防止部分丢失
            //此处也可以只传递认证的header
            //requestTemplate.header("json-token", request.getHeader("json-token"));
            for (Map.Entry<String, String> 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<String, String> getHeaders(HttpServletRequest request) {
        Map<String, String> map = new LinkedHashMap<>();
        Enumeration<String> enumeration = request.getHeaderNames();
        if(enumeration!=null){
            while (enumeration.hasMoreElements()) {
                String key = enumeration.nextElement();
                String value = request.getHeader(key);
                map.put(key, value);
            }
        }
        return map;
    }
}

    @Nullable
    public static RequestAttributes getRequestAttributes() {
        RequestAttributes attributes = (RequestAttributes)requestAttributesHolder.get();
        if (attributes == null) {
            attributes = (RequestAttributes)inheritableRequestAttributesHolder.get();
        }
        return attributes;
    }

private static final ThreadLocal<RequestAttributes> requestAttributesHolder = new NamedThreadLocal("Request attributes");

public class NamedThreadLocal<T> extends ThreadLocal<T> {
    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;
    }
}

//获取之前的请求
RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
CompletableFuture<Void> getAddress = CompletableFuture.runAsync(() -> {
    System.out.println(Thread.currentThread().getId());
    //每一个线程都来共享之前请求的数据
    RequestContextHolder.setRequestAttributes(requestAttributes);
    List<MemberAddressVo> address = memberFeignService.getAddress(memberRespVo.getId());
    confirmVo.setAddress(address);
}, executor);