dubbo的学习笔记

dubbo的学习笔记
分布的简单介绍

Dubbo是用于分布式系统的框架所以我们要先了解什么是分布式

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

老式系统(单一应用架构)就是把一个系统，统一放到一个服务器当中然后每一个服务器上放一个系统，如果说要更新代码的话，每一个服务器上的系统都要重新去部署十分的麻烦。

而分布式系统就是将一个完整的系统拆分成多个不同的服务，然后在将每一个服务单独的放到一个服务器当中。

应用架构的发展演变

下面图片来自dubbo的官网Apache Dubbo

发展演变

**ORM **单一应用架构：一个项目装到一个服务器当中，也可以运行多个服务器每一个服务器当中都装一个项目。

缺点：
1. 如果要添加某一个功能的话就要把一个项目重新打包，在分别部署到每一个服务器当中去。
2. 如果后期项目越来越大的话单台服务器跑一个项目压力会很大的。会不利于维护，开发和程序的性能。
**MVC **垂直应用架构：将应用切割成几个互不相干的小应用，在将每个小应用独立放到一个服务器上，如果哪一个应用的访问数量多就多加几台服务器。

分布式服务架构

RPC简介

分布式应用架构(远程过程调用)：当垂直应用越来越多，应用之间交互不可避免，将核心业务抽取出来，作为独立的服务，逐渐形成稳定的服务中心，使前端应用能更快速的响应多变的市场需求。

什么叫RPC
1. RPC [ Remote Procedure Call]是指远程过程调用，是一种进程问通信方式，他是一种技术的思想，而不是规范。它允许程序调用另一个地址空间(通常是共享网络的另一台机器上)的过程或函数，而不用程序员显式编码这个远程调用的细节。即程序员无论是调用本地的还是远程的函数，本质上编写的调用代码基本相同。
2. RPC（Remote Procedure Call）— 远程过程调用，它是一种通过网络从远程计算机程序上请求服务，而不需要了解底层网络技术的协议。也就是说两台服务器A，B，一个应用部署在A服务器上，想要调用B服务器上应用提供的方法，由于不在一个内存空间，不能直接调用，需要通过网络来表达调用的语义和传达调用的数据。
RPC的工作原理

下面是对于上图的详细解释,也就是上面原理图的详细执行过程
1. Client像调用本地服务似的调用远程服务；
2. Client stub接收到调用后，将方法、参数序列化
3. 客户端通过sockets将消息发送到服务端
4. Server stub 收到消息后进行解码（将消息对象反序列化）
5. Server stub 根据解码结果调用本地的服务
6. 本地服务执行(对于服务端来说是本地执行)并将结果返回给Server stub
7. Server stub将返回结果打包成消息（将结果消息对象序列化）
8. 服务端通过sockets将消息发送到客户端
9. Client stub接收到结果消息，并进行解码（将结果消息反序列化）
10. 客户端得到最终结果。
RPC 调用分以下两种：

同步调用：客户方等待调用执行完成并返回结果

异步调用：客户方调用后不用等待执行结果返回，但依然可以通过回调通知等方式获取返回结果。若客户方不关心调用返回结果，则变成单向异步调用，单向调用不用返回结果。

RPC步骤解析

SOA
流动计算架构：在分布式应用架构的基础上增加了一个调度、治理中心基于访问压力实时管理集群容量、提高集群的利用率，用于提高机器利用率的资源调度和治理中心(SOA) 是关键 (不浪费计算机资源)

dubbo的核心概念

下图截至dubbo的官网,dubbo由阿里开源给Apache组织

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

 dubbo设计架构

该图来自Dubbo官网，描述了服务注册中心、服务提供方、服务消费方、服务监控中心之间的调用关系。

蓝颜色的线为初始化的过程,对于为图中的0,1,2,0这个过程为服务启动的过程

而红色的虚线为异步调用的过程

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

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

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

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

Dubbo的特性

