import com.netflix.hystrix.strategy.metrics.HystrixMetricsPublisher; //导入依赖的package包/类
/**
 * registers the {@link ExecutionContextAwareHystrixStrategy}
 */
public static void init() {
    // keeps references of existing Hystrix plugins.
    HystrixConcurrencyStrategy existingConcurrencyStrategy = HystrixPlugins.getInstance().getConcurrencyStrategy();
    HystrixEventNotifier eventNotifier = HystrixPlugins.getInstance().getEventNotifier();
    HystrixMetricsPublisher metricsPublisher = HystrixPlugins.getInstance().getMetricsPublisher();
    HystrixPropertiesStrategy propertiesStrategy = HystrixPlugins.getInstance().getPropertiesStrategy();
    HystrixCommandExecutionHook commandExecutionHook = HystrixPlugins.getInstance().getCommandExecutionHook();
    // reset the Hystrix plugin
    HystrixPlugins.reset();
    // configure the  plugin
    HystrixPlugins.getInstance().registerConcurrencyStrategy(new ExecutionContextAwareHystrixStrategy(existingConcurrencyStrategy));
    HystrixPlugins.getInstance().registerEventNotifier(eventNotifier);
    HystrixPlugins.getInstance().registerMetricsPublisher(metricsPublisher);
    HystrixPlugins.getInstance().registerPropertiesStrategy(propertiesStrategy);
    HystrixPlugins.getInstance().registerCommandExecutionHook(commandExecutionHook);
    log.info("Context propagation enabled for Hystrix.");
}
 

import com.netflix.hystrix.strategy.metrics.HystrixMetricsPublisher; //导入依赖的package包/类
@PostConstruct
public void init() {
	// Keeps references of existing Hystrix plugins.
	HystrixEventNotifier eventNotifier = HystrixPlugins.getInstance()
			.getEventNotifier();
	HystrixMetricsPublisher metricsPublisher = HystrixPlugins.getInstance()
			.getMetricsPublisher();
	HystrixPropertiesStrategy propertiesStrategy = HystrixPlugins.getInstance()
			.getPropertiesStrategy();
	HystrixCommandExecutionHook commandExecutionHook = HystrixPlugins.getInstance()
			.getCommandExecutionHook();

	HystrixPlugins.reset();

	// Registers existing plugins excepts the Concurrent Strategy plugin.
	HystrixPlugins.getInstance().registerConcurrencyStrategy(
			new SecurityContextConcurrencyStrategy(existingConcurrencyStrategy));
	HystrixPlugins.getInstance().registerEventNotifier(eventNotifier);
	HystrixPlugins.getInstance().registerMetricsPublisher(metricsPublisher);
	HystrixPlugins.getInstance().registerPropertiesStrategy(propertiesStrategy);
	HystrixPlugins.getInstance().registerCommandExecutionHook(commandExecutionHook);
}
 

import com.netflix.hystrix.strategy.metrics.HystrixMetricsPublisher; //导入依赖的package包/类
private TracingConcurrencyStrategy(Tracer tracer) {
    this.tracer = tracer;
    try {
        this.delegateStrategy = HystrixPlugins.getInstance().getConcurrencyStrategy();
        if (this.delegateStrategy instanceof TracingConcurrencyStrategy) {
            return;
        }

        HystrixCommandExecutionHook commandExecutionHook =
            HystrixPlugins.getInstance().getCommandExecutionHook();
        HystrixEventNotifier eventNotifier = HystrixPlugins.getInstance().getEventNotifier();
        HystrixMetricsPublisher metricsPublisher =
            HystrixPlugins.getInstance().getMetricsPublisher();
        HystrixPropertiesStrategy propertiesStrategy =
            HystrixPlugins.getInstance().getPropertiesStrategy();

        HystrixPlugins.reset();
        HystrixPlugins.getInstance().registerConcurrencyStrategy(this);
        HystrixPlugins.getInstance().registerCommandExecutionHook(commandExecutionHook);
        HystrixPlugins.getInstance().registerEventNotifier(eventNotifier);
        HystrixPlugins.getInstance().registerMetricsPublisher(metricsPublisher);
        HystrixPlugins.getInstance().registerPropertiesStrategy(propertiesStrategy);
    } catch (Exception ex) {
        log.log(Level.SEVERE, "Failed to register " + TracingConcurrencyStrategy.class +
            ", to HystrixPlugins", ex);
    }
}
 

