Dubbo服务发现

Dubbo是阿里巴巴公司开源的RPC框架，在国内有着非常大的用户群体，但是其微服务开发组件相对Spring Cloud 来说并不那么完善。

官方网站：https://dubbo.apache.org/zh/index.html

Spring Cloud Alibaba微服务开发框架集成了Dubbo，可实现微服务对外暴露Dubbo协议的接口，Dubbo协议相比RESTful协议速度更快。

RPC：RPC是远程过程调用（Remote Procedure Call）的缩写形式，调用RPC远程方法就像调用本地方法一样，非常方便。

下面案例讲解具体调用过程实现：

1. Dubbo服务架构

下图是微服务采用Dubbo协议的系统架构图：

组件说明：

1. 客户端：前端或外部系统
2. API网关：系统唯一入口，路由转发
3. application-1 ：应用1，前端提供Http接口，接收用户的交互请求
4. service-1 ：微服务1，提供业务逻辑处理服务
5. service-2：微服务2，提供业务逻辑处理服务

交互流程：

1. 网关负责客户端请求的统一入口，路由转发，前端通过网关请求后端服务。
2. 网关收到前端请求，转发请求给应用。
3. 应用接收前端请求，调用微服务进行业务逻辑处理
4. 微服务为应用提供业务逻辑处理的支撑，为应用提供Dubbo协议接口

优势分析：

此架构同时提供RESTful和Dubbo接口服务，应用层对前端提供RESTful接口，RESTful是互联网通用的轻量级交互协议，方便前端接入系统；微服务层向应用层提供Dubbo接口，Dubbo接口基于RPC通信协议速度更快。

本架构采用阿里开源的Nacos，集服务发现和配置中心于一身，支持RESTful及Dubbo服务的注册。

2. 案例环境搭建

父工程：仍然使用nacos-dicovery。

application1：使用nacos-restful-consumer。

service1微服务：需要新建

service2微服务：需要新建

api网关：这次没有搭建

3. service2微服务

service2对外暴露dubbo协议的接口，考虑远程接口可能 会被其它多个服务调用，这里将service2的接口单独抽取出api工程，service2微服务工程的结构如下：

service2-api：存放接口，独立成一个工程方便被其它服务工程依赖。

service2-server：存放接口实现，即dubbo服务的实现部分。

3.1 定义service2-api

1、创建service2工程

父级 pom.xml

<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">
    <parent>
        <artifactId>nacos-discoveryartifactId>
        <groupId>com.yyl.nacosgroupId>
        <version>1.0-SNAPSHOTversion>
    parent>
    <modelVersion>4.0.0modelVersion>

    <artifactId>nacos-dubbo-service2artifactId>


project>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2、创建service2-api工程

<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">
    <parent>
        <artifactId>nacos-dubbo-service2artifactId>
        <groupId>com.yyl.nacosgroupId>
        <version>1.0-SNAPSHOTversion>
    parent>
    <modelVersion>4.0.0modelVersion>

    <artifactId>service2-apiartifactId>


project>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

3、定义接口

package com.yyl.microservice.service2.api;

/
 * Created by Administrator.
 */
public interface Service2Api {
    public String dubboService2();
}

1
2
3
4
5
6
7
8
9

3.2 定义service2-server

1、创建service2-server工程

<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">
    <parent>
        <artifactId>nacos-dubbo-service2artifactId>
        <groupId>com.yyl.nacosgroupId>
        <version>1.0-SNAPSHOTversion>
    parent>
    <modelVersion>4.0.0modelVersion>

    <artifactId>service2-serverartifactId>

    <dependencies>
        <dependency>
            <groupId>com.yyl.nacosgroupId>
            <artifactId>service2-apiartifactId>
            <version>1.0-SNAPSHOTversion>
        dependency>
        <dependency>
            <groupId>com.alibaba.cloudgroupId>
            <artifactId>spring-cloud-starter-dubboartifactId>
        dependency>
        <dependency>
            <groupId>com.alibaba.cloudgroupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discoveryartifactId>
        dependency>
    dependencies>

