拥抱微服务--Dubbo入门

随着微服务的流行，Dubbo和Spring Cloud框架受到越来越多的关注，本文主要通过1个简单Demo来介绍Dubbo框架的工作流程。

Dubbo是什么?

Apache Dubbo (incubating) is a high-performance, java based, open source RPC framework.

Dubbo是：

• 一个分布式服务框架；
• 致力于提供高性能和透明化的RPC远程服务调用方案；
• 阿里巴巴SOA服务化治理方案的核心框架，每天为2,000+个服务提供3,000,000,000+次访问量支持。

注：SOA是Service-Oriented Architecture的英文简称，即面向服务的架构，其主要解决多服务凌乱的问题，因此有人也称之为服务治理。

dubbo的主要流程如下：

其中：

Provider为服务提供者，负责发布服务；

Consumer为服务消费者，负责调用服务；

Container为Dubbo容器，其依赖于Spring容器；

Registry为注册中心，当Container启动时会将所有可提供的服务在Registry进行注册，其作用是告知Consumer有哪些服务，以及服务的地址；

Monitor为监听器，负责服务注册、调用等流程的监控；

其中虚线为异步访问，实线为同步访问；

蓝色虚线代表Dubbo启动时完成的功能，红色虚线(实线)为程序运行过程中执行的功能。

注册中心

Dubbo支持以下4种注册中心：

• Multicast

不需要启动任何中心节点，只要广播地址，就可以互相发现。组播受网络结构限制，只适合小规模应用或开发阶段使用。

• Zookeeper

其优点是支持网络集群。

• Redis

使用Redis的Key/Map结构存储数据；

主Key为服务名和类型；

Map中的Key为URL地址；

Map中的Value为过期时间，用于判断脏数据，脏数据由监控中心删除。(注意：服务器时间必须同步，否则过期检测会不准确)；

使用Redis的Publish/Subscribe事件通知数据变更；

• Simple

本身为普通的Dubbo服务，可以减少第三方依赖，使整体通讯方式一致，不支持集群，可作为自定义注册中心的参考，但不适合直接用于生产环境。

负载均衡策略

Dubbo支持以下4种负载均衡策略：

Random LoadBalance

• 随机，按权重设置随机概率。
• 在一个截面上碰撞的概率高，但调用量越大分布越均匀，而且按概率使用权重后也比较均匀，有利于动态调整提供者权重。

RoundRobin LoadBalance

• 轮询，按公约后的权重设置轮询比率。
• 存在慢的提供者累积请求的问题，比如：第二台机器很慢，但没挂，当请求调到第二台时就卡在那，久而久之，所有请求都卡在调到第二台上。

LeastActive LoadBalance

• 最少活跃调用数，相同活跃数的随机，活跃数指调用前后计数差。
• 使慢的提供者收到更少请求，因为越慢的提供者的调用前后计数差会越大。

ConsistentHash LoadBalance

• 一致性 Hash，相同参数的请求总是发到同一提供者。
• 当某一台提供者挂时，原本发往该提供者的请求，基于虚拟节点，平摊到其它提供者，不会引起剧烈变动。
• 算法参见：http://en.wikipedia.org/wiki/Consistent_hashing
• 缺省只对第一个参数 Hash，如果要修改，请配置 <dubbo:parameter key=“hash.arguments” value=“0,1” />
• 缺省用 160 份虚拟节点，如果要修改，请配置 <dubbo:parameter key=“hash.nodes” value=“320” />

实例编写

下面通过1个简单Demo体验一把Dubbo。

构建环境

• Java 1.8.0_191
• Zookeeper-3.4.10
• dubbo 2.5.9
• dubbo-monitor-simple-2.5.3
• IntelliJ IDEA 2018.1

dubbo_service

首先，基于Maven构建dubbo_service工程，其作用仅是定义服务的接口。

对应的pom.xml文件如下：

