Apache Dubbo学习与实践

RPC

RPC（Remote Procedure Call Protocol），远程过程调用协议，它是一种通过网络从远程计算机应用行请求服务，而不需要了解底层网络技术的协议。该协议允许一台计算机的程序调用另一台计算机的子程序。

RPC请求流程

影响RPC框架性能的两个因素

1. 通信：能否在多个服务器之间快速建立连接
2. 序列化：序列化和反序列化的速度

Apache Dubbo

Apache Dubbo 是一款高性能Java RPC框架。

• 具有如下特征：
  1. 面向接口代理的高性能RPC调用
  2. 智能负载均衡
  3. 服务自动注册与发现
  4. 高度可拓展能力
  5. 运行期流量调度
  6. 可视化的服务治理和运维
• 设计架构
  
• Container: 服务容器
• Provider: 服务提供者
• Registry: 注册中心
• Consumer: 服务消费者

实践

项目是基于Maven的聚合结构，两个子项目使用SpringBoot框架，版本2.0.1.RELEASE

1. 在Idea中新建一个空的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>org.example</groupId>
    <artifactId>dubbotest</artifactId>
    <version>1.0-SNAPSHOT</version>
    <name>DubboTest</name>
    <description>Apache Dubbo Test Project</description>
    <packaging>pom</packaging>

    <properties>
        <jdk.version>1.8</jdk.version>
        <spring.boot.version>2.0.1.RELEASE</spring.boot.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <dubbo.version>2.7.3</dubbo.version>
        <assembly.attach>false</assembly.attach>
        <assembly.skip>false</assembly.skip>
    </properties>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>2.0.1.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>

            <!-- Apache Dubbo  -->
            <dependency>
                <groupId>org.apache.dubbo</groupId>
                <artifactId>dubbo-dependencies-bom</artifactId>
                <version>${dubbo.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>

            <dependency>
                <groupId>org.apache.dubbo</groupId>
                <artifactId>dubbo</artifactId>
                <version>${dubbo.version}</version>
                <exclusions>
                    <exclusion>
                        <groupId>org.springframework</groupId>
                        <artifactId>spring</artifactId>
                    </exclusion>
                    <exclusion>
                        <groupId>javax.servlet</groupId>
                        <artifactId>servlet-api</artifactId>
                    </exclusion>
                    <exclusion>
                        <groupId>log4j</groupId>
                        <artifactId>log4j</artifactId>
                    </exclusion>
                </exclusions>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <dependencies>
        <!-- Dubbo Spring Boot Starter -->
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo-spring-boot-starter</artifactId>
            <version>2.7.4.1</version>
        </dependency>

        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo</artifactId>
            <version>2.7.4.1</version>
        </dependency>
        <dependency>
            <groupId>org.apache.zookeeper</groupId>
            <artifactId>zookeeper</artifactId>
            <version>3.4.10</version>
        </dependency>
        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-framework</artifactId>
            <version>4.0.1</version>
        </dependency>
        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-recipes</artifactId>
            <version>4.0.1</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.10</version>
        </dependency>
    </dependencies>

    <!--模块管理-->
    <modules>
        <module>provider</module>
        <module>consumer</module>
    </modules>
    
    <!--打包插件-->
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <classifier>exec</classifier>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

2. 新建子项目provider，并添加接口DemoService.class

public interface DemoService {
    /**
     * @return String
     */
    String sayHello();
}

在实现这个接口

@Slf4j
public class DemoServiceImpl implements DemoService {
    public String sayHello() {
        String ip = "20881";
        log.info("IP:{}", ip);
        return ip;
    }
}

最重要的是加入Dubbo的配置，这里基于XML文件配置，也可以通过Java代码配置

<?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://dubbo.apache.org/schema/dubbo"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
       http://dubbo.apache.org/schema/dubbo
       http://dubbo.apache.org/schema/dubbo/dubbo.xsd">

    <!-- 生产者应用信息，用于计算依赖关系 -->
    <dubbo:application name="dubbo-test-provider"/>

    <!-- 指定注册中兴地址 -->
    <dubbo:registry protocol="zookeeper" address="localhost:2181"/>

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

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

    <!-- 接口实现 -->
    <bean id="demoService" class="com.lhc.dubbo.provider.service.impl.DemoServiceImpl"/>
</beans>

3. 新建子项目consumer，并调用provider中暴露的接口

package com.lhc.dubbo.consumer.controller;

import com.lhc.dubbo.provider.service.DemoService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @ProjectName: dubbotest
 * @Package: com.lhc.dubbo.consumer.controller
 * @ClassName: TestController
 * @Author: lhc
 * @Description: TODO
 * @Date: 2020/1/2 下午 02:46
 */
@RestController
public class TestController {

    @Autowired
    private DemoService demoService;

    @GetMapping(value = "getMenthod")
    public String getMenthod() {
        return demoService.sayHello();
    }
}

consumer项目的Dubbo配置

<?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://dubbo.apache.org/schema/dubbo"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
       http://dubbo.apache.org/schema/dubbo
       http://dubbo.apache.org/schema/dubbo/dubbo.xsd">

    <!-- 消费方应用名，用于计算依赖关系-->
    <dubbo:application name="dubbo-test-consumer"/>

    <!-- 使向注册中心暴露发现服务地址 -->
    <dubbo:registry protocol="zookeeper" address="localhost:2181" check="false"/>

    <!-- 生成远程服务代理，可以和本地bean一样使用demoService -->
    <dubbo:reference id="demoService" interface="com.lhc.dubbo.provider.service.DemoService" loadbalance="random"/>
</beans>

4. 将两个子项目打包部署到服务器，这里注册中心使用zookeeper，也可以使用Nacos；

   1. 首先启动注册中心；
   2. 再启动服务提供者
   3. 再启动服务消费者

5. 也可以加入监控中心，我使用了dubbo-monitor-simple，修改配置文件即可使用

负载均衡

Dubbo目前支持4中负载均衡策略，本项目使用Random LoadBalance

• Random LoadBalance：随机，按权重设置随机概率。
• RoundRobin LoadBalance：轮询，按公约后的权重设置轮询比率
• LeastActive LoadBalance： 最少活跃调用数，相同活跃数的随机，活跃数指调用前后计数差
• ConsistentHash LoadBalance： 一致性 Hash，相同参数的请求总是发到同一提供者

参考文章：

• Apache Dubbo
• RPC 编程
• RPC简介及框架选择

代码：https://download.csdn.net/download/lhc_makefunny/12087133
如有错误欢迎指正