（1）服务注册中心
- 相比Hessian类RPC框架，Dubbo有自己的服务中心，写好的服务可以注册到服务中心，客户端从服务中心寻找服务，然后再到相应的服务提供者机器获取服务。通过服务中心可以实现集群、负载均衡、高可用(容错) 等重要功能。
- 服务中心一般使用zookeeper实现，也有redis和其他一些方式。以使用zookeeper作为服务中心为例，服务提供者启动后会在zookeeper的/dubbo节点下创建提供的服务节点，包含服务提供者ip、port等信息。服务提供者关闭时会从zookeeper中移除对应的服务。
- 服务使用者会从注册中心zookeeper中寻找服务，同一个服务可能会有多个提供者，Dubbo会帮我们找到合适的服务提供者，也就是针对服务提供者的负载均衡。
（2）负载均衡
- 当同一个服务有多个提供者在提供服务时，客户端如何正确的选择提供者实现负载均衡呢？dubbo也给我们提供了几种方案
  - random 随机选提供者，并可以给提供者设置权重
  - roundrobin 轮询选择提供者
  - leastactive 最少活跃调用数，相同活跃数的随机，活跃数：指调用前后计数差。使慢的提供者收到更少请求，因为越慢的提供者的调用前后计数差会越大。
  - consistenthash 一致性hash，相同参数的请求发到同一台机器上。
（3）简化测试，允许直连提供者

在开发阶段为了方便测试，通常系统客户端能指定调用某个服务提供者，那么可以在引用服务时加一个url参数去指定服务提供者。配置如下：
```
 <dubbo:reference id="xxxService"interface="com.alibaba.xxx.XxxService"url="dubbo://localhost:20890"/>
1
```
（4）服务版本，服务分组

在Dubbo配置文件中可以通过制定版本实现连接制定提供者，也就是通过服务版本可以控制服务的不兼容升级；当同一个服务有多种实现时，可以使用服务分组进行区分。

dubbo环境搭建 ZooKeeper注册中心

 搭建zookeeper注册中心环境

官网参考地址,由于官网会不断的更新和改变,官网是最好的参考资料Zookeeper | Apache Dubbo

安装,得到对应版本的软件之后,直接解压就可以用了吗,不过需要修改一些配置。

在zookeeper官网下载zookeeper
http://mirror.bit.edu.cn/apache/zookeeper/zookeeper-3.4.14/

下载的为3.4.14版本的

进入到conf目录下

复制文件
- 修改配置文件
可以看到上面的配置文件中的数据存储的方式是以linux系统的方式进行存储的,可以修改为window下的,并创建对应的目录
- 创建data目录
- 通过cmd命令进入到黑窗口之后,执行命令
- 可以看到服务在2181端口启动了
- 验证,进入一个新的黑窗口,注意是在bin目录下执行命令,bin下的为可执行文件
进入到该界面,表示没有问题
- 测试
再次查看的可以看到有两个节点了

如果想要详细的了解Dubbo可以参考官方的资料,使用

 Zookeeper 注册中心的基本使用和工作原理。

如果想要了解更多由于Zookeeper的原理有关的知识,可以参考下面的文档Zookeeper | Apache Dubbo

zookeeper监控中心的配置和安装

1、下载dubbo-admin

可以在github中进行下载,如果github没有当前的版本,可以直接使用后面的资料中提供的下好的安装包。下载的可以说是一个完整的项目,现在需要做的就是将这个项目部署在服务器中。(一般使用别人的项目在自己的环境中进行运行的话,都需要修改一些配置文件)

下载之后解压的文件
- 打开配置文件之后发现和我们所期待的配置相同,因此不需要改动
- 通过cmd命令进入到dubbo-admin目录下,通过mvn对项目进行打包
  
  注意:打包可能需要花费几分钟的时间,需要耐心等待,同时注意zkServer.cmd是否开启状态(没有开启将会失败)
建议在打包前最好查看一下当前maven的版本,版本过高可能会打包失败。

我当前使用的版本为3.6.1
```
mvn -v    //查看版本
maven clean package         //清理并打包,如果是第一次打包该项目,可以不需要clean命令
1
2
```
- 打包成功
可以看到该目录下会多出一个目录

