import org.springframework.cloud.sleuth.SpanInjector; //导入依赖的package包/类
public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException {
    boolean isTraceDubbo = false;
    Tracer tracer = null;
    SpanInjector spanInjector = null;
    try {
        tracer = ApplicationContextAwareBean.CONTEXT.getBean(Tracer.class);
        spanInjector = ApplicationContextAwareBean.CONTEXT.getBean(DubboSpanInjector.class);
        isTraceDubbo = (tracer != null && spanInjector != null);
        if (isTraceDubbo) {
            String spanName = invoker.getUrl().getParameter("interface") + ":" + invocation.getMethodName() + ":" + invoker.getUrl().getParameter("version") + "(" + invoker.getUrl().getHost() + ")";
            Span newSpan = tracer.createSpan(spanName);
            spanInjector.inject(newSpan, RpcContext.getContext());
            newSpan.logEvent(Span.CLIENT_SEND);

        }

        Result result = invoker.invoke(invocation);
        return result;

    } finally {
        if (isTraceDubbo) {
            if (tracer.isTracing()) {
                tracer.getCurrentSpan().logEvent(Span.CLIENT_RECV);
                tracer.close(tracer.getCurrentSpan());
            }

        }
    }
}
 

import org.springframework.cloud.sleuth.SpanInjector; //导入依赖的package包/类
@Bean
public FilterRegistrationBean traceWebFilter(Tracer tracer, TraceKeys traceKeys,
		SkipPatternProvider skipPatternProvider, SpanReporter spanReporter,
		SpanExtractor<HttpServletRequest> spanExtractor,
		SpanInjector<HttpServletResponse> spanInjector,
		HttpTraceKeysInjector httpTraceKeysInjector, TraceFilter traceFilter) {
	FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean(traceFilter);
	filterRegistrationBean.setDispatcherTypes(ASYNC, ERROR, FORWARD, INCLUDE, REQUEST);
	return filterRegistrationBean;
}
 

import org.springframework.cloud.sleuth.SpanInjector; //导入依赖的package包/类
@Bean
public TraceFilter traceFilter(Tracer tracer, TraceKeys traceKeys,
		SkipPatternProvider skipPatternProvider, SpanReporter spanReporter,
		SpanExtractor<HttpServletRequest> spanExtractor,
		SpanInjector<HttpServletResponse> spanInjector,
		HttpTraceKeysInjector httpTraceKeysInjector) {
	return new TraceFilter(tracer, traceKeys, skipPatternProvider.skipPattern(),
			spanReporter, spanExtractor, spanInjector, httpTraceKeysInjector);
}
 

import org.springframework.cloud.sleuth.SpanInjector; //导入依赖的package包/类
@Bean
@ConditionalOnMissingBean
public TraceRestTemplateInterceptor traceRestTemplateInterceptor(Tracer tracer,
		SpanInjector<HttpRequest> spanInjector,
		HttpTraceKeysInjector httpTraceKeysInjector) {
	return new TraceRestTemplateInterceptor(tracer, spanInjector, httpTraceKeysInjector);
}
 

import org.springframework.cloud.sleuth.SpanInjector; //导入依赖的package包/类
/**
 * According to the JavaDocs all Spring {@link AsyncClientHttpRequestFactory} implement
 * the {@link ClientHttpRequestFactory} interface.
 *
 * In case that it's not true we're setting the {@link SimpleClientHttpRequestFactory}
 * as a default for sync request processing.
 *
 * @see org.springframework.web.client.AsyncRestTemplate#AsyncRestTemplate(AsyncClientHttpRequestFactory)
 */
public TraceAsyncClientHttpRequestFactoryWrapper(Tracer tracer,
		SpanInjector<HttpRequest> spanInjector,
		AsyncClientHttpRequestFactory asyncDelegate,
		HttpTraceKeysInjector httpTraceKeysInjector) {
	super(tracer, spanInjector, httpTraceKeysInjector);
	this.asyncDelegate = asyncDelegate;
	this.syncDelegate = asyncDelegate instanceof ClientHttpRequestFactory ?
			(ClientHttpRequestFactory) asyncDelegate : defaultClientHttpRequestFactory();
}
 

import org.springframework.cloud.sleuth.SpanInjector; //导入依赖的package包/类
public TraceFilter(Tracer tracer, TraceKeys traceKeys, SpanReporter spanReporter,
		SpanExtractor<HttpServletRequest> spanExtractor,
		SpanInjector<HttpServletResponse> spanInjector,
		HttpTraceKeysInjector httpTraceKeysInjector) {
	this(tracer, traceKeys, Pattern.compile(DEFAULT_SKIP_PATTERN), spanReporter,
			spanExtractor, spanInjector, httpTraceKeysInjector);
}
 

