关于dubbo:万字长文Dubbo-入门总结-一款高性能的-Java-RPC-框架

这篇文章是我学习整顿 Dubbo 的一篇文章，首先大部分内容参考了官网 + 某硅谷的视频，内容解说进行了从新编排，40 多张图片，也都是我批改重制的，尽管一万多字，然而其实也能够看进去，更多的内容集中在了概念或性能的介绍，具体环境的搭建，以及如何配置，疾速上手下面，然而对于这样一款优良的框架，文章中提到的每一个点其实开展来讲都能写这样篇幅的一篇文章，仅仅入门来看也没必要，总得学会走，才能够去试着跑

• 文章提及了 SSM 和 Springboot 下的不同配置形式，然而 Zookeeper 环境搭在了 Windows 下，前面筹备重新整理的 Redis 我思考在 Linux 中来跑，会更贴近理论一些
• 说句题外话，设计模式也没停，还有一篇存稿，不过想整顿的货色太多，还有学校等等的事件，真有点自闭了
• 有什么倡议和意见欢送在评论区和我交换哈，感激各位大佬的反对~

早安，学习人 & 打工人 ~ ~ ~

一 必备基础知识

(一) 分布式基础理论

在百度以及维基中的定义都绝对业余且艰涩，大部分博客或者教程常常会应用《分布式系统原理和范型》中的定义，即：“分布式系统是若干独立计算机的汇合，这些计算机对于用户来说就像是单个相干零碎”

上面咱们用一些篇幅来艰深的解释一下什么叫做分布式

(1) 什么是集中式零碎

提到分布式，不得不提的就是 “集中式零碎”，这个概念最好了解了，它就是将性能，程序等装置在同一台设施上，就由这一台主机设施向外提供服务

举个最简略的例子：你拿一台 PC 主机，将其改装成了一台简略的服务器，配置好各种内容后，你将 MySQL，Web 服务器，FTP，Nginx 等等，全副装置在其中，打包部署我的项目后，就能够对外提供服务了，然而一旦这台机器无论是软件还是硬件呈现了问题，整个零碎都会受到重大的株连谬误，鸡蛋放在一个篮子里，要打就全打了

(2) 什么是分布式系统

既然集中式零碎有这样一种牵一发而动全身的问题，那么分布式的其中一个作用，天然是来解决这样的问题了，正如定义中所知，分布式系统在用户的体验感官里，就像传统的单零碎一样，一些变动都是这个零碎自身外部进行的，对于用户并没有什么太大的感觉

例如：淘宝，京东这种大型电商平台，它们的主机都是数以万计的，否则基本没法解决大量的数据和申请，具体其中有什么划分，以及操作，咱们上面会说到，然而对于用户的咱们，咱们不须要也不想关怀这些，咱们仍能够单纯的认为，咱们面对的就是“淘宝”这一台“主机”

所以分布式的一个绝对业余一些的说法是这样的（过程粒度）两个或者多个程序，别离运行在不同的主机过程上，它们互相配合协调，实现独特的性能，那么这几个程序之间形成的零碎就能够叫做分布式系统

• 这几者都是雷同的程序 —— 分布式
• 这几者都是不同的程序 —— 集群

(3) 倒退过程

A：繁多利用架构

当网站流量很小时，只需一个利用，将所有性能都部署在一起，以缩小部署节点和老本。此时，用于简化增删改查工作量的数据拜访框架 (ORM) 是要害

长处：

• 所有性能集中在一起，开发以及前期保护均绝对简略
• 对于小型网站及管理系统，简略易用

毛病：

• 对于大型项目，降级保护艰难
• 无奈对于一个模块进行程度扩大或优化
• 模块之间耦合严密，容错率低

B：垂直利用架构

当访问量逐步增大，繁多利用减少机器带来的加速度越来越小，晋升效率的办法之一是将利用拆成互不相干的几个利用，以晋升效率。此时，用于减速前端页面开发的 Web 框架 (MVC) 是要害

长处：

• 通过切分业务达到各模块独立部署，保护和部署更加简略
• 能够对一个模块进行程度扩大或优化

毛病：

• 零碎之间无奈互相调用
• 具备反复代码，且专用模块无奈反复利用

C：分布式服务架构

当垂直利用越来越多，利用之间交互不可避免，将外围业务抽取进去，作为独立的服务，逐步造成稳固的服务中心，使前端利用能更疾速的响应多变的市场需求。此时，用于进步业务复用及整合的分布式服务框架 (RPC) 是要害

长处：

• 抽取公共代码，代码复用性进步

毛病：

• 调用关系简单，保护很麻烦

D：流动计算架构

当服务越来越多，容量的评估，小服务资源的节约等问题逐步浮现，此时需减少一个调度核心基于拜访压力实时治理集群容量，进步集群利用率。此时，用于进步机器利用率的资源调度和治理核心 (SOA) 是要害

长处：

• 简单的调用关系不再须要自行保护

毛病：

• 服务具备依赖性，一个服务呈现问题或者会导致其余零碎不可用

(4) RPC 介绍

RPC（Remote Procedure Call）是指近程过程调用 ，是一种过程间通信形式，他是一种技术的思维，而不是标准。 它容许程序调用另一个地址空间（通常是共享网络的另一台机器上）的过程或函数，而不必程序员显式编码这个近程调用的细节

这应该是很好了解的，调用本地 A 服务器上的函数或者办法的时候很简略，然而如果 A 想要拜访 B 的办法时，两者的内存空间压根都不是同一个，只能通过网络传输调用的相干内容，对于传输协定亦或者传输方式，都由 RPC 帮咱们背地实现

也就是说，即程序员无论是调用本地的还是近程的函数，实质上编写的调用代码基本相同

对于 RPC 更加粗疏业余的解释阐明

RPC 是一种通过网络从近程计算机程序上申请服务，而不须要理解底层网络技术的协定。RPC 协定假设某些传输协定的存在，如 TCP 或 UDP，为通信程序之间携带信息数据。在 OSI 网络通信模型中，RPC 逾越了传输层和应用层。RPC 使得开发包含网络分布式多程序在内的应用程序更加容易

RPC 采纳客户机 / 服务器模式。申请程序就是一个客户机，而服务提供程序就是一个服务器。首先，客户机调用过程发送一个有过程参数的调用信息到服务过程，而后期待应答信息。在服务器端，过程放弃睡眠状态直到调用信息达到为止。当一个调用信息达到，服务器取得过程参数，计算结果，发送回答信息，而后期待下一个调用信息，最初，客户端调用过程接管回答信息，取得过程后果，而后调用执行持续进行