project>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

2、定义接口实现
注意：使用@org.apache.dubbo.config.annotation.Service标记dubbo服务
如下图所示：

package com.yyl.microservice.service2.service;

import com.yyl.microservice.service2.api.Service2Api;

/
 * @author Administrator
 * @version 1.0
 /
@org.apache.dubbo.config.annotation.Service
public class Service2ApiImpl implements Service2Api {
    public String dubboService2() {

        return "dubboService2";
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

3、定义启动类

package com.yyl.microservice.service2;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/
 * @author Administrator
 * @version 1.0
 /
@SpringBootApplication
public class Service2Bootstrap {
    public static void main(String[] args) {
        SpringApplication.run(Service2Bootstrap.class,args);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

4、定义配置文件bootstrap.yml

注意：Spring Boot 2.1 需要设定 allow-bean-definition-overriding （允许bean定义重写覆盖）为true

server:
  port: 56040 #启动端口 命令行注入

spring:
  application:
    name: dubbo-service2
  main:
    allow-bean-definition-overriding: true # Spring Boot 2.1 需要设定
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848
dubbo:
  scan:
    # dubbo 服务扫描基准包
    base-packages: com.yyl.microservice.service2.service
  protocol:
    # dubbo 协议
    name: dubbo
    # dubbo 协议端口
    port: 20891
  registry:
    address: nacos://127.0.0.1:8848
  application:
    qos-enable: false #dubbo运维服务是否开启
  consumer:
    check: false  #启动时就否检查依赖的服务
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

5、启动service2-server

启动成功观察nacos的服务列表

6、bootstrap.yml配置说明

bootstrap.yml内容的上半部分为SpringCloud的相关配置：

• spring.application.name : Spring 应用名称，用于 Spring Cloud 服务注册和发现。

  该值在 Dubbo Spring Cloud 加持下被视作 dubbo.application.name ，因此，无需再显示地配置 dubbo.application.name

• spring.cloud.nacos.discovery : Nacos 服务发现与注册配置，其中子属性 server-addr 指定 Nacos 服务器主机和端口

4. application1调用service2

根据dubbo服务的架构图，我们将nacos-restful-consumer作为application1，实现application1调用 service2。

4.1 引用service2

在nacos-restful-consumer工程中引用service2依赖

在pom.xml中引入service2-api的依赖

<dependency>
    <groupId>com.yyl.nacosgroupId>
    <artifactId>service2-apiartifactId>
    <version>1.0-SNAPSHOTversion>
dependency>
1
2
3
4
5

引入 spring-cloud-starter-dubbo依赖，它会根据接口生成代理对象

<dependency>
    <groupId>com.alibaba.cloudgroupId>
    <artifactId>spring-cloud-starter-dubboartifactId>
dependency>
1
2
3
4

4.2 实现远程调用

修改nacos-restful-consumer工程的RestConsumerController：

@org.apache.dubbo.config.annotation.Reference
Service2Api service2Api;

@GetMapping(value = "/service2")
public String service2(){
    //远程调用service2
    String providerResult = service2Api.dubboService2();
    return "远程调用 consumer dubbo invoke |"+providerResult;
}
1
2
3
4
5
6
7
8
9

注意：这里的 @Reference 注解是 org.apache.dubbo.config.annotation.Reference

测试： 请求：http://127.0.0.1:56020/service2

显示：

dubboService2 表明service2调用成功。

5. service1微服务

service1采用和service2相同的工程结构。

本节实现service1对外暴露dubbo接口，并用实现service1调用service2。

5.1 定义service1-api

1、创建service1工程

<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">
    <parent>
        <artifactId>nacos-discoveryartifactId>
        <groupId>com.yyl.nacosgroupId>
        <version>1.0-SNAPSHOTversion>
    parent>
    <modelVersion>4.0.0modelVersion>

    <artifactId>nacos-dubbo-service1artifactId>


project>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2、创建service1-api工程

<?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">
    <parent>
        <artifactId>nacos-dubbo-service1</artifactId>
        <groupId>com.yyl.nacos</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>service1-api</artifactId>

</project>
1
2
3
4
5
6
7
8
9
10
11
12
13
14

3、定义接口

package com.yyl.microservice.service1.api;

/**
 * Created by Administrator.
 */
public interface Service1Api {
    public String dubboService1();
}

1
2
3
4
5
6
7
8
9

5.2 定义service1-server

1、创建service1-server工程

由于实现service1调用service2，这里需要引入 service2依赖。

<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">
    <parent>
        <artifactId>nacos-dubbo-service1artifactId>
        <groupId>com.yyl.nacosgroupId>
        <version>1.0-SNAPSHOTversion>
    parent>
    <modelVersion>4.0.0modelVersion>

    <artifactId>service1-serverartifactId>

<dependencies>
    <dependency>
        <groupId>com.yyl.nacosgroupId>
        <artifactId>service1-apiartifactId>
        <version>1.0-SNAPSHOTversion>
    dependency>
    
    <dependency>
        <groupId>com.yyl.nacosgroupId>
        <artifactId>service2-apiartifactId>
        <version>1.0-SNAPSHOTversion>
    dependency>
    <dependency>
        <groupId>com.alibaba.cloudgroupId>
        <artifactId>spring-cloud-starter-dubboartifactId>
    dependency>
    <dependency>
        <groupId>com.alibaba.cloudgroupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-discoveryartifactId>
    dependency>
dependencies>
project>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

2、定义接口实现

package com.yyl.microservice.service1.service;

import com.yyl.microservice.service1.api.Service1Api;
import com.yyl.microservice.service2.api.Service2Api;

/**
 * @author Administrator
 * @version 1.0
 **/
@org.apache.dubbo.config.annotation.Service
public class Service1ApiImpl implements Service1Api {

    @org.apache.dubbo.config.annotation.Reference
    Service2Api service2Api;

    public String dubboService1() {
        //远程调用service2
        String s = service2Api.dubboService2();
        return "先调用 dubboService1 | 再调用"+s;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

3、定义启动类

package com.yyl.microservice.service1;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * @author Administrator
 * @version 1.0
 **/
@SpringBootApplication
public class Service1Bootstrap {
    public static void main(String[] args) {
        SpringApplication.run(Service1Bootstrap.class,args);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

4、定义配置文件bootstrap.yml

server:
  port: 56030 #启动端口 命令行注入

spring:
  application:
    name: dubbo-service1
  main:
    allow-bean-definition-overriding: true # Spring Boot 2.1 需要设定
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848
dubbo:
  scan:
    # dubbo 服务扫描基准包
    base-packages: com.yyl.microservice.service1.service
  protocol:
    # dubbo 协议
    name: dubbo
    # dubbo 协议端口
    port: 20881
  registry:
    address: nacos://127.0.0.1:8848
  application:
    qos-enable: false #dubbo运维服务是否开启
  consumer:
    check: false  #启动时就否检查依赖的服务
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

5、启动service1-server

启动成功观察nacos的服务列表

5.3 application1调用service1

1、在application1引入 service1-api的依赖

<dependency>
    <groupId>com.yyl.nacosgroupId>
    <artifactId>service1-apiartifactId>
    <version>1.0-SNAPSHOTversion>
dependency>
1
2
3
4
5

2、在application1的controller中调用service1接口

@org.apache.dubbo.config.annotation.Reference
Service1Api service1Api;


@GetMapping(value = "/service3")
public String service3(){
    //远程调用service1
    String providerResult = service1Api.dubboService1();
    return "远程调用 consumer dubbo invoke |"+providerResult;
}
1
2
3
4
5
6
7
8
9
10

3、测试，请求http://127.0.0.1:56020/service3

显示 ：

表明调用service1成功，service1调用service2成功。