<?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>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <groupId>com.ruanshubin</groupId>
    <artifactId>dubbo_service</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <!-- https://mvnrepository.com/artifact/com.alibaba/dubbo -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>dubbo</artifactId>
            <version>2.5.9</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.apache.zookeeper/zookeeper -->
        <dependency>
            <groupId>org.apache.zookeeper</groupId>
            <artifactId>zookeeper</artifactId>
            <version>3.4.10</version>
            <type>pom</type>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.101tec/zkclient -->
        <dependency>
            <groupId>com.101tec</groupId>
            <artifactId>zkclient</artifactId>
            <version>0.11</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/junit/junit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

• DemoService

package com.ruanshubin.service;

public interface DemoService {
    String sayHello(String name);
}

dubbo_provider

dubbo_provider为服务提供者，故其需要实现前面定义的服务接口。

其pom.xml文件如下：

<?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>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <groupId>com.ruanshubin</groupId>
    <artifactId>dubbo_provider</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>com.ruanshubin</groupId>
            <artifactId>dubbo_service</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <!-- 打包操作 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>2.3</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                            <transformers>
                                <transformer
                                        implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
                                    <resource>META-INF/spring.handlers</resource>
                                </transformer>
                                <transformer
                                        implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
                                    <resource>META-INF/spring.schemas</resource>
                                </transformer>
                                <transformer
                                        implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                    <mainClass></mainClass>
                                </transformer>
                            </transformers>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

• 接口实现类DemoServiceImpl

package com.ruanshubin.service.Impl;

import com.ruanshubin.service.DemoService;

public class DemoServiceImpl implements DemoService {

    @Override
    public String sayHello(String name) {
        System.out.println("服务被调用！");
        return "Hello " + name;
    }
}

下面需要编写Container的启动类Provider。

package com.ruanshubin.dubbo;

import org.springframework.context.support.ClassPathXmlApplicationContext;
import java.io.IOException;

public class Provider {
    public static void main(String[] args) throws IOException {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("provider.xml");
        context.start();
        System.out.println("服务启动成功！");
        System.in.read(); // 按任意键退出，该行代码的目的是保持容器的启动状态

    }
}

其中，provider.xml为Provider端的启动配置文件，具体为：

<?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-4.3.xsd
    http://code.alibabatech.com/schema/dubbo
    http://code.alibabatech.com/schema/dubbo/dubbo.xsd">

    <!-- 提供方应用信息，用于计算依赖关系 -->
    <dubbo:application name="hello-world-app"  />

    <!-- 配置注册中心 -->
    <dubbo:registry address="10.194.224.61:2181?backup=10.194.224.62:2181,10.194.224.63:2181" protocol="zookeeper"/>

    <!-- 用dubbo协议在20880端口暴露服务 -->
    <dubbo:protocol name="dubbo" port="20880" />

    <!-- 声明需要暴露的服务接口 -->
    <dubbo:service interface="com.ruanshubin.service.DemoService" ref="demoService" />

    <!-- 和本地bean一样实现服务 -->
    <bean id="demoService" class="com.ruanshubin.service.Impl.DemoServiceImpl" />
</beans>

dubbo_consumer

dubbo_consumer为服务消费者，先从注册中心拉取服务列表，然后调用相应服务。

其启动类Consumer如下：

package com.ruanshubin.dubbo;

import com.ruanshubin.service.DemoService;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Consumer {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("consumer.xml");
        // 获取服务实例
        DemoService service = context.getBean("demoService", DemoService.class);
        // 调取服务的方法，调用10次来测试负载均衡
        for(int i=0; i<10; i++){
            String result = service.sayHello(args[0]);
            System.out.println(result);
        }
    }

}

其中，consumer.xml为Consumer端的启动配置文件，具体为：

<?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-4.3.xsd
    http://code.alibabatech.com/schema/dubbo
    http://code.alibabatech.com/schema/dubbo/dubbo.xsd">

    <!-- 提供方应用信息，用于计算依赖关系 -->
    <dubbo:application name="hello-world-app"  />

    <!-- 配置注册中心 -->
    <dubbo:registry address="10.194.224.61:2181?backup=10.194.224.62:2181,10.194.224.63:2181" protocol="zookeeper"/>

    <!-- 声明需要调用的服务接口 -->
    <dubbo:reference interface="com.ruanshubin.service.DemoService" id="demoService" />

</beans>

对dubbo_service执行install后，然后分别对dubbo_provider和dubbo_consumer执行package打包。

