sly1311220942 / demo-seata-springcloud Goto Github PK

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