详解feign调用session丢失解决方案

@Configuration @EnableFeignClients(basePackages = "com.xxx.xxx.client") public class FeignClientsConfigurationCustom implements RequestInterceptor {   @Override  public void apply(RequestTemplate template) {    RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();   if (requestAttributes == null) {    return;   }    HttpServletRequest request = ((ServletRequestAttributes) requestAttributes).getRequest();   Enumeration<String> headerNames = request.getHeaderNames();   if (headerNames != null) {    while (headerNames.hasMoreElements()) {     String name = headerNames.nextElement();     Enumeration<String> values = request.getHeaders(name);     while (values.hasMoreElements()) {      String value = values.nextElement();      template.header(name, value);     }    }   }   }  } 

RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();

hystrix.command.default.execution.isolation.strategy: SEMAPHORE

/** * Abstract class for defining different behavior or implementations for concurrency related aspects of the system with default implementations. * <p> * For example, every {@link Callable} executed by {@link HystrixCommand} will call {@link #wrapCallable(Callable)} to give a chance for custom implementations to decorate the {@link Callable} with * additional behavior. * <p> * When you implement a concrete {@link HystrixConcurrencyStrategy}, you should make the strategy idempotent w.r.t ThreadLocals. * Since the usage of threads by Hystrix is internal, Hystrix does not attempt to apply the strategy in an idempotent way. * Instead, you should write your strategy to work idempotently. See https://github.com/Netflix/Hystrix/issues/351 for a more detailed discussion. * <p> * See {@link HystrixPlugins} or the Hystrix GitHub Wiki for information on configuring plugins: <a * href="https://github.com/Netflix/Hystrix/wiki/Plugins" rel="external nofollow" >https://github.com/Netflix/Hystrix/wiki/Plugins</a>. */public abstract class HystrixConcurrencyStrategy 

public class FeignHystrixConcurrencyStrategy extends HystrixConcurrencyStrategy {   private static final Logger log = LoggerFactory.getLogger(FeignHystrixConcurrencyStrategy.class);  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();    }   }  } } 

 @Bean public FeignHystrixConcurrencyStrategy feignHystrixConcurrencyStrategy() {  return new FeignHystrixConcurrencyStrategy(); }