某乎：谁能用艰深的语言解释一下什么是 RPC 框架？

本地过程调用

RPC 就是要像调用本地的函数一样去调近程函数。在钻研 RPC 前，咱们先看看本地调用是怎么调的。假如咱们要调用函数 Multiply 来计算 lvalue * rvalue 的后果:

…… 省略，此篇可细细看一下

问题答者：洪春涛

来看一下从 A 想要拜访 B 中办法的一个流程例子

顺着执行路线来捋一下

• ① 客户端 Client 收回一个调用近程服务的信号
• ② Client Stub 接管到调用，把办法参数进行序列化解决
• ③ 客户端 Client 通过 Sockets 将音讯发送到服务端
• ④ 服务端的 Server Stub，对收到的音讯进行解码，也就是反序列化的过程
• ⑤ 服务端 Server Stub，依据解码后果，调用服务端的本地服务
• ⑥ 服务端的本地服务执行，且将后果返回给本人的 Server Stub
• ⑦ Server Stub 打包后果成音讯，即序列化后果音讯
• ⑧ 服务端通过 Sockets 将音讯发送到客户端
• ⑨ 客户端的 Client Stub 接管到服务端传来的后果音讯，进行解码解决，即反序列化
• ⑩ 客户端失去从服务端传来的最初后果

第③点阐明：RPC 采纳客户机 / 服务器模式。申请程序就是一个客户机，而服务提供程序就是一个服务器。

(二) Dubbo 概念

(1) 介绍

Dubbo 官网：http://dubbo.apache.org/zh/

Apache Dubbo 是一款高性能、轻量级的开源 Java 服务框架

Apache Dubbo |ˈdʌbəʊ| 提供了六大外围能力：面向接口代理的高性能 RPC 调用，智能容错和负载平衡，服务主动注册和发现，高度可扩大能力，运行期流量调度，可视化的服务治理与运维。

面向接口代理的高性能 RPC 调用

• 提供高性能的基于代理的近程调用能力，服务以接口为粒度，为开发者屏蔽近程调用底层细节。

智能负载平衡

• 内置多种负载平衡策略，智能感知上游节点健康状况，显著缩小调用提早，进步零碎吞吐量。

服务主动注册与发现

• 反对多种注册核心服务，服务实例高低线实时感知。

高度可扩大能力

• 遵循微内核 + 插件的设计准则，所有外围能力如 Protocol、Transport、Serialization 被设计为扩大点，平等看待内置实现和第三方实现。

运行期流量调度

• 内置条件、脚本等路由策略，通过配置不同的路由规定，轻松实现灰度公布，同机房优先等性能。

可视化的服务治理与运维

• 提供丰盛服务治理、运维工具：随时查问服务元数据、服务衰弱状态及调用统计，实时下发路由策略、调整配置参数。

(2) 架构

这是 Dubbo 的架构图

首先介绍一下这五个节点的角色（五个圆角矩形框）

• Provider：裸露服务的 服务提供方
• Consume：调用近程服务的 服务生产方
• Registry：服务注册与发现的 注册核心
• Monitor：统计服务的调用次数和调用工夫的 监控核心
• Container：服务 运行容器

再来看一下调用的关系和流程：

• ① 服务容器负责启动，加载，运行服务提供者
• ② 服务提供者在启动时，向注册核心注册本人提供的服务
• ③ 注册核心返回服务提供者地址列表给消费者，如果有变更，注册核心将基于长连贯推送变更数据给消费者
• ④ 服务消费者，从提供者地址列表中，基于软负载平衡算法，选一台提供者进行调用，如果调用失败，再选另一台调用
• ⑤ 服务消费者和提供者，在内存中累计调用次数和调用工夫，定时每分钟发送一次统计数据到监控核心

(三) dubbo 环境搭建

阐明：以下为学习演示不便，均为 Windows 零碎搭建，实在 Linux 场景搭建会在前面出一篇，如何在 Linux 装置配置常见的软件

(1) 搭建 zookeeper 注册核心环境

A：下载 zookeeper

首先先将 zookeeper 下载下来

官网（查看文档，下载）：https://zookeeper.apache.org/

嫌麻烦就间接去下载页面：https://downloads.apache.org/zookeeper/

这里下载的版本是：apache-zookeeper-3.6.2

留神：下载，apache-zookeeper-3.6.2.tar.gz，apache-zookeeper-3.6.2-bin.tar.gz，尽管实质咱们是用前者，然而启动过程中遇到了报错，须要后者局部文件来进行修复

B：配置及排错

XXX\apache-zookeeper-3.6.2\bin，上面的 zkServer.cmd 和 zkCli.cmd 就是咱们想要运行的，能够在当前目录下关上 cmd（什么都行）运行 zkServer.cmd，首先可能会遇到第一个谬误——找不到或无奈加载主类

这个时候就须要解压方才下载的 apache-zookeeper-3.6.2-bin.tar.gz，而后在其目录下，复制整个 lib 文件夹到方才的 apache-zookeeper-3.6.2 文件夹下，这样就解决了

再次运行，会有第二个问题：一个配置文件的缺失

这个问题只须要在 XXX\apache-zookeeper-3.6.2\conf 中把 zoo_sample.cfg 文件复制一份，且名字改为 zoo.cfg

能够关上编辑这个新复制过去的 zoo.cfg 文件，其中就是一些配置内容，例如端口还有一个数据的存储地址，因为它默认用的是 linux 的地位，所以咱们如果想要批改，也能够将 dataDir=/tmp/zookeeper 批改为 dataDir=../data，就是在根目录下创立了一个 data 文件夹，也能够本人指定，也能够不论这个

C：运行服务端及客户端

都解决好了，来运行 zkServer.cmd，就启动胜利了

运行 zkCli.cmd，能够胜利连贯到 zookeeper 的服务器

服务端客户端都跑起来了，搭建 zookeeper 注册核心环境到这里就算 OK 了

(2) 配置 zookeeper 监控核心

dubbo 自身并不是一个服务软件。它其实就是一个 jar 包可能帮你的 java 程序连贯到 zookeeper，并利用 zookeeper 生产、提供服务。所以你不必在 Linux 上启动什么 dubbo 服务

