Dubbo从入门到实战：实战篇
程序员文章站
2022-07-04 22:47:42
在前面的案例中，我们没有使用任何的注册中心，而是用一种直连的方式进行的。但是，实际上很多时候，我们都是使用 dubbo + zookeeper 的方式，使用 zookeeper 作为注册中心，这里，我们就介绍一下 zookeeper 作为注册中心的使用方法。 ......
一、加入 zookeeper 作为注册中心
在前面的案例中，我们没有使用任何的注册中心，而是用一种直连的方式进行的。但是，实际上很多时候，我们都是使用 dubbo + zookeeper 的方式，使用 zookeeper 作为注册中心，这里，我们就介绍一下 zookeeper 作为注册中心的使用方法。
这里，我们在前面的入门实例中进行改造。
1.1 服务端
在服务端中，我们只需要修改 provider.xml 即可。
<?xml version="1.0" encoding="utf-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/xmlschema-instance"
xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
xsi:schemalocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd">
<!--当前项目在整个分布式架构里面的唯一名称，计算依赖关系的标签-->
<dubbo:application name="provider" owner="sihai">
<dubbo:parameter key="qos.enable" value="true"/>
<dubbo:parameter key="qos.accept.foreign.ip" value="false"/>
<dubbo:parameter key="qos.port" value="55555"/>
</dubbo:application>
<dubbo:monitor protocol="registry"/>
<!--dubbo这个服务所要暴露的服务地址所对应的注册中心-->
<!--<dubbo:registry address="n/a"/>-->
<dubbo:registry address="zookeeper://localhost:2181" check="false"/>
<!--当前服务发布所依赖的协议；webserovice、thrift、hessain、http-->
<dubbo:protocol name="dubbo" port="20880"/>
<!--服务发布的配置，需要暴露的服务接口-->
<dubbo:service
interface="com.sihai.dubbo.provider.service.providerservice"
ref="providerservice"/>
<!--bean bean定义-->
<bean id="providerservice" class="com.sihai.dubbo.provider.service.providerserviceimpl"/>
</beans>
重点关注这句话
<dubbo:registry address="zookeeper://localhost:2181" />
在 address 中，使用我们的 zookeeper 的地址。
如果是 zookeeper 集群 的话，使用下面的方式。
<dubbo:registry protocol="zookeeper" address="192.168.11.129:2181,192.168.11.137:2181,192.168.11.138:2181"/>
服务端的配置就好了，其他的跟 入门案例 一样。
1.2 消费端
跟服务端一样，在消费端，我们也只需要修改 consumer.xml 即可。
<?xml version="1.0" encoding="utf-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/xmlschema-instance"
xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
xsi:schemalocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd">
<!--当前项目在整个分布式架构里面的唯一名称，计算依赖关系的标签-->
<dubbo:application name="consumer" owner="sihai"/>
<!--dubbo这个服务所要暴露的服务地址所对应的注册中心-->
<!--点对点的方式-->
<!--<dubbo:registry address="n/a" />-->
<dubbo:registry address="zookeeper://localhost:2181" check="false"/>
<!--生成一个远程服务的调用代理-->
<!--点对点方式-->
<!--<dubbo:reference id="providerservice"
interface="com.sihai.dubbo.provider.service.providerservice"
url="dubbo://192.168.234.1:20880/com.sihai.dubbo.provider.service.providerservice"/>-->
<dubbo:reference id="providerservice"
interface="com.sihai.dubbo.provider.service.providerservice"/>
</beans>
① 注册中心配置跟服务端一样。
<dubbo:registry address="zookeeper://localhost:2181"/>
② dubbo:reference 由于我们这里使用 zookeeper 作为注册中心，所以，跟点对点的方式是不一样的，这里不再需要 dubbo 服务端提供的 url 了，只需要直接引用服务端提供的接口即可。
<dubbo:reference id="providerservice"
interface="com.sihai.dubbo.provider.service.providerservice"/>
好了，消费端也配置好了，这样就可以使用 修改的入门案例 ，重新启动运行了。
同样成功了。
这时候的区别在于， 将 dubbo 发布的 url 注册到了 zookeeper，消费端从 zookeeper 消费，zookeeper 相当于一个中介，给消费者提供服务。
你以为这就完了？不，好戏才刚刚开始呢。
二、多种配置方式
在 入门实例 的时候，我们使用的是 xml 配置 的方式，对 dubbo 的环境进行了配置，但是，官方还提供了其他的配置方式，这里我们也一一分解。
2.1 api配置方式
这种方式其实官方是 不太推荐 的， 官方推荐使用 xml 配置的方式 ，但是，在有的时候测试的时候，还是可以用的到的，另外，为了保证完整性，这些内容还是有必要讲讲的。
首先还是回到服务端工程。
服务端
这里我们使用 api 的方式 配置，所以， provider.xml 这个配置文件就暂时不需要了，我们只需要在上面的 appapi 这个类中的 main 方法中用 api配置及启动即可。
package com.sihai.dubbo.provider;
import com.alibaba.dubbo.config.applicationconfig;
import com.alibaba.dubbo.config.protocolconfig;
import com.alibaba.dubbo.config.registryconfig;
import com.alibaba.dubbo.config.serviceconfig;
import com.sihai.dubbo.provider.service.providerservice;
import com.sihai.dubbo.provider.service.providerserviceimpl;
import java.io.ioexception;
/**
* api方式启动
* api的方式调用不需要其他的配置，只需要下面的代码即可。
* 但是需要注意，官方建议：
* api方式用于测试用例使用，推荐xml的方式
*/
public class appapi
{
public static void main( string[] args ) throws ioexception {
// 服务实现
providerservice providerservice = new providerserviceimpl();
// 当前应用配置
applicationconfig application = new applicationconfig();
application.setname("provider");
application.setowner("sihai");
// 连接注册中心配置
registryconfig registry = new registryconfig();
registry.setaddress("zookeeper://localhost:2181");
// registry.setusername("aaa");
// registry.setpassword("bbb");
// 服务提供者协议配置
protocolconfig protocol = new protocolconfig();
protocol.setname("dubbo");
protocol.setport(20880);
//protocol.setthreads(200);
// 注意：serviceconfig为重对象，内部封装了与注册中心的连接，以及开启服务端口
// 服务提供者暴露服务配置
serviceconfig<providerservice> service = new serviceconfig<providerservice>(); // 此实例很重，封装了与注册中心的连接，请自行缓存，否则可能造成内存和连接泄漏
service.setapplication(application);
service.setregistry(registry); // 多个注册中心可以用setregistries()
service.setprotocol(protocol); // 多个协议可以用setprotocols()
service.setinterface(providerservice.class);
service.setref(providerservice);
service.setversion("1.0.0");
// 暴露及注册服务
service.export();
}
}
分析
看到上面的代码是不是云里雾里，不要慌，我们通过对照 xml 的方式分析一下。
registry 的 xml 方式
<dubbo:registry protocol="zookeeper" address="localhost:2181"/>
api 的方式
registryconfig registry = new registryconfig();
registry.setaddress("zookeeper://localhost:2181");
dubbo:registry 节点对应 registryconfig ，xml 的 属性 对应 api 方式用 set 方法就可以了。对比之下，你就会发现，如果 api 的方式不熟悉，可以对照 xml 配置方式就可以。
其他 api
org.apache.dubbo.config.serviceconfig org.apache.dubbo.config.referenceconfig org.apache.dubbo.config.protocolconfig org.apache.dubbo.config.registryconfig org.apache.dubbo.config.monitorconfig org.apache.dubbo.config.applicationconfig org.apache.dubbo.config.moduleconfig org.apache.dubbo.config.providerconfig org.apache.dubbo.config.consumerconfig org.apache.dubbo.config.methodconfig org.apache.dubbo.config.argumentconfig
更详细的可以查看官方文档： dubbo.apache.org/zh-cn/docs/…
我们再看看我配置的消费端的 api 方式。
消费端
同样，我们不需要 consumer.xml 配置文件了，只需要在 main 方法中启动即可。
package com.sihai.dubbo.consumer;
import com.alibaba.dubbo.config.applicationconfig;
import com.alibaba.dubbo.config.referenceconfig;
import com.alibaba.dubbo.config.registryconfig;
import com.sihai.dubbo.provider.service.providerservice;
/**
* api的方式调用
* api的方式调用不需要其他的配置，只需要下面的代码即可。
* 但是需要注意，官方建议：
* api方式用于测试用例使用，推荐xml的方式
*/
public class appapi {
public static void main(string[] args) {
// 当前应用配置
applicationconfig application = new applicationconfig();
application.setname("consumer");
application.setowner("sihai");
// 连接注册中心配置
registryconfig registry = new registryconfig();
registry.setaddress("zookeeper://localhost:2181");
// 注意：referenceconfig为重对象，内部封装了与注册中心的连接，以及与服务提供方的连接
// 引用远程服务
referenceconfig<providerservice> reference = new referenceconfig<providerservice>(); // 此实例很重，封装了与注册中心的连接以及与提供者的连接，请自行缓存，否则可能造成内存和连接泄漏
reference.setapplication(application);
reference.setregistry(registry); // 多个注册中心可以用setregistries()
reference.setinterface(providerservice.class);
// 和本地bean一样使用xxxservice
providerservice providerservice = reference.get(); // 注意：此代理对象内部封装了所有通讯细节，对象较重，请缓存复用
providerservice.sayhello("hello dubbo! i am sihai!");
}
}
这部分的 api 配置的方式就到这了，注意： 官方推荐 xml 的配置方法 。
2.2 注解配置方式
注解配置方式还是需要了解一下的，现在微服务都倾向于这种方式，这也是以后发展的趋势，0 配置应该是这几年的趋势。
那么如何对 dubbo 使用注解的方式呢？我们先看服务端。
服务端
第一步：定义接口及实现类，在上面的截图中的 annotation 包下
package com.sihai.dubbo.provider.service.annotation;
/**
* 注解方式接口
*/
public interface providerserviceannotation {
string sayhelloannotation(string word);
}
package com.sihai.dubbo.provider.service.annotation;
import com.alibaba.dubbo.config.annotation.service;
/**
* 注解方式实现类
*/
@service(timeout = 5000)
public class providerserviceimplannotation implements providerserviceannotation{
public string sayhelloannotation(string word) {
return word;
}
}
@service
@service 用来配置 dubbo 的服务提供方。
**第二步：组装服务提供方。**通过 spring 中 java config 的技术（ @configuration ）和 annotation 扫描（ @enabledubbo ）来发现、组装、并向外提供 dubbo 的服务。
package com.sihai.dubbo.provider.configuration;
import com.alibaba.dubbo.config.applicationconfig;
import com.alibaba.dubbo.config.protocolconfig;
import com.alibaba.dubbo.config.providerconfig;
import com.alibaba.dubbo.config.registryconfig;
import com.alibaba.dubbo.config.spring.context.annotation.enabledubbo;
import org.springframework.context.annotation.bean;
import org.springframework.context.annotation.configuration;
/**
* 注解方式配置
*/
@configuration
@enabledubbo(scanbasepackages = "com.sihai.dubbo.provider.service.annotation")
public class dubboconfiguration {
@bean // #1 服务提供者信息配置
public providerconfig providerconfig() {
providerconfig providerconfig = new providerconfig();
providerconfig.settimeout(1000);
return providerconfig;
}
@bean // #2 分布式应用信息配置
public applicationconfig applicationconfig() {
applicationconfig applicationconfig = new applicationconfig();
applicationconfig.setname("dubbo-annotation-provider");
return applicationconfig;
}
@bean // #3 注册中心信息配置
public registryconfig registryconfig() {
registryconfig registryconfig = new registryconfig();
registryconfig.setprotocol("zookeeper");
registryconfig.setaddress("localhost");
registryconfig.setport(2181);
return registryconfig;
}
@bean // #4 使用协议配置，这里使用 dubbo
public protocolconfig protocolconfig() {
protocolconfig protocolconfig = new protocolconfig();
protocolconfig.setname("dubbo");
protocolconfig.setport(20880);
return protocolconfig;
}
}
分析
- 通过 @enabledubbo 指定在
com.sihai.dubbo.provider.service.annotation下扫描所有标注有@service的类 - 通过
@configuration将dubboconfiguration中所有的@bean通过java config的方式组装出来并注入给 dubbo 服务，也就是标注有@service的类。这其中就包括了：- providerconfig：服务提供方配置
- applicationconfig：应用配置
- registryconfig：注册中心配置
- protocolconfig：协议配置
看起来很复杂，其实。。。
第三步：启动服务
package com.sihai.dubbo.provider;
import com.alibaba.dubbo.config.spring.context.annotation.dubbocomponentscan;
import com.sihai.dubbo.provider.configuration.dubboconfiguration;
import org.springframework.context.annotation.annotationconfigapplicationcontext;
import sun.applet.main;
import java.io.ioexception;
/**
* 注解启动方式
*/
public class appannotation {
public static void main(string[] args) throws ioexception {
annotationconfigapplicationcontext context = new annotationconfigapplicationcontext(dubboconfiguration.class);
context.start();
system.in.read();
}
}
发现输出下面信息就表示 success 了。
消费端
同样我们下看看消费端的工程，有一个感性认识。
第一步：引用服务
package com.sihai.dubbo.consumer.annotation;
import com.alibaba.dubbo.config.annotation.reference;
import com.sihai.dubbo.provider.service.annotation.providerserviceannotation;
import org.springframework.stereotype.component;
/**
* 注解方式的service
*/
@component("annotatedconsumer")
public class consumerannotationservice {
@reference
private providerserviceannotation providerserviceannotation;
public string dosayhello(string name) {
return providerserviceannotation.sayhelloannotation(name);
}
}
在 consumerannotationservice 类中，通过 @reference 引用服务端提供的类，然后通过方法调用这个类的方式，给消费端提供接口。 **注意：**如果这里找不到 providerserviceannotation 类，请在服务端先把服务端工程用 maven intall 一下，然后将服务端的依赖放到消费端的 pom 中。如下：
<dependency>
<groupid>com.ouyangsihai</groupid>
<artifactid>dubbo-provider</artifactid>
<version>1.0-snapshot</version>
</dependency>
第二步：组装服务消费者这一步和服务端是类似的，这里就不在重复了。
package com.sihai.dubbo.consumer.configuration;
import com.alibaba.dubbo.config.applicationconfig;
import com.alibaba.dubbo.config.consumerconfig;
import com.alibaba.dubbo.config.registryconfig;
import com.alibaba.dubbo.config.spring.context.annotation.enabledubbo;
import org.springframework.context.annotation.bean;
import org.springframework.context.annotation.componentscan;
import org.springframework.context.annotation.configuration;
import java.util.hashmap;
import java.util.map;
/**
* 注解配置类
*/
@configuration
@enabledubbo(scanbasepackages = "com.sihai.dubbo.consumer.annotation")
@componentscan(value = {"com.sihai.dubbo.consumer.annotation"})
public class consumerconfiguration {
@bean // 应用配置
public applicationconfig applicationconfig() {
applicationconfig applicationconfig = new applicationconfig();
applicationconfig.setname("dubbo-annotation-consumer");
map<string, string> stringstringmap = new hashmap<string, string>();
stringstringmap.put("qos.enable","true");
stringstringmap.put("qos.accept.foreign.ip","false");
stringstringmap.put("qos.port","33333");
applicationconfig.setparameters(stringstringmap);
return applicationconfig;
}
@bean // 服务消费者配置
public consumerconfig consumerconfig() {
consumerconfig consumerconfig = new consumerconfig();
consumerconfig.settimeout(3000);
return consumerconfig;
}
@bean // 配置注册中心
public registryconfig registryconfig() {
registryconfig registryconfig = new registryconfig();
registryconfig.setprotocol("zookeeper");
registryconfig.setaddress("localhost");
registryconfig.setport(2181);
return registryconfig;
}
}
第三步：发起远程调用
在 main 方法中通过启动一个 spring context ，从其中查找到组装好的 dubbo 的服务消费者，并发起一次远程调用。
package com.sihai.dubbo.consumer;
import com.sihai.dubbo.consumer.annotation.consumerannotationservice;
import com.sihai.dubbo.consumer.configuration.consumerconfiguration;
import com.sihai.dubbo.provider.service.providerservice;
import org.springframework.context.annotation.annotationconfigapplicationcontext;
import org.springframework.context.support.classpathxmlapplicationcontext;
import java.io.ioexception;
/**
* 注解方式启动
*
*/
public class appannotation
{
public static void main( string[] args ) throws ioexception {
annotationconfigapplicationcontext context = new annotationconfigapplicationcontext(consumerconfiguration.class);
context.start(); // 启动
consumerannotationservice consumerannotationservice = context.getbean(consumerannotationservice.class);
string hello = consumerannotationservice.dosayhello("annotation"); // 调用方法
system.out.println("result: " + hello); // 输出结果
}
}
结果
三、常用场景
在下面的讲解中，都会是以 xml 配置的方式来讲解的，这也是 dubbo 官方比较推荐的方式。以下的操作都是在服务端的 xml 配置文件和消费端的配置文件来讲解的。
3.1 启动时检查
dubbo 缺省会在启动时检查依赖的服务是否可用，不可用时会抛出异常，阻止 spring 初始化完成，以便上线时，能及早发现问题，默认 `check="true"。
但是，有的时候，我们并不是都需要启动时就检查的，比如测试的时候，我们是需要更快速的启动，所以，这种场景的时候，我们是需要关闭这个功能的。
下面，我们看看如何使用这个功能。
在服务端注册的时候（客户端注册时同样适用）；
<dubbo:registry protocol="zookeeper" address="localhost:2181,localhost:2182,localhost:2183" check="false"/>
在客户端引用服务端服务的时候；
<dubbo:reference check="false" id="providerservice"
interface="com.sihai.dubbo.provider.service.providerservice"/>
就是这么简单，就是这么强！
3.2 集群容错
dubbo 也是支持集群容错的，同时也有很多可选的方案，其中，默认的方案是 failover ，也就是重试机制。
首先，我们先把所有的容错机制都整理一遍，然后再看看使用。
使用实例在发布服务或者引用服务的时候设置
<!--服务发布的配置，需要暴露的服务接口-->
<dubbo:service cluster="failover" retries="2"
interface="com.sihai.dubbo.provider.service.providerservice"
ref="providerservice"/>
<dubbo:reference cluster="failover" retries="2" check="false" id="providerservice"
interface="com.sihai.dubbo.provider.service.providerservice"/>
3.3 负载均衡
负载均衡想必是一个再熟悉不过的概念了，所以，dubbo 支持也是再正常不过了，这里也总结一下 dubbo 支持的负载均衡的一些方案及使用方法。
3.4 直连提供者
在开发及测试环境下，经常需要绕过注册中心，只测试指定服务提供者，所以，这种情况下，我们只需要直接连接服务端的地即可，其实，这种方法在前面的讲解已经使用到了，第一种讲解的方式就是这种方式，因为这种方式简单。
使用
<dubbo:reference id="providerservice"
interface="com.sihai.dubbo.provider.service.providerservice"
url="dubbo://192.168.234.1:20880/com.sihai.dubbo.provider.service.providerservice"/>
说明：可以看到，只要在消费端在 dubbo:reference 节点使用 url 给出服务端的方法即可。
3.5 只订阅
只订阅就是只能够订阅服务端的服务，而不能够注册。
引用官方的使用场景如下：
为方便开发测试，经常会在线下共用一个所有服务可用的注册中心，这时，如果一个正在开发中的服务提供者注册，可能会影响消费者不能正常运行。 可以让服务提供者开发方，只订阅服务(开发的服务可能依赖其它服务)，而不注册正在开发的服务，通过直连测试正在开发的服务。
<dubbo:registry register="false" protocol="zookeeper" address="localhost:2181,localhost:2182,localhost:2183" check="false"/>
① 使用只订阅方式
当在服务提供端使用 register="false" 的时候，我们使用下面的方式获取服务端的服务；
<dubbo:reference cluster="failover" retries="2" check="false" id="providerservice"
interface="com.sihai.dubbo.provider.service.providerservice"/>
启动信息
发现，这时候并不是向 注册中心 zookeeper 注册，而只是做了 发布服务和启动netty。
② 不使用只订阅方式
<dubbo:registry protocol="zookeeper" address="localhost:2181,localhost:2182,localhost:2183" check="false"/>
启动信息
可以发现，这里就向注册中心 zookeeper 注册了。
3.6 只注册
只注册正好跟前面的只订阅相反，这个时候可以向注册中心注册，但是，消费端却不能够读到服务。
应用场景
如果有两个镜像环境，两个注册中心，有一个服务只在其中一个注册中心有部署，另一个注册中心还没来得及部署，而两个注册中心的其它应用都需要依赖此服务。这个时候，可以让服务提供者方只注册服务到另一注册中心，而不从另一注册中心订阅服务。
使用说明
<dubbo:registry subscribe="false" address="localhost:2181"></dubbo:registry>
在服务端的 dubbo:registry 节点下使用 subscribe="false" 来声明这个服务是只注册的服务。
这个时候消费端调用的时候是不能调用的。
3.7 多协议机制
在前面我们使用的协议都是 dubbo 协议，但是 dubbo 除了支持这种协议外还支持其他的协议，比如，rmi、hessian等，另外，而且还可以用多种协议同时暴露一种服务。
使用方法
① 一种接口使用一种协议
先声明多种协议
<!--当前服务发布所依赖的协议；webserovice、thrift、hessain、http-->
<dubbo:protocol name="dubbo" port="20880"/>
<dubbo:protocol name="rmi" port="1099" />
然后在发布接口的时候使用具体协议
<!--服务发布的配置，需要暴露的服务接口-->
<dubbo:service cluster="failover" retries="2"
interface="com.sihai.dubbo.provider.service.providerservice"
ref="providerservice"/>
<dubbo:service cluster="failover" retries="2"
interface="com.sihai.dubbo.provider.service.providerservice"
ref="providerservice" protocol="rmi"/>
在输出日志中，就可以找到rmi发布的接口。
rmi://192.168.234.1:1099/com.sihai.dubbo.provider.service.providerservice?anyhost=true&application=provider&bean.name=com.sihai.dubbo.provider.service.providerservice&cluster=failover&dubbo=2.0.2&generic=false&interface=com.sihai.dubbo.provider.service.providerservice&methods=sayhello&owner=sihai&pid=796&retries=2&side=provider×tamp=1564281053185, dubbo version: 2.6.6, current host: 192.168.234.1
② 一种接口使用多种协议声明协议和上面的方式一样，在发布接口的时候有一点不一样。
<dubbo:service cluster="failover" retries="2"
interface="com.sihai.dubbo.provider.service.providerservice"
ref="providerservice" protocol="rmi,dubbo"/>
**说明：**protocol属性，可以用 , 隔开，使用多种协议。
3.8 多注册中心
dubbo 支持同一服务向多注册中心同时注册，或者不同服务分别注册到不同的注册中心上去，甚至可以同时引用注册在不同注册中心上的同名服务。
服务端多注册中心发布服务
一个服务可以在不同的注册中心注册，当一个注册中心出现问题时，可以用其他的注册中心。
注册
<!--多注册中心-->
<dubbo:registry protocol="zookeeper" id="reg1" timeout="10000" address="localhost:2181"/>
<dubbo:registry protocol="zookeeper" id="reg2" timeout="10000" address="localhost:2182"/>
<dubbo:registry protocol="zookeeper" id="reg3" timeout="10000" address="localhost:2183"/>
发布服务
<!--服务发布的配置，需要暴露的服务接口-->
<dubbo:service cluster="failover" retries="2"
interface="com.sihai.dubbo.provider.service.providerservice"
ref="providerservice" registry="reg1"/>
<dubbo:service cluster="failover" retries="2"
interface="com.sihai.dubbo.provider.service.providerservice"
ref="providerservice" protocol="rmi" registry="reg2"/>
**说明：**使用 registry="reg2" 指定该接口使用的注册中心，同时也可以使用多个，用 ，隔开，例如， registry="reg1,,reg2" 。
消费端多注册中心引用服务
首先，先向不同注册中心注册;
<!--多注册中心-->
<dubbo:registry protocol="zookeeper" id="reg1" timeout="10000" address="localhost:2181"/>
<dubbo:registry protocol="zookeeper" id="reg2" timeout="10000" address="localhost:2182"/>
<dubbo:registry protocol="zookeeper" id="reg3" timeout="10000" address="localhost:2183"/>
其次，不同的消费端服务引用使用不同的注册中心；
<!--不同的服务使用不同的注册中心-->
<dubbo:reference cluster="failover" retries="2" check="false" id="providerservice"
interface="com.sihai.dubbo.provider.service.providerservice" registry="reg1"/>
<dubbo:reference cluster="failover" retries="2" check="false" id="providerservice2"
interface="com.sihai.dubbo.provider.service.providerservice" registry="reg2"/>
**说明：**上面分别使用注册中心1和注册中心2。
3.9 多版本
不同的服务是有版本不同的，版本可以更新并且升级，同时，不同的版本之间是不可以调用的。
<!--服务发布的配置，需要暴露的服务接口-->
<dubbo:service cluster="failover" retries="2"
interface="com.sihai.dubbo.provider.service.providerservice"
ref="providerservice" registry="reg1" version="1.0.0"/>
<dubbo:service cluster="failover" retries="2"
interface="com.sihai.dubbo.provider.service.providerservice"
ref="providerservice" protocol="rmi" registry="reg2" version="1.0.0"/>
加入了版本控制。
3.10 日志管理
dubbo 也可以将日志信息记录或者保存到文件中的。
① 使用accesslog输出到log4j
<dubbo:protocol accesslog="true" name="dubbo" port="20880"/>
<dubbo:protocol accesslog="true" name="rmi" port="1099" />
② 输出到文件
<dubbo:protocol accesslog="http://localhost/log.txt" name="dubbo" port="20880"/>
<dubbo:protocol accesslog="http://localhost/log2.txt" name="rmi" port="1099" />
四、总结
这系列的文章就到这里了，主要讲了一下几个内容 1、为什么需要dubbo 2、dubbo架构简析 3、dubbo入门 4、zookeeper注册中心加入dubbo 5、dubbo多种配置方式（xml、api、注解） 6、常用场景介绍 下一篇文章，将讲讲源码分析。
文章有不当之处，欢迎指正，如果喜欢微信阅读，你也可以关注我的 微信公众号 ：
java技术zhai，获取优质学习资源。免费java高级资料需要自己领取，涵盖了java、redis、mongodb、mysql、zookeeper、spring cloud、dubbo高并发分布式等教程，一共40g。
传送门： https://mp.weixin.qq.com/s/dhcu6akf4nz4hnov9c0izg
上一篇： 曾经天真的以为单例只有懒汉和恶汉两种！原来单例模式还能被破解！！！
下一篇： 新交一女朋友