准备工作： 1、在idea中打开demo代码 2、启动zookeeper

一、下载dubbo-demo

dubbo的代码托管在了github上，并为开发者提供了丰富的演示案例：https://github.com/apache/dubbo

可通过git命令拉取demo代码：

$ git clone https://github.com/apache/dubbo-samples.git

拉取成功后用idea打开并导入为maven项目，会自动下载依赖项。

注意：目前dubbo最新版已升级到3.0.1。此处下载的演示代码默认版本为2.7.7

二、api方式

demo结构（dubbo-samples-api）：

1、服务接口与实现

获取消费者传入的name参数，返回拼装好的 'hi' + name

2、服务提供者

src/main/java/org/apache/dubbo/samples/provider/Application.java

package org.apache.dubbo.samples.provider;
import org.apache.dubbo.config.ApplicationConfig;
import org.apache.dubbo.config.RegistryConfig;
import org.apache.dubbo.config.ServiceConfig;
import org.apache.dubbo.samples.api.GreetingsService;
import java.util.concurrent.CountDownLatch;
public class Application {
    // 获取系统中的属性，不存在则取传入的默认值
    private static String zookeeperHost = System
            .getProperty("zookeeper.address", "192.168.203.128");
    private static String zookeeperPort = System.getProperty("zookeeper.port",
            "2181");
    public static void main(String[] args) throws Exception {
        // 服务提供者实例，内部封装了与注册中心的连接和开启服务端口操作等所有通讯细节
        // 实例开销大，实际开发时需要做缓存，否则容易造成内存和连接泄露
        ServiceConfig<GreetingsService> service = new ServiceConfig<>();
        // 暴露服务配置
        // 设置应用名称
        service.setApplication(new ApplicationConfig("first-dubbo-provider"));
        // 设置注册中心配置 多个注册中心可用setRegistries()
        service.setRegistry(new RegistryConfig(
                "zookeeper://" + zookeeperHost + ":" + zookeeperPort));
        // 设置对外提供的服务接口
        service.setInterface(GreetingsService.class);
        // 设置服务接口的实现类
        service.setRef(new GreetingsServiceImpl());
        // 开放服务端口
        service.export();
        System.out.println("dubbo service started");
        // 阻塞当前线程，维持服务提供者状态
        new CountDownLatch(1).await();
    }
}

除此之外，还有其他信息也可以通过api方式来设置：

// 服务版本信息
service.setVersion("1.0.0");
// 服务提供者协议配置 默认dubbo协议    
ProtocolConfig protocol = new ProtocolConfig();
protocol.setName("dubbo");
protocol.setPort(12345);
protocol.setThreads(200);
// 多个协议可用setProtocols()
service.setProtocol(protocol);

3、服务消费者

src/main/java/org/apache/dubbo/samples/client/Application.java

package org.apache.dubbo.samples.client;
import org.apache.dubbo.config.ApplicationConfig;
import org.apache.dubbo.config.ReferenceConfig;
import org.apache.dubbo.config.RegistryConfig;
import org.apache.dubbo.samples.api.GreetingsService;
public class Application {
    private static String zookeeperHost = System
            .getProperty("zookeeper.address", "192.168.203.128");
    private static String zookeeperPort = System.getProperty("zookeeper.port",
            "2181");
    public static void main(String[] args) {
        // 服务引用者实例，内部封装了与注册中心的连接和开启服务端口操作等所有通讯细节
        // 实例较重，实际开发时需要做缓存，否则容易造成内存和连接泄露
        ReferenceConfig<GreetingsService> reference = new ReferenceConfig<>();
        // 引用远程服务配置
        // 设置应用名称
        reference.setApplication(new ApplicationConfig("first-dubbo-consumer"));
        // 设置注册中心配置 多个注册中心可以用setRegistries()
        reference.setRegistry(new RegistryConfig(
                "zookeeper://" + zookeeperHost + ":" + zookeeperPort));
        // 设置引用的服务接口
        reference.setInterface(GreetingsService.class);
        // 和本地使用接口一样使用服务
        GreetingsService service = reference.get();
        String message = service.sayHi("dubbo");
        System.out.println(message);
    }
}