进入之后就可以看到一个打包好的文件,该打包好的现在已经可以单独执行了
- 可以把打包好的文件单独拿出来,这样看起来更舒服
- 在该jar所在的目录进入cmd中,运行该jar包,和平时的springboot项目启动一样
```
java -jar dubbo-admin-0.0.1-SNAPSHOT.jar
1
```
- 测试,在浏览器中输入
```
127.0.0.1:7001
1
```
  会提示输入账号和密码都为root
- 运行界面
Dubbo环境搭建，创建提供者、消费者项目

基于以下图实现服务提供者、消费者

 消费者接口的搭建

创建Maven项目=> user-service-provider 服务提供者

通过idea创建一个maven项目

为了避免不必要的麻烦,在本项目中就没有连接数据库,而是通过假数据的方式

UserAddress.java
```
public class UserAddress implements Serializable {
    private Integer id;
    private String userAddress; //用户地址
    private String userId; //用户id
    private String consignee; //收货人
    private String phoneNum; //电话号码
    private String isDefault; //是否为默认地址    Y-是     N-否
    
    //下面是get,set,无参构造,有参构造,可以通过 @Data注解的方式生成,也可以通过快捷键的方式生成
}
1
2
3
4
5
6
7
8
9
10
```
UserService
```
public  interface UserService {
    /**
     * 按照用户的id返回所有的收获地址
     * @param userId
     * @return
     */
    public List<UserAddress> getUserAddressList(String userId);
}
1
2
3
4
5
6
7
8
```
接口的实现类UserServiceImp.java
```
public class UserServiceImpl implements UserService {
    public List<UserAddress> getUserAddressList(String userId) {

        UserAddress address1 = new UserAddress(1, "河南省郑州巩义市宋陵大厦2F", "1", "安然", "150360313x", "Y");
        UserAddress address2 = new UserAddress(2, "北京市昌平区沙河镇沙阳路", "1", "情话", "1766666395x", "N");
        return Arrays.asList(address1,address2);
    }
}
1
2
3
4
5
6
7
8
```
目前的目录结构

 消费者的接口搭建

创建Maven项目=> order-service-consumer 服务消费者(订单服务)

OrderService.java
```
public interface OrderService {

    /**
     * 初始化订单
     * @param userId
     */
    public void initOrder(String userId);
}
1
2
3
4
5
6
7
8
```
实现类
```
public class OrderServiceImpl implements OrderService {

    UserService userService;

    public void initOrder(String userId) {
        //查询用户的收获地址
        List<UserAddress> addressList = userService.getUserAddressList(userId);
        System.out.println(addressList);

    }
}
1
2
3
4
5
6
7
8
9
10
11
```
由于最终两个模块可能需要部署在不同的服务器中,所以需要将消息提供者的Bean和用户接口复制过来

 创建公共的服务接口

这样的话更加的好

创建完成之后最终的目录结构如下所示
- 将bean和接口都提取到一个模块中,而将之前的删除掉
然后再user-service-provider中的pom.xml文件中添加依赖,否者将会报错
```
<dependencies>
		<dependency>
			<groupId>com.wjiangquan.gmail</groupId>
			<artifactId>gmall-interface</artifactId>
			<version>1.0-SNAPSHOT</version>
		</dependency>
</dependencies>
1
2
3
4
5
6
7
```
同时在order-service-consumer模块的pom.xml文件中也需要导入上面的依赖

 服务提供者配置及测试
实现步骤
1. 将服务的提供者注册到注册中心(暴露服务)
  
  (1) 导入dubbo和zookeeper依赖
  
  导入dubbo依赖(2.6.2)
  
  <dependency> <groupId>com.alibabagroupId> <artifactId>dubboartifactId> <version>2.6.2version> dependency>
  1
  2
  3
  4
  5
  6
  7
  
  导入zookeeper
  
   <dependency> <groupId>org.apache.curator</groupId> <artifactId>curator-framework</artifactId> <version>2.12.0</version> </dependency>
  1
  2
  3
  4
  5
  6
  7
(2) 配置服务提供者