然而为了让用户更好的治理监控泛滥的 dubbo 服务，官网提供了一个可视化的监控程序——dubbo-admin，不过这个监控即便不装也不影响应用

A：下载 dubbo-admin

下载地址：https://github.com/apache/dub…

从 github 上 down 到本地，有 dubbo-admin-master 一个文件夹，其中含有三个次要文件夹

• dubbo-admin
• dubbo-monitor-simple
• dubbo-registry-simple

B：先确认配置正确

咱们当初先只针对 dubbo-admin 操作

关上编辑配置文件：XXX\dubbo-admin-master\dubbo-admin\src\main\resources\application.properties

确认其中的配置，比方端口，明码什么等等都是失常的，例如服务端口 7001，明码 root，最要害的就是地址，因为咱们测试是在本机，所以地址如下就能够了

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

C：打包运行

既然没问题了，就在 xx\dubbo-admin-master\dubbo-admin，这个文件夹下进行打包，用 cmd 也都一样，命令如下：

mvn clean package

打包胜利后，target 文件夹中会多出一个 dubbo-admin-0.0.1-SNAPSHOT.jar，咱们把它复制到一个本人指定的地位，而后通过 cmd 运行这个 jar

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

其实就是运行了一个 springboot 的我的项目，而后控制台会有写到是一个 7001 端口，来去拜访一下，用户名，明码都是 root，呈现如下所图就是胜利了

留神：要想拜访到这个页面，请保障 zookeeper 注册核心启动了

(四) 第一个 Dubbo 我的项目

咱们第一个例子就照着这个网络上参考的例子来做（代码并不重要，要害是了解调用关系和配置形式）：

解释一下，订单生成前的时候，须要调用用户服务，查问到用户所有的收货地址，用户选定地址后，再生成订单，如果订单服务和用户服务分属于不同的服务器 A 和 B，而咱们要解决的就是如何在 A 的订单服务中，调用到 B 的用户服务

顺便提一句，很分明的能够看进去，用户服务是被调用的，所有它就是服务的提供者，而订单服务作为消费者

(1) 创立我的项目及各个模块

为了在一台机器上演示，我首先创立了一个 Maven 的空我的项目，而后别离创立几个子模块（程序很简略，不须要 Maven 骨架）

A：创立用户服务（服务提供者）

在空我的项目中创立第一个模块 user-service-provider

首先创立出 实体 和业务层接口 以及 实现类

实体：UserAddress

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 构造方法 toString
        
}

业务层接口：UserService

public interface UserService {
    /**
     * 依照用户 id 返回所有的收货地址
     * @param userId
     * @return
     */
    public List<UserAddress> getUserAddressList(String userId);
}

业务层实现类：UserServiceImpl

public class UserServiceImpl implements UserService {public List<UserAddress> getUserAddressList(String userId) {UserAddress address1 = new UserAddress(1, "广东省 xxx 市 xxx 区 xxx 路 xxx 小区 24 栋 1 单元 801 户", "1", "阿文", "13999999999", "Y");
        UserAddress address2 = new UserAddress(2, "北京市 yyy 区 yyy 路 yyy 小区 19 号 3 单元 502 户", "1", "南方少女的梦", "13888888888", "N");

        return Arrays.asList(address1,address2);
    }
}

程序很简略，数据都是拟进去的

以下是这个模块的结构图：

B：创立订单服务（服务消费者）

在我的项目中创立第二个模块 order-service-consumer

业务层接口：OrderService

public interface OrderService {
    /**
     * 初始化订单
     * @param userID
     */
    public void initOrder(String userID);
}

业务层实现类：OrderServiceImpl

当初还是一个空实现，前面会补充好

public class OrderServiceImpl implements OrderService {public void initOrder(String userID) {// 查问用户的收货地址}
}

如果咱们想要在实现类中，调用用户服务，拿到所有地址，然而调用办法必定会报错的，毕竟咱们这个我的项目中并没有拿到用户地址的办法

有一种形式，就是将服务提供者，也就是用户服务的实体类以及它的 UserService 接口，复制到咱们这个订单的模块中，然而总不能当前有一个中央调用就复制一次吧，这也太麻烦了

所以通用的做法是再创立一个模块，将服务接口，模型等等全放在一起，保护以及调用会更好

C：创立接口模块

在我的项目中创立：mall-interface 模块

将用户模块（服务提供者）和订单模块（服务消费者）中的所有实体类和 service 接口复制到以后模块下

删除原有的实体类包及 service 包，也就是将实体类及 service 放在了以后公共的我的项目中了

既然原来两个模块都删掉了实体等内容，咱们想要用到这个公共的接口模块，只须要引入依赖即可

<dependency>
    <groupId>cn.ideal.mall</groupId>
    <artifactId>mall-interface</artifactId>
    <version>1.0-SNAPSHOT</version>
</dependency>

(2) 服务提供者配置及测试

A：引入依赖

咱们先对用户服务进行配置，首先要引入 dubbo 和 zookeeper 客户端的依赖

至于版本，能够去 maven 中去查

因为咱们应用 zookeeper 作为注册核心，所以须要操作 zookeeper
dubbo 2.6 以前的版本引入 zkclient 操作 zookeeper
dubbo 2.6 及当前的版本引入 curator 操作 zookeeper
上面两个 zk 客户端依据 dubbo 版本 2 选 1 即可

Dubbo 用了 2.6.9

curator 用了 5.1.0

B：创立配置文件

在 resource 文件中创立 provider.xml

正文中都写的很分明了，批改为本人的配置就好了

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.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">
    <!--1、指定以后服务 / 利用的名字(同样的服务名字雷同，不要和别的服务同名)-->
    <dubbo:application name="user-service-provider"></dubbo:application>
    <!--2、指定注册核心的地位 -->
    <!--<dubbo:registry address="zookeeper://127.0.0.1:2181"></dubbo:registry>-->
    <dubbo:registry protocol="zookeeper" address="127.0.0.1:2181"></dubbo:registry>
    <!--3、指定通信规定（通信协议? 服务端口）-->
    <dubbo:protocol name="dubbo" port="20880"></dubbo:protocol>
    <!--4、裸露服务 让他人调用 ref 指向服务的真正实现对象，通过 ref 援用上面自定义的 bean-->
    <dubbo:service interface="cn.ideal.mall.service.UserService" ref="userServiceImpl"></dubbo:service>