除此之外，还有其他信息也可以通过api方式来设置：

// 设置版本信息
reference.setVersion("1.0.0")

4、测试

运行服务提供者与服务消费者的main方法，查看控制台输出日志：


进入虚机查看zookeeper中的服务信息：

# 连接zookeeper客户端
$ [root@localhost zookeeper]# bin/zkCli.sh -server 127.0.0.1:2181
# 查看所有dubbo服务
$ ls /dubbo

5、补充

方法级别设置

// 方法级配置
List<MethodConfig> methods = new ArrayList<MethodConfig>();
MethodConfig method = new MethodConfig();
method.setName("sayHi");
// 设置方法连接超时时间（单位毫秒）
method.setTimeout(10000);
// 设置失败重试次数
method.setRetries(0);
methods.add(method);
// 引用远程服务
ReferenceConfig<GreetingsService> reference = new ReferenceConfig<GreetingsService>();
// 设置方法级配置
reference.setMethods(methods);

点对点直连（需要设置接口）

ReferenceConfig<GreetingsService> reference = new ReferenceConfig<GreetingsService>();
// 如果点对点直连，可以用reference.setUrl()指定目标地址，设置url后将绕过注册中心，
// 其中，协议对应provider.setProtocol()的值，端口对应provider.setPort()的值，
// 路径对应service.setPath()的值，如果未设置path，缺省path为接口名
reference.setUrl("dubbo://127.0.0.1:20880/org.apache.dubbo.samples.api.GreetingsService");

三、xml配置方式

demo结构（dubbo-samples-basic）：

1、服务接口与实现

2、服务提供者

src/main/resources/spring/dubbo-demo-provider.xml

<?xml version="1.0" encoding="UTF-8"?>
<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" xmlns:context="http://www.springframework.org/schema/context"
       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 http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
    <context:property-placeholder/>
    <!--应用名称-->
    <dubbo:application name="demo-provider"/>
    <!--注册中心配置 此案例开启了嵌入式zookeeper，可以不配置虚机的zookeeper地址-->
    <dubbo:registry address="zookeeper://${zookeeper.address:127.0.0.1}:2181"/>
    <!--开启令牌验证，随机生成动态令牌-->
    <dubbo:provider token="true"/>
    <!--注入接口实现类-->
    <bean id="demoService" class="org.apache.dubbo.samples.basic.impl.DemoServiceImpl"/>
    <!--服务提供者对外暴露接口-->
    <dubbo:service interface="org.apache.dubbo.samples.basic.api.DemoService" ref="demoService"/>
</beans>

src/main/java/org/apache/dubbo/samples/basic/BasicProvider.java

package org.apache.dubbo.samples.basic;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import java.util.concurrent.CountDownLatch;
public class BasicProvider {
    public static void main(String[] args) throws Exception {
        // 启动独立的嵌入式zookeeper实例
        new EmbeddedZooKeeper(2181, false).start();
        // 等待zookeeper启动
        Thread.sleep(1000);
        // spring加载配置文件
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring/dubbo-demo-provider.xml");
        // 启动容器
        context.start();
        System.out.println("dubbo service started");
        new CountDownLatch(1).await();
    }
}

3、服务消费者

src/main/resources/spring/dubbo-demo-consumer.xml

<?xml version="1.0" encoding="UTF-8"?>
<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" xmlns:context="http://www.springframework.org/schema/context"
       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 http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
    <context:property-placeholder/>
    <!--应用名称-->
    <dubbo:application name="demo-consumer"/>
    <!--注册中心配置 此案例开启了嵌入式zookeeper，可以不配置虚机的zookeeper地址-->
    <dubbo:registry address="zookeeper://${zookeeper.address:127.0.0.1}:2181"/>
    <!--服务消费者引用已提供的接口-->
    <dubbo:reference id="demoService" check="true" interface="org.apache.dubbo.samples.basic.api.DemoService"/>
</beans>

src/main/java/org/apache/dubbo/samples/basic/BasicConsumer.java