实例测试

监控中心及管理控制台

为方便查看服务的启动和调用(消费)情况，需要安装监控中心及管理控制台，其具体安装步骤如下：

• 监控中心

# 创建安装目录
[root@slave1 software]# mkdir dubbo

# 上传安装包、解压
[root@slave1 ~]# mv dubbo-monitor-simple-2.5.3-assembly.tar.gz /usr/software/dubbo/
tar -zxvf dubbo-monitor-simple-2.5.3-assembly.tar.gz

# 修改配置文件，主要是修改注册中心的地址dubbo.registry.address
# 这里填上设置好的Zookeeper集群地址
[root@slave1 dubbo-monitor-simple-2.5.3]# vim conf/dubbo.properties

dubbo.container=log4j,spring,registry,jetty
dubbo.application.name=simple-monitor
dubbo.application.owner=
#dubbo.registry.address=multicast://224.5.6.7:1234
dubbo.registry.address=zookeeper://slave1:2181?backup=slave2:2181,slave3:2181
#dubbo.registry.address=redis://127.0.0.1:6379
#dubbo.registry.address=dubbo://127.0.0.1:9090
dubbo.protocol.port=7070
dubbo.jetty.port=9090
dubbo.jetty.directory=${user.home}/monitor
dubbo.charts.directory=${dubbo.jetty.directory}/charts
dubbo.statistics.directory=${user.home}/monitor/statistics
dubbo.log4j.file=logs/dubbo-monitor-simple.log
dubbo.log4j.level=WARN

# 修改完配置文件，然后启动
bin/start.sh

管理控制台

# 首先安装tomcat容器

# 创建安装目录
mkdir /usr/software/tomcat
# 将安装包移动到安装目录
mv ~/apache-tomcat-8.5.35.tar.gz /usr/software/tomcat
# 切换到安装目录并解压
cd /usr/software/tomcat 
tar -zxvf apache-tomcat-8.5.35.tar.gz
# 启动
bin/startup.sh
# 登录界面 IP:8080

# 清空tomcat/webapps/ROOT目录
[root@slave1 apache-tomcat-8.5.35]# rm -rf webapps/ROOT/*
# 解压dubbo-admin.war至tomcat/webapps/ROOT
[root@slave1 apache-tomcat-8.5.35]# mv ~/dubbo-admin-2.5.4-jdk1.8.war /usr/software/dubbo/apache-tomcat-8.5.35
[root@slave1 apache-tomcat-8.5.35]# unzip dubbo-admin-2.5.4-jdk1.8.war -d webapps/ROOT/

# 修改配置文件，主要是配置管理控制台的注册中心地址，及用户名密码
[root@slave1 apache-tomcat-8.5.35]# cd webapps/ROOT/WEB-INF/
[root@slave1 WEB-INF]# vim dubbo.properties

dubbo.registry.address=zookeeper://slave1:2181?backup=slave2:2181,slave3:2181
dubbo.admin.root.password=root
dubbo.admin.guest.password=guest

# 启动tomcat
bin/startup.sh 

管理控制台默认Web端口号为8080。

部署测试

首先，将Provider端部署包dubbo_provider-1.0-SNAPSHOT.jar上传到相应机器，这里我上传了4台机器：

在4台机器上分别执行下述命令：

java -jar dubbo_provider-1.0-SNAPSHOT.jar

注意：部署的机器须保证有对应版本的Java环境。

登录Dubbo的管理控制台，可以看到DemoService服务已经存在，并存在于4台机器上。

随便找一台有Java环境且与上述4台能网络通信的机器，上传dubbo_consumer-1.0-SNAPSHOT.jar，打开终端输入以下命令：

java -jar dubbo_consumer-1.0-SNAPSHOT.jar World

可以看出，调用远程服务成功。

下面看看4台机器被调用的次数：

1号机器调用5次：

2号机器被调用3次：

3号机器被调用2次：

4号机器被调用0次：

之所以这样的原因是：Dubbo默认的负载均衡策略为Random。

Dubbo有4种均衡策略，其具体的工作机制是怎么样的呢，篇幅有限，我们下次出一篇专门讲。