<dependencies>
        <!-- 1. Zookeeper 客户端依赖 -->
        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-framework</artifactId>
            <version>2.12.0</version>
            <exclusions>
                <exclusion>
                    <groupId>io.netty</groupId>
                    <artifactId>netty</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <!-- 2. Dubbo 依赖 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>dubbo</artifactId>
            <version>2.6.2</version>
        </dependency>
    </dependencies>

其中：

1. Dubbo 这里依赖独立的 Zookeeper Server 做服务发现，这里使用的客户端是 Curator
2. 引入 Dubbo 框架的依赖，原则上 2.6 的任何版本都是工作的，这里使用的是 2.6.2 版本

实现

我们这里构造的场景是一个有两个节点的服务依赖链，也就是，当一个 Dubbo 客户端调用服务 A 时，服务 A 将会继续调用服务 B。在这个例子中，服务 A 是 greeting service，它所依赖的下游服务服务 B 是 hello service。

定义服务接口

为此需要事先定义两个服务接口 GreetingService 以及 HelloService

1. com.alibaba.dubbo.samples.api.GreetingService

   package com.alibaba.dubbo.samples.api;
   
   public interface GreetingService {
       String greeting(String message);
   }

2. com.alibaba.dubbo.samples.api.HelloService

   package com.alibaba.dubbo.samples.api;
   
   public interface HelloService {
       String hello(String message);
   }

实现服务接口

为了区分对待，所有和 HelloService 相关的实现代码都放在 hello 子包下，同理 GreetingService 相关的放在 greeting 子包下。

1. 实现 com.alibaba.dubbo.samples.api.HelloService

   package com.alibaba.dubbo.samples.service.hello;
   
   import com.alibaba.dubbo.samples.api.HelloService;
   
   import java.util.Random;
   
   public class HelloServiceImpl implements HelloService {
       @Override
       public String hello(String message) {
           try {
               // 通过 sleep 模拟业务逻辑处理时间
               Thread.sleep(new Random(System.currentTimeMillis()).nextInt(1000));
           } catch (InterruptedException e) {
               // no op
           }
           return "hello, " + message;
       }
   }

2. 实现 com.alibaba.dubbo.samples.api.GreetingService

   package com.alibaba.dubbo.samples.service.greeting;
   
   import com.alibaba.dubbo.samples.api.GreetingService;
   import com.alibaba.dubbo.samples.api.HelloService;
   
   import java.util.Random;
   
   public class GreetingServiceImpl implements GreetingService {
       // 下游依赖服务，运行时靠 spring 容器注入 HelloService 的服务代理
       private HelloService helloService;
   
       public void setHelloService(HelloService helloService) {
           this.helloService = helloService;
       }
   
       @Override
       public String greeting(String message) {
           try {
               // 通过 sleep 模拟业务逻辑处理时间
               Thread.sleep(new Random(System.currentTimeMillis()).nextInt(1000));
           } catch (InterruptedException e) {
               // no op
           }
           return "greeting, " + helloService.hello(message);
       }
   }

   这里需要注意的是，GreetingServiceImpl 的实现中声明了一个类型是 HelloService 的成员变量，并在 greeting 方法中，执行完自己逻辑之后又调用了 HelloService 上的 hello 方法。这里的 helloService 的实现将会在运行态由外部注入，注入的不是 HelloServiceImpl 的实现，而是 HelloService 的远程调用代理。通过这样的方式，完成了在一个 Dubbo 服务中继续调用另一个远程 Dubbo 服务的目的。从链路追踪的角度来说，客户端调用 GreetingService 是一个 span，GreetingService 调用 HelloService 是另一个 span，并且两者有父子关系，同属于一个 trace，也就是属于同一条调用链路。

   另外，在 GreetingServiceImpl 和 HelloServiceImpl 的实现中，通过 Thread.sleep 来模拟了处理业务逻辑的耗时，以便在 Zipkin UI 上更好的展示。

配置

为了专注在展示如何使用 Zipkin 这一点上，本文在配置和编程模型上没有采用更多的高级技术，而是使用了最传统的 Spring XML 的配置方式，帮助读者理解。更高级的通过 annotation 甚至 spring boot 的方式，读者可以自行查阅 Dubbo 和 Zipkin 相关的文档。

