共计 28914 个字符,预计需要花费 73 分钟才能阅读完成。
这篇文章是我学习整顿 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:默认配置,仅仅作用于以上两者没有配置时。
- 如果在 classpath 下有超过一个 dubbo.properties 文件,比方,两个 jar 包都各自蕴含了 dubbo.properties,dubbo 将随机抉择一个加载,并且打印谬误日志。
- 如果
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…
属性 | 对应 URL 参数 | 类型 | 是否必填 | 缺省值 | 作用 | 形容 | 兼容性 |
---|---|---|---|---|---|---|---|
timeout | default.timeout | int | 可选 | 1000 | 性能调优 | 近程服务调用超时工夫(毫秒) |
(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"));
}
}