    <!-- 服务的实现 -->
    <bean id="userServiceImpl" class="cn.ideal.mall.service.impl.UserServiceImpl"></bean>

</beans>

C：创立一个启动类

public class MailApplication {public static void main(String[] args) throws IOException {ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:provider.xml");
        applicationContext.start();
        System.in.read();}
}

如果除了 slf4j 以外没有报出什么正告或者异样，就是胜利了

• 别忘了关上，zookeeper 注册核心的 zkServer.cmd、和 zkCli.cmd 服务
• 还有运行 java -jar dubbo-admin-0.0.1-SNAPSHOT.jar

而后持续拜访 dubbo-admin 的治理页面 http://localhost:7001/，在服务治理的提供者中，曾经能够看到发现了这个提供者

(3) 服务消费者配置及测试

A：引入依赖

<!--dubbo-->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>dubbo</artifactId>
    <version>2.6.9</version>
</dependency>
<!-- 注册核心是 zookeeper，引入 zookeeper 客户端 -->
<dependency>
    <groupId>org.apache.curator</groupId>
    <artifactId>curator-framework</artifactId>
    <version>5.1.0</version>
</dependency>

B：创立配置文件

<?xml version="1.0" encoding="UTF-8"?>
<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="cn.ideal.mall.service.impl"/>

    <!-- 指定以后服务 / 利用的名字(同样的服务名字雷同，不要和别的服务同名)-->
    <dubbo:application name="order-service-consumer"></dubbo:application>
    <!-- 指定注册核心的地位 -->
    <dubbo:registry address="zookeeper://127.0.0.1:2181"></dubbo:registry>

    <!-- 调用近程裸露的服务，生成近程服务代理 -->
    <dubbo:reference interface="cn.ideal.mall.service.UserService" id="userService"></dubbo:reference>

    <!--dubbo-monitor-simple 监控核心发现的配置 -->
    <dubbo:monitor protocol="registry"></dubbo:monitor>
    <!--<dubbo:monitor address="127.0.0.1:7070"></dubbo:monitor>-->

</beans>

C：补充订单业务实现类代码

这个实现类，方才还空着，通过引入接口依赖，Dubbo 等依赖以及配置，曾经能够调用了，调用一下这个办法，当然上面的输入语句齐全能够不写，就是为了一个察看不便

@Service
public class OrderServiceImpl implements OrderService {
    @Autowired
    public UserService userService;
    public void initOrder(String userID) {
        // 查问用户的收货地址
        List<UserAddress> userAddressList = userService.getUserAddressList(userID);

        // 为了直观的看到失去的数据，以下内容也可不写
        System.out.println("以后接管到的 userId=>"+userID);
        System.out.println("**********");
        System.out.println("查问到的所有地址为：");
        for (UserAddress userAddress : userAddressList) {
            // 打印近程服务地址的信息
            System.out.println(userAddress.getUserAddress());
        }
    }
}

C：创立启动类

public class ConsumerApplication {public static void main(String[] args) throws IOException {ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("consumer.xml");
        OrderService orderService = applicationContext.getBean(OrderService.class);

        // 调用办法查问出数据
        orderService.initOrder("1");
        System.out.println("调用实现...");
        System.in.read();}
}

运行后，持续去 查看 http://localhost:7001/

能够看到，消费者也被发现了，同时控制台也胜利的输入了内容

到这里，其实一个简略的调用过程曾经实现了

(4) 装置繁难的监控核心

dubbo-monitor-simple——繁难监控核心

其实这个货色就是方才 dubbo-admin-master 这个文件夹下除了 dubbo-admin 的其中一个，实质也是一个图形化的界面，不便查看服务提供和消费者的信息

首先还是打包，而后 target 文件夹中会生成这个文件 dubbo-monitor-simple-2.0.0.jar 以及 dubbo-monitor-simple-2.0.0-assembly.tar.gz

将 dubbo-monitor-simple-2.0.0-assembly.tar.gz 解压进去，解压后 config 文件查看 properties 的配置是否是本地的 zookeeper，配置文件的地位如下：

D:\develop\dubbo-monitor-simple-2.0.0\conf\dubbo.properties

• D:\develop 是我的门路

因为后面可能运行的问题，我前面有一些端口占用的问题，所以我把 dubbo.jetty.port=8080 批改成了 8081，这些能够依据须要自行批改

进入 assembly.bin 文件夹，而后双击运行 start.bat 呈现以下内容即启动胜利

在服务者和消费者的 XML 文件中增加以下内容

<!--dubbo-monitor-simple 监控核心发现的配置 -->
<dubbo:monitor protocol="registry"></dubbo:monitor>
<!--<dubbo:monitor address="127.0.0.1:7070"></dubbo:monitor>-->

而后启动这两个模块的启动类

注：这时候要保障 zookeeper 服务客户端等后面的内容放弃开着

拜访 localhost:8081，能够看到一个监控核心

点进去 Services 能够看到服务提供者和消费者的信息

到这里，这个监控核心也算装置好了！！！

(五) SpringBoot 整合 Dubbo

下面这个我的项目就是一个一般的 maven 我的项目，通过 XML 配置文件进行配置，在 SSM 我的项目中就能够这样应用，而 SpringBoot 作为当初开发的主力军之一，天然也要再讲一下它的一个配置运行形式

(1) 创立用户服务（服务提供者）

创立一个 SpringBoot 我的项目，名为：boot-user-service-provider

导入依赖

依据其 github 中的提醒，因为咱们抉择的是 2.6.9 所以咱们抉择 0.2.1.RELEASE 这个版本就行了

https://github.com/apache/dub…

https://github.com/apache/dub…

点进去查看 0.2.1.RELEASE，依据其提醒导入依赖

注：0.2.0 的版本中，导入 dubbo-spring-boot-starter 即同步背地帮你导入了 dubbo，curator 等等，然而我拿 0.2.1 的版本测试的时候却发现并没有（可能是我的问题），所以你也不能运行，能够思考像我一样，显式的引入这些内容

记得别忘了引入这个咱们自定义公共的接口模块喔

<dependency>
    <groupId>cn.ideal.mall</groupId>
    <artifactId>mall-interface</artifactId>
    <version>1.0-SNAPSHOT</version>
</dependency>

<!-- Dubbo Spring Boot Starter -->
<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>2.6.9</version>
</dependency>
<dependency>
    <groupId>io.netty</groupId>
    <artifactId>netty-all</artifactId>
</dependency>

<!-- 注册核心是 zookeeper，引入 zookeeper 客户端 -->
<dependency>
    <groupId>org.apache.curator</groupId>
    <artifactId>curator-framework</artifactId>
    <version>5.1.0</version>
</dependency>

在咱们方才的 user-service-provider 中将 service 的实现类按门路复制过去

留神：这个 @Service 是 dubbo 的，而 @Component 是因为，如果仍应用 Spring 的 @Service 会使得 dubbo 的那个以全称显示，不是很难看，不过你非要的话，也能够哈

package cn.ideal.mall.service.impl;

import cn.ideal.mall.pojo.UserAddress;
import cn.ideal.mall.service.UserService;
import com.alibaba.dubbo.config.annotation.Service;
import org.springframework.stereotype.Component;

import java.util.Arrays;
import java.util.List;

/**
 * @ClassName: UserServiceImpl
 * @Author: BWH_Steven
 * @Date: 2020/12/2 20:58
 * @Version: 1.0
 */
@Service
@Component
public class UserServiceImpl implements UserService {public List<UserAddress> getUserAddressList(String userId) {UserAddress address1 = new UserAddress(1, "广东省 xxx 市 xxx 区 xxx 路 xxx 小区 24 栋 1 单元 801 户", "1", "阿文", "13999999999", "Y");
        UserAddress address2 = new UserAddress(2, "北京市 yyy 区 yyy 路 yyy 小区 19 号 3 单元 502 户", "1", "南方少女的梦", "13888888888", "N");