1. 暴露 HelloService 服务

   在 resouces/spring/hello-service.xml 中增加以下的配置来将 HelloServiceImpl 暴露成一个 Dubbo 服务：

   • 使用了本地启动的 Zookeeper Server 作为注册中心，地址为默认值 zookeeper://127.0.0.1:2181
   • 用 Dubbo 原生服务在端口 20880 上暴露服务
   • 将 HelloServiceImpl 注册成 id 是 helloService 的 Spring Bean，这样就可以在后续的 <dubbo:service> 中引用到这个实现类
   • 通过 <dubbo:service> 将 HelloServiceImpl 暴露成 Dubbo 服务

       <!-- 定义 HelloService 的应用名 -->
       <dubbo:application name="hello-service-provider"/>
   
       <!-- 指定注册中心地址 -->
       <dubbo:registry address="zookeeper://127.0.0.1:2181"/>
   
       <!-- 使用 Dubbo 原生协议在 20880 端口上暴露服务 -->
       <dubbo:protocol name="dubbo" port="20880"/>
   
       <!-- 将 HelloServiceImpl 的实现声明成一个 spring bean -->
       <bean id="helloService" class="com.alibaba.dubbo.samples.service.hello.HelloServiceImpl"/>
   
       <!-- 将 HelloServiceImpl 声明成一个 Dubbo 服务 -->
       <dubbo:service interface="com.alibaba.dubbo.samples.api.HelloService" ref="helloService"/>

2. 增加 Zipkin 相关的配置

   在 resources/spring/hello-service.xml 中增加 Zipkin 相关的配置：

   • 修改 dubbo 服务暴露的配置，添加 Zipkin 的 tracing filter 到 Dubbo 的 filter chain 中
   • 按照 https://github.com/openzipkin/brave/blob/master/spring-beans/README.md 来配置 Zipkin 的 sender 和 tracing 的 spring bean

       <!-- 1. 修改 dubbo 服务暴露配置，在 filter chain 中增加 zipkin 的 tracing 过滤器 -->
       <dubbo:service interface="com.alibaba.dubbo.samples.api.HelloService" ref="helloService" filter="tracing"/>
   
       <!-- 2. zipkin 相关的配置 -->
       <!-- 使用 OKHttp 来发送 trace 信息到 Zipkin Server。这里的 Zipkin Server 启动在本地 -->
       <bean id="sender" class="zipkin2.reporter.beans.OkHttpSenderFactoryBean">
           <property name="endpoint" value="http://localhost:9411/api/v2/spans"/>
       </bean>
   
       <bean id="tracing" class="brave.spring.beans.TracingFactoryBean">
           <property name="localServiceName" value="hello-service"/>
           <property name="spanReporter">
               <bean class="zipkin2.reporter.beans.AsyncReporterFactoryBean">
                   <property name="sender" ref="sender"/>
                   <!-- wait up to half a second for any in-flight spans on close -->
                   <property name="closeTimeout" value="500"/>
               </bean>
           </property>
           <property name="currentTraceContext">
               <bean class="brave.spring.beans.CurrentTraceContextFactoryBean">
                   <property name="scopeDecorators">
                       <bean class="brave.context.slf4j.MDCScopeDecorator" factory-method="create"/>
                   </property>
               </bean>
           </property>
       </bean>

3. 增加 HelloService 的启动类

   在 com.alibaba.dubbo.samples.service.hello.Application 中通过 ClassPathXmlApplicationContext 读取 刚才配置的 spring/hello-service.xml 来初始化一个 spring context 并启动

   package com.alibaba.dubbo.samples.service.hello;
   
   import org.springframework.context.support.ClassPathXmlApplicationContext;
   
   import java.io.IOException;
   
   public class Application {
       public static void main(String[] args) throws IOException {
           ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring/hello-service.xml");
           context.start();
   
           System.out.println("Hello service started");
           // press any key to exit
           System.in.read();
       }
   }

