什么是分布式

在了解什么是dubbo和zookeeper之前，我们需要先了解什么是分布式，因为dubbo和zookeeper就是为了解决分布式所带来的问题才顺势而生的。以下是百度百科对分布式的介绍：

分布式服务顾名思义服务是分散部署在不同的机器上的，一个服务可能负责几个功能，是一种面向SOA架构的，服务之间也是通过rpc来交互或者是webservice来交互的。逻辑架构设计完后就该做物理架构设计，系统应用部署在超过一台服务器或虚拟机上，且各分开部署的部分彼此通过各种通讯协议交互信息，就可算作分布式部署，生产环境下的微服务肯定是分布式部署的，分布式部署的应用不一定是微服务架构的，比如集群部署，它是把相同应用复制到不同服务器上，但是逻辑功能上还是单体应用。

以往的项目都基本是单体应用，所有的功能都在一个项目模块里，这样的部署方式对于用户访问量少的小型应用来说是可以这么做的，但对于访问量大的应用来说，由于某一功能的经常访问，可能会导致服务器的奔溃，这时候就有两个分布式的解决方案可供选择：

• 第一是多部署几台服务器，每台服务器都能处理相同的请求任务，然后利用负载均衡实现各服务器之间的利用率平衡，这就是集群。
• 第二是将项目分成几个模块，分别部署在不同的服务器上，对于访问请求次数多的模块可以多分配服务器。

分布式的出现我认为就是为了减轻服务器的压力，防止项目奔溃停止，也为了解耦合。分布式的出现也面临着一些问题，比如部署在不同服务器中的模块如何进行通信，怎么管理这些分散的服务，服务崩了怎么办等等一些列问题，所以就顺势而出了很多解决问题的框架，dubbo就是其中之一。

什么是dubbo

以下是百度给的解释：

Dubbo(读音[ˈdʌbəʊ])是阿里巴巴公司开源的一个高性能优秀的服务框架，使得应用可通过高性能的 RPC 实现服务的输出和输入功能，可以和 Spring框架无缝集成。
Dubbo是一款高性能、轻量级的开源Java RPC框架，它提供了三大核心能力：面向接口的远程方法调用，智能容错和负载均衡，以及服务自动注册和发现。

看介绍发现了个新的知识点—RPC，什么是RPC呢？不慌，再问下百度

RPC是远程过程调用（Remote Procedure Call）的缩写形式。SAP系统RPC调用的原理其实很简单，有一些类似于三层构架的C/S系统，第三方的客户程序通过接口调用SAP内部的标准或自定义函数，获得函数返回的数据进行处理后显示或打印。

我的理解是以前我们的调用都是本地调用，在类里面写方法然后在别的类或者自己类调用，这些都是在本地进行的，而远程调用就是部署在不同服务器上的两个模块，其中一个模块要调用另一个模块中某个接口中的方法。拿生活中的事情举个例子，你在网上购物，平常快递到了你都是自己去快递站拿快递，可是某一天你有事出差了，快递又刚好到了，你就打电话叫你的好朋友帮你去拿下快递，这就是远程调用。
以下是官网给Dubbo的原理图：

这张图的执行流程就是首先你需要一个Provider来提供服务并且注册到Registry（注册中心）,对于要使用的服务的Consumer需要向Registry订阅你所需要的服务，然后注册中心会返回给你提供者的地址，然后你选择其中一个来执行服务，Moniter就是个监控中心，隔断时间就监控Consumer和Provider的状态。Dubbo只是个框架，其中Registry需要外界提供，而这就是zookeeper,对于zookeeper，就是文件系统+监听机制。

Springboot 整合dubbo和zookeeper

1、下载zookeeper

百度网盘下载链接–>下载链接 提取码：1314
下载后解压如下：

点开conf,复制一份下面的文件在当前位置并改名为： zoo.cfg

如果要开启服务就点开bin，看自己是什么系统就点哪个

2、springboot的配置

1、创建两个modul，分别是provider和consumer，如下（可以先创建Empty项目，再创建两个modul,因为只是简单测试，只需勾选web模块就行）

3、provider的配置

1、导入相关的依赖

 <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
     </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo-spring-boot-starter</artifactId>
            <version>2.7.12</version>
        </dependency>

        <dependency>
            <groupId>com.github.sgroschupf</groupId>
            <artifactId>zkclient</artifactId>
            <version>0.1</version>
        </dependency>
        <!-- 引入zookeeper -->
        <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>
            <exclusions>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>slf4j-log4j12</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

