SpringBoot集成Dubbo_springboot dubbo

#博学谷IT学习技术支持#

参考：
Linux环境安装docker
docker安装zookeeper

这次我们来实现一下springboot集成dubbo,并介绍一些dubbo的具体功能。然后包含一些zookeeker中的信息

1. 构建SpringBoot环境

1.1 创建一个dubbo-parent项目

• dubbo-consumer：是服务消费方
• dubbo-provider：是服务提供方
• dubbo-interface：存放接口，因为dubbo是根据接口进行服务注册发现的，因此我们要把接口单独拿出来，provider提供方实现该接口并注册服务， consumer要根据接口进行注入
• duubo-dependency：方便依赖管理

1.2 引入依赖坐标

1.2.1 dubbo-parent

<parent>
	<groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.1.5.RELEASE</version>
    <relativePath/> <!-- lookup parent from repository -->
</parent>
1
2
3
4
5
6

在dubbo-parent中引入parent为spring-boot-starter-parent
这里我们使用的版本为2.1.5。

具体的版本可以在maven仓库查看，https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-parent

1.2.2 dubbo-dependency

 <parent>
        <artifactId>dubbo-parent</artifactId>
        <groupId>org.example</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>dubbo-dependency</artifactId>
    <properties>
        <dubbo.version>2.6.5</dubbo.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba.boot</groupId>
            <artifactId>dubbo-spring-boot-starter</artifactId>
            <version>0.2.1.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>dubbo</artifactId>
            <version>${dubbo.version}</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
        </dependency>
    </dependencies>
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
36
37
38
39
40
41

有几点需要注意

1、springboot集成dubbo，需要引入dubbo-spring-boot-starter依赖，版本为0.2.1.RELEASE，可以在仓库中参看具体的依赖信息 https://mvnrepository.com/artifact/com.alibaba.boot/dubbo-spring-boot-starter
2、在引入dubbo-spring-boot-starter依赖后，还需要引入dubbo依赖。至于dubbo依赖的版本具体是多少，我们可以点进dubbo-spring-boot-starter查看其所依赖的dubbo-spring-boot-parent.pom文件，里面有关于dubbo的版本信息，我们可以直接使用

3、我们还需要引入log4j和self-4j的依赖
4、因为我们是以一个web服务进行启动，因此我们需要引入spring-boot-starter-web依赖

1.2.3 dubbo-consumer

 <dependencies>
        <dependency>
            <groupId>org.example</groupId>
            <artifactId>dubbo-dependency</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>org.example</groupId>
            <artifactId>dubbo-interface</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>
1
2
3
4
5
6
7
8
9
10
11
12

1.2.4 dubbo-provider

 <dependencies>
        <dependency>
            <groupId>org.example</groupId>
            <artifactId>dubbo-dependency</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>org.example</groupId>
            <artifactId>dubbo-interface</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>
1
2
3
4
5
6
7
8
9
10
11
12

1.2.5 dubbo-interface
内部暂时不需要其他依赖

2. Linux 环境配置

使用dubbo框架时，需要使用zookeeper来充当注册中心，我们来搭建一下linux的zookeeper环境。
为了方便，我们可以使用docker容器来搭建zookeeper

2.1 安装docker

https://docs.docker.com/engine/install/ 我们可以根据关于的手册进行安装，这里我们使用CentOS，后续根据官方文档进行安装即可。
如果感觉官网看起来比较麻烦，可以根据该博客来进行安装
https://blog.csdn.net/MX__LL/article/details/125797414?spm=1001.2014.3001.5501

2.1 安装zookeeper

https://www.cnblogs.com/kendoziyu/p/14960377.html

安裝完成后，docker ps 查看zookeeper状态

3. yml配置文件

3.1 provider提供者yml配置

server:
  port: 8000 #web服务端口
spring:
  application:
    name: dubbo-provider # 服务名称
dubbo:
  application:
    name: dubbo-provider #dubbo提供者名称
  registry:
    address: zookeeper://xxxxxx:2181 #注册地址 使用zookeeper
  scan:
    base-packages: com.dtchao.dubbo #配置扫描路径，这里的扫描路径，要根据自己实际的package来写
  protocol:
    name: dubbo #使用dubbo协议
    port: 20880 #协议端口为20880
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

我们要在启动类加上@EnableDubbo注解

@SpringBootApplication
@EnableDubbo
public class DubboProviderApp {
    public static void main(String[] args) {
        SpringApplication.run(DubboProviderApp.class, args);
    }
}
1
2
3
4
5
6
7

3.2 consumer提供者yml配置

server:
  port: 9000
spring:
  application:
    name: dubbo-consumer
dubbo:
  registry:
    address: zookeeper://xxxxxxxxx:2181
  protocol:
    name: dubbo
    port: 20880
  scan:
    base-packages: com.dtchao.dubbo #如果消费者也需要提供服务的话，需要加上扫描包路径，这里的扫描路径，要根据自己实际的package来写
  application:
    name: dubbo-consumer
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

消费者如果不提供服务，也就是不把接口注册到注册中心时，可以不添加@EnableDubbo注解

4. 服务测试

4.1 新增接口

在dubbo-interface模块中新增一个接口

package com.dtchao.dubbo.service;

public interface GoodsService {
    public String getData(String data);
    public String getGoods();
}
1
2
3
4
5
6

4.2 接口实现

在dubbo-provider中实现dubbo-interface中创建的GoodsService

package com.dtchao.dubbo.service.impl;

import com.alibaba.dubbo.config.annotation.Service;
import com.dtchao.dubbo.service.GoodsService;

@Service // 这里的service注解不能使用spring的注解，要使用dubbo中的注解
public class GoodsServiceImpl implements GoodsService {
    @Override
    public String getData(String data) {
        System.out.println("getData 方法被访问了！data: " + data);
        return null;
    }

    @Override
    public String getGoods() {
        System.out.println("getGoods 方法被访问了！");
        return null;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

4.2 服务引用

在dubbo-consumer中创建一个controller,并引用GoodsService。

package com.dtchao.dubbo.controller;

import com.alibaba.dubbo.config.annotation.Reference;
import com.dtchao.dubbo.service.GoodsService;
import org.springframework.web.bind.annotation.RequestMapping;


@RestController
@RequestMapping("/goods")
public class GoodsController {

    @Reference //使用dubbo中的@Reference注解
    private GoodsService goodsService;

    @RequestMapping("/get")
    public Object getGoods() {
        return goodsService.getGoods();
   	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

4.3 服务测试

1. 我们先在服务器查看一下zookeeper中的信息

1、执行docker ps查看zookeeper容器状态，复制zookeeper对应的 CONTAINER ID

2、执行docker exec -it ${CONTAINER ID} /bin/bash

3、进入后ls查看目录，执行cd bin 进入bin目录
4、执行./zkCli.sh脚本，连接zookeeper客户端

5、执行ls / 查看目录 我们可以看到，现在只有一个zookeeper

2. 启动dubbo-provider和dubbo-consumer
3. 启动后查看zookeeper内容

1、服务启动后，再执行ls /查看内容可以看到多了一个dubbo

2、执行ls /dubbo 查看，可以看到我们注册的接口的路径

3、继续查看，可以看还存在consumer和provider,查看consumer和provider，可以看到具体的注册中心，到这里说明我们已经注册完成了

4. 浏览器访问测试

1、dubbo-consumer使用的端口为9000,在浏览器访问一下


可以看到访问已经成功了,并且dubbo-provider的控制台也有输出信息；

至此，springboot集成dubbo就已经完成了，关于dubbo中的一些其实使用，将在下一章介绍