SpringBoot dubbo+zeekeeper

最新推荐文章于 2024-04-18 04:36:06 发布

目起

最新推荐文章于 2024-04-18 04:36:06 发布

阅读量436

点赞数

分类专栏： springboot学习

本文链接：https://blog.csdn.net/cs_quan/article/details/117379642

版权

springboot学习专栏收录该内容

16 篇文章 0 订阅

订阅专栏

1 分布式系统理论

1 什么是分布式

分布式系统是由一组通过网络进行通信、为了完成共同的任务而协调工作的计算机节点组成的系统

分布式系统的出现是为了用廉价的、普通的机器完成单个计算机无法完成的计算、存储任务。其目的是利用更多的机器，处理更多的数据。

分布式系统是若干独立计算机的集合，这些计算机对于用户来说就像单个相关系统”；

分布式常见的网络通信协议有RPC，和HTTP

2 互联网应用架构的发展

单体应用架构

当网站流量很小时，只需一个应用，将所有功能都部署在一起，以减少部署节点和成本。此时，用于简化增删改查工作量的数据访问框架(ORM)是关键。

在这里插入图片描述

适用于小型网站，小型管理系统，将所有功能都部署到一个功能里，简单易用。

缺点：

1、性能扩展比较难

2、协同开发问题

3、不利于升级维护

2 垂直应用架构

当访问量逐渐增大，单一应用增加机器带来的加速度越来越小，将应用拆成互不相干的几个应用，以提升效率。此时，用于加速前端页面开发的Web框架(MVC)是关键。

在这里插入图片描述

通过切分业务来实现各个模块独立部署，降低了维护和部署的难度，团队各司其职更易管理，性能扩展也更方便，更有针对性

缺点：公用模块无法重复利用，开发性的浪费

3 分布式应用架构

当垂直应用越来越多，应用之间交互不可避免，将核心业务抽取出来，作为独立的服务，逐渐形成稳定的服务中心，使前端应用能更快速的响应多变的市场需求。此时，用于提高业务复用及整合的**分布式服务框架(RPC)**是关键。

在这里插入图片描述

4 流动式计算架构

当服务越来越多，容量的评估，小服务资源的浪费等问题逐渐显现，此时需增加一个调度中心基于访问压力实时管理集群容量，提高集群利用率。此时，用于提高机器利用率的资源调度和治理中心(SOA)[ Service Oriented Architecture]是关键。

在这里插入图片描述

2 什么是RPC

RPC【Remote Procedure Call】是指远程过程调用，是一种进程间通信方式，他是一种技术的思想，而不是规范。它允许程序调用另一个地址空间（通常是共享网络的另一台机器上）的过程或函数，而不用程序员显式编码这个远程调用的细节。

1 什么是本地调用

假设你有一个计算器接口，Calculator，以及它的实现类CalculatorImpl，那么在系统还是单体应用时，你要调用Calculator的add方法来执行一个加运算，直接new一个CalculatorImpl，然后调用add方法就行了

2 什么远程调用

现在将系统变为分布式系统，将实现类CalculatorImpl放在另外一台服务器，形成一个服务，那么Calculator如何调用另一台服务器中的代码

解决方案

模仿B/S架构的调用方式呀，在B服务暴露一个Restful接口，然后A服务通过调用这个Restful接口来间接调用B的方法
- 缺点每次调用时，都需要写一串发起http请求的代码，如何让使用者感知不到远程调用的过程
用代理模式呀！而且最好是结合Spring IoC一起使用，通过Spring注入calculator对象，注入时，如果扫描到对象加了@Reference注解，那么就给它生成一个代理对象，将这个代理对象放进容器中。而这个代理对象的内部，就是通过httpClient来实现RPC远程过程调用的。

许多RPC框架就是利用上面原理实现的

RPC要解决的两个问题：

解决分布式系统中，服务之间的调用问题。
远程调用时，要能够像本地调用一样方便，让调用者感知不到远程调用的逻辑。

RPC的本质是通过网络编程的Socket等相关技术，来实现调用远程的服务

RPC的基本原理

