Dubbo 一篇文章就够了：Dubbo遇到初恋
文章目錄
- 一 為什么需要 dubbo
- 二 Dubbo 技術架構
- 三 Dubbo 開始入門
- 3.1 服務端
- 接口定義
- 導入 maven 依賴
- 暴露接口（xml 配置方法）
- 發布接口
- 3.2 消費端
- 消費端環境配置
- maven 依賴
- 調用服務
- 四 加入 zookeeper 作為注冊中心
- 4.1 服務端
- 4.2 消費端
- 五 多種配置方式
- 5.1 API配置方式
- 服務端
- 消費端
- 5.2 注解配置方式
- 服務端
- 消費端
- 六 常用場景
- 6.1 啟動時檢查
- 6.2 集群容錯
- 6.3 負載均衡
- 6.4 直連提供者
- 6.5 只訂閱
- 6.6 只注冊
- 6.7 多協議機制
- 6.8 多注冊中心
- 服務端多注冊中心發布服務
- 消費端多注冊中心引用服務
- 6.9 多版本
- 6.10 日志管理
- 七 總結
一 為什么需要 dubbo
很多時候，其實我們使用這個技術的時候，可能都是因為項目需要，所以，我們就用了，但是，至于為什么我們需要用到這個技術，可能自身并不是很了解的，但是，其實了解技術的來由及背景知識，對于理解一項技術還是有幫助的，那么，dubbo是怎么被提上日程的呢？
在互聯網的發展過程中，在以前，我們只需要一個服務器，將程序全部打包好就可以，但是，隨著流量的增大，常規的垂直應用架構已無法應對，所以，架構就發生了演變。
1 單一應用架構
2 應用和數據庫單獨部署
3 應用和數據庫集群部署
4 數據庫壓力變大，讀寫分離
5 使用緩存技術加快速度
6 數據庫分庫分表
7 應用分為不同的類型拆分
發展到這個階段的時候，我們發現，應用與應用之間的關系已經十分的復雜了，就會出現以下幾個問題（以下摘錄于官網）：
① 當服務越來越多時，服務 URL 配置管理變得非常困難，F5 硬件負載均衡器的單點壓力也越來越大。
② 當進一步發展，服務間依賴關系變得錯蹤復雜，甚至分不清哪個應用要在哪個應用之前啟動，架構師都不能完整的描述應用的架構關系。
③ 接著，服務的調用量越來越大，服務的容量問題就暴露出來，這個服務需要多少機器支撐？什么時候該加機器？
為了解決這由于架構的演變所產生的問題幾個問題，于是，dubbo 產生了。當然，解決這個問題的技術不止 dubbo 。
從上面 Dubbo 的服務治理圖我們就可以看到，Duboo 很好了解決了上面所出現的一些問題。
所以，當你的系統架構發展到了這種階段的時候，就需要考慮使用 Dubbo 了。
二 Dubbo 技術架構
我們已經非常清楚的知道為什么在我們的系統中需要 Dubbo 這項技術了，下面，我們接著嘮叨嘮叨 Dubbo 的架構。
首先，上一張圖（摘自官網）。
看到圖之后，可能你對上面的幾個概念還是一臉懵逼，無從下手，下面，帶你看看這幾個角色到底是什么意思？
節點角色說明
| Provider | 暴露服務的服務提供方 |
| Consumer | 調用遠程服務的服務消費方 |
| Registry | 服務注冊與發現的注冊中心 |
| Monitor | 統計服務的調用次數和調用時間的監控中心 |
| Container | 服務運行容器 |
看了這幾個概念后似乎發現，其實 Dubbo 的架構也是很簡單的（其實現細節是復雜的），為什么這么說呢，有沒有發現，其實很像生產者-消費者模型。只是在這種模型上，加上了注冊中心和監控中心，用于管理提供方提供的url，以及管理整個過程。
那么，整個發布-訂閱的過程就非常的簡單了。
- 啟動容器，加載，運行服務提供者。
- 服務提供者在啟動時，在注冊中心發布注冊自己提供的服務。
- 服務消費者在啟動時，在注冊中心訂閱自己所需的服務。
如果考慮失敗或變更的情況，就需要考慮下面的過程。
- 注冊中心返回服務提供者地址列表給消費者，如果有變更，注冊中心將基于長連接推送變更數據給消費者。
- 服務消費者，從提供者地址列表中，基于軟負載均衡算法，選一臺提供者進行調用，如果調用失敗，再選另一臺調用。
- 服務消費者和提供者，在內存中累計調用次數和調用時間，定時每分鐘發送一次統計數據到監控中心。
通過這番講解，我相信 Dubbo 的架構我們也輕車熟路了，那就直接入手，開車吧。
三 Dubbo 開始入門
終于走到這一步了，寫到這里停了大概一周的時間，主要原因還是最近項目太忙，趕著交差呢，今天希望能一鼓作氣，完完整整的寫完 dubbo 的基礎篇！
3.1 服務端
首先，我們先把服務端的接口寫好，因為其實 dubbo 的作用簡單來說就是給消費端提供接口。
接口定義
/*** xml方式服務提供者接口*/ public interface ProviderService {String SayHello(String word); }這個接口非常簡單，只是包含一個 SayHello 的方法。
接著，定義它的實現類。
/*** xml方式服務提供者實現類*/ public class ProviderServiceImpl implements ProviderService{public String SayHello(String word) {return word;} }這樣我們就把我們的接口寫好了，那么我們應該怎么將我們的服務暴露出去呢？
導入 maven 依賴
<?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><groupId>com.ouyangsihai</groupId><artifactId>dubbo-provider</artifactId><version>1.0-SNAPSHOT</version><dependencies><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>3.8.1</version><scope>test</scope></dependency><!-- https://mvnrepository.com/artifact/com.alibaba/dubbo --><dependency><groupId>com.alibaba</groupId><artifactId>dubbo</artifactId><version>2.6.6</version></dependency><dependency><groupId>org.apache.zookeeper</groupId><artifactId>zookeeper</artifactId><version>3.4.10</version></dependency><dependency><groupId>com.101tec</groupId><artifactId>zkclient</artifactId><version>0.5</version></dependency><dependency><groupId>io.netty</groupId><artifactId>netty-all</artifactId><version>4.1.32.Final</version></dependency><dependency><groupId>org.apache.curator</groupId><artifactId>curator-framework</artifactId><version>2.8.0</version></dependency><dependency><groupId>org.apache.curator</groupId><artifactId>curator-recipes</artifactId><version>2.8.0</version></dependency></dependencies> </project>這里使用的 dubbo 的版本是 2.6.6 ，需要注意的是，如果你只導入 dubbo 的包的時候是會報錯的，找不到 netty 和 curator 的依賴，所以，在這里我們需要把這兩個的依賴加上，就不會報錯了。
另外，這里我們使用 zookeeper 作為注冊中心。
到目前為止，dubbo 需要的環境就已經可以了，下面，我們就把上面剛剛定義的接口暴露出去。
暴露接口（xml 配置方法）
首先，我們在我們項目的 resource 目錄下創建 META-INF.spring 包，然后再創建 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="N/A" /><!--當前服務發布所依賴的協議；webserovice、Thrift、Hessain、http--><dubbo:protocol name="dubbo" port="20880"/><!--服務發布的配置，需要暴露的服務接口--><dubbo:serviceinterface="com.sihai.dubbo.provider.service.ProviderService"ref="providerService"/><!--Bean bean定義--><bean id="providerService" class="com.sihai.dubbo.provider.service.ProviderServiceImpl"/></beans>① 上面的文件其實就是類似 spring 的配置文件，而且，dubbo 底層就是 spring。
② 節點：dubbo:application
就是整個項目在分布式架構中的唯一名稱，可以在 name 屬性中配置，另外還可以配置 owner 字段，表示屬于誰。
下面的參數是可以不配置的，這里配置是因為出現了端口的沖突，所以配置。
③ 節點：dubbo:monitor
監控中心配置， 用于配置連接監控中心相關信息，可以不配置，不是必須的參數。
④ 節點：dubbo:registry
配置注冊中心的信息，比如，這里我們可以配置 zookeeper 作為我們的注冊中心。address 是注冊中心的地址，這里我們配置的是 N/A 表示由 dubbo 自動分配地址。或者說是一種直連的方式，不通過注冊中心。
⑤ 節點：dubbo:protocol
服務發布的時候 dubbo 依賴什么協議，可以配置 dubbo、webserovice、Thrift、Hessain、http等協議。
⑥ 節點：dubbo:service
這個節點就是我們的重點了，當我們服務發布的時候，我們就是通過這個配置將我們的服務發布出去的。interface 是接口的包路徑，ref 是第 ⑦ 點配置的接口的 bean。
⑦ 最后，我們需要像配置 spring 的接口一樣，配置接口的 bean。
到這一步，關于服務端的配置就完成了，下面我們通過 main 方法將接口發布出去。
發布接口
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.alibaba.dubbo.container.Main; import com.sihai.dubbo.provider.service.ProviderService; import com.sihai.dubbo.provider.service.ProviderServiceImpl; import org.springframework.context.support.ClassPathXmlApplicationContext;import java.io.IOException;/*** xml方式啟動**/ public class App {public static void main( String[] args ) throws IOException {//加載xml配置文件啟動ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("META-INF/spring/provider.xml");context.start();System.in.read(); // 按任意鍵退出} }發布接口非常簡單，因為 dubbo 底層就是依賴 spring 的，所以，我們只需要通過 ClassPathXmlApplicationContext 拿到我們剛剛配置好的 xml ，然后調用 context.start() 方法就啟動了。
看到下面的截圖，就算是啟動成功了，接口也就發布出去了。
你以為到這里就結束了了，并不是的，我們拿到 dubbo 暴露出去的 url分析分析。
dubbo 暴露的 url
dubbo://192.168.234.1:20880/com.sihai.dubbo.provider.service.ProviderService?anyhost=true&application=provider&bean.name=com.sihai.dubbo.provider.service.ProviderService&bind.ip=192.168.234.1&bind.port=20880&dubbo=2.0.2&generic=false&interface=com.sihai.dubbo.provider.service.ProviderService&methods=SayHello&owner=sihai&pid=8412&qos.accept.foreign.ip=false&qos.enable=true&qos.port=55555&side=provider×tamp=1562077289380分析
① 首先，在形式上我們發現，其實這么牛逼的 dubbo 也是用類似于 http 的協議發布自己的服務的，只是這里我們用的是 dubbo 協議。
② dubbo://192.168.234.1:20880/com.sihai.dubbo.provider.service.ProviderService
上面這段鏈接就是 ? 之前的鏈接，構成：協議://ip:端口/接口。發現是不是也沒有什么神秘的。
③ anyhost=true&application=provider&bean.name=com.sihai.dubbo.provider.service.ProviderService&bind.ip=192.168.234.1&bind.port=20880&dubbo=2.0.2&generic=false&interface=com.sihai.dubbo.provider.service.ProviderService&methods=SayHello&owner=sihai&pid=8412&qos.accept.foreign.ip=false&qos.enable=true&qos.port=55555&side=provider×tamp=1562077289380
? 之后的字符串，分析后你發現，這些都是剛剛在 provider.xml 中配置的字段，然后通過 & 拼接而成的，聞到了 http 的香味了嗎？
終于，dubbo 服務端入門了。下面我們看看拿到了 url 后，怎么消費呢？
3.2 消費端
上面提到，我們在服務端提供的只是點對點的方式提供服務，并沒有使用注冊中心，所以，下面的配置也是會有一些不一樣的。
消費端環境配置
首先，我們在消費端的 resource 下建立配置文件 consumer.xml。
分析
① 發現這里的 dubbo:application 和 dubbo:registry 是一致的。
② dubbo:reference ：我們這里采用點對點的方式，所以，需要配置在服務端暴露的 url 。
maven 依賴
和服務端一樣
<?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><groupId>com.ouyangsihai</groupId><artifactId>dubbo-consumer</artifactId><version>1.0-SNAPSHOT</version><dependencies><dependency><groupId>com.ouyangsihai</groupId><artifactId>dubbo-provider</artifactId><version>1.0-SNAPSHOT</version></dependency><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>3.8.1</version><scope>test</scope></dependency><!-- https://mvnrepository.com/artifact/com.alibaba/dubbo --><dependency><groupId>com.alibaba</groupId><artifactId>dubbo</artifactId><version>2.6.6</version></dependency><dependency><groupId>org.apache.zookeeper</groupId><artifactId>zookeeper</artifactId><version>3.4.10</version></dependency><dependency><groupId>com.101tec</groupId><artifactId>zkclient</artifactId><version>0.5</version></dependency><dependency><groupId>io.netty</groupId><artifactId>netty-all</artifactId><version>4.1.32.Final</version></dependency><dependency><groupId>org.apache.curator</groupId><artifactId>curator-framework</artifactId><version>2.8.0</version></dependency><dependency><groupId>org.apache.curator</groupId><artifactId>curator-recipes</artifactId><version>2.8.0</version></dependency></dependencies> </project>調用服務
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; import org.springframework.context.support.ClassPathXmlApplicationContext;import java.io.IOException;/*** xml的方式調用**/ public class App {public static void main( String[] args ) throws IOException {ClassPathXmlApplicationContext context=new ClassPathXmlApplicationContext("consumer.xml");context.start();ProviderService providerService = (ProviderService) context.getBean("providerService");String str = providerService.SayHello("hello");System.out.println(str);System.in.read();} }這里和服務端的發布如出一轍。
如此，我們就成功調用接口了。
四 加入 zookeeper 作為注冊中心
在前面的案例中，我們沒有使用任何的注冊中心，而是用一種直連的方式進行的。但是，實際上很多時候，我們都是使用 dubbo + zookeeper 的方式，使用 zookeeper 作為注冊中心，這里，我們就介紹一下 zookeeper 作為注冊中心的使用方法。
這里，我們在前面的入門實例中進行改造。
4.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:serviceinterface="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"/>服務端的配置就好了，其他的跟 入門案例 一樣。
4.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 發布的 url 注冊到了 zookeeper，消費端從 zookeeper 消費，zookeeper 相當于一個中介，給消費者提供服務。
你以為這就完了？不，好戲才剛剛開始呢。
五 多種配置方式
在入門實例的時候，我們使用的是 xml 配置的方式，對 dubbo 的環境進行了配置，但是，官方還提供了其他的配置方式，這里我們也一一分解。
5.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更詳細的可以查看官方文檔：
http://dubbo.apache.org/zh-cn/docs/user/configuration/api.html
我們再看看我配置的消費端的 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一樣使用xxxServiceProviderService providerService = reference.get(); // 注意：此代理對象內部封裝了所有通訊細節，對象較重，請緩存復用providerService.SayHello("hello dubbo! I am sihai!");} }這部分的 API 配置的方式就到這了，注意：官方推薦 xml 的配置方法。
5.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 使用協議配置，這里使用 dubbopublic 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 {@Referenceprivate ProviderServiceAnnotation providerServiceAnnotation;public String doSayHello(String name) {return providerServiceAnnotation.SayHelloAnnotation(name);} }在 ConsumerAnnotationService 類中，通過 @Reference 引用服務端提供的類，然后通過方法調用這個類的方式，給消費端提供接口。
**注意：**如果這里找不到 ProviderServiceAnnotation 類，請在服務端先把服務端工程用 Maven intall 一下，然后將服務端的依賴放到消費端的 pom 中。如下：
第二步：組裝服務消費者
這一步和服務端是類似的，這里就不在重復了。
第三步：發起遠程調用
在 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 配置文件和消費端的配置文件來講解的。
6.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"/>就是這么簡單，就是這么強！
6.2 集群容錯
dubbo 也是支持集群容錯的，同時也有很多可選的方案，其中，默認的方案是 failover，也就是重試機制。
首先，我們先把所有的容錯機制都整理一遍，然后再看看使用。
| Failover Cluster | 失敗自動切換，當出現失敗，重試其它服務器。通常用于讀操作，但重試會帶來更長延遲。可通過 retries=“2” 來設置重試次數(不含第一次)。 | cluster=“xxx” xxx：集群模式名稱 ，例如cluster=“failover” |
| Failfast Cluster | 快速失敗，只發起一次調用，失敗立即報錯。通常用于非冪等性的寫操作，比如新增記錄。 | |
| Failsafe Cluster | 失敗安全，出現異常時，直接忽略。 | |
| Failback Cluster | 失敗自動恢復，后臺記錄失敗請求，定時重發。通常用于消息通知操作。 | |
| Forking Cluster | 并行調用多個服務器，只要一個成功即返回。通常用于實時性要求較高的讀操作，但需要浪費更多服務資源。可通過 forks=“2” 來設置最大并行數。 | |
| Broadcast Cluster | 廣播調用所有提供者，逐個調用，任意一臺報錯則報錯。通常用于通知所有提供者更新緩存或日志等本地資源信息。 |
使用實例
在發布服務或者引用服務的時候設置
6.3 負載均衡
負載均衡想必是一個再熟悉不過的概念了，所以，dubbo 支持也是再正常不過了，這里也總結一下 dubbo 支持的負載均衡的一些方案及使用方法。
| Random LoadBalance | 隨機 按權重設置隨機概率 | <dubbo:service loadbalance=“xxx”/> xxx：負載均衡方法 |
| RoundRobin LoadBalance | 輪詢 按公約后的權重設置輪詢比率。 | |
| LeastActive LoadBalance | 最少活躍調用數 相同活躍數的隨機，活躍數指調用前后計數差。 | |
| ConsistentHash LoadBalance | 一致性 Hash 相同參數的請求總是發到同一提供者。 當某一臺提供者掛時，原本發往該提供者的請求，基于虛擬節點，平攤到其它提供者，不會引起劇烈變動。 |
6.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 給出服務端的方法即可。
6.5 只訂閱
只訂閱就是只能夠訂閱服務端的服務，而不能夠注冊。
引用官方的使用場景如下：
為方便開發測試，經常會在線下共用一個所有服務可用的注冊中心，這時，如果一個正在開發中的服務提供者注冊，可能會影響消費者不能正常運行。
可以讓服務提供者開發方，只訂閱服務(開發的服務可能依賴其它服務)，而不注冊正在開發的服務，通過直連測試正在開發的服務。
① 使用只訂閱方式
當在服務提供端使用 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 注冊了。
6.6 只注冊
只注冊正好跟前面的只訂閱相反，這個時候可以向注冊中心注冊，但是，消費端卻不能夠讀到服務。
應用場景
如果有兩個鏡像環境，兩個注冊中心，有一個服務只在其中一個注冊中心有部署，另一個注冊中心還沒來得及部署，而兩個注冊中心的其它應用都需要依賴此服務。這個時候，可以讓服務提供者方只注冊服務到另一注冊中心，而不從另一注冊中心訂閱服務。
使用說明
<dubbo:registry subscribe="false" address="localhost:2181"></dubbo:registry>在服務端的 dubbo:registry 節點下使用 subscribe="false" 來聲明這個服務是只注冊的服務。
這個時候消費端調用的時候是不能調用的。
6.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② 一種接口使用多種協議
聲明協議和上面的方式一樣，在發布接口的時候有一點不一樣。
**說明：**protocol屬性，可以用,隔開，使用多種協議。
6.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。
6.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"/>加入了版本控制。
6.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，獲取優質學習資源。
總結
以上是生活随笔為你收集整理的Dubbo 一篇文章就够了：Dubbo遇到初恋的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： Failed to invoke the
- 下一篇： 解决从github上拉取代码慢的问题