前言：

本文内容：Dubbo及Zookeeper安装、Dubbo-admin安装测试、服务注册发现实战

推荐免费SpringBoot基础教程视频：【狂神说Java】SpringBoot最新教程通俗易懂_哔哩哔哩_bilibili

SpringBoot笔记代码下载地址：

坚果云：下载地址 密码：jokerdig

百度云：下载地址 提取码：rk39

Dubbo及Zookeeper安装

Dubbo的概念

什么是Dubbo

Apache Dubbo是一个分布式、高性能、透明化的RPC服务框架，提供服务自动注册、自动发现等高效服务治理方案，可以和Spring框架无缝集成。

Dubbo的基本概念

48

服务提供者(Provider)：暴露服务的提供方，服务提供者在启动时，向注册中心注册自己提供的服务

服务消费者(Consumer)：调用远程服务的消费方，服务消费者在启动时，向注册中心订阅自己所需的服务，并选择一台提供者进行调用，若失败再选另一台调用

注册中心(Registry)：注册中心返回服务提供者地址列表给消费者，如果有变更，注册中心将基于长连接推送变更数据给消费者

监控中心(Monitor)：服务消费者和提供者，在内存中累计调用次数和调用时间，定时每分钟发送一次统计数据到监控中心

Dubbo环境搭建

Dubbo官方文档，推荐我们使用zookeeper 注册中心

关于Apache ZooKeeper

Windows下载安装zookeeper

  1. 下载zookeeper

    官方下载：Apache ZooKeeper

    国内镜像：Apache Zookeeper

  2. 解压后，打开bin目录，双击运行zkServer.cmd

    运行出现闪退，可以在zkServer.cmd倒数第二行添加pause查看错误提示

    问题：..\conf\zoo.cfg

    需要在conf下新建zoo.cfg

  3. 将conf下的zoo_sample.cfg复制一份，并改名为zoo.cfg

  4. 再运行zkServer.cmd，服务端成功运行

  5. 运行zkCli.cmd，启动客户端进行测试

    注意，以下命令的空格不能省略

  6. 输入ls /，查看根下保存的所有文件

    [zookeeper]

  7. create -e /jokerdig abc创建一个文件

    [jokerdig,zookeeper]

  8. get /jokerdig获取文件内容

    abc

  9. 安装简单介绍完毕

Dubbo-admin安装测试

安装

dubbo本身并不是一个服务软件，而是一个jar包，能够帮你的Java程序连接到zookeeper，并利用zookeeper消费、提供服务。

但为了让用户更好的管理和监控众多dubbo服务，官方提供了一个可视化的监控程序dubbo-admin(即使不安装也不影响使用)。