在这里插入图片描述
Client 的Application 要调用远程的Server 服务，Client Stub 表示要调用服务接口的代理类，这个代理类通过 Client Run-time Library，（实现远程调用的工具包）通过序列化，将需要调用的请求序列化传输给Server
Server 通过反序列化，以及Client Run-time Library接收 Client的请求信息
通过Server Stub ，所负责的，只是去解析请求对象，知道调用方要调的是哪个RPC接口，传进来的参数又是什么，然后再把这些参数传给对应的RPC接口，即相关服务的实现类去调用，然后通过远程调用，将结果序列化传递给Client

这个过程CLient 就好像调用本地服务一样，实际上是通过远程调用调用远程的服务进行处理

在这里插入图片描述

RPC两个核心模块：通讯，序列化。

如何实现一个RPC

在这里插入图片描述
这里以ServiceA ,要调用ServiceB 为例子

根据完整的RPC流程
在这里插入图片描述
1 Service A的应用层代码中，调用了Calculator的一个实现类的add方法，希望执行一个加法运算；
2 这个Calculator实现类，内部并不是直接实现计算器的加减乘除逻辑，而是通过远程调用Service B的RPC接口，来获取运算结果，因此称之为Stub；
3 Stub怎么和Service B建立远程通讯呢？这时候就要用到远程通讯工具了，也就是图中的Run-time Library，这个工具将帮你实现远程通讯的功能，比如Java的Socket，就是这样一个库，当然，你也可以用基于Http协议的HttpClient，或者其他通讯工具类，都可以，RPC并没有规定说你要用何种协议进行通讯；
4 Stub通过调用通讯工具提供的方法，和Service B建立起了通讯，然后将请求数据发给Service B。需要注意的是，由于底层的网络通讯是基于二进制格式的，因此这里Stub传给通讯工具类的数据也必须是二进制，比如calculator.add(1,2)，你必须把参数值1和2放到一个Request对象里头（这个Request对象当然不只这些信息，还包括要调用哪个服务的哪个RPC接口等其他信息），然后序列化为二进制，再传给通讯工具类，这一点也将在下面的代码实现中体现；
5 二进制的数据传到Service B这一边了，Service B当然也有自己的通讯工具，通过这个通讯工具接收二进制的请求；
既然数据是二进制的，那么自然要进行反序列化了，将二进制的数据反序列化为请求对象，然后将这个请求对象交给Service B的Stub处理；
和之前的Service A的Stub一样，这里的Stub也同样是个“假玩意”，它所负责的，只是去解析请求对象，知道调用方要调的是哪个RPC接口，传进来的参数又是什么，然后再把这些参数传给对应的RPC接口，也就是Calculator的实际实现类去执行。很明显，如果是Java，那这里肯定用到了反射。
6 RPC接口执行完毕，返回执行结果，现在轮到Service B要把数据发给Service A了，怎么发？一样的道理，一样的流程，只是现在Service B变成了Client，Service A变成了Server而已：Service B反序列化执行结果->传输给Service A->Service A反序列化执行结果 -> 将结果返回给Application，完毕。

实际代码
1 服务消费者

1 编程ComsumerApp 调用 Provider 提供的服务


public class ComsumerApp {
    public static void main(String[] args) {
        Calculator calculator = new CalculatorRemoteImpl();
        int result = calculator.add(1, 2);
    }
}

2 CalculatorRemoteImpl 是实现RPC逻辑的类这样客户端调用时感知不到远程调用的麻烦

public class CalculatorRemoteImpl implements Calculator {
    public int add(int a, int b) {
     	// 寻找所有提供 "Calculator.add"的提供者
        List<String> addressList = lookupProviders("Calculator.add");
        // 选择一个提供者
        String address = chooseTarget(addressList);
        try {
        
            Socket socket = new Socket(address, PORT);

            // 将请求序列化
            CalculateRpcRequest calculateRpcRequest = generateRequest(a, b);
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream());

            // 将请求发给服务提供方
            objectOutputStream.writeObject(calculateRpcRequest);

            // 将响应体反序列化
            ObjectInputStream objectInputStream = new ObjectInputStream(socket.getInputStream());
            Object response = objectInputStream.readObject();

            if (response instanceof Integer) {
                return (Integer) response;
            } else {
                throw new InternalError();
            }

        } catch (Exception e) {
            log.error("fail", e);
            throw new InternalError();
        }
    }
}

 //寻找服务提供者，因为可能有多个服务提供者
    public static List<String> lookupProviders(String name) {
        List<String> strings = new ArrayList();
        strings.add("127.0.0.1");
        return strings;
    }

    private String chooseTarget(List<String> providers) {
        if (null == providers || providers.size() == 0) {
            throw new IllegalArgumentException();
        }
        // 默认选择第一个
        return providers.get(0);
    }