4. 暴露 GreetingService 服务，并使用 Zipkin

   在 resources/spring/greeting-service.xml 中配置 GreetingService。相关步骤与 HelloService 类似，不再赘述，重点关注如何在 GreetingService 中配置下游服务的依赖。完整的 XML 配置如下：

   <beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xmlns:dubbo="http://dubbo.apache.org/schema/dubbo"
          xmlns="http://www.springframework.org/schema/beans"
          xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
          http://dubbo.apache.org/schema/dubbo http://dubbo.apache.org/schema/dubbo/dubbo.xsd">
   
       <!-- 1. 定义 GreetingService 的应用名 -->
       <dubbo:application name="greeting-service-provider"/>
   
       <!-- 2. 指定注册中心地址 -->
       <dubbo:registry address="zookeeper://127.0.0.1:2181"/>
   
        <!-- 3. 使用 Dubbo 原生协议在 20881 端口上暴露服务 -->
       <dubbo:protocol name="dubbo" port="20881"/>
       
       <!-- 4. 声明 HelloService 的远程代理，并在 Dubbo 的 filter chain 中增加 tracing filter -->
       <dubbo:reference id="helloService" check="false" interface="com.alibaba.dubbo.samples.api.HelloService" filter="tracing"/>
       
       <!-- 5. 将 GreetingServiceImpl 的实现声明成一个 spring bean，并将 HelloService 的远程代理装配进去 -->
       <bean id="greetingService" class="com.alibaba.dubbo.samples.service.greeting.GreetingServiceImpl">
           <property name="helloService" ref="helloService"/>
       </bean>
   
       <!-- 6. 将 GreetingServiceImpl 声明成一个 Dubbo 服务，并在 Dubbo 的 filter chain 中增加 tracing filter -->
       <dubbo:service interface="com.alibaba.dubbo.samples.api.GreetingService" ref="greetingService" filter="tracing"/>
   
       <!-- 7. zipkin 相关的配置 -->
       <bean id="sender" class="zipkin2.reporter.beans.OkHttpSenderFactoryBean">
           <property name="endpoint" value="http://localhost:9411/api/v2/spans"/>
       </bean>
   
       <bean id="tracing" class="brave.spring.beans.TracingFactoryBean">
           <property name="localServiceName" value="greeting-service"/>
           <property name="spanReporter">
               <bean class="zipkin2.reporter.beans.AsyncReporterFactoryBean">
                   <property name="sender" ref="sender"/>
                   <!-- wait up to half a second for any in-flight spans on close -->
                   <property name="closeTimeout" value="500"/>
               </bean>
           </property>
           <property name="currentTraceContext">
               <bean class="brave.spring.beans.CurrentTraceContextFactoryBean">
                   <property name="scopeDecorators">
                       <bean class="brave.context.slf4j.MDCScopeDecorator" factory-method="create"/>
                   </property>
               </bean>
           </property>
       </bean>
   </beans>

   这里的配置与上面的 HelloService 类似，需要重点关注的有两点：

   • 第 3 步中注意服务需要暴露在不同的端口上，否则会和 HelloService 冲突，本例中选择的是 20881 这个端口
   • 通过第 4 步先声明 HelloService 的远程代理，然后在第 5 步中将其组装给 GreetingService 来完成服务上下游依赖的声明

   增加 GreeeingService 的启动类，与 HelloService 类似，通过 spring/greeting-service.xml 的配置来初始化一个新的 spring context 来完成。

   package com.alibaba.dubbo.samples.service.greeting;
   
   import org.springframework.context.support.ClassPathXmlApplicationContext;
   
   import java.io.IOException;
   
   public class Application {
       public static void main(String[] args) throws IOException {
           ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring/greeting-service.xml");
           context.start();
   
           System.out.println("Greeting service started");
           // press any key to exit
           System.in.read();
       }
   }

$ zkServer start

$ curl -sSL https://zipkin.io/quickstart.sh | bash -s
$ java -jar zipkin.jar

$ mvn exec:java -Dexec.mainClass=com.alibaba.dubbo.samples.service.hello.Application

$ mvn exec:java -Dexec.mainClass=com.alibaba.dubbo.samples.service.greeting.Application

$ mvn exec:java -Dexec.mainClass=com.alibaba.dubbo.samples.client.Application