package org.apache.dubbo.samples.basic;
import org.apache.dubbo.samples.basic.api.DemoService;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class BasicConsumer {
    public static void main(String[] args) {
        // spring加载配置文件
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring/dubbo-demo-consumer.xml");
        // 启动容器
        context.start();
        // 从容器中获取服务接口
        DemoService demoService = (DemoService) context.getBean("demoService");
        // 调用服务
        String hello = demoService.sayHello("world");
        System.out.println(hello);
//        System.out.println("start void test...");
//        demoService.testVoid();
    }
}

4、测试

运行服务提供者与服务消费者的main方法，查看控制台输出日志：

5、补充

src/main/java/org/apache/dubbo/samples/basic/EmbeddedZooKeeper.java：

用于启动独立（非集群）zooKeeper 的嵌入式实例的 Helper 类，可以不用为测试代码单独搭建zookeeper实例。
spring-xd（大数据）包中有集成：org.springframework.xd.dirt.zookeeper.EmbeddedZooKeeper

四、annotation注解方式

demo结构（dubbo-samples-annotation）：

1、服务接口与实现

注意：本案例中Notify接口与实现类并未使用

2、服务提供者

src/main/resources/spring/dubbo-provider.properties

# dubbo应用名称
dubbo.application.name=samples-annotation-provider
# 注册中心配置连接地址
dubbo.registry.address=zookeeper://${zookeeper.address:127.0.0.1}:2181
# 配置传输协议
dubbo.protocol.name=dubbo
# 协议端口
dubbo.protocol.port=20880
# 开启随随机令牌，用于身份校验
dubbo.provider.token=true

src/main/java/org/apache/dubbo/samples/annotation/config/ProviderConfiguration.java

package org.apache.dubbo.samples.annotation.config;
import org.apache.dubbo.config.ProviderConfig;
import org.apache.dubbo.config.spring.context.annotation.EnableDubbo;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
// 声明这是一个spring配置类
@Configuration
// 开启dubbo，声明并装载扫描包下所有的dubbo服务
@EnableDubbo(scanBasePackages = "org.apache.dubbo.samples.annotation.impl")
// 声明properties配置文件
@PropertySource("classpath:/spring/dubbo-provider.properties")
public class ProviderConfiguration {
    @Bean
    public ProviderConfig providerConfig() {
        ProviderConfig providerConfig = new ProviderConfig();
        // 配置服务提供者连接的超时时间
        providerConfig.setTimeout(1000);
        return providerConfig;
    }
}

src/main/java/org/apache/dubbo/samples/annotation/AnnotationProviderBootstrap.java

package org.apache.dubbo.samples.annotation;
import org.apache.dubbo.samples.annotation.config.ProviderConfiguration;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import java.util.concurrent.CountDownLatch;
public class AnnotationProviderBootstrap {
    public static void main(String[] args) throws Exception {
        // 启动嵌入式zookeeper
        new EmbeddedZooKeeper(2181, false).start();
        // 加载配置类作为启动容器上下文
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(ProviderConfiguration.class);
        context.start();
        System.out.println("dubbo service started.");
        new CountDownLatch(1).await();
    }
}

3、服务消费者

src/main/resources/spring/dubbo-consumer.properties

# dubbo应用名称
dubbo.application.name=samples-annotation-consumer
# 配置注册中心连接地址
dubbo.registry.address=zookeeper://${zookeeper.address:127.0.0.1}:2181
# 服务消费者超时时间配置，注意：一个服务的调用超时时间会以消费者配置为准
dubbo.consumer.timeout=1000

src/main/java/org/apache/dubbo/samples/annotation/action/AnnotationAction.java