2、创建需要提供服务的包

TickServiceImpl类如下：

import org.apache.dubbo.config.annotation.DubboService;
import org.springframework.stereotype.Component;

@DubboService//向注册中心暴露该服务
@Component
public class TickServiceImpl implements TickService {
    @Override
    public String printInfo() {
        return "hello world";
    }
}

还得在启动类加上个注解@EnableDubbo

3、配置文件

#服务的名称
dubbo.application.name=provider-server
#服务注册地址
dubbo.registry.address=zookeeper://127.0.0.1:2181
#提供的服务
dubbo.scan.base-packages=com.example.service
#项目启动端口
server.port=8081

这里的2181你自己也可以改成别的，点开刚改名的zoo.cfg文件

到这provider就配置完了。

4、consumer配置

1、导入依赖（与provider导入的依赖一样）
2、创建相应的包

3、配置文件

#服务的名称
dubbo.application.name=consume-server
#服务注册地址
dubbo.registry.address=zookeeper://127.0.0.1:2181

server.port=8082

4、创建个测试类来引用

@Component
public class UserService {

    @DubboReference//引用provider提供的服务
    TickService tickService;

    public void info(){
        System.out.println(tickService.printInfo());
    }

}

到这consumer就写好了，接下来就是测试了。

测试

1、首先要打开zookeeper服务


2、先打开provider项目，再打开consumer项目

3、在consumer中写个测试

@SpringBootTest
class ConsumerServerApplicationTests {

    @Autowired
    UserService userService;

    @Test
    void contextLoads() {
        userService.info();
    }

}

测试结果如下：

1、Zookeeper的安装

1. Zookeeper概述

ZooKeeper 是一种分布式协调服务，用于管理大型主机。在分布式环境中协调和管理服务是一个复杂的过程。ZooKeeper 通过其简单的架构和 API 解决了这个问题。ZooKeeper 允许开发人员专注于核心应用程序逻辑，而不必担心应用程序的分布式特性。

ZooKeeper 框架最初是在“Yahoo!"上构建的，用于以简单而稳健的方式访问他们的应用程序。 后来，Apache ZooKeeper 成为 Hadoop，HBase 和其他分布式框架使用的有组织服务的标准。 例如，Apache HBase 使用 ZooKeeper 跟踪分布式数据的状态。