在resource文件中创建provider.xml
```
 ```xml
 
 
 	
 	
 	
 	
 	
 	
 	
 	
 	
             
 	
 	
 	            
 
 ```
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
```
编写一个ProviderApplication启动类程序，运行测试配置
```
public class MailApplication {
    public static void main(String[] args) throws IOException {
        ClassPathXmlApplicationContext applicationContext= new ClassPathXmlApplicationContext("provider.xml");
        applicationContext.start();
        System.in.read();
    }
}
1
2
3
4
5
6
7
```
运行成功之后的效果

运行结果如下,运行之后刷新之后就可以看到数据了

可以查看服务的提供者

可以查看应用,都是正常的

包括服务也可以查看

等等,可以查看一系列的信息,至此,服务提供者的配置和测试完成

 服务消费者配置及测试

在 order-service-consumer 服务消费者项目中引入依赖
```
	
		<dependency>
			<groupId>com.alibabagroupId>
			<artifactId>dubboartifactId>
			<version>2.6.2version>
		dependency>
		
		<dependency>
			<groupId>org.apache.curatorgroupId>
			<artifactId>curator-frameworkartifactId>
			<version>2.12.0version>
		dependency>
1
2
3
4
5
6
7
8
9
10
11
12
```
创建consumer.xml
```
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:dubbo="http://dubbo.apache.org/schema/dubbo"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd
		http://dubbo.apache.org/schema/dubbo http://dubbo.apache.org/schema/dubbo/dubbo.xsd
		http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd">
	
	<context:component-scan base-package="com.wjiangquan.gmall.service.imp"/>

	
	<dubbo:application name="order-service-consumer">dubbo:application>
	
	<dubbo:registry address="zookeeper://127.0.0.1:2181">dubbo:registry>

	
	<dubbo:reference interface="com.wjiangquan.gmall.service.UserService" id="userService">dubbo:reference>
	
beans>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
```
把当前OrderServiceImpl实现类中加上注解
```
package com.wjiangquan.gmall.service.imp;

import com.wjiangquan.gmall.bean.UserAddress;
import com.wjiangquan.gmall.service.OrderService;
import com.wjiangquan.gmall.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.io.IOException;
import java.util.List;

/**
 * @author weijiangquan
 * @date 2022/9/13 -17:35
 * @Description
 */

@Service
public class OrderServiceImpl implements OrderService {


    @Autowired
    UserService userService;


    public void initOrder(String userId) throws IOException {
        //查询用户的收获地址
        System.out.println("用户id"+userId);
        List<UserAddress> addressList = userService.getUserAddressList(userId);

        for (UserAddress userAddress:addressList){
            System.out.println(userAddress.getUserAddress());
        }
    }
}

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
```
启动类
```
import com.wjiangquan.gmall.service.OrderService;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.io.IOException;

/**
 * @author weijiangquan
 * @date 2022/9/13 -21:40
 * @Description
 */
public class MainApplication {

    @SuppressWarnings("resource")
    public static void main(String[] args) throws IOException {
        ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("consumer.xml");
        OrderService orderService = classPathXmlApplicationContext.getBean(OrderService.class);
        orderService.initOrder("1");
        System.out.println("调用完成......");
        System.in.read();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
```
运行结果

 dubbo-monitor-simple简易监控中心

执行命令,耐心等待,打包可能需要花费几分钟的时间
```
mvn package
1
```
打包成功

将打包之后生成的压缩包解压到当前目录

解压上面的文件并放到dubbo目录下(个人习惯)

进入配置文件

通过查看文件之后发现注册中心的地址配置是正确的

进入到bin目录中双击启动项目

如下提示启动成功

访问8080端口,发现正常

在服务提供者和消费者的xml中配置以下内容，再次启动服务提供和消费者启动类。
```
    
    <dubbo:monitor protocol="registry"></dubbo:monitor>
    
1
2
3
```
重新启动之后,在监控中心可以看到相关的信息

 Dubbo与SpringBoot整合

 boot-user-service-provider 服务提供者

创建Maven项目 boot-user-service-provider 服务提供者

创建项目

点击下一步之后不用选择任何模块,就是一个普通的应用

将之前提供者的实现复制过来