        return Arrays.asList(address1,address2);
    }
}

配置 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

spring.main.allow-bean-definition-overriding=true

server.port=8082

增加启动类注解

@EnableDubbo // 开启基于注解的 dubbo 性能
@SpringBootApplication
public class BootUserServiceProviderApplication {public static void main(String[] args) {SpringApplication.run(BootUserServiceProviderApplication.class, args);
    }
}

(2) 创立订单服务（服务消费者）

创立 springboot 我的项目boot-order-service-consumer，此我的项目应该是一个 web 我的项目，留神引入 web 的 starter

同样引入一样的依赖

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

<dependency>
    <groupId>cn.ideal.mall</groupId>
    <artifactId>mall-interface</artifactId>
    <version>1.0-SNAPSHOT</version>
</dependency>

<!-- Dubbo Spring Boot Starter -->
<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>2.6.9</version>
</dependency>

<dependency>
    <groupId>io.netty</groupId>
    <artifactId>netty-all</artifactId>
</dependency>

<!-- 注册核心是 zookeeper，引入 zookeeper 客户端 -->
<dependency>
    <groupId>org.apache.curator</groupId>
    <artifactId>curator-framework</artifactId>
    <version>5.1.0</version>
</dependency>

把之前 order-service-consumer 我的项目中的 service 实现类按门路复制过去

有两点留神：

• @Autowired ==> @Reference
• 因为是一个 web 我的项目，要在浏览器查看后果，所以将后果从 void 改成 List 返回回去，因而须要批改公共的接口模块中的此办法接口，将返回类型改为 List

package cn.ideal.mall.service.impl;

import cn.ideal.mall.pojo.UserAddress;
import cn.ideal.mall.service.OrderService;
import cn.ideal.mall.service.UserService;
import com.alibaba.dubbo.config.annotation.Reference;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * @ClassName: OrderServiceImpl
 * @Author: BWH_Steven
 * @Date: 2020/12/2 22:38
 * @Version: 1.0
 */
@Service
public class OrderServiceImpl implements OrderService {

    @Reference
    public UserService userService;

    public List<UserAddress> initOrder(String userID) {
        // 查问用户的收货地址
        List<UserAddress> userAddressList = userService.getUserAddressList(userID);

        // 为了直观的看到失去的数据，以下内容也可不写
        System.out.println("以后接管到的 userId=>"+userID);
        System.out.println("**********");
        System.out.println("查问到的所有地址为：");
        for (UserAddress userAddress : userAddressList) {
            // 打印近程服务地址的信息
            System.out.println(userAddress.getUserAddress());
        }
        return userAddressList;
    }
}

编写 controller

@Controller
public class OrderController {
    @Autowired
    OrderService orderService;

    @RequestMapping("/initOrder")
    @ResponseBody
    public List<UserAddress> initOrder(@RequestParam("uid")String userId) {return orderService.initOrder(userId);
    }
}

配置 application.properties

dubbo.application.name=boot-order-service-consumer
dubbo.registry.address=zookeeper://127.0.0.1:2181

#连贯监控核心 注册核心协定
dubbo.monitor.protocol=registry

spring.main.allow-bean-definition-overriding=true

server.port=8083

启动类增加注解

@EnableDubbo // 开启基于注解的 dubbo 性能
@SpringBootApplication
public class BootOrderServiceConsumerApplication {public static void main(String[] args) {SpringApplication.run(BootOrderServiceConsumerApplication.class, args);
    }
}

(3) 测试

首先保障关上了，zookeeper 注册核心的 zkServer.cmd、和 zkCli.cmd 服务

还有运行 java -jar dubbo-admin-0.0.1-SNAPSHOT.jar，想开的话还能够关上监控核心 dubbo-monitor-simple-2.0.0

而后就能够运行服务提供者 boot-user-service-provider，而后运行 服务消费者 boot-order-service-consumer，运行胜利后能够看一下成果

这是应用 http://localhost:7001/ 拜访的后果

或者 http://localhost:8001 (我的监控核心端口设置的是 8081)

以及依据本人设置的我的项目端口号去申请

能够看到后果都是没问题的，SpringBoot 整合 Dubbo 就是这样一个形式

(4) 其余几种形式

一 将服务提供者注册到注册核心(如何裸露服务)

• ① 导入 Dubbo 的依赖 和 zookeeper 客户端

二 让服务消费者去注册核心订阅服务提供者的服务地址

Springboot 与 Dubbo 整合的三种形式

• ① 导入 dubbo-starter。在 application.properties 配置属性，应用 @Service【裸露服务】，应用 @Reference【援用服务】

• ② 保留 Dubbo 相干的 xml 配置文件

  • 导入 dubbo-starter，应用 @ImportResource 导入 Dubbo 的 xml 配置文件
  • 例如：在启动类增加 @ImportResource(locations = “classpath:provider.xml”)

• ③ 应用 注解 API 的形式

