Dubbo從入門到實戰：實戰篇

 

一、加入 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&timestamp=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