并在pom.xml文件中添加依赖导入公共的依赖,不然会报错
```
<dependency>
    <groupId>com.wjiangquan.gmail</groupId>
    <artifactId>gmall-interface</artifactId>
    <version>1.0-SNAPSHOT</version>
</dependency>
1
2
3
4
5
```
配置 application.properties
```
dubbo.application.name=boot-user-service-provider
dubbo.registry.address=127.0.0.1:2181
dubbo.registry.protocol=zookeeper

dubbo.protocol.name=dubbo
dubbo.protocol.port=20880

dubbo.monitor.protocol=registry
1
2
3
4
5
6
7
8
```
导入dubbo依赖
```
		<dependency>
			<groupId>com.alibaba.bootgroupId>
			<artifactId>dubbo-spring-boot-starterartifactId>
			<version>0.2.0version>
		dependency>

1
2
3
4
5
6
```
UserServiceImpl 在之前spring创建的基础之上加上这个@com.alibaba.dubbo.config.annotation.Service //暴露服务
```
@com.alibaba.dubbo.config.annotation.Service     //暴露服务
@Service
public class UserServiceImpl implements UserService {
    public List<UserAddress> getUserAddressList(String userId) {

        UserAddress address1 = new UserAddress(1, "河南省郑州巩义市宋陵大厦2F", "1", "安然", "150360313x", "Y");
        UserAddress address2 = new UserAddress(2, "北京市昌平区沙河镇沙阳路", "1", "情话", "1766666395x", "N");
        return Arrays.asList(address1,address2);

    }
}
1
2
3
4
5
6
7
8
9
10
11
```
启动类
```
@EnableDubbo  //开启基于注解的dubbo功能
@SpringBootApplication
public class BootUserServiceProviderApplication {
    public static void main(String[] args) {
        SpringApplication.run(BootUserServiceProviderApplication.class, args);
    }
}
1
2
3
4
5
6
7
```
boot-order-service-consumer 服务消费者

创建Maven项目 boot-order-service-consumer 服务消费者

创建为web工程

将之前spring项目时的消费者的实现复制过来

导入依赖,初次可能需要等待几分钟
```
	<dependencies>
		<dependency>
			<groupId>com.wjiangquan.gmail</groupId>
			<artifactId>gmall-interface</artifactId>
			<version>1.0-SNAPSHOT</version>
		</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.0</version>
		</dependency>
	</dependencies>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
```
把order-service-consumer项目中的service复制到当前项目。
```
@Service
public class OrderServiceImpl implements OrderService {


    @Reference //引用远程提供者服务
    UserService userService;


    public List<UserAddress> initOrder(String userId){
        //查询用户的收获地址
        System.out.println("用户id"+userId);
        List<UserAddress> addressList = userService.getUserAddressList(userId); //负责远程调用

        //输出打印
        for (UserAddress userAddress:addressList){
            System.out.println(userAddress.getUserAddress());
        }

        return addressList;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
```
创建application.properties 配置
```
server.port=8081
dubbo.application.name=boot-order-service-consumer
dubbo.registry.address=zookeeper://127.0.0.1:2181

#连接监控中心 注册中心协议
dubbo.monitor.protocol=registry

1
2
3
4
5
6
7
```
BootConsumerApplication 启动类创建
```
@EnableDubbo
@SpringBootApplication
public class BootOrderServiceConsumerApplication {

    public static void main(String[] args) {
        SpringApplication.run(BootOrderServiceConsumerApplication.class, args);
    }
}
1
2
3
4
5
6
7
8
```
书写controller层
```
@Controller
public class OrderController {

    @Autowired
    OrderService orderService;

    @ResponseBody
    @RequestMapping("/initOrder")
    public List<UserAddress> initOrder(@RequestParam("uid") String userId){
        return orderService.initOrder(userId);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
```
注意这个时候需要将消费者接口和实现类中中的initOrder()的返回值由原来的void改为List,

测试

在地址栏中输入地址就可以得到对应的信息

至此springboot的整合成功

 Dubbo配置

1、配置原则