  • 将每一个组件手动配置到容器中，让 dubbo 来扫描其余的组件

例如创立一个 config，其本质就是为了放弃掉 xml 和配置文件，这种形式在学习 Spring 配置的时候也有用过哈

@Configuration
public class MyDubboConfig {
    
    @Bean
    public ApplicationConfig applicationConfig() {ApplicationConfig applicationConfig = new ApplicationConfig();
        applicationConfig.setName("boot-user-service-provider");
        return applicationConfig;
    }
    
    //<dubbo:registry protocol="zookeeper" address="127.0.0.1:2181"></dubbo:registry>
    @Bean
    public RegistryConfig registryConfig() {RegistryConfig registryConfig = new RegistryConfig();
        registryConfig.setProtocol("zookeeper");
        registryConfig.setAddress("127.0.0.1:2181");
        return registryConfig;
    }
    
    //<dubbo:protocol name="dubbo" port="20882"></dubbo:protocol>
    @Bean
    public ProtocolConfig protocolConfig() {ProtocolConfig protocolConfig = new ProtocolConfig();
        protocolConfig.setName("dubbo");
        protocolConfig.setPort(20882);
        return protocolConfig;
    }
    
    /**
     *<dubbo:service interface="com.atguigu.gmall.service.UserService" 
        ref="userServiceImpl01" timeout="1000" version="1.0.0">
        <dubbo:method name="getUserAddressList" timeout="1000"></dubbo:method>
    </dubbo:service>
     */
    @Bean
    public ServiceConfig<UserService> userServiceConfig(UserService userService){ServiceConfig<UserService> serviceConfig = new ServiceConfig<>();
        serviceConfig.setInterface(UserService.class);
        serviceConfig.setRef(userService);
        serviceConfig.setVersion("1.0.0");
        
        // 配置每一个 method 的信息
        MethodConfig methodConfig = new MethodConfig();
        methodConfig.setName("getUserAddressList");
        methodConfig.setTimeout(1000);
        
        // 将 method 的设置关联到 service 配置中
        List<MethodConfig> methods = new ArrayList<>();
        methods.add(methodConfig);
        serviceConfig.setMethods(methods);
        
        //ProviderConfig
        //MonitorConfig
        
        return serviceConfig;
    }

}

二 Dubbo 配置

(一) 重写与配置优先级

http://dubbo.apache.org/zh/do…

优先级从高到低：

• JVM -D 参数：当你部署或者启动利用时，它能够轻易地重写配置，比方，扭转 dubbo 协定端口；
• XML：XML 中的以后配置会重写 dubbo.properties 中的；
• Properties：默认配置，仅仅作用于以上两者没有配置时。

1. 如果在 classpath 下有超过一个 dubbo.properties 文件，比方，两个 jar 包都各自蕴含了 dubbo.properties，dubbo 将随机抉择一个加载，并且打印谬误日志。
2. 如果 id 没有在 protocol 中配置，将应用 name 作为默认属性。

(二) 启动时查看

Dubbo 缺省会在启动时查看依赖的服务是否可用，不可用时候就会抛出异样，同时阻止 Spring 初始化实现，益处就是上线的时候能够及早的发现问题，注：默认 check=“true”

• 能够通过 check=“false”敞开查看，比方，测试时，有些服务不关怀，或者呈现了循环依赖，必须有一方先启动。
• 另外，如果你的 Spring 容器是懒加载的，或者通过 API 编程提早援用服务，请敞开 check，否则服务长期不可用时，会抛出异样，拿到 null 援用，如果 check=“false”，总是会返回援用，当服务复原时，能主动连上

比方在 order-service-consumer 消费者中，在 consumer.xml 中增加配置

<!-- 配置以后消费者的对立规定, 以后所有的服务都不启动时查看 -->
<dubbo:consumer check="false"></dubbo:consumer>

也能够在每一个下面加 check

(三) 全局超时配置

因为网络或服务端不牢靠，会导致调用呈现一种不确定的中间状态（超时），为了防止超时导致客户端资源（线程）挂起耗尽，必须设置超时工夫

(1) Dubbo 生产端

<!-- 全局超时配置 -->
<dubbo:consumer timeout="5000" />

<!-- 调用近程裸露的服务，生成近程服务代理 -->
<dubbo:reference interface="cn.ideal.mall.service.UserService" id="userService" timeout="2000">
    <dubbo:method name="getUserAddressList" timeout="3000"/>
</dubbo:reference>

(2) Dubbo 服务端

<!-- 全局超时配置 -->
<dubbo:consumer timeout="5000" />

<!-- 调用近程裸露的服务，生成近程服务代理 -->
<dubbo:service interface="cn.ideal.mall.service.UserService" ref="userServiceImpl" timeout="2000">
    <dubbo:method name="getUserAddressList" timeout="3000"/>
</dubbo:service>

设置超时工夫其实算蛮简略的，然而最次要留神的问题就是优先级问题，在下面不论是消费者还是服务者，我都配置了三种档次的超时配置，这几者的优先级别简略总结就是：

• ① 更细，更精准的优先：1. 办法级别 <== 2. 接口级别 <== 3. 全局级别
• ② 消费者设置优先：级别统一的状况下，消费者优先于提供者

补充：

• dubbo:consumer 超时默认值为 1000

http://dubbo.apache.org/zh/do…

(3) 配置准则

dubbo 举荐在 Provider 上尽量多配置 Consumer 端属性

• 作服务的提供者，比服务应用方更分明服务性能参数，如调用的超时工夫，正当的重试次数，等等
• 在 Provider 配置后，Consumer 不配置则会应用 Provider 的配置值，即 Provider 配置能够作为 Consumer 的缺省值。否则，Consumer 会应用 Consumer 端的全局设置，这对于 Provider 不可控的，并且往往是不合理的

(四) 多版本问题

https://dubbo.apache.org/zh/d…

当一个接口实现，呈现不兼容降级时，能够用版本号过渡，版本号不同的服务相互间不援用。

能够依照以下的步骤进行版本迁徙：

• 在低压力时间段，先降级一半提供者为新版本
• 再将所有消费者降级为新版本
• 而后将剩下的一半提供者降级为新版本

老版本服务提供者配置：

<dubbo:service interface="cn.ideal.mall.service.UserService" ref="userServiceImpl" version="1.0.0"/>

<!-- 服务的实现 -->
<bean id="userServiceImpl" class="cn.ideal.mall.service.impl.UserServiceImpl"/>

新版本服务提供者配置：

<dubbo:service interface="cn.ideal.mall.service.UserService" ref="userServiceImpl" version="2.0.0"/>

<!-- 服务的实现 -->
<bean id="userServiceImpl" class="cn.ideal.mall.service.impl.UserServiceImpl"/>

老版本服务消费者配置：

<dubbo:reference id="userService" interface="cn.ideal.mall.service.UserService version="1.0.0" />

新版本服务消费者配置：

<dubbo:reference id="userService" interface="cn.ideal.mall.service.UserService version="2.0.0" />

如果不须要辨别版本，能够依照以下的形式配置（2.2.0 以上版本反对）

<dubbo:reference id="barService" interface="com.foo.BarService" version="*" />

三 Dubbo 高可用

这一块的解说次要是针对，在一些突发的谬误，或者大并发下等如何保障 Dubbo 仍为高可用状态的一些概念，以及措施

注：高可用，即通过设计，缩小零碎不能提供服务的工夫

(一) zookeeper 宕机 和 Dubbo 直连

(1) zookeeper 宕机

zookeeper 作为注册核心，如果部署运行着它的服务器出问题了，呈现了 zookeeper 宕机，那么这个时候消费者岂不是找不到被裸露的服务了

然而咱们被动关掉 zookeeper 的服务，在 dubbo-admin 监控中能够看到服务呈现了谬误，然而咱们去申请接口，能够发现依然能申请失去后果，即，还能够生产 dubbo 裸露的服务

这一点与 Dubbo 设计时实现的健壮性无关

• 监控核心宕掉不影响应用，只是失落局部采样数据
• 数据库宕掉后，注册核心仍能通过缓存提供服务列表查问，但不能注册新服务
• 注册核心对等集群，任意一台宕掉后，将主动切换到另一台
• 注册核心全副宕掉后，服务提供者和服务消费者仍能通过本地缓存通信
• 服务提供者无状态，任意一台宕掉后，不影响应用
• 服务提供者全副宕掉后，服务消费者利用将无奈应用，并有限次重连期待服务提供者复原
  高可用：通过设计，缩小零碎不能提供服务的工夫

https://dubbo.apache.org/zh/d…

Dubbo 的服务注册核心

目前服务注册核心应用了数据库来保留服务提供者和消费者的信息。注册核心集群不同注册核心也通过数据库来进行同步数据，以感知其它注册核心上提供者的变动。注册核心会在内存中保留一份提供者和消费者数据，数据库不可用时，注册核心独立对外提供服务以保障失常运行，只是拿不到其它注册核心的数据。当数据库复原时，重试逻辑会将内存中批改的数据写回数据库，并拿到数据库中新数据。

服务的消费者

服务消费者从注册核心拿到提供者列表后，会保留提供者列表到内存和磁盘文件中。这样注册核心宕机后消费者能够失常运行，甚至能够在注册核心宕机过程中重启消费者。消费者启动时，发现注册核心不可用，会读取保留在磁盘文件中提供者列表。重试逻辑保障注册核心复原后，更新信息。

(2) Dubbo 直连

如果注册核心当初有点问题，或者无意的不想拜访注册核心上的服务，而是想要间接在本地上调试 dubbo 接口，也能够应用 Dubbo 直连

• 第一种：通过 @Reference 的 url 属性（Springboot）

@Reference(url = "127.0.0.1:20081")
public UserService userService;

• 第二种：在 consumer.xml 中指定 url（SSM）

<dubbo:reference interface="cn.ideal.mall.service.UserService" id="userService"  url="127.0.0.1:20081">

• 第三种：增加映射配置文件