package org.apache.dubbo.samples.annotation.action;
import org.apache.dubbo.config.annotation.DubboReference;
import org.apache.dubbo.config.annotation.Method;
import org.apache.dubbo.samples.annotation.AnnotationConstants;
import org.apache.dubbo.samples.annotation.api.GreetingService;
import org.apache.dubbo.samples.annotation.api.HelloService;
import org.springframework.stereotype.Component;
// 声明组件名，项目启动时被扫描并装载进spring容器
@Component("annotationAction")
public class AnnotationAction {
    // 声明并注入dubbo服务引用，配置服务接口、版本
    @DubboReference(interfaceClass = HelloService.class, version = AnnotationConstants.VERSION)
    private HelloService helloService;
    // 声明并注入dubbo服务引用，配置服务接口、版本、超时时间、方法（方法名、超时时间、失败重试次数）
    @DubboReference(interfaceClass = GreetingService.class,
            version = AnnotationConstants.VERSION,
            timeout = 1000,
            methods = {@Method(name = "greeting", timeout = 3000, retries = 1)})
    private GreetingService greetingService;
    public String doSayHello(String name) {
        try {
            return helloService.sayHello(name);
        } catch (Exception e) {
            e.printStackTrace();
            return "Throw Exception";
        }
    }
    public String doSayGoodbye(String name) {
        try {
            return helloService.sayGoodbye(name);
        } catch (Exception e) {
            e.printStackTrace();
            return "Throw Exception";
        }
    }
    public String doGreeting(String name) {
        try {
            return greetingService.greeting(name);
        } catch (Exception e) {
            e.printStackTrace();
            return "Throw Exception";
        }
    }
    public String replyGreeting(String name) {
        try {
            return greetingService.replyGreeting(name);
        } catch (Exception e) {
            e.printStackTrace();
            return "Throw Exception";
        }
    }
}

src/main/java/org/apache/dubbo/samples/annotation/config/ConsumerConfiguration.java

package org.apache.dubbo.samples.annotation.config;
import org.apache.dubbo.config.spring.context.annotation.EnableDubbo;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
// 声名这是一个spring配置类
@Configuration
// 开启dubbo，项目启动时扫描并装载包下的所有dubbo服务
@EnableDubbo(scanBasePackages = "org.apache.dubbo.samples.annotation.action")
// 引用properties配置
@PropertySource("classpath:/spring/dubbo-consumer.properties")
// 包扫描，将扫描到的类装载进容器
@ComponentScan(value = {"org.apache.dubbo.samples.annotation.action"})
public class ConsumerConfiguration {
}

src/main/java/org/apache/dubbo/samples/annotation/AnnotationConsumerBootstrap.java

package org.apache.dubbo.samples.annotation;
import org.apache.dubbo.samples.annotation.action.AnnotationAction;
import org.apache.dubbo.samples.annotation.config.ConsumerConfiguration;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class AnnotationConsumerBootstrap {
    public static void main(String[] args) {
        // 加载配置类作为启动容器上下文
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(ConsumerConfiguration.class);
        context.start();
        // 从容器中获取对象（annotationAction中引用了dubbo服务）
        final AnnotationAction annotationAction = (AnnotationAction) context.getBean("annotationAction");
        System.out.println("hello : " + annotationAction.doSayHello("world"));
        System.out.println("goodbye : " + annotationAction.doSayGoodbye("world"));
        System.out.println("greeting : " + annotationAction.doGreeting("world"));
        System.out.println("reply : " + annotationAction.replyGreeting("world"));
    }
}

4、测试

运行服务提供者与服务消费者的main方法，查看控制台输出日志：

五、配置总结

1、归纳

2、配置之间的关系

3、配置优先级顺序

以 timeout 为例，下图显示了配置的查找顺序，其它 retries, loadbalance, actives 等类似：

• 方法级优先，接口级次之，全局配置再次之。
• 如果级别一样，则消费方优先，提供方次之。（注意：建议由服务提供方设置超时，因为一个方法需要执行多长时间，服务提供方更清楚，如果一个消费方同时引用多个服务，就不需要关心每个服务的超时设置）。

所有配置最终都将转换为 URL 表示，并由服务提供方生成，经注册中心传递给消费方。

理论上 ReferenceConfig 中除了interface这一项，其他所有配置项都可以缺省不配置，框架会自动使用ConsumerConfig，ServiceConfig, ProviderConfig等提供的缺省配置。