JVM 启动 -D 参数优先，这样可以使用户在部署和启动时进行参数重写，比如在启动时需改变协议的端口。

XML 次之，如果在 XML 中有配置，则 dubbo.properties 中的相应配置项无效。

Properties 最后，相当于缺省值，只有 XML 没有配置时，dubbo.properties 的相应配置项才会生效，通常用于共享公共配置，比如应用名。

2、启动时检查

Dubbo 缺省会在启动时检查依赖的服务是否可用，不可用时会抛出异常，阻止 Spring 初始化完成，以便上线时，能及早发现问题，默认 check=“true”。

可以通过 check=“false” 关闭检查，比如，测试时，有些服务不关心，或者出现了循环依赖，必须有一方先启动。

另外，如果你的 Spring 容器是懒加载的，或者通过 API 编程延迟引用服务，请关闭 check，否则服务临时不可用时，会抛出异常，拿到 null 引用，如果 check=“false”，总是会返回引用，当服务恢复时，能自动连上。

以order-service-consumer消费者为例，在consumer.xml中添加配置
```

 <dubbo:consumer check="false"></dubbo:consumer>
1
2
```
添加后，即使服务提供者不启动，启动当前的消费者，也不会出现错误。

3、全局超时配置
```
全局超时配置
<dubbo:provider timeout="5000" />

指定接口以及特定方法超时配置
<dubbo:provider interface="com.foo.BarService" timeout="2000">
    <dubbo:method name="sayHello" timeout="3000" />
</dubbo:provider>

1
2
3
4
5
6
7
8
```
配置原则

dubbo推荐在Provider上尽量多配置Consumer端属性
```
1、作为服务的提供者，比服务使用方更清楚服务性能参数，如调用的超时时间，合理的重试次数，等等
2、在Provider配置后，Consumer不配置则会使用Provider的配置值，即Provider配置可以作为Consumer的缺省值。否则，Consumer会使用Consumer端的全局设置，这对于Provider不可控的，并且往往是不合理的
1
2
```
配置的覆盖规则：
- 方法级配置别优于接口级别，即小Scope优先
- Consumer端配置优于 Provider配置优于全局配置，
- 最后是Dubbo Hard Code的配置值（见配置文档）
多版本

 dubbo与springboot整合的三种方式

 高可用

zookeeper宕机与dubbo直连

现象：zookeeper注册中心宕机，还可以消费dubbo暴露的服务。

原因:

健壮性↓
- 监控中心宕掉不影响使用，只是丢失部分采样数据
- 数据库宕掉后，注册中心仍能通过缓存提供服务列表查询，但不能注册新服务
- 注册中心对等集群，任意一台宕掉后，将自动切换到另一台
- 注册中心全部宕掉后，服务提供者和服务消费者仍能通过本地缓存通讯
- 服务提供者无状态，任意一台宕掉后，不影响使用
- 服务提供者全部宕掉后，服务消费者应用将无法使用，并无限次重连等待服务提供者恢复
  
  高可用：通过设计，减少系统不能提供服务的时间；
集群下dubbo负载均衡配置

在集群负载均衡时，Dubbo 提供了多种均衡策略，缺省为 random 随机调用。

负载均衡策略如下

Random LoadBalance 基于权重的随机负载均衡机制

随机，按权重设置随机概率。在一个截面上碰撞的概率高，但调用量越大分布越均匀，而且按概率使用权重后也比较均匀，有利于动态调整提供者权重。

RoundRobin LoadBalance 基于权重的轮询负载均衡机制

轮循，按公约后的权重设置轮循比率。存在慢的提供者累积请求的问题，比如：第二台机器很慢，但没挂，当请求调到第二台时就卡在那，久而久之，所有请求都卡在调到第二台上。

LeastActive LoadBalance最少活跃数负载均衡机制

最少活跃调用数，相同活跃数的随机，活跃数指调用前后计数差。使慢的提供者收到更少请求，因为越慢的提供者的调用前后计数差会越大。

ConsistentHash LoadBalance一致性hash 负载均衡机制

整合hystrix，服务熔断与降级处理

 服务降级