import com.netflix.hystrix.strategy.metrics.HystrixMetricsPublisher; //导入依赖的package包/类
public SleuthHystrixConcurrencyStrategy(Tracer tracer, TraceKeys traceKeys) {
	this.tracer = tracer;
	this.traceKeys = traceKeys;
	try {
		this.delegate = HystrixPlugins.getInstance().getConcurrencyStrategy();
		if (this.delegate instanceof SleuthHystrixConcurrencyStrategy) {
			// 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();
		logCurrentStateOfHysrixPlugins(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);
	}
}
 

import com.netflix.hystrix.strategy.metrics.HystrixMetricsPublisher; //导入依赖的package包/类
private void logCurrentStateOfHysrixPlugins(HystrixEventNotifier eventNotifier,
		HystrixMetricsPublisher metricsPublisher,
		HystrixPropertiesStrategy propertiesStrategy) {
	log.debug("Current Hystrix plugins configuration is [" + "concurrencyStrategy ["
			+ this.delegate + "]," + "eventNotifier [" + eventNotifier + "],"
			+ "metricPublisher [" + metricsPublisher + "]," + "propertiesStrategy ["
			+ propertiesStrategy + "]," + "]");
	log.debug("Registering Sleuth Hystrix Concurrency Strategy.");
}
 

import com.netflix.hystrix.strategy.metrics.HystrixMetricsPublisher; //导入依赖的package包/类
private void logCurrentStateOfHysrixPlugins(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.");
	}
}
 

import com.netflix.hystrix.strategy.metrics.HystrixMetricsPublisher; //导入依赖的package包/类
private HystrixPrometheusMetricsPublisher(boolean exportProperties,
                                          boolean exportDeprecatedMetrics,
                                          HystrixMetricsCollector collector,
                                          HystrixMetricsPublisher metricsPublisherDelegate) {
    this.collector = collector;
    this.exportProperties = exportProperties;
    this.exportDeprecatedMetrics = exportDeprecatedMetrics;
    this.metricsPublisherDelegate = metricsPublisherDelegate;
}
 

import com.netflix.hystrix.strategy.metrics.HystrixMetricsPublisher; //导入依赖的package包/类
public ComposedHystrixMetricsPublisher(HystrixMetricsPublisher... publishers) {
    log.trace("Creating ComposedHystrixMetricsPublisher");
    this.publishers = Arrays.asList(publishers);
}
 

import com.netflix.hystrix.strategy.metrics.HystrixMetricsPublisher; //导入依赖的package包/类
public void buildAndRegister() {
    HystrixPlugins plugins = HystrixPlugins.getInstance();

    // memorize the registered plugins
    HystrixCommandExecutionHook commandExecutionHook = plugins.getCommandExecutionHook();
    HystrixEventNotifier eventNotifier = plugins.getEventNotifier();
    HystrixMetricsPublisher metricsPublisher = plugins.getMetricsPublisher();
    HystrixPropertiesStrategy propertiesStrategy = plugins.getPropertiesStrategy();
    HystrixConcurrencyStrategy concurrencyStrategy = plugins.getConcurrencyStrategy();

    HystrixMetricsCollector collector = new HystrixMetricsCollector(namespace,
            new Consumer<Histogram.Builder>() {
                @Override
                public void accept(Histogram.Builder builder) {
                    if (metrics == MetricsType.EXPONENTIAL) {
                        builder.exponentialBuckets(exponentialStart, exponentialFactor, exponentialCount);
                    } else if (metrics == MetricsType.LINEAR) {
                        builder.linearBuckets(linearStart, linearWidth, linearCount);
                    } else if (metrics == MetricsType.DISTINCT) {
                        builder.buckets(distinctBuckets);
                    } else if (metrics == MetricsType.DEFAULT) {
                        // nothing to do
                    } else {
                        throw new IllegalStateException("unknown enum state " + metrics);
                    }
                }
            }).register(registry);

    // wrap the metrics publisher plugin
    HystrixPrometheusMetricsPublisher wrappedMetricsPublisher =
            new HystrixPrometheusMetricsPublisher(exportProperties,
                    exportDeprecatedMetrics, collector, metricsPublisher);

    // reset all plugins
    HystrixPlugins.reset();
    // the following statement wouldn't be necessary, but I'm paranoid that reset might
    // change the plugin instance.
    plugins = HystrixPlugins.getInstance();

    // set previous values for all plugins, but not if they would use the default implementation,
    // as this would block the slot for plugins to be registered.

    // REASON: if there was no previous setting, Hystrix would have returned the default implementation
    // and not all other plugin use the reset-and-wrap approach we do here.

    // ASSUMPTION: the default strategies/hooks can't wrap a different strategy/hook

    // CAVEAT: instead of a default implementation there is a sophisticated Archaius configuration mechanism
    // to determine a class from property settings. There is a corner case where someone would register a
    // default implementation manually overriding an Archaius configuration. Therefore this is configurable
    // using "registerDefaultPlugins".

    if (registerDefaultPlugins || concurrencyStrategy.getClass() != HystrixConcurrencyStrategyDefault.class) {
        plugins.registerConcurrencyStrategy(concurrencyStrategy);
    }
    if (registerDefaultPlugins || commandExecutionHook.getClass() != HystrixCommandExecutionHookDefault.class) {
        plugins.registerCommandExecutionHook(commandExecutionHook);
    }
    if (registerDefaultPlugins || eventNotifier.getClass() != HystrixEventNotifierDefault.class) {
        plugins.registerEventNotifier(eventNotifier);
    }
    if (registerDefaultPlugins || propertiesStrategy.getClass() != HystrixPropertiesStrategyDefault.class) {
        plugins.registerPropertiesStrategy(propertiesStrategy);
    }

    // ... except for the metrics publisher that will now be wrapped
    plugins.registerMetricsPublisher(wrappedMetricsPublisher);
}