(更多信息：https://www.w3cschool.cn/zookeeper/zookeeper_overview.html)

2. Zookeeper的安装与启动

去官网：https://archive.apache.org/dist/zookeeper/
下载对应的安装包，我选择zookeeper-3.3.6版本。其他高版本，如zookeeper-3.5.8、zookeeper-3.6.2在Windows 10可能无法启动（亲测），不服可以试试。原因我没有去探究。

下载完成后，在zookeeper-3.3.6\conf\目录下 把 zoo_sample.cfg 改为 zoo.cfg

然后在zookeeper-3.3.6\bin 目录下 双击zkServer.cmd文件启动zookeeper（Windows）

如图表示启动成功，它会一直停在那个cmd窗口（表示服务正在运行），直到你关闭命令窗口（服务停止）

2、springboot整合Dubbo和Zookeeper实现分布式开发

Dubbo是阿里巴巴公司开源的一个高性能优秀的服务框架，使得应用可通过高性能的 RPC 实现服务的输出和输入功能，可以和Spring框架无缝集成。

Dubbo是一款高性能、轻量级的开源Java RPC框架，它提供了三大核心能力：面向接口的远程方法调用，智能容错和负载均衡，以及服务自动注册和发现。

1. 创建服务接口模块dubbotest-api

总体上项目是这样的

dubbotest-api项目是一个maven项目，主要是定义接口与实体类，用于提供接口，类似于数据库的dao层。
主要代码如下：
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>

    <groupId>org.example</groupId>
    <artifactId>dubbotest-api</artifactId>
    <!-- 打包成正式版,这样生产者与消费者就可以引用 -->
    <version>1.0.0</version>
</project>

UserService.java

package com.example.duubo.service;

/*
*  springboot接口
*  ye
*  2020.12.04
* */
public interface UserService {
    public String hello(String name);
}

2. 开发dubbotest-provider生产者模块

dubbotest-provider 是一个生产者通过实现dubbotest-api的接口可以提供服务，也可以自己创建自己的服务，在这一点类似于springboot 的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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.4.0</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>dubbotest-provider</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>dubbotest-provider</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>

        <!--dubbo -->
        <dependency>
            <groupId>com.alibaba.spring.boot</groupId>
            <artifactId>dubbo-spring-boot-starter</artifactId>
            <version>2.0.0</version>
        </dependency>
        <!-- zookeeper -->
        <dependency>
            <groupId>com.101tec</groupId>
            <artifactId>zkclient</artifactId>
            <version>0.10</version>
        </dependency>

        <!-- 接口的jar包 -->
        <dependency>
            <groupId>org.example</groupId>
            <artifactId>dubbotest-api</artifactId>
            <version>1.0.0</version>
        </dependency>
        
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

application.properties

# 端口
server.port = 8081

# Dubbo配置,不能少,工程的名字
spring.application.name=dubbotest-provider

# 表示提供者，可以省略
spring.dubbo.server=true

# 注册中心地址
spring.dubbo.registry=zookeeper://localhost:2181

入口类

package com.example.dubbotestprovider;

import com.alibaba.dubbo.spring.boot.annotation.EnableDubboConfiguration;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@EnableDubboConfiguration  //开启自动配置支持
public class DubbotestProviderApplication {

    public static void main(String[] args) {
        SpringApplication.run(DubbotestProviderApplication.class, args);
    }

}

UserServiceImpl.java

package com.example.dubbotestprovider.serviceimpl;

import com.alibaba.dubbo.config.annotation.Service;
import com.example.duubo.service.UserService;
import org.springframework.stereotype.Component;

/*
*  服务提供者
*  ye
*  2020.12.04
* */

@Component
// 相当于 <dubbo:service interface="" ref="">
@Service(interfaceClass = UserService.class,timeout = 10000)
public class UserServiceImpl implements UserService {
    @Override
    public String hello(String name) {
        return "你好呀~"+name;
    }
}

3. 开发dubbotest-consumer消费者模块

消费者是使用生产者的服务的一种角色，类似于springboot的controller层
具体代码如下：

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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.4.0</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>dubbotest-consumer</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>dubbotest-consumer</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <!--dubbo -->
        <dependency>
            <groupId>com.alibaba.spring.boot</groupId>
            <artifactId>dubbo-spring-boot-starter</artifactId>
            <version>2.0.0</version>
        </dependency>

        <!-- zookeeper -->
        <dependency>
            <groupId>com.101tec</groupId>
            <artifactId>zkclient</artifactId>
            <version>0.10</version>
        </dependency>


        <!-- 接口的jar包 -->
        <dependency>
            <groupId>org.example</groupId>
            <artifactId>dubbotest-api</artifactId>
            <version>1.0.0</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

application.properties

# 端口
server.port = 8082

# Dubbo配置,不能少
spring.application.name=dubbotest-consumer

# 表示提供者，可以省略
spring.dubbo.appname=springboot-dubbo-consumer

# 注册中心地址
spring.dubbo.registry=zookeeper://localhost:2181

入口类

package com.example.dubbotestconsumer;

import com.alibaba.dubbo.spring.boot.annotation.EnableDubboConfiguration;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@EnableDubboConfiguration  //开启自动配置支持
public class DubbotestConsumerApplication {

    public static void main(String[] args) {
        SpringApplication.run(DubbotestConsumerApplication.class, args);
    }

}

UserController.java

package com.example.dubbotestconsumer.controller;

import com.alibaba.dubbo.config.annotation.Reference;
import com.example.duubo.service.UserService;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

/*
*  消费者
*  ye
*  2020.12.04
*
* */

@RestController
public class UserController {

    //引用远程的dubbo服务 <dubbo:refrence id="" interface="">
    @Reference
    private UserService userService;

    @GetMapping("/dubbotest")
    public String hello(){
        return userService.hello("Chasing stars");
    }
}

4.测试

打开zookeeper服务，运行生产者，消费者模块，在浏览器输入 http://localhost:8082/dubbotest
出现如下图：

表示测试成功！

参考资料：https://www.w3cschool.cn/zookeeper/zookeeper_overview.html
参考资料：https://baike.baidu.com/item/Dubbo/18907815?fr=aladdin

服务提供者（Provider）：暴露服务的服务提供方，服务提供者在启动时，向注册中心注册自己提供的服务。
服务消费者（Consumer）: 调用远程服务的服务消费方，服务消费者在启动时，向注册中心订阅自己所需的服务，服务消费者，从提供者地址列表中，基于软负载均衡算法，选一台提供者进行调用，如果调用失败，再选另一台调用。
注册中心（Registry）：注册中心返回服务提供者地址列表给消费者，如果有变更，注册中心将基于长连接推送变更数据给消费者
监控中心（Monitor）：服务消费者和提供者，在内存中累计调用次数和调用时间，定时每分钟发送一次统计数据到监控中心

1. dubbo 环境安装

1.1 Windows下zookeeper安装使用

1. 下载zookeeper 链接
2. 解压zookeeper
3. 运行zkServer.cmd ，初次运行会报错，没有zoo.cfg配置文件
4. 修改zoo.cfg配置文件
5. 将conf下的zoo_sample.cfg复制一份改名为zoo.cfg即可。
   注意几个重要位置：
   dataDir=./ 临时数据存储的目录（可写相对路径）
   clientPort=2181 zookeeper的端口号
   修改完成后再次启动zookeeper
6. 使用zkCli.cmd测试
   ls /：列出zookeeper根下保存的所有节点
   create –e /atguigu 123：创建一个atguigu节点，值为123
   get /atguigu：获取/atguigu节点的值

1.2 Windos下安装dubbo-admin管理控制台

1. 下载dubbo-admin 链接
2. 进入目录，修改dubbo-admin
3. 配置修改 src\main\resources\application.properties 指定zookeeper地址
   
4. 打包dubbo-admin

 mvn clean package -Dmaven.test.skip=true 

5. 运行dubbo-admin

java -jar dubbo-admin-0.0.1-SNAPSHOT.jar

6. 

2. springboot的配置

2.1 创建两个modul，分别是provider和consumer，如下（可以先创建Empty项目，再创建两个modul,因为只是简单测试，只需勾选web模块就行）

2.2 provider的配置

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.apache.dubbo</groupId>
    <artifactId>dubbo-spring-boot-starter</artifactId>
    <version>2.7.12</version>
</dependency>

<dependency>
    <groupId>com.github.sgroschupf</groupId>
    <artifactId>zkclient</artifactId>
    <version>0.1</version>
</dependency>
<!-- 引入zookeeper -->
<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>
    <exclusions>
        <exclusion>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
        </exclusion>
    </exclusions>
</dependency>

2.3 创建需要提供服务的包

2.3.1 TickService接口代码

package com.muluo.service;

/**
 * @author Muluo
 * @create 2022-04-06 16:52
 */
public interface TickService {
    String printInfo();
}

2.3.2 TickServiceImpl实现类代码

package com.muluo.service;

import org.apache.dubbo.config.annotation.DubboService;
import org.springframework.stereotype.Component;

/**
 * @author Muluo
 * @create 2022-04-06 16:52
 */
@DubboService
@Component
public class TickServiceImpl implements TickService {

    @Override
    public String printInfo() {
        return "Hello World";
    }
}

2.3.3 启动类加注解

package com.muluo;

import org.apache.dubbo.config.spring.context.annotation.EnableDubbo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@EnableDubbo(scanBasePackages = {"com.muluo.service"})
@SpringBootApplication
public class ProviderApplication {

    public static void main(String[] args) {
        SpringApplication.run(ProviderApplication.class, args);
    }

}

2.4 配置文件

server.port=9090
dubbo.application.name=provider-server
dubbo.registry.address=zookeeper://127.0.0.1:2181
dubbo.scan.base-packages=com.muluo.service
#dubbo.protocol.port=2022

2.5 consumer配置

1. 导入依赖（与provider导入的依赖一样）
2. 创建相应的包
   

2.6 配置consumer的配置文件

server.port=9091
#服务的名称
dubbo.application.name=consume-server
#服务注册地址
dubbo.registry.address=zookeeper://127.0.0.1:2181

2.7 创建个测试类

@Component
public class UserService {

    @DubboReference//引用provider提供的服务
    TickService tickService;

    public void info(){
        System.out.println(tickService.printInfo());
    }

}

3 测试过程

3.1 打开zookeeper

3.2 打开dubbo监控中心

3.3 启动provider

3.4 启动consumer

3.5 测试结果