当服务器压力剧增的情况下，根据实际业务情况及流量，对一些服务和页面有策略的不处理或换种简单的方式处理，从而释放服务器资源以保证核心交易正常运作或高效运作。

可以通过服务降级功能临时屏蔽某个出错的非关键服务，并定义降级后的返回策略。

向注册中心写入动态配置覆盖规则：
```
RegistryFactory registryFactory = ExtensionLoader.getExtensionLoader(RegistryFactory.class).getAdaptiveExtension();
Registry registry = registryFactory.getRegistry(URL.valueOf("zookeeper://10.20.153.10:2181"));
registry.register(URL.valueOf("override://0.0.0.0/com.foo.BarService?category=configurators&dynamic=false&application=foo&mock=force:return+null"));

1
2
3
4
```
其中：
- mock=force:return+null 表示消费方对该服务的方法调用都直接返回 null 值，不发起远程调用。用来屏蔽不重要服务不可用时对调用方的影响。
- 还可以改为 mock=fail:return+null 表示消费方对该服务的方法调用在失败后，再返回 null 值，不抛异常。用来容忍不重要服务不稳定时对调用方的影响。
集群容错

在集群调用失败时，Dubbo 提供了多种容错方案，缺省为 failover 重试。

集群容错模式

Failover Cluster

失败自动切换，当出现失败，重试其它服务器。通常用于读操作，但重试会带来更长延迟。可通过 retries=“2” 来设置重试次数(不含第一次)。

重试次数配置如下：
```
<dubbo:service retries=“2” />
或
<dubbo:reference retries=“2” />
或
dubbo:reference
<dubbo:method name=“findFoo” retries=“2” />
dubbo:reference>
1
2
3
4
5
6
7
```
服务熔断错处理配置参考=> 我是参考

Hystrix 旨在通过控制那些访问远程系统、服务和第三方库的节点，从而对延迟和故障提供更强大的容错能力。Hystrix具备拥有回退机制和断路器功能的线程和信号隔离，请求缓存和请求打包，以及监控和配置等功能

配置spring-cloud-starter-netflix-hystrix

spring boot官方提供了对hystrix的集成，直接在pom.xml里加入依赖：
```
 <dependency>
     <groupId>org.springframework.cloudgroupId>
      <artifactId>spring-cloud-starter-netflix-hystrixartifactId>
      <version>1.4.4.RELEASEversion>
dependency>
1
2
3
4
5
```
然后在Application类上增加@EnableHystrix来启用hystrix starter：
```
@SpringBootApplication
@EnableHystrix //开启服务容错功能
public class ProviderApplication {
	...启动方法
}
1
2
3
4
5
```
配置Provider端

在Dubbo的Provider上增加@HystrixCommand配置，这样子调用就会经过Hystrix代理。
```
@Service(version = "1.0.0")
public class HelloServiceImpl implements HelloService {
    @HystrixCommand(commandProperties = {
     @HystrixProperty(name = "circuitBreaker.requestVolumeThreshold", value = "10"),
     @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "2000") })
    @Override
    public String sayHello(String name) {
        // System.out.println("async provider received: " + name);
        // return "annotation: hello, " + name;
        throw new RuntimeException("Exception to show hystrix enabled.");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
```
- 配置Consumer端
对于Consumer端，则可以增加一层method调用，并在method上配置@HystrixCommand。当调用出错时，会走到fallbackMethod = "reliable"的调用里。
```
@Reference(version = "1.0.0")
    private HelloService demoService;

    @HystrixCommand(fallbackMethod = "reliable")
    public String doSayHello(String name) {
        return demoService.sayHello(name);
    }
    public String reliable(String name) {
        return "hystrix fallback value";
    }
1
2
3
4
5
6
7
8
9
10
```
dubbo原理

 RPC原理

dubbo只用了两步1和8，中间的过程是透明的看不到的。RPC框架的目标就是要2~8这些步骤都封装起来，这些细节对用户来说是透明的，不可见的。

netty通信原理

Netty是一个异步事件驱动的网络应用程序框架，用于快速开发可维护的高性能协议服务器和客户端。它极大地简化并简化了TCP和UDP套接字服务器等网络编程。

