Dubbo 一篇文章就夠了:從入門到實戰

一 爲何須要 dubbo

不少時候,其實咱們使用這個技術的時候,可能都是由於項目須要,因此,咱們就用了,可是,至於爲何咱們須要用到這個技術,可能自身並非很瞭解的,可是,其實瞭解技術的來由及背景知識,對於理解一項技術仍是有幫助的,那麼,dubbo是怎麼被提上日程的呢?html

在互聯網的發展過程當中,在之前,咱們只須要一個服務器,將程序所有打包好就能夠,可是,隨着流量的增大,常規的垂直應用架構已沒法應對,因此,架構就發生了演變。java

1 單一應用架構web

2 應用和數據庫單獨部署算法

3 應用和數據庫集羣部署spring

4 數據庫壓力變大,讀寫分離數據庫

5 使用緩存技術加快速度apache

6 數據庫分庫分表api

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:service
            interface="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&timestamp=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&timestamp=1562077289380 ? 以後的字符串,分析後你發現,這些都是剛剛在 provider.xml 中配置的字段,而後經過 & 拼接而成的,聞到了 http 的香味了嗎?

終於,dubbo 服務端入門了。下面咱們看看拿到了 url 後,怎麼消費呢?

3.2 消費端

上面提到,咱們在服務端提供的只是點對點的方式提供服務,並無使用註冊中心,因此,下面的配置也是會有一些不同的。

消費端環境配置

首先,咱們在消費端的 resource 下創建配置文件 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:applicationdubbo: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: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"/>

服務端的配置就行了,其餘的跟 入門案例 同樣。

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:reference id="providerService"
                     interface="com.sihai.dubbo.provider.service.ProviderService"/>

好了,消費端也配置好了,這樣就可使用修改的入門案例,從新啓動運行了。

一樣成功了。

這時候的區別在於,將 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同樣使用xxxService
        ProviderService 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 使用協議配置,這裏使用 dubbo
    public ProtocolConfig protocolConfig() {
        ProtocolConfig protocolConfig = new ProtocolConfig();
        protocolConfig.setName("dubbo");
        protocolConfig.setPort(20880);
        return protocolConfig;
    }
}

分析

  • 經過 @EnableDubbo 指定在com.sihai.dubbo.provider.service.annotation 下掃描全部標註有 @Service 的類
  • 經過 @ConfigurationDubboConfiguration 中全部的 @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 了。

消費端

一樣咱們下看看消費端的工程,有一個感性認識。 圖片.png

第一步:引用服務

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 配置文件和消費端的配置文件來說解的。

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 廣播調用全部提供者,逐個調用,任意一臺報錯則報錯。一般用於通知全部提供者更新緩存或日誌等本地資源信息。

使用實例 在發佈服務或者引用服務的時候設置

<!--服務發佈的配置,須要暴露的服務接口-->
    <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"/>

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 只訂閱

只訂閱就是隻可以訂閱服務端的服務,而不可以註冊。

引用官方的使用場景以下:

爲方便開發測試,常常會在線下共用一個全部服務可用的註冊中心,這時,若是一個正在開發中的服務提供者註冊,可能會影響消費者不能正常運行。 可讓服務提供者開發方,只訂閱服務(開發的服務可能依賴其它服務),而不註冊正在開發的服務,經過直連測試正在開發的服務。

<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"/>

啓動信息 圖片.png 發現,這時候並非向註冊中心 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&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屬性,能夠用,隔開,使用多種協議。

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" />

七 總結

這篇文章就到這裏了,主要講了一下幾個內容 一、爲何須要dubbo 二、dubbo架構簡析 三、dubbo入門 四、zookeeper註冊中心加入dubbo 五、dubbo多種配置方式(xml、api、註解) 六、經常使用場景介紹 下一篇文章,將講講源碼分析。

文章有不當之處,歡迎指正,若是喜歡微信閱讀,你也能夠關注個人wx公衆號好好學java,獲取優質學習資源。

相關文章
相關標籤/搜索