引用缺省是懒加载的，只有引用被注入到其它 Bean，或被 getBean() 获取时，才会初始化。如果需要饿加载（没有人引用也立即生成动态代理），可以配置：<dubbo:reference ... init="true" />

4、属性配置

可以将 xml 的 tag 名和属性名组合起来，用 ‘.’ 分隔。每行一个属性。

• dubbo.application.name=foo 相当于 <dubbo:application name="foo" />
• dubbo.registry.address=10.20.153.10:9090 相当于 <dubbo:registry address="10.20.153.10:9090" />

如果在 xml 配置中有超过一个的 tag，那么你可以使用 ‘id’ 进行区分。如果你不指定 id，它将作用于所有 tag。

• dubbo.protocol.rmi.port=1099 相当于 <dubbo:protocol id="rmi" name="rmi" port="1099" />
• dubbo.registry.china.address=10.20.153.10:9090 相当于 <dubbo:registry id="china" address="10.20.153.10:9090" />

优先级从高到低：

• JVM -D 参数：当你部署或者启动应用时，它可以轻易地重写配置，比如，改变 dubbo 协议端口；
• XML：XML 中的当前配置会重写 dubbo.properties 中的；
• Properties：默认配置，仅仅作用于以上两者没有配置时。
  1. 如果在 classpath 下有超过一个 dubbo.properties 文件，比如，两个 jar 包都各自包含了 dubbo.properties，dubbo 将随机选择一个加载，并且打印错误日志。
  2. 如果 id 没有在 protocol 中配置，将使用 name 作为默认属性。

5、全部配置

1）dubbo:service

服务提供者暴露服务配置。对应的配置类：org.apache.dubbo.config.ServiceConfig

2）dubbo:reference

服务消费者引用服务配置。对应的配置类： org.apache.dubbo.config.ReferenceConfig

3）dubbo:protocol

服务提供者协议配置。对应的配置类： org.apache.dubbo.config.ProtocolConfig。同时，如果需要支持多协议，可以声明多个 <dubbo:protocol> 标签，并在 <dubbo:service> 中通过 protocol 属性指定使用的协议。

4）dubbo:application

应用信息配置。对应的配置类：org.apache.dubbo.config.ApplicationConfig

| architecture

| string | 可选 |
| 服务治理 | 用于服务分层对应的架构。如，intl、china。不同的架构使用不同的分层。 | 2.0.7以上版本 | | environment | environment | string | 可选 |
| 服务治理 | 应用环境，如：develop/test/product，不同环境使用不同的缺省值，以及作为只用于开发测试功能的限制条件 | 2.0.0以上版本 | | compiler | compiler | string | 可选 | javassist | 性能优化 | Java字节码编译器，用于动态类的生成，可选：jdk或javassist | 2.1.0以上版本 | | logger | logger | string | 可选 | slf4j | 性能优化 | 日志输出方式，可选：slf4j,jcl,log4j,log4j2,jdk | 2.2.0以上版本 |

5）dubbo:module

模块信息配置。对应的配置类 org.apache.dubbo.config.ModuleConfig

6）dubbo:registry

注册中心配置。对应的配置类： org.apache.dubbo.config.RegistryConfig。同时如果有多个不同的注册中心，可以声明多个 <dubbo:registry> 标签，并在 <dubbo:service> 或 <dubbo:reference> 的 registry 属性指定使用的注册中心。

7）dubbo:monitor

监控中心配置。对应的配置类： org.apache.dubbo.config.MonitorConfig

8）dubbo:provider

服务提供者缺省值配置。对应的配置类： org.apache.dubbo.config.ProviderConfig。同时该标签为 <dubbo:service> 和 <dubbo:protocol>标签的缺省值设置。

9）dubbo:consumer

服务消费者缺省值配置。配置类： org.apache.dubbo.config.ConsumerConfig 。同时该标签为 <dubbo:reference>标签的缺省值设置。

10）dubbo:method

方法级配置。对应的配置类： org.apache.dubbo.config.MethodConfig。同时该标签为 <dubbo:service> 或 <dubbo:reference> 的子标签，用于控制到方法级。比如:

<dubbo:reference interface="com.xxx.XxxService">
    <dubbo:method name="findXxx" timeout="3000" retries="2" />