BIO：(Blocking IO)

Connect（连接就绪）、Accept（接受就绪）、Read（读就绪）、Write（写就绪）

selector一般称为选择器,也可以翻译成多路复用器

Netty基本原理：

dubbo原理

 1.dubbo原理 -框架设计
- config 配置层：对外配置接口，以 ServiceConfig, ReferenceConfig 为中心，可以直接初始化配置类，也可以通过 spring 解析配置生成配置类
- proxy 服务代理层：服务接口透明代理，生成服务的客户端 Stub 和服务器端 Skeleton, 以 ServiceProxy 为中心，扩展接口为 ProxyFactory
- registry 注册中心层：封装服务地址的注册与发现，以服务 URL 为中心，扩展接口为 RegistryFactory, Registry, RegistryService
- cluster 路由层：封装多个提供者的路由及负载均衡，并桥接注册中心，以 Invoker 为中心，扩展接口为 Cluster, Directory, Router, LoadBalance
- monitor 监控层：RPC 调用次数和调用时间监控，以 Statistics 为中心，扩展接口为 MonitorFactory, Monitor, MonitorService
- protocol 远程调用层：封装 RPC 调用，以 Invocation, Result 为中心，扩展接口为 Protocol, Invoker, Exporter
- exchange 信息交换层：封装请求响应模式，同步转异步，以 Request, Response 为中心，扩展接口为 Exchanger, ExchangeChannel, ExchangeClient, ExchangeServer
- transport 网络传输层：抽象 mina 和 netty 为统一接口，以 Message 为中心，扩展接口为 Channel, Transporter, Client, Server, Codec
- serialize 数据序列化层：可复用的一些工具，扩展接口为 Serialization, ObjectInput, ObjectOutput, ThreadPool
2.dubbo原理 -启动解析、加载配置信息

3.dubbo原理 -服务暴露

 4.dubbo原理 -服务引用

 5.dubbo原理 -服务调用

 参考资料

资料链接: https://pan.baidu.com/s/1EaOm8iQ9KnC2URypjfk-kw?pwd=8gdt

提取码: 8gdt 复制这段内容后打开百度网盘手机App，操作更方便哦

视频资料 参考视频
相关阅读:
python爬取某乎保存为json文件
 【畅所欲言】AI诈骗：防范与应对策略
 [vue] element的表格fixed悬浮固定列错乱的官方解决办法
 805.数组的均值分割(回溯+折半搜索+数学)
SQL 报表制作和整形
 共享单车需求量登记分类及影响因素分析——基于机器学习模型的比较分析
 你应该知道的数仓安全：都是同名Schema惹的祸
 CSS外边距重叠：原理、结果
 PyTorch基础知识学习
 RTL8720DN开发笔记一环境搭建与mqtt实例
原文地址：https://blog.csdn.net/weixin_47994845/article/details/126861270

分布的简单介绍

应用架构的发展演变

发展演变

RPC的工作原理

RPC 调用分以下两种：

dubbo的核心概念

dubbo设计架构

Dubbo的特性

dubbo环境搭建 ZooKeeper注册中心

搭建zookeeper注册中心环境

Zookeeper 注册中心的基本使用和工作原理。

zookeeper监控中心的配置和安装

Dubbo环境搭建，创建提供者、消费者项目

消费者接口的搭建

消费者的接口搭建

创建公共的服务接口

服务提供者配置及测试

服务消费者配置及测试

dubbo-monitor-simple简易监控中心

Dubbo与SpringBoot整合

boot-user-service-provider 服务提供者

boot-order-service-consumer 服务消费者

测试

Dubbo配置

多版本

dubbo与springboot整合的三种方式

高可用

集群下dubbo负载均衡配置

整合hystrix，服务熔断与降级处理

服务降级

集群容错

dubbo原理

RPC原理

netty通信原理

dubbo原理

1.dubbo原理 -框架设计

2.dubbo原理 -启动解析、加载配置信息

4.dubbo原理 -服务引用

5.dubbo原理 -服务调用

参考资料