import org.springframework.cloud.sleuth.SpanInjector; //导入依赖的package包/类
public TraceRestClientRibbonCommandFactory(SpringClientFactory clientFactory,
		Tracer tracer, SpanInjector<HttpRequest.Builder> spanInjector,
		HttpTraceKeysInjector httpTraceKeysInjector) {
	super(clientFactory);
	this.tracer = tracer;
	this.spanInjector = spanInjector;
	this.httpTraceKeysInjector = httpTraceKeysInjector;
}
 

import org.springframework.cloud.sleuth.SpanInjector; //导入依赖的package包/类
@SuppressWarnings("deprecation")
public TraceRestClientRibbonCommand(String commandKey, RestClient restClient,
		HttpRequest.Verb verb, String uri, Boolean retryable,
		MultiValueMap<String, String> headers,
		MultiValueMap<String, String> params, InputStream requestEntity,
		Tracer tracer, SpanInjector<HttpRequest.Builder> spanInjector,
		HttpTraceKeysInjector httpTraceKeysInjector)
				throws URISyntaxException {
	super(commandKey, restClient, verb, uri, retryable, headers, params,
			requestEntity);
	this.tracer = tracer;
	this.spanInjector = spanInjector;
	this.httpTraceKeysInjector = httpTraceKeysInjector;
}
 

import org.springframework.cloud.sleuth.SpanInjector; //导入依赖的package包/类
protected AbstractTraceChannelInterceptor(Tracer tracer, TraceKeys traceKeys,
		SpanExtractor<Message<?>> spanExtractor,
		SpanInjector<MessageBuilder<?>> spanInjector) {
	this.tracer = tracer;
	this.traceKeys = traceKeys;
	this.spanExtractor = spanExtractor;
	this.spanInjector = spanInjector;
}
 

import org.springframework.cloud.sleuth.SpanInjector; //导入依赖的package包/类
@Bean
@GlobalChannelInterceptor
public TraceChannelInterceptor traceChannelInterceptor(Tracer tracer,
		TraceKeys traceKeys, Random random, SpanExtractor<Message<?>> spanExtractor,
		SpanInjector<MessageBuilder<?>> spanInjector) {
	return new IntegrationTraceChannelInterceptor(tracer, traceKeys, spanExtractor,
			spanInjector);
}
 

import org.springframework.cloud.sleuth.SpanInjector; //导入依赖的package包/类
@Bean
public SpanInjector<RpcContext> dubboSpanInjector() {
    Logger logger = Logger.getLogger(TraceDubboAutoConfiguration.class.getCanonicalName());
    logger.info("生成dubbo span跟踪支持");
    return new DubboSpanInjector();
}
 

import org.springframework.cloud.sleuth.SpanInjector; //导入依赖的package包/类
public HttpResponseInjectingTraceFilter(Tracer tracer,
		SpanInjector<HttpServletResponse> spanInjector) {
	this.tracer = tracer;
	this.spanInjector = spanInjector;
}
 

import org.springframework.cloud.sleuth.SpanInjector; //导入依赖的package包/类
@Bean
SpanInjector<HttpServletResponse> customHttpServletResponseSpanInjector() {
	return new CustomHttpServletResponseSpanInjector();
}
 

import org.springframework.cloud.sleuth.SpanInjector; //导入依赖的package包/类
@Bean
public SpanInjector<HttpServletResponse> httpServletResponseSpanInjector() {
	return new HttpServletResponseInjector();
}
 

import org.springframework.cloud.sleuth.SpanInjector; //导入依赖的package包/类
protected AbstractTraceHttpRequestInterceptor(Tracer tracer,
		SpanInjector<HttpRequest> spanInjector, HttpTraceKeysInjector keysInjector) {
	this.tracer = tracer;
	this.spanInjector = spanInjector;
	this.keysInjector = keysInjector;
}
 

import org.springframework.cloud.sleuth.SpanInjector; //导入依赖的package包/类
public TraceRestTemplateInterceptor(Tracer tracer, SpanInjector<HttpRequest> spanInjector,
		HttpTraceKeysInjector httpTraceKeysInjector) {
	super(tracer, spanInjector, httpTraceKeysInjector);
}
 

import org.springframework.cloud.sleuth.SpanInjector; //导入依赖的package包/类
@Bean
public SpanInjector<HttpRequest> httpRequestSpanInjector() {
	return new HttpRequestInjector();
}
 

import org.springframework.cloud.sleuth.SpanInjector; //导入依赖的package包/类
TraceFeignRequestInterceptor(Tracer tracer,
		SpanInjector<RequestTemplate> spanInjector) {
	this.tracer = tracer;
	this.spanInjector = spanInjector;
}
 

import org.springframework.cloud.sleuth.SpanInjector; //导入依赖的package包/类
private SpanInjector<RequestTemplate> feignRequestTemplateInjector() {
	return new FeignRequestTemplateInjector();
}
 

import org.springframework.cloud.sleuth.SpanInjector; //导入依赖的package包/类
private SpanInjector<FeignResponseHeadersHolder> feignResponseHeadersInjector() {
	return new FeignResponseHeadersInjector();
}