Dubbo 一篇文章就够了：从入门到实战

时间 2019-11-08

标签 dubbo 一篇文章够了入门实战栏目 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: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: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...

咱们再看看我配置的消费端的 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 的类
经过 @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 配置文件和消费端的配置文件来说解的。

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

启动信息

发现，这时候并非向注册中心 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、注解）
六、经常使用场景介绍
下一篇文章，将讲讲源码分析。

文章有不当之处，欢迎指正，若是喜欢微信阅读，你也能够关注个人 微信公众号： 好好学java，获取优质学习资源。