  • 如果不想要批改工程内容，能够思考应用这个形式

在本地电脑用户下新建一个叫 dubbo-resolve.properties 的文件门路是 ${user.home}/dubbo-resolve.properties

而后就不须要批改本地工程的其余配置信息，在文件里配置好须要直连的服务信息即可

# 直连本地的服务
cn.ideal.mall.service.UserService=dubbo://localhost:20890

(二) 集群下 Dubbo 的负载平衡策略

这一块，咱们只对几种负载平衡策略做一些阐明和解释，具体的算法实现，不是几句话能说的分明地，须要再深刻的去学习以及钻研，以下是官网对于负载平衡具体的阐明

https://dubbo.apache.org/zh/d…

(1) 什么是负载平衡

LoadBalance 中文意思为负载平衡，它的职责是将网络申请，或者其余模式的负载“均摊”到不同的机器上。防止集群中局部服务器压力过大，而另一些服务器比拟闲暇的状况。

通过负载平衡，能够让每台服务器获取到适宜本人解决能力的负载。在为高负载服务器分流的同时，还能够防止资源节约，两全其美。

负载平衡可分为软件负载平衡和硬件负载平衡。在咱们日常开发中，个别很难接触到硬件负载平衡。但软件负载平衡还是能够接触到的，比方 Nginx。

在 Dubbo 中，也有负载平衡的概念和相应的实现。Dubbo 须要对服务消费者的调用申请进行调配，防止多数服务提供者负载过大。服务提供者负载过大，会导致局部申请超时。因而将负载平衡到每个服务提供者上，是十分必要的。

Dubbo 提供了 4 种负载平衡实现，别离是

• 基于权重随机算法的 Random LoadBalance
• 以及基于加权轮询算法的 RoundRobin LoadBalance
• 基于起码沉闷调用数算法的 LeastActive LoadBalance
• 基于 hash 一致性的 ConsistentHash LoadBalance

(2) 四种负载平衡策略

A：Random LoadBalance

基于权重随机算法的 RandomLoadBalance

随机算法，按权重设置随机概率

在一个截面上碰撞的概率高，但调用量越大散布越平均，而且按概率使用权重后也比拟平均，有利于动静调整提供者权重

依据权重的这个比重来决定到底用哪个

注：weight 代表权重，即在所有份数中所占的比例

B：RoundRobin LoadBalance

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

如果只思考轮轮询的意思就是，比方拜访 1 –> 2 –> 3，再一轮又是 1 –> 2 –> 3，然而如果还要基于权重，是这样的，比方第一次是 1 –> 2 –> 3 的程序，而后第二轮 1 –> 2，当应该到 3 时候，依照这个权重比例，总共看成 7 份机会，1 和 2 调用了两次了，各自占据了 2 份，然而 3 服务应该只能占据 1 份，所以只能跳过 3 了，再第三轮，1 曾经两份了，所以也不应该用了，所以思考取去 2，所以这几轮的程序就是 1 –> 2 –> 3 –>1 –> 2 –> 2 –> 2

毛病：存在慢的提供者累积申请的问题，比方：第二台机器很慢，但没挂，当申请调到第二台时就卡在那，长此以往，所有申请都卡在调到第二台上

C：LeastActiveLoad Balance

LeastActive LoadBalance 起码沉闷数负载平衡机制

沉闷数指调用前后计数差，计算沉闷数使慢的提供者收到更少申请，因为越慢的提供者的调用前后计数差会越大

注：如果沉闷数雷同，就随机

D：ConsistentHash LoadBalance

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

这个算法会对，办法调用的第一个参数进行 Hash，例如就是对下面的 param 参数前面的 1、2、3 进行哈希，一致性 Hash，雷同参数的申请总是发到同一提供者

益处就是，当某一台提供者挂时，本来发往该提供者的申请，基于虚构节点，平摊到其它提供者，不会引起激烈变动

(三) 整合 hystrix，服务熔断与降级解决

(1) 服务降级

当服务器压力剧增的状况下，依据理论业务状况及流量，对一些服务和页面有策略的不解决或换种简略的形式解决，从而开释服务器资源以保障外围交易失常运作或高效运作

能够通过服务降级性能长期屏蔽某个出错的非关键服务，并定义降级后的返回策略

向注册核心写入动静配置笼罩规定：

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"));

其中：

• mock=force:return+null 示意生产方对该服务的办法调用都间接返回 null 值，不发动近程调用。用来屏蔽不重要服务不可用时对调用方的影响
• 还能够改为 mock=fail:return+null 示意生产方对该服务的办法调用在失败后，再返回 null 值，不抛异样。用来容忍不重要服务不稳固时对调用方的影响

(2) 集群容错

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

A：集群容错模式

Failover Cluster

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

重试次数配置如下：

<dubbo:service retries="2" />

或

<dubbo:reference retries="2" />

或

<dubbo:reference>
    <dubbo:method name="findFoo" retries="2" />
</dubbo:reference>

Failfast Cluster

疾速失败，只发动一次调用，失败立刻报错。通常用于非幂等性的写操作，比方新增记录。

Failsafe Cluster

失败平安，出现异常时，间接疏忽。通常用于写入审计日志等操作。

Failback Cluster

失败主动复原，后盾记录失败申请，定时重发。通常用于音讯告诉操作。

Forking Cluster

并行调用多个服务器，只有一个胜利即返回。通常用于实时性要求较高的读操作，但须要节约更多服务资源。可通过 forks="2" 来设置最大并行数。

Broadcast Cluster

播送调用所有提供者，一一调用，任意一台报错则报错。通常用于告诉所有提供者更新缓存或日志等本地资源信息。

B：集群模式配置（2.1.0 开始反对）

依照以下示例在服务提供方和生产方配置集群模式，缺省为 failover 重试

<dubbo:service cluster="模式名" />

或

<dubbo:reference cluster="模式名" />

(四) 整合 Hystrix

在微服务架构中存在多个可间接调用的服务，这些服务若在调用时呈现故障会导致连锁效应，也就是可能会让整个零碎变得不可用，这种状况咱们称之为服务雪崩效应，在这种时候，就须要咱们的 熔断机制 来解救整个零碎

在微服务架构下，很多服务都相互依赖，如果不能对依赖的服务进行隔离，那么服务自身也有可能产生故障，Hystrix 通过 Hystrix Command 对调用进行隔离，这样能够阻止故障的连锁反应，可能让接口调用疾速失败并迅速恢复正常，或者回退并优雅降级

对于 Hystrix，会在 SpringCloud 的学习文章整顿中进行介绍，这里只做一个简略的应用

首先引入依赖

留神，留神！如果拟引入的 hystrix 版本绝对较新，或者会报错

Error creating bean with name ‘configurationPropertiesBeans…….

一种状况就是你的 springboot 版本太新了，须要升高一下，spring 官网能够看到 当初的 cloud 对应能反对到哪个版本的 boot

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
    <version>2.2.5.RELEASE</version>
</dependency>

启动类增加 @EnableHystrix 注解

@EnableDubbo // 开启基于注解的 dubbo 性能
@EnableHystrix // 开启服务容错性能
@SpringBootApplication
public class BootUserServiceProviderApplication {public static void main(String[] args) {SpringApplication.run(BootUserServiceProviderApplication.class, args);
    }
}

在提供者中增加注解

能够间接应用 @HystrixCommand，前面都是一些属性设置，上面的随机数判断是为了模仿异样

@Service
@Component
public class UserServiceImpl implements UserService {