Window下安装dubbo-admin

  1. 下载dubbo-admin，分支选择master-0.2.0

    apache/dubbo-admin at master (github.com)

  2. 解压到目录

    修改dubbo-admin\src\main\resources\application.properties并指定zookeeper地址

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    server.port=7001
    spring.velocity.cache=false
    spring.velocity.charset=UTF-8
    spring.velocity.layout-url=/templates/default.vm
    spring.messages.fallback-to-system-locale=false
    spring.messages.basename=i18n/message
    spring.root.password=root
    spring.guest.password=guest

    dubbo.registry.address=zookeeper://127.0.0.1:2181

  3. 在项目根目录下打包dubbo-admin

    1
    mvn clean package -Dmaven.test.skip=true

    第一次打包过程有点慢，请耐心等待，出现以下提示表示项目打包成功，会在dubbo-admin\target目录生成一个jar包

    47

  4. 执行dubbo-admin\target下的dubbo-admin-0.0.1-SNAPSHOT.jar

    执行前要保证zookeeper的zkServer.cmd在运行

    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
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
       java -jar dubbo-admin-0.0.1-SNAPSHOT.jar

    5. 运行成功后在浏览器访问

       地址：http://localhost:7001

       默认账号密码都为`root`

       登录成功后显示`Dubbo-admin`的可视化页面

       ![46](https://jokerdig.oss-cn-shanghai.aliyuncs.com/jokerdig/202209072131275.png)

    6. 搭建完成

    ### 服务注册发现实战

    **SpringBoot+zookeeper+dubbo**

    > 一定要保证`zkServer.cmd`和`dubbo-admin`已经启动

    1. 新建一个`Empty Project`名为`springboot-10-dubbo_zookeeper`

    2. 新建一个`SpringBoot`的服务端`Module`名为`provider-server`并勾选`Spring Web`

    3. 在`pom`中引入依赖

       ```xml
       <!--        引入依赖dubbo+zookeeper-->
       <dependency>
           <groupId>org.apache.dubbo</groupId>
           <artifactId>dubbo-spring-boot-starter</artifactId>
           <version>2.7.3</version>
       </dependency>
       <dependency>
           <groupId>com.github.sgroschupf</groupId>
           <artifactId>zkclient</artifactId>
           <version>0.1</version>
       </dependency>
       <!--        解决日志冲突-->
       <dependency>
           <groupId>org.apache.curator</groupId>
           <artifactId>curator-framework</artifactId>
           <version>2.12.0</version>
       </dependency>
       <dependency>
           <groupId>org.apache.curator</groupId>
           <artifactId>curator-recipes</artifactId>
           <version>2.12.0</version>
       </dependency>
       <dependency>
           <groupId>org.apache.zookeeper</groupId>
           <artifactId>zookeeper</artifactId>
           <version>3.4.14</version>
            <!--去除slf4j-log4j12-->
           <exclusions>
               <exclusion>
                   <groupId>org.slf4j</groupId>
                   <artifactId>slf4j-log4j12</artifactId>
               </exclusion>
           </exclusions>
       </dependency>

  5. 在service包下新建TicketService接口和TicketServiceImpl实现类

    TicketService

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    package com.jokerdig.service;


    /**
     * @author Joker大雄
     * @data 2022/8/1 - 12:59
     **/
    public interface TicketService {
        public String getTicket();

    }

    TicketServiceImpl

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    package com.jokerdig.service;
    import org.apache.dubbo.config.annotation.Service;
    import org.springframework.stereotype.Component;

    /**
     * @author Joker大雄
     * @data 2022/8/1 - 13:00
     **/
    // 服务注册与发现
    @Service //dubbo的@service
    @Component
    public class TicketServiceImpl implements TicketService{

        @Override
        public String getTicket() {
            return "《jokerdig.com》";
        }
    }

  6. 在application.properties中配置

    1
    2
    3
    4
    5
    6
    7
    8
    # 配置端口
    server.port=8081
    # 服务名
    dubbo.application.name=provider-server
    # 注册地址
    dubbo.registry.address=zookeeper://127.0.0.1:2181
    # 哪些服务要注册
    dubbo.scan.base-packages=com.jokerdig.service

  7. 运行provider-server项目可以在dubbo-admin界面中看到我们的方法

    45

  8. 新建一个SpringBoot的客户端Module名为client-server并勾选Spring Web

  9. 在pom引入依赖

    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
    <!--        引入依赖dubbo+zookeeper-->
    <dependency>
        <groupId>org.apache.dubbo</groupId>
        <artifactId>dubbo-spring-boot-starter</artifactId>
        <version>2.7.3</version>
    </dependency>
    <dependency>
        <groupId>com.github.sgroschupf</groupId>
        <artifactId>zkclient</artifactId>
        <version>0.1</version>
    </dependency>
    <!--        解决日志冲突-->
    <dependency>
        <groupId>org.apache.curator</groupId>
        <artifactId>curator-framework</artifactId>
        <version>2.12.0</version>
    </dependency>
    <dependency>
        <groupId>org.apache.curator</groupId>
        <artifactId>curator-recipes</artifactId>
        <version>2.12.0</version>
    </dependency>
    <dependency>
        <groupId>org.apache.zookeeper</groupId>
        <artifactId>zookeeper</artifactId>
        <version>3.4.14</version>
        <!--        去除slf4j-log4j12-->
        <exclusions>
            <exclusion>
                <groupId>org.slf4j</groupId>
                <artifactId>slf4j-log4j12</artifactId>
            </exclusion>
        </exclusions>
    </dependency>

  10. 在service包下新建UserService类，并复制provider-server中的TicketService接口到service包下

    这里复制的TicketService其实主要是保证与provider-server中的一致即可

    UserService

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    package com.jokerdig.service;

    import org.apache.dubbo.config.annotation.Reference;
    import org.springframework.stereotype.Service;

    /**
     * @author Joker大雄
     * @data 2022/8/1 - 13:07
     **/
    @Service // 这里是spring包下的
    public class UserService {
        // 获取provider-server里的内容
        @Reference // 远程引用 dubbo包下的
        TicketService ticketService;

        public void buyTicket(){
            String ticket = ticketService.getTicket();
            System.out.println("到注册中心拿到了："+ticket);
        }
    }

  11. 在application.properties中进行配置

    1
    2
    3
    4
    5
    6
    # 配置端口
    server.port=8082
    # 消费者获取，暴露自己的名字
    dubbo.application.name=client-server
    # 注册中心地址
    dubbo.registry.address=zookeeper://127.0.0.1:2181

  12. 在测试类中调用，查看是否能从provider-server中获取

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    package com.jokerdig.service;

    import org.apache.dubbo.config.annotation.Reference;
    import org.springframework.stereotype.Service;

    /**
     * @author Joker大雄
     * @data 2022/8/1 - 13:07
     **/
    @Service // 这里是spring包下的
    public class UserService {
        // 获取provider-server里的内容
        @Reference // 远程引用 dubbo包下的
        TicketService ticketService;

        public void buyTicket(){
            String ticket = ticketService.getTicket();
            System.out.println("到注册中心拿到了："+ticket);
        }
    }

  13. 运行test测试

    成功获取到了数据

    1
    到注册中心拿到了：《jokerdig.com》

  14. 步骤小结

    前提：zookeeper服务已开启

    • 提供者提供服务

      1. 导入依赖
      2. 配置注册中心的地址，以及服务发现名，和要扫描的包
      3. 在想要被注册的服务上增加一个注解@Service

    • 消费者如何消费

      1. 导入依赖
      2. 配置注册中心的地址，配置自己的服务名
      3. 从远程注入服务 @Reference