SpringCloud Feign转发请求头(防止session失效)的解决方案

获取：
@requestmapping(value = "/api/test", method = requestmethod.get)
public string testfun(@requestparam string name, @requestheader("uniqueid") string uniqueid) {
  if(uniqueid == null ){
     return "must defined the uniqueid , it can not be null";
  }
  log.info(uniqueid, "begin testfun... ");
 return uniqueid;
}

@feignclient(value = "demo-service")
public interface callclient {

  /**
 * 访问demo-service服务的/api/test接口，通过注解将logid传递给下游服务
 */
 @requestmapping(value = "/api/test", method = requestmethod.get)
  string callapitest(@requestparam(value = "name") string name, @requestheader(value = "uniqueid") string uniqueid);

}

import com.intellif.log.loggerutili;
import feign.requestinterceptor;
import org.springframework.context.annotation.bean;
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;
import java.util.enumeration;

/**
 * 自定义的请求头处理类，处理服务发送时的请求头；
 * 将服务接收到的请求头中的uniqueid和token字段取出来，并设置到新的请求头里面去转发给下游服务
 * 比如a服务收到一个请求，请求头里面包含uniqueid和token字段，a处理时会使用feign客户端调用b服务
 * 那么uniqueid和token这两个字段就会添加到请求头中一并发给b服务；
 *
 * @author mozping
 * @version 1.0
 * @date 2018/6/27 14:13
 * @see feignheadconfiguration
 * @since jdk1.8
 */
@configuration
public class feignheadconfiguration {
  private final loggerutili logger = loggerutili.getlogger(this.getclass().getname());

  @bean
  public requestinterceptor requestinterceptor() {
    return requesttemplate -> {
      servletrequestattributes attrs = (servletrequestattributes) requestcontextholder.getrequestattributes();
      if (attrs != null) {
        httpservletrequest request = attrs.getrequest();
        enumeration<string> headernames = request.getheadernames();
        if (headernames != null) {
          while (headernames.hasmoreelements()) {
            string name = headernames.nextelement();
            string value = request.getheader(name);
            /**
             * 遍历请求头里面的属性字段，将logid和token添加到新的请求头中转发到下游服务
             * */
            if ("uniqueid".equalsignorecase(name) || "token".equalsignorecase(name)) {
              logger.debug("添加自定义请求头key:" + name + ",value:" + value);
              requesttemplate.header(name, value);
            } else {
              logger.debug("feignheadconfiguration", "非自定义请求头key:" + name + ",value:" + value + "不需要添加!");
            }
          }
        } else {
          logger.warn("feignheadconfiguration", "获取请求头失败！");
        }
      }
    };
  }

}

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 org.slf4j.logger;
import org.slf4j.loggerfactory;
import org.springframework.stereotype.component;
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;

/**
 * 自定义feign的隔离策略;
 * 在转发feign的请求头的时候，如果开启了hystrix，hystrix的默认隔离策略是thread(线程隔离策略)，因此转发拦截器内是无法获取到请求的请求头信息的，可以修改默认隔离策略为信号量模式：hystrix.command.default.execution.isolation.strategy=semaphore，这样的话转发线程和请求线程实际上是一个线程，这并不是最好的解决方法，信号量模式也不是官方最为推荐的隔离策略；另一个解决方法就是自定义hystrix的隔离策略，思路是将现有的并发策略作为新并发策略的成员变量,在新并发策略中，返回现有并发策略的线程池、queue；将策略加到spring容器即可；
 *
 * @author mozping
 * @version 1.0
 * @date 2018/7/5 9:08
 * @see feignhystrixconcurrencystrategyintellif
 * @since jdk1.8
 */
@component
public class feignhystrixconcurrencystrategyintellif extends hystrixconcurrencystrategy {

  private static final logger log = loggerfactory.getlogger(feignhystrixconcurrencystrategyintellif.class);
  private hystrixconcurrencystrategy delegate;

  public feignhystrixconcurrencystrategyintellif() {
    try {
      this.delegate = hystrixplugins.getinstance().getconcurrencystrategy();
      if (this.delegate instanceof feignhystrixconcurrencystrategyintellif) {
        // 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();
      }
    }
  }
}