3 calculateRpcRequest 将请求封装成一个对象

package com.sexycode.simplerpc.request;

import java.io.Serializable;

public class CalculateRpcRequest implements Serializable {

    private static final long serialVersionUID = 7503710091945320739L;
    private String method;
    private int a;
    private int b;

    public String getMethod() {
        return method;
    }

    public void setMethod(String method) {
        this.method = method;
    }

    public int getA() {
        return a;
    }

    public void setA(int a) {
        this.a = a;
    }

    public int getB() {
        return b;
    }

    public void setB(int b) {
        this.b = b;
    }

    @Override
    public String toString() {
        return "CalculateRpcRequest{" +
                "method='" + method + '\'' +
                ", a=" + a +
                ", b=" + b +
                '}';
    }


}

到此消费者实现完毕

4 服务提供者

1 创建要提供的服务

public interface Calculator {
    int add(int a, int b);
}



public class CalculatorImpl implements Calculator {
    public int add(int a, int b) {
        return a + b;
    }
}

2 创建进行服务提供的类

public class ProviderApp {
    private Calculator calculator = new CalculatorImpl();
    private static Logger log = LoggerFactory.getLogger(ProviderApp.class);

    public static void main(String[] args) {
        new ProviderApp().run();
    }

    private void run(){
        ServerSocket serverSocket = null;
        ObjectInputStream objectInputStream = null;
        ObjectOutputStream objectOutputStream =null;
        Socket accept = null;
        //1 创建 ServerSocket
        try {
            serverSocket = new ServerSocket(9898);

            while (true){
                //2 监听Socket
                 accept = serverSocket.accept();
                //3 获取消费者的请求
                 objectInputStream = new ObjectInputStream(accept.getInputStream());
                Object object = objectInputStream.readObject();
                log.info("request is {}", object);

                int result=0;
                //4 对消费者的请求进行处理，
                if (object instanceof CalculateRpcRequest){
                   CalculateRpcRequest calculateRpcRequest =  (CalculateRpcRequest) object;
                    if ("add".equals(calculateRpcRequest.getMethod())) {
                        result = calculator.add(calculateRpcRequest.getA(), calculateRpcRequest.getB());
                    } else {
                        throw new UnsupportedOperationException();
                    }
                }

                //5 将计算的结果序列化后，发送给消费者
                 objectOutputStream = new ObjectOutputStream(accept.getOutputStream());
                objectOutputStream.writeObject(result);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            if (serverSocket != null){
                try {
                    serverSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            if (accept != null){
                try {
                    accept.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            if (objectInputStream != null){
                try {
                    objectInputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            if (objectOutputStream != null){
                try {
                    objectOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }


}

5 项目中需要的依赖,以及相关的配置文件

# Set root logger level to DEBUG and its only appender to A1.
log4j.rootLogger=DEBUG, A1

# A1 is set to be a ConsoleAppender.
log4j.appender.A1=org.apache.log4j.ConsoleAppender

# A1 uses PatternLayout.
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=%-4r [%t] %-5p %c %x - %m%n

6 依赖

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>${slf4jVersion}</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>${slf4jVersion}</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.16</version>
            <scope>runtime</scope>
        </dependency>
    </dependencies>

小结
RPC的本次还是利用了远程调用的相关库，比如Socket，将请求序列化
然后远程调用别的服务，然后把结果序列化，传递给Client端
就这样我们实现了一个简陋而又详细的RPC。

缺点
1、缺乏通用性
我通过给Calculator接口写了一个CalculatorRemoteImpl，来实现计算器的远程调用，下一次要是有别的接口需要远程调用，是不是又得再写对应的远程调用实现类？这肯定是很不方便的
那该如何解决呢？先来看看使用Dubbo时是如何实现RPC调用的：

@Reference
private Calculator calculator;

...

calculator.add(1,2);

Dubbo通过和Spring的集成，在Spring容器初始化的时候，如果扫描到对象加了@Reference注解，那么就给这个对象生成一个代理对象，这个代理对象会负责远程通讯，然后将代理对象放进容器中。所以代码运行期用到的calculator就是那个代理对象了。
我们可以先不和Spring集成，也就是先不采用依赖注入，但是我们要做到像Dubbo一样，无需自己手动写代理对象，怎么做呢？那自然是要求所有的远程调用都遵循一套模板，把远程调用的信息放到一个RpcRequest对象里面，发给Server端，Server端解析之后就知道你要调用的是哪个RPC接口、以及入参是什么类型、入参的值又是什么，就像Dubbo的RpcInvocation：

public class RpcInvocation implements Invocation, Serializable {

private static final long serialVersionUID = -4355285085441097045L;

private String methodName;

private Class<?>[] parameterTypes;

private Object[] arguments;

private Map<String, String> attachments;

private transient Invoker<?> invoker;

2、集成Spring
在实现了代理对象通用化之后，下一步就可以考虑集成Spring的IOC功能了，通过Spring来创建代理对象，这一点就需要对Spring的bean初始化有一定掌握了。

3、长连接or短连接
总不能每次要调用RPC接口时都去开启一个Socket建立连接吧？是不是可以保持若干个长连接，然后每次有rpc请求时，把请求放到任务队列中，然后由线程池去消费执行？只是一个思路，后续可以参考一下Dubbo是如何实现的。

4 我们现在的Server端，是单线程的，每次都要等一个请求处理完，才能去accept另一个socket的连接，这样性能肯定很差，是不是可以通过一个线程池，来实现同时处理多个RPC请求？同样只是一个思路。

5 正如之前提到的，要调用服务，首先你需要一个服务注册中心，告诉你对方服务都有哪些实例。Dubbo的服务注册中心是可以配置的，官方推荐使用Zookeeper。如果使用Zookeeper的话，要怎样往上面注册实例，又要怎样获取实例，这些都是要实现的

6 如何从多个实例里挑选一个出来，进行调用，这就要用到负载均衡了。负载均衡的策略肯定不只一种，要怎样把策略做成可配置的？又要如何实现这些策略？同样可以参考Dubbo

7、结果缓存
每次调用查询接口时都要真的去Server端查询吗？是不是要考虑一下支持缓存？

8、异步调用
客户端调用完接口之后，不想等待服务端返回，想去干点别的事，可以支持不？

Dubbo的原理重要

在这里插入图片描述

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

服务消费者（Consumer）：调用远程服务的服务消费方，服务消费者在启动时，向注册中心订阅自己所需的服务，服务消费者，从提供者地址列表中，基于软负载均衡算法，选一台提供者进行调用，如果调用失败，再选另一台调用

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

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

调用关系说明

l 服务容器负责启动，加载，运行服务提供者。

l 服务提供者在启动时，向注册中心注册自己提供的服务。

l 服务消费者在启动时，向注册中心订阅自己所需的服务。

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

l 服务消费者，从提供者地址列表中，基于软负载均衡算法，选一台提供者进行调用，如果调用失败，再选另一台调用。

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

3 Dubbo环境搭建

1 下载安装zookeeper

ZooKeeper 是一个用于维护配置信息、命名、提供分布式同步和提供组服务的集中服务。

所有这些类型的服务都以某种形式被分布式应用程序所使用。

Zookeeper是一个注册中心，常见的注册中心有

1 zookeeper的安装

1 下载地址

https://www.apache.org/dyn/closer.lua/zookeeper/zookeeper-3.7.0/apache-zookeeper-3.7.0-bin.tar.gz

2 下载后解压文件夹

在这里插入图片描述

3 进入bin文件中，zkServer.cmd ,如果出现闪退

编辑zkServer.cmd

taskkill /pid %%%%p /t /f" -cp "%CLASSPATH%" %ZOOMAIN% "%ZOOCFG%" %*
//加上
pause
endlocal

这样我们能够查看具体出现的问题 显示zoo.config 未找到

4 进入config文件夹，复制zoo_sample.cfg，重命名为zoo.cfg

5 双击 zkServer.cmd zkCli.cmd 查看是否启动成功

zookeeper的默认端口号2181

6 zookeeper的常见命令

ls /：列出zookeeper根下保存的所有节点
create –e /kuangshen 123：创建一个kuangshen节点，值为123
get /kuangshen：获取/kuangshen节点的值

2 window下安装dubbo-admin

dubbo-admin ：是一个监控管理后台，查看我们注册了哪些服务，哪些服务被消费了

1 下载dubbo-admin

1 https://github.com/apache/dubbo-admin/tree/master

2 解压

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

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

mvn clean package -Dmaven.test.skip=true

打包时间有点久

在这里插入图片描述

出现上面结果则成功

如果失败，请修改dubbo-admin-master 下的prom.xml 的jdk版本
在这里插入图片描述

重新打包

4 打开zookeeper的服务 Server.cmd Cli.cmd

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

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

6 访问一下 http://localhost:7001/ 需要输入登录账户和密码，都是默认的root-root；

4 服务注册发现实战

创建多个SpringBoot 模块，实现注册Provider模块中的服务到注册中兴，Consumer模块从注册中心调用Provider注册的服务

1 创建一个空项目

NEW->PROJECT ->EMPTY PROJECT

2 创建两个SpringBoot 模块

在这里插入图片描述

添加SpringBoot -web依赖即可

3 进入provider-server

导入依赖


   <!--dubbo-->
        <!-- Dubbo Spring Boot Starter -->
        <!-- https://mvnrepository.com/artifact/org.apache.dubbo/dubbo-spring-boot-starter -->
        <!--        Dubbo 依赖-->
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo-spring-boot-starter</artifactId>
            <version>2.7.8</version>
        </dependency>
        <!--        zookeeper依赖-->
        <!-- https://mvnrepository.com/artifact/com.github.sgroschupf/zkclient -->
        <dependency>
            <groupId>com.github.sgroschupf</groupId>
            <artifactId>zkclient</artifactId>
            <version>0.1</version>
        </dependency>
  <!-- 引入zookeeper，依赖包，以及新版解决和SpringBoot 的日志冲突 -->
        <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>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

创建要提供的服务

public interface TicketService {

    String getTicket();
}
//将服务自动注册到服务中心
@DubboService
//注册bean 
@Service
public class TicketServiceImpl implements TicketService{
    @Override
    public String getTicket() {
        return "<<狂神说Java>>";
    }
}

老版本Dubbo ,有和Spring Framarker 一样的@Service 注解，作用和DubboService一样

在配置文件中配置Dubbo信息
- Dubbo应用名
- 注册中心地址
- 要扫描的服务

# 配置Dubbo的相关属性
dubbo.application.name=provider-server
#配置要扫描的服务
dubbo.scan.base-packages=com.kuang.service
#配置注册中心的地址
dubbo.registry.address=zookeeper://127.0.0.1:2181

4 进入consumer-server

1 导入依赖，和上面一样

  <!-- 引入zookeeper，依赖包，以及新版解决和SpringBoot 的日志冲突 -->
        <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>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

2 配置Dubbo信息

#配置Dubbo
dubbo.application.name=consumer-server
dubbo.registry.address=zookeeper://127.0.0.1:2181

3 使用服务

@Service
public class UserService {

	//远程引用指定的服务，他会按照全类名进行匹配，看谁给注册中心注册了这个全类名
    @DubboReference
    private TicketService ticketService;

    public void buyTicket(){
        System.out.println("在注册中心买了一张"+ticketService.getTicket());
    }
}

注意应该建立和提供服务相同包结构的TicketService服务接口

4 测试

启动两个模块再进行测试

@SpringBootTest
class ConsumerServerApplicationTests {


    @Autowired
    private UserService userService;

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

}

注意这里后台服务都应该开启如 Dubbo 的服务
Zookeeper的服务

访问http://localhost:7001/ 查看提供者和消费者，两者都存在

在这里插入图片描述

成功

参考文档

作者：柳树之
链接：https://www.jianshu.com/p/5b90a4e70783
作者：狂神说
原文链接：https://blog.csdn.net/qq_33369905/article/details/106647287

目起

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
3
评论
SpringBoot dubbo+zeekeeper

1 分布式系统理论1 什么是分布式分布式系统是由一组通过网络进行通信、为了完成共同的任务而协调工作的计算机节点组成的系统分布式系统的出现是为了用廉价的、普通的机器完成单个计算机无法完成的计算、存储任务。其目的是利用更多的机器，处理更多的数据。分布式系统是若干独立计算机的集合，这些计算机对于用户来说就像单个相关系统”；分布式常见的网络通信协议有RPC，和HTTP2 互联网应用架构的发展单体应用架构当网站流量很小时，只需一个应用，将所有功能都部署在一起，以减少部署节点和成本。此时，用于简化增
复制链接

扫一扫