    @HystrixCommand(commandProperties = {@HystrixProperty(name = "circuitBreaker.requestVolumeThreshold", value = "10"),
            @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "2000") })
//    @HystrixCommand
    public List<UserAddress> getUserAddressList(String userId) {UserAddress address1 = new UserAddress(1, "广东省 xxx 市 xxx 区 xxx 路 xxx 小区 24 栋 1 单元 801 户", "1", "阿文", "13999999999", "Y");
        UserAddress address2 = new UserAddress(2, "北京市 yyy 区 yyy 路 yyy 小区 19 号 3 单元 502 户", "1", "南方少女的梦", "13888888888", "N");
        if (Math.random() > 0.5){throw new RuntimeException();
        }
        return Arrays.asList(address1,address2);
    }
}

在消费者中增加注解

method 上配置 @HystrixCommand。当调用出错时，会走 fallbackMethod = “testError”

@Service
public class OrderServiceImpl implements OrderService {

    @Reference
    public UserService userService;

    @HystrixCommand(fallbackMethod = "testError")
    public List<UserAddress> initOrder(String userID) {

        // 查问用户的收货地址
        List<UserAddress> userAddressList = userService.getUserAddressList(userID);

        // 为了直观的看到失去的数据，以下内容也可不写
        System.out.println("以后接管到的 userId=>"+userID);
        System.out.println("**********");
        System.out.println("查问到的所有地址为：");
        for (UserAddress userAddress : userAddressList) {
            // 打印近程服务地址的信息
            System.out.println(userAddress.getUserAddress());
        }
        return userAddressList;
    }

    public List<UserAddress> testError(){
        return Arrays.asList(new UserAddress(10,"谬误测试地址",
                "1","测试 BWH","15555555555","N"));
    }
}