</dubbo:reference>

11）dubbo:argument

方法参数配置。对应的配置类： org.apache.dubbo.config.ArgumentConfig。该标签为 的子标签，用于方法参数的特征描述，比如：

<dubbo:method name="findXxx" timeout="3000" retries="2">
    <dubbo:argument index="0" callback="true" />
</dubbo:method>

12）dubbo:config-center

配置中心。对应的配置类：org.apache.dubbo.config.ConfigCenterConfig

13）dubbo:parameter

选项参数配置。对应的配置类：java.util.Map。同时该标签为<dubbo:protocol>或<dubbo:service>或<dubbo:provider>或<dubbo:reference>或<dubbo:consumer>的子标签，用于配置自定义参数，该配置项将作为扩展点设置自定义参数使用。比如：

<dubbo:protocol name="napoli">
    <dubbo:parameter key="http://10.20.160.198/wiki/display/dubbo/napoli.queue.name" value="xxx" />
</dubbo:protocol>
<!--或-->
<dubbo:protocol name="jms" p:queue="xxx" />

六、常见问题

1、连接超时

1）连接注册中心

连接报错：

Caused by: java.lang.IllegalStateException: zookeeper not connected at org.apache.dubbo.remoting.zookeeper.curator.CuratorZookeeperClient. (CuratorZookeeperClient.java:80) … 34 more

dubbo连接zookeeper，注册中心请求超时时间(毫秒)会由两个配置影响：
注册中心registry默认5s，配置中心config默认3s
跟踪源代码，发现dubbo会先在注册中心中找timeout配置，不存在则取配置中心默认的配置：


可通过更改超时时间解决。
基于xml：

<dubbo:registry address="zookeeper://${zookeeper.address:localhost}:2181"  timeout="5000"/>
<!--或-->
<dubbo:config-center timeout="5000"></dubbo:config-center>

基于properties/yml：

dubbo.registry.timeout=5000

也直接在url后添加参数（不推荐）：

dubbo.registry.address=zookeeper://${zookeeper.address:localhost}:${zookeeper.port:2181}?timeout=5000

2）连接服务

报错：

Caused by: com.alibaba.dubbo.remoting.TimeoutException: Waiting server-side response timeout. start time: 2017-08-0518:14:52.751, end time: 2017-08-0518:14:53.764, client elapsed: 6 ms, server elapsed: 1006 ms, timeout: 1000 ms, request: Request [id=0, version=2.0.0, twoway=true, event=false, broken=false, data=RpcInvocation [methodName=getCommentsByProductId, parameterTypes=[classjava.lang.Long], arguments=[1], attachments={traceId=6299543007105572864, spanId=6299543007105572864, input=259, path=com.jim.framework.dubbo.core.service.CommentService, interface=com.jim.framework.dubbo.core.service.CommentService, version=0.0.0}]]

dubbo的超时是针对客户端的，dubbo默认采用了netty做为网络组件，它属于一种NIO的模式。消费端发起远程请求后，线程不会阻塞等待服务端的返回，而是马上得到一个ResponseFuture，消费端通过不断的轮询机制判断结果是否有返回。因为是通过轮询，轮询有个需要特别注要的就是避免死循环，所以为了解决这个问题就引入了超时机制，只在一定时间范围内做轮询，如果超时时间就返回超时异常。
虽然超时了，但仅仅是消费端不再等待服务端的反馈，并不代表此时服务端也停止了执行。

可以通过更改超时时间解决。
服务消费者：

• 全局控制

  <dubbo:consumer timeout="1000"></dubbo:consumer>

• 接口控制

  <dubbo:reference timeout="1000"></dubbo:reference>

• 方法控制

  <dubbo:method timeout="1000"></dubbo:method>

  服务提供者：

• 全局控制

  <dubbo:provider timeout="1000"></dubbo:provider>

• 接口控制

  <dubbo:service timeout="1000"></dubbo:service>

• 方法控制

  <dubbo:method timeout="1000"></dubbo:method>

参考资料： Dubbo 官方文档