Feign之Jwt值传递

青旅半醒 2023-06-29 10:51 12阅读 0赞

[附：SpringCloud之系列汇总跳转地址][SpringCloud]

在微服务系统中，为了保证微服务系统的安全,常常使用jwt来鉴权，而jwt又往往存放在ThreadLocal中，可是服务内部的相互调用时，这样的做法在Feign开启了Hystrix的情况下，是有问题的。

首先我们先看下在Feign关闭Hystrix的情况下，是怎样的情况：

feign.hystrix.enabled=false

FeignInterceptor中，我们希望为Feign的请求头部带上accessToken请求凭证

package com.yj.feign.interceptor;
    
    import org.springframework.stereotype.Component;
    import org.springframework.web.context.request.RequestContextHolder;
    import org.springframework.web.context.request.ServletRequestAttributes;
    import feign.RequestInterceptor;
    import feign.RequestTemplate;
    
    @Component
    public class FeignInterceptor implements RequestInterceptor {
    
    	private static final String AUTHORIZATION_HEADER = "accessToken";
    
    	@Override
    	public void apply(RequestTemplate template) {
    		ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
    		System.out.println("attributes:" + attributes);
    		String accessToken = attributes.getRequest().getHeader(AUTHORIZATION_HEADER);
    		System.out.println("accessToken:" + accessToken);
    		template.header(AUTHORIZATION_HEADER, accessToken);
    	}
    }

发现能够获取RequestContextHolder中的ServletRequestAttributes对象，输出

attributes:org.apache.catalina.connector.RequestFacade@6e29865d

然后我们开启Hyxtrix，Feign中默认就是开启Hystrix

feign.hystrix.enabled=true

我们发现，此时RequestContextHolder中的ServletRequestAttributes对象为null了，也就是说隔离的线程无法获取当前请求线程的属性值了，原因在于，Hystrix的默认隔离策略是`THREAD` 。而 `RequestContextHolder` 源码中，使用了两个血淋淋的`ThreadLocal。`

### `解决方案一：调整Hystrix的隔离策略` ###

将隔离策略设为SEMAPHORE即可：

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

这样配置后，Feign可以正常工作。但该方案不是特别好。**原因是Hystrix官方强烈建议使用THREAD作为隔离策略！** 于是，那么有没有更好的方案呢？

### `解决方案二：`自定义并发策略 ###

既然Hystrix不太建议使用SEMAPHORE作为隔离策略，那么是否有其他方案呢？答案是自定义并发策略，目前，Spring Cloud Sleuth以及Spring Security都通过该方式传递 `ThreadLocal` 对象。

下面我们来编写自定义的并发策略。编写自定义并发策略比较简单，只需编写一个类，让其继承`HystrixConcurrencyStrategy` ，并重写`wrapCallable`方法即可。

RequestHystrixConcurrencyStrategy

package com.yj.feign.interceptor;
    
    import java.util.concurrent.BlockingQueue;
    import java.util.concurrent.Callable;
    import java.util.concurrent.ThreadPoolExecutor;
    import java.util.concurrent.TimeUnit;
    
    import org.apache.commons.logging.Log;
    import org.apache.commons.logging.LogFactory;
    import org.springframework.stereotype.Component;
    import org.springframework.web.context.request.RequestAttributes;
    import org.springframework.web.context.request.RequestContextHolder;
    
    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;
    
    @Component
    public class RequestHystrixConcurrencyStrategy extends HystrixConcurrencyStrategy {
    	private static final Log log = LogFactory.getLog(RequestHystrixConcurrencyStrategy.class);
    	private HystrixConcurrencyStrategy delegate;
    	public RequestHystrixConcurrencyStrategy() {
    		try {
    			this.delegate = HystrixPlugins.getInstance().getConcurrencyStrategy();
    			if (this.delegate instanceof RequestHystrixConcurrencyStrategy) {
    				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();
    			}
    		}
    	}
    }

*  `wrapCallable`方法拿到 `RequestContextHolder.getRequestAttributes()` ，也就是我们想传播的对象
 *  在`WrappedCallable` 类中，我们将要传播的对象作为成员变量，并在其中的call方法中，为静态方法设值
 *  这样，在Hystrix包裹的方法中，就可以使用`RequestContextHolder.getRequestAttributes()` 获取到相关属性。也就是说，可以拿到`RequestContextHolder` 中的`ThreadLocal` 属性

经过测试，代码又能正常工作

[附：SpringCloud之系列汇总跳转地址][SpringCloud]

[SpringCloud]: https://blog.csdn.net/qq_24313635/article/details/104061217