Dubbo
Apache Dubbo 是一款 RPC 服务开发框架,用于解决微服务架构下的服务治理与通信问题,官方提供了 Java、Golang 等多语言 SDK 实现。使用 Dubbo 开发的微服务原生具备相互之间的远程地址发现与通信能力, 利用 Dubbo 提供的丰富服务治理特性,可以实现诸如服务发现、负载均衡、流量调度等服务治理诉求。Dubbo 被设计为高度可扩展,用户可以方便的实现流量拦截、选址的各种定制逻辑。(摘自官网)
更多Dubbo
相关介绍,可查阅官方文档:
官方文档地址:https://dubbo.apache.org/zh/overview/what/overview/总结下来就是Dubbo
发展至今各行各业广泛应用,无论是稳定性还是各方面的特性都得到了完整的考验与实践。如今已升级到Dubbo 3.0
在易用性、超大规模微服务实践、云原生基础设施适配、安全性等场景任占有一席之地,依然是RPC服务框架的首选。
1、分布式基础理论回顾
1.1、为什么需要分布式?
现如今的大型互联网应用为什么要采用分布式架构??
首选需要明确的是:只有当单个阶段的处理能力无法满足日益增长的计算、存储任务的时候并且硬件的提升(增加内存、加磁盘、使用更好的CPU)都没得到更好的优化,我们才考虑采用分布式架构。因为分布式系统要解决的问题本身就是和单机系统一样的,而由于分布式架构有多节点、通过网络通信的拓扑结构会引入很多单机系统没有的问题,为了解决这些问题又会引入更多的机制、协议、带来更多意料的问题等
那么什么是分布式架构,简单理解就是为了分散应用的压力,将不同模块部署在不同的服务器上,各模块直接采用轻量级的通信机制互相调用与协作,来减轻应用系统的处理压力。
因此随着互联网的发展,网站应用的规模不断扩大,常规的垂直应用架构已无法应对,分布式服务架构以及流动计算架构势在必行。如下图(网站演进过程)
1、1~10
单一应用架构,也称为单体架构
当网站流量很小时,只需要一个应用,将所有的功能都部署在一起,以减少部署的节点和成本,此时简化增删改查工作量的数据访问框架(ORM)是关键。这种架构适用于小型网站、小型管理系统、简单易用。
缺点:
- 性能扩展比较难
- 协同开发问题(不利于协同开发)
- 不利于维护(例如功能调整上线时需要重新打包、停应用等)
2、10~1000
垂直应用架构
当访问量逐渐增大,单一应用增加机器带来的优化速度越来越小,将应用拆分成互不相干的几个应用,以提升处理效率。此时用于加速前端页面开发的Web框架(MVC)是关键。
优点:通过切分业务来实现各个模块的独立部署,降低了维护和部署的难度,团队各司其职更容易管理,性能扩展也更方便,更有针对性。
缺点:公共模块无法重复利用,模块耦合度高,维护成本也高。
3、1000~10000
分布式服务架构
垂直应用系统架构的改进,当垂直应用越来越多,应用之间交互不可避免,将核心业务抽取出来,作为独立的服务,逐渐形成稳定的服务中心,使前端应用能更快的响应多变的市场需求。此时,用于提高业务复用及整合与管理各服务互相协作的分布式服务框架(RPC)是关键。
4、10000+
流动计算架构
当服务越来越多,服务资源得不到合理的利用逐渐呈现出来(例如有的服务调用频率特别大,有的服务调用频率又特别小,此时应该协调出调用频率小的服务器资源给调用频率高的服务),此时需增加一个调度中心基于访问压力实时管理集群容量,提高集群利用率。
SOA(Service Oriented Architecture)
用于提供机器利用率的资源调度和治理中心,成为流动计算架构的关键性技术。
1.2、RPC
1、什么是RPC?
RPC(Remote Procedure Call):远程过程调用。是一种进程间通信方式,它是一种技术思想不是规范或约定。它允许程序调用另外一个地址空间(通常是共享网络的另一台机器上)的过程或函数,而不用开发者实现这个远程调用的细节。即开发者无论是调用本地的还是远程的函数,本质上编写的调用代码基本上都是相同的。
也就是说两台服务器A,B,一个应用部署在A服务器上,想要调用B服务器上应用提供的函数/方法,由于不在一个内存空间,不能直接调用,需要通过网络来表达调用的语义和传达调用的数据。
2、为什么要用RPC呢?
就是无法在一个进程内,甚至一个计算机内通过本地调用的方式完成的需求,比如不同的系统间的通讯,甚至不同的组织间的通讯,由于计算能力需要横向扩展,需要在多台机器组成的集群上部署应用。RPC就是要像调用本地的函数一样去调远程函数。
基本原理示意图:
小结:
client stub
和server stub
可以视为协调调用远程函数的"助手",主要完成如下几个工作:
client stub
:
1、客户端调用
2、序列化
3、发送消息
9、将调用结果反序列化
10、返回调用结果
server stub
:
4、反序列化
5、调用本地服务
6、返回处理结果
7、将调用结果序列化
8、响应消息
因此不难看出影响RPC
调用效率的因素主要有两个:
1、通讯(轻量级的通讯尤为重要)
2、序列化与反序列化(采用XML还是JSON或是二进制流进行数据的传输)
基于这种RPC
的思想市面上也衍生出了很多RPC
框架,例如:bubbo、gRPC、Thrift、HSF(High Speed Service Framework)
2、Dubbo
2.1、dubbo的角色划分
更多Dubbo
的介绍就不重复啰嗦了,官方文档已经说的很明白了。
节点角色说明
节点 | 角色说明 |
---|---|
Provider | 暴露服务的服务提供方 |
Consumer | 调用远程服务的服务消费方 |
Registry | 服务注册与发现的注册中心 |
Monitor | 统计服务的调用次数和调用时间的监控中心 |
Container | 服务运行容器 |
了解个节点的含义后我们再来看Dubbo
的工作流程:
start
服务容器负责启动,加载,运行服务提供者。register
服务提供者在启动时,向注册中心注册自己提供的服务。subscribe
服务消费者在启动时,向注册中心订阅自己所需的服务。notify
注册中心返回服务提供者地址列表给消费者,如果有变更,注册中心将基于长连接推送变更数据给消费者。invoke
服务消费者,从提供者地址列表中,基于软负载均衡算法,选一台提供者进行调用,如果调用失败,再选另一台调用。count
服务消费者和提供者,在内存中累计调用次数和调用时间,定时每分钟发送一次统计数据到监控中心。
2.2、Dubbo环境搭建
1、首先是注册中心
Dubbo
都可以适配主流的注册中心,例如Zookeeper、Nacos、Mulicast、Redis
等,这里我们采用Zookeeper
做为Dubbo
的注册中心,Zookeeper
是一个树形的目录服务,支持变更推送,适合作为Dubbo
服务的注册中心,这也是官方推荐使用的注册中心。
Docker
构建zookeeper服务端
# 拉取最新zookeeper镜像
docker pull zookeeper
# 启动zookeeper
docker run -d -p 2181:2181 --name zookeeper --restart always [imageId]
# 进入容器查看Zookeeper运行状态
root@c1a413096894:/apache-zookeeper-3.7.0-bin/bin# pwd
/apache-zookeeper-3.7.0-bin/bin
root@c1a413096894:/apache-zookeeper-3.7.0-bin/bin# ./zkServer.sh status
ZooKeeper JMX enabled by default
Using config: /conf/zoo.cfg
Client port found: 2181. Client address: localhost. Client SSL: false.
Mode: standalone
2、到这里Dubbo
的基本环境也就搭建完了,接下来就是项目集成Dubbo
即可。需要注意的是Dubbo
本身并不是一个服务软件!它其实就是一个jar
包,能够帮助我们的Java
程序连接到Zookeeper
,并利用Zookeeper
消费或提供服务。
3、需要自己创建两个项目,一个是provider
服务提供者,另外一个是consumer
服务消费者,我们需要借助这两个项目完成Dubbo
各种测试。
2.3、hello world实现
假设现有用户服务(provider
)和订单服务(consumer
),两个服务分别部署在不同的服务器上,创建订单的时候,需要获取到用户信息包括电话号码,收获地址等,此时就需要订单服务可以远程调用用户服务提供的接口或方法。
1、将服务提供者注册到Zookeeper
注册中心(如何暴露服务)
1.给服务提供者项目添加Dubbo
依赖(服务提供者我们使用SpringBoot
,服务消费者我们使用原生Spring
,两种集成方式可做参考)
<!-- https://mvnrepository.com/artifact/org.apache.dubbo/dubbo-spring-boot-starter -->
<dependency>
<groupId>org.apache.dubbo</groupId>
<artifactId>dubbo-spring-boot-starter</artifactId>
<version>2.7.8</version>
</dependency>
2.由于Dubbo
使用Curator
作为与 Zookeeper Server 交互的编程客户端。注册中心Zookeeper
还需要引入操作Zookeeper
的客户端Curator
,dubbo-dependencies-zookeeper
将自动为应用增加 Zookeeper 相关客户端的依赖(也就是curator
相关的依赖)。
<!-- https://mvnrepository.com/artifact/org.apache.dubbo/dubbo-dependencies-zookeeper -->
<dependency>
<groupId>org.apache.dubbo</groupId>
<artifactId>dubbo-dependencies-zookeeper</artifactId>
<version>2.7.8</version>
<type>pom</type>
</dependency>
注意:官方明确指出Dubbo
和dubbo-dependencies-zookeeper
有版本兼容性问题,如使用中遇到版本兼容问题,也可以不使用dubbo-dependencies-zookeeper
,而是自行添加Curator、Zookeeper Client
等依赖,例如:
<!-- https://mvnrepository.com/artifact/org.apache.curator/curator-framework -->
<dependency>
<groupId>org.apache.curator</groupId>
<artifactId>curator-framework</artifactId>
<version>4.2.0</version>
</dependency>
版本兼容性说明
3.编写配置文件(暴露服务配置)这里有3
种写法
方式1:基于注解实现服务的暴露(使用@DubboService
暴露服务,使用@DubboReference
引用服务)非常的方便与简洁,弊端就是注解只能加在类上面,注解配置属性属于类配置,无法精确到方法的配置。
# 指定当前服务的名字(同样的服务名字相同,不要和别的服务名相同)
dubbo.application.name=provider-server
# 指定注册中心地址
dubbo.registry.address=zookeeper://180.76.238.29:2181
# 默认超时时间是5000毫秒,如果5000毫秒还没有连上zk,就报java.lang.IllegalStateException: zookeeper not connected,所以我们设大一点
dubbo.registry.timeout=20000
# 指定协议与通信端口(通信规则)
dubbo.protocol.name=dubbo
dubbo.protocol.port=20880
# 指定包扫描路径(或在主程序类上加上@EnableDubbo) 指定包扫描路径和@EnableDubbo两种选其中一个即可
dubbo.scan.base-packages=com.laizhenghua.cache.service
方式2:使用XML
配置文件,dubbo
相关的配置文件,之前怎么写,现在还是怎么写。在主程序中使用@ImportResource
导入配置文件即可,例如:
spring-dubbo.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://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd">
<!-- 1.指定当前服务或应用的名字(同样的服务名字相同,不要和别的服务同名) -->
<dubbo:application name="user-service"/>
<!-- 2.指定注册中心的位置(两种配置方式) -->
<!--<dubbo:registry address="zookeeper://127.0.0.1:2181"/>-->
<dubbo:registry protocol="zookeeper" address="127.0.0.1:2181"/>
<!-- 3.指定通信规则(通信协议与通信端口) -->
<dubbo:protocol name="dubbo" port="20880"/>
<!-- 4.暴露服务配置 -->
<dubbo:service interface="com.laizhenghua.cache.service.UserService" ref="userService"/>
<bean id="userService" class="com.laizhenghua.cache.service.impl.UserServiceImpl"/>
</beans>
在主程序中导入或集成配置文件
/**
* @description: 主程序
* @author: laizhenghua
* @date: 2022/5/4 17:06
*/
@EnableCaching // 开启基于注解的缓存
@ImportResource(locations = {"classpath:spring/spring-dubbo.xml"}) // 集成dubbo配置文件
@SpringBootApplication
public class ApplicationMain {
public static void main(String[] args) {
SpringApplication.run(ApplicationMain.class, args);
}
}
方式3:使用配置类方式,将每一个组件手动创建并注入到容器中。例如
/**
* @description: dubbo配置类
* @author: laizhenghua
* @date: 2022/8/9 23:00
*/
@Configuration
public class DubboConfiguration {
@Autowired
private UserService userService;
@Bean
public ApplicationConfig applicationConfig() {
ApplicationConfig config = new ApplicationConfig();
config.setName("user-service");
return config;
}
@Bean
public RegistryConfig registryConfig() {
RegistryConfig config = new RegistryConfig();
config.setProtocol("zookeeper");
config.setAddress("127.0.0.1:2181");
return config;
}
@Bean
public ProtocolConfig protocolConfig() {
ProtocolConfig config = new ProtocolConfig();
config.setName("dubbo");
config.setPort(20882);
return config;
}
@Bean
public ServiceConfig<UserService> serviceConfig() {
// 配置接口与实现类
ServiceConfig<UserService> serviceConfig = new ServiceConfig<>();
serviceConfig.setInterface(UserService.class);
serviceConfig.setRef(userService);
serviceConfig.setVersion("1.0-SNAPSHOT");
// 配置method信息
MethodConfig methodConfig = new MethodConfig();
methodConfig.setName("getList");
methodConfig.setReturn(true);
methodConfig.setTimeout(10000);
List<MethodConfig> methodConfigList = new ArrayList<>();
methodConfigList.add(methodConfig);
// 注册method信息
serviceConfig.setMethods(methodConfigList);
return serviceConfig;
}
}
三种配置方式,自己喜欢哪一种就选择选哪一种!最后再进入zookeeper
看看我们的服务有没有注册成功:
[zk: localhost:2181(CONNECTED) 12] ls /
[dubbo, zookeeper]
[zk: localhost:2181(CONNECTED) 13] ls /dubbo
[metadata, config, com.laizhenghua.cache.service.UserService]
[zk: localhost:2181(CONNECTED) 14]
# 可以看到com.laizhenghua.cache.service.UserService节点,说明这个服务已经注册成功了
2、让服务消费者去注册中心订阅服务提供者的服务地址(为了笔记的完整性,服务消费者我们通过纯XML
配置文件实现)
spring-dubbo.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://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd">
<!-- 1.指定当前服务的名字 -->
<dubbo:application name="consumer-server"/>
<!-- 2.指定注册中心(注意超时时间设置) -->
<dubbo:registry address="zookeeper://180.76.238.29:2181" timeout="20000"/>
<!-- 3.声明需要调用的远程服务的接口(生成远程服务代理) 也可以使用@DubboReference声明 -->
<dubbo:reference interface="com.laizhenghua.cache.service.DubboUserService" id="dubboUserService"/>
</beans>
主程序(注意点:远程调用如果涉及到Java
对象传输,Java
对象需保证可序列化。另外服务消费者需要建立与服务提供者一样的包结构,例如服务提供者暴露的服务是com.laizhenghua.cache.service.DubboUserService
,那么服务消费者也要有一个这样的包结构,或者是把涉及到远程调用的内容,单独抽离出来做一个公共的工程模块):
@SpringBootApplication
@ImportResource({"classpath:spring/spring-dubbo.xml"})
public class CacheApplication {
public static void main(String[] args) {
SpringApplication.run(CacheApplication.class, args);
}
}
OK
到这里,所有环境已经搭建完了,就可以真正尝试一下远程过程调用!如何测试呢???
1、服务提供者provider-server
,从DubboUserService.java
编写测试代码并重启应用,例如
/**
* @description: 服务提供者 DubboUserService
* @author: laizhenghua
* @date: 2022/5/4 17:54
*/
public interface DubboUserService {
// 测试方法
String login(String username, String password);
}
// =========================================================
// 实现类
@DubboService
@Service(value = "dubboUserService")
public class DubboUserServiceImpl implements DubboUserService {
private static final org.apache.logging.log4j.Logger log = org.apache.logging.log4j.LogManager.getLogger(DubboUserServiceImpl.class);
@Override
public String login(String username, String password) {
JSONObject response = new JSONObject();
response.put("token", UUID.randomUUID().toString());
response.put("username", username);
response.put("password", password);
return response.toString();
}
}
2、服务消费者consumer-server
,DubboUserService.java
新增login
方法,此时spring
容器中已经注入DubboUserService
类型的bean
,在需要调用的地方引用即可,例如
/**
* @description: 服务消费者 DubboUserService
* @author: laizhenghua
* @date: 2022/5/4 17:54
*/
public interface DubboUserService {
// 测试方法
String login(String username, String password);
}
// =========================================================
// 测试远程过程调用
@SpringBootTest
class CacheApplicationTests {
@Autowired
private DubboUserService dubboUserService; // 注意这里也可以把 @Autowired 换成 @DubboReference 但是主程序要加上 @EnableDubbo
@Test
void test() {
String token = dubboUserService.login("admin", "123");
String jsonToken = JSONObject.toJSONString(JSON.parseObject(token), SerializerFeature.WriteMapNullValue, SerializerFeature.PrettyFormat, SerializerFeature.SortField);
System.out.println(jsonToken);
}
}
输出情况:
2.4、新版dubbo-admin搭建
dubbo
由阿里捐献给apache
后,apache
对dubbo-admin
进行了重构,前端使用Vue
,后端使用SpringBoot
,整体上页面更加漂亮,功能也更加强大,如下图。类似开源项目部署与研究一样,如何开始呢?且听我慢慢道来!
1、下载源码至本地,GitHub
地址:https://github.com/apache/dubbo-admin。从releases
下找到Dubbo Admin 0.3.0
(因为我们使用的Dubbo
版本是2.7+
),如下图
找到Sorce code (zip)
,下载至本地并解压初始化项目依赖等。
2、后端本地调试,解压项目后找到dubbo-admin-server
工程模块,进行依赖jar
包初始化(刷新Maven依赖)。修改配置文件,配置zookeeper
相关的配置,例如:
application.properties
# centers in dubbo2.7, if you want to add parameters, please add them to the url
# 这里我只是截取了 zookeeper 相关的配置,要想增加 zookeeper 连接参数,在url上加上即可,例如连接超时时间 ?timeout=20000
admin.registry.address=zookeeper://180.76.238.29:2181?timeout=20000
admin.config-center=zookeeper://180.76.238.29:2181
admin.metadata-report.address=zookeeper://180.76.238.29:2181
启动项目,并访问http://127.0.0.1:8080/swagger-ui.html
3、本地前端调试,前端工程模块为dubbo-admin-ui
,在package.json
同级目录下执行npm install
命令(注意node
的版本,需要大于10.x)。修改后端应用访问地址,后端应用访问地址配置的就是本机的回环地址,但是最后我们需要部署到服务器上,所以需要了解后端应用访问地址修改方式。
vue.config.js
module.exports = {
outputDir: "target/dist",
lintOnSave: false,
devServer: {
port: 8082,
historyApiFallback: {
rewrites: [
{from: /.*/, to: path.posix.join('/', 'index.html')},
],
},
publicPath: '/',
proxy: {
'/': {
target: 'http://127.0.0.1:8080/', // 主要修改这里,改成本地地址和端口即可
changeOrigin: true,
pathRewrite: {
'^/': '/'
}
}
}
}
....
}
4、启动前端,npm run serve
或npm run dev
都行。
如果报xxx\node_modules\eslint\lib\rules\no-octal-escape.js:41 /^(?:[^\\]|\\.)*?\\([0-3][0-7]{1,2}|[4-7][0-7]|0(?=[89])|[1-7])/su
这种错误,就把vue.config.js
的lintOnSave
配置项改成false
。
到这里,本地启动与访问,就结束了。后面就是Linux
发布教程。
dubbo-admin
部署在Linux
服务器上:
1、本地后端改造,SpringBoot
配置Tomcat
部署,使用jar
运行后端也行。但是对于前后端分离项目,笔者更喜欢把前端和后端部署在一个Tomcat
上。
pom.xml
(注意我注释的内容)
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>dubbo-admin</artifactId>
<groupId>org.apache.dubbo</groupId>
<version>${revision}</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<!-- 1.修改打包方式 -->
<packaging>war</packaging>
<artifactId>dubbo-admin-server</artifactId>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<java.version>1.8</java.version>
<mockito-version>2.23.4</mockito-version>
</properties>
<!-- 2.排除掉内嵌的tomcat容器依赖和logback -->
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<exclusions>
<exclusion>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
</exclusion>
<exclusion>
<groupId>ch.qos.logback</groupId>
<artifactId>logback-classic</artifactId>
</exclusion>
</exclusions>
</dependency>
<!-- 3.添加 spring-boot-starter-tomcat依赖 -->
<!-- 注意<scope>一定要记得添加,因为provided表明该包只在编译和测试的时候用。所以当启动tomcat的时候,就不会冲突了 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
<scope>provided</scope>
</dependency>
...
<dependencies/>
...
</project>
修改主程序:
/**
* dubbo-admin主程序
*/
@SpringBootApplication(exclude={ DataSourceAutoConfiguration.class, HibernateJpaAutoConfiguration.class})
public class DubboAdminApplication extends SpringBootServletInitializer {
@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
// TODO Auto-generated method stub
return builder.sources(DubboAdminApplication.class);
}
public static void main(String[] args) {
SpringApplication.run(DubboAdminApplication.class, args);
}
}
修改application.properties
配置文件,例如
server.port=8080
server.servlet.context-path=/dubbo-admin
# centers in dubbo2.7, if you want to add parameters, please add them to the url
admin.registry.address=zookeeper://121.41.57.179:2181
admin.config-center=zookeeper://121.41.57.179:2181
admin.metadata-report.address=zookeeper://121.41.57.179:2181
...
修改好后,在pom.xml
同级目录下,执行maven
命令,例如
mvn clean
mvn package
2、前端打包也很简单,都是基本操作。例如
新建.env.prod
文件用于配置NODE_ENV
环境与VUE_APP_BASE_URL
文件内容如下:
.env.prod
NODE_ENV=prod
VUE_APP_BASE_URL = 'http://121.41.57.179:8080/dubbo-admin/'
修改package.json
文件,配置执行脚本命令
找到http-common.js
文件,修改axios
实例(如下图所示位置)
修改内容如下:
import axios from 'axios'
import Vue from 'vue'
import HttpStatus from 'http-status'
import router from '@/router'
import i18n from '@/lang'
// 主要修改这里
let instance = axios.create({
// baseURL: '/api/' + process.env.NODE_ENV,
baseURL: process.env.VUE_APP_BASE_URL + 'api/' + process.env.NODE_ENV,
timeout: 600000
})
...
ok
到这里就可以执行npm run build:prod
命令,build前端项目,得到如下目录文件:
在这级目录下,使用Java
自带的jar
命令在进行压缩,例如jar -cvf app.war *
就会得到一个app.war
文件,把前后端war
包文件放到Linux
下的Tomcat
下并进行解压即可。
2.5、Dubbo的配置文件
Spring
框架配置模块的写法永远支持三种写法:
XML
配置文件properties
配置文件API
配置
看自己习惯使用哪一种,当然Dubbo
也抽象或简化了一系列的结构化配置,既可以以最小化配置快速启动服务,又可以在需要时通过复杂的配置精确的控制服务的行为。关于Dubbo
配置我们并不是所有的都讲,很多时候遇到了到官网上或搜索引擎上查阅一下即可。
以XML
文件为例,可配置的标签有:
每个标签可配置的属性可查阅官方文档,例如:
1、启动时检查配置
Dubbo
支持在应用启动时检查依赖的服务是否可用,不可用时会抛出异常,阻止Spring
容器完成初始化,以便上线时,能及早发现问题。可以通过check="false"
关闭检查。默认是true
。
<!-- 1.关闭 BarService 服务启动时检查(即注册中心没有这个服务也能启动成功)-->
<dubbo:reference interface="com.foo.BarService" check="false"/>
<!-- 2.关闭所有服务启动时检查(没有服务提供者也能启动成功) -->
<dubbo:consumer check="false"/>
<!-- 3.关闭注册中心启动时检查(没有从注册中心订阅成功也能启动成功) -->
<dubbo:registry check="false" />
2、服务调用超时配置
为避免出现执行线程阻塞,应该合理设置调用服务超时时间,在指定时间内没有返回结果,及时抛出异常,释放线程资源。
<!-- 接口级配置(指定服务调用超时时间为3s) -->
<dubbo:reference interface="com.laizhenghua.cache.service.DubboUserService" id="dubboUserService" check="false" timeout="3000"/>
<!-- 全局配置 -->
<dubbo:consumer application="consumer-server" timeout="5000"/>
<!-- 方法级配置 -->
<dubbo:reference interface="com.laizhenghua.cache.service.DubboUserService" id="dubboUserService" check="false">
<dubbo:method name="login" timeout="4000"/>
</dubbo:reference>
支持多种配置方式,因此有优先级:方法级优先,接口级次之,全局配置再次之。级别一样消费者优先,提供者此致。注意优先级retries/loadbalance/actives
属性也是一样的。
3、重试次数
远程调用时,由于网络等原因可能会调用失败。Dubbo
也支持设置重新调用。例如:
<!-- retries设置重试次数,第一次调用失败后,尝试重新调用3次(不包含第一次调用) -->
<dubbo:reference interface="com.laizhenghua.cache.service.DubboUserService" id="dubboUserService" check="false">
<dubbo:method name="login" timeout="4000" retries="3"/>
</dubbo:reference>
注意:重试次数一般用在幂等方法(执行多次结果都一样)比较合适。
4、Dubbo多版本
Dubbo
也支持为同一个服务配置多个版本,即当一个接口实现,出现不兼容升级时,可以用版本号过度,版本号不同的服务互相不引用。言外之意,可以新老版本共存,即可以调用新版本的接口,也可以调用旧版本的接口,使用版本区分即可。
例如:服务提供者有两个版本分别为v1.0
和v2.0
。
@DubboService(version = "v1.0")
@Service(value = "dubboUserService")
public class DubboUserServiceImpl implements DubboUserService {
...
}
@DubboService(version = "v2.0")
@Service(value = "dubboUserService2")
public class DubboUserServiceImpl2 implements DubboUserService {
...
}
服务消费者可以选择调用v1.0
或v2.0
的接口(使用version
控制):
<!-- 1.调用v1.0接口 -->
<dubbo:reference interface="com.laizhenghua.cache.service.DubboUserService" id="dubboUserService" version="v1.0">
<dubbo:method name="login" timeout="5000"/>
</dubbo:reference>
<!-- 2.调用v2.0接口 -->
<dubbo:reference interface="com.laizhenghua.cache.service.DubboUserService" id="dubboUserService" version="v2.0">
<dubbo:method name="login" timeout="5000"/>
</dubbo:reference>
<!-- 3.随机调用 * 号配置 -->
<dubbo:reference interface="com.laizhenghua.cache.service.DubboUserService" id="dubboUserService" version="*">
<dubbo:method name="login" timeout="5000"/>
</dubbo:reference>
5、本地存根(local stub
)
远程调用过程中,客户端通常只能看到接口,而接口实现全在服务器端,但提供方有些时候想在客户端也执行部分逻辑(参数验证、调用失败后伪造容错数据等等),就可以使用本地存根这个配置来实现(类似于AOP的前置通知,调用远程接口之前先执行前置代码,如下图XxxServiceStub
)
那么如何实现呢?
1、配置启用stub
功能
<!-- 使用stub属性开启 -->
<dubbo:reference interface="com.laizhenghua.cache.service.DubboUserService" id="dubboUserService" version="v1.0" stub="true">
<dubbo:method name="login" timeout="5000"/>
</dubbo:reference>
2、提供stub
的实现
/**
* @description:
* @author: laizhenghua
* @date: 2022/8/28 13:01
*/
public class DubboUserServiceStub implements DubboUserService {
private final DubboUserService dubboUserService;
// 必须编写这个构造函数(传入真正的远程代理对象)
public DubboUserServiceStub(DubboUserService dubboUserService) {
this.dubboUserService = dubboUserService;
}
@Override
public String login(String username, String password) {
// 在此处可以做参数合法验证、ThreadLocal本地缓存等 如
if ("admin".equals(username)) {
JSONObject successRes = new JSONObject();
successRes.put("message", "管理员无需登录!");
successRes.put("success", true);
return successRes.toString();
}
String response = null;
try {
response = dubboUserService.login(username, password);
} catch (Exception e) {
e.printStackTrace(); // 输出报错信息
// 构造容错数据(可以做任何AOP拦截事项) 如
JSONObject errorRes = new JSONObject();
errorRes.put("message", "登录失败!失败原因:" + e.getMessage());
errorRes.put("success", false);
errorRes.put("code", 500);
response = errorRes.toString();
}
return response;
}
}
3、Dubbo高可用
3.1、宕机与直连
Dubbo
远程调用时,依赖于注册中心如Zookeeper
,注册中心难免会出现宕机的情况!但是还可以消费Dubbo
暴露的服务(可以自行测试一下)。能调用或消费的原因是:注册中心全部宕机后,服务提供者和服务消费者任然能通过本地缓存信息(会记录一下服务提供者信息)进行通讯。
除了本地缓存通讯外,Duboo
还有一些高可用的特性:
- 监控中心宕机并不影响使用,只是会丢失部分采样数据
- 数据库宕机后,注册中心仍能通过缓存提供服务列表查询,但不能注册新服务。
- 注册中心对等集群,任意一台宕机,将自动切换到另外一台。
- 服务提供者无状态,任意一台宕机后,不影响使用
- 服务提供者全部宕机后,服务消费者应用将无法使用,并无限次重连等待服务提供者恢复
因此得出的结论就是:注册中心只是保存一些服务提供者的一些信息。远程调用时也可以不使用注册中心,即通过直连的方式进行通讯。
例如(直连就是使用url属性指定远程提供者信息):
xml
配置
<!-- 指定url属性 -->
<dubbo:reference interface="com.laizhenghua.cache.service.DubboUserService" id="dubboUserService" version="v1.0" url="127.0.0.1:20880">
<dubbo:method name="login" timeout="5000"/>
</dubbo:reference>
使用@DubboReference
注解
@DubboReference(url = "127.0.0.1:20880", version = "v1.0", timeout = 5000)
private DubboUserService dubboUserService; // 注意这里也可以把 @Autowired 换成 @DubboReference 但是主程序要加上 @EnableDubbo
小结:
- 即使注册中心宕机了,
Dubbo
也能通过本地缓存调用服务提供者提供的的方法 Dubbo
也可以不依赖注册中心,通过直连的方式进行通信。
3.2、集群模式下的负载均衡
准备环境:
Provider
(编写一个获取服务端口接口,集群环境方便知道调用了那个服务通过端口区分)
import com.laizhenghua.common.api.ServerRemoteService;
import org.apache.dubbo.config.annotation.DubboService;
import org.springframework.beans.factory.annotation.Value;
// 注意 ServerRemoteService 接口是申明在公共模块common下的一个接口后面消费者也要引入common模块,这也比较常规的写法
@DubboService(
interfaceClass = ServerRemoteService.class, interfaceName = "serverRemoteService",
version = "v0.1", group = "server", timeout = 5000, retries = 3
)
public class ServerServiceImpl implements ServerRemoteService {
@Value("${server.port}")
private String port;
@Override
public String getServerPort() {
return port;
}
}
我们来做个测试,验证是否遵循以下几种负载均衡机制。首先需要准备服务提供者集群环境,集群环境也很简单,我们只需准备好一个jar
,通过JVM
参数改变应用端口和dubbo
通信协议端口即可,例如(分别在不同的终端执行即可):
java -Dserver.port=8081 -Ddubbo.protocol.port=20881 -jar provider-1.0-SNAPSHOT.jar
java -Dserver.port=8082 -Ddubbo.protocol.port=20882 -jar provider-1.0-SNAPSHOT.jar
java -Dserver.port=8083 -Ddubbo.protocol.port=20883 -jar provider-1.0-SNAPSHOT.jar
我们再来看dubbo-admin
OK
👌🏻到这里集群环境已经搭建完毕。
Provider
消费者简单编写一个测试接口就可以测试Dubbo
的负载均衡策略例如:
@RestController
@RequestMapping("/test")
public class TestController {
@DubboReference(interfaceClass = ServerRemoteService.class, interfaceName = "serverRemoteService",
version = "v0.1", group = "server")
private ServerRemoteService serverRemoteService;
@GetMapping("/get/port")
public R getPort() {
String port = serverRemoteService.getServerPort();
return R.success(port);
}
}
在集群环境,Dubbo
也提供了多种均衡策略,缺省为random
随机调用(每个服务的权重相同),上面获取端口号那个例子已经得到了验证。除此之外源码中也可以看到,例如:
// RandomLoadBalance.NAME = random
@SPI(RandomLoadBalance.NAME)
public interface LoadBalance {
// LoadBalance是org.apache.dubbo.rpc.cluster包下的一个接口,它的各种实现类就是dubbo的各种负载均衡策略(算法/源码)
@Adaptive("loadbalance")
<T> Invoker<T> select(List<Invoker<T>> invokers, URL url, Invocation invocation) throws RpcException;
}
那么如何更改负载均衡策略呢?官方文档也有详细说明,我们可以在生产者暴露服务、消费者引入服务、方法级更改负载均衡策略。例如可以在官网配置项参考手册中全局搜索loadbalance
就可以查到负载均衡的所有配置项。
1、Random LoadBalance
:基于权重的随机负载均衡机制,可以为每台机器设置不同的权重。给服务设置权重一般在dubbo-admin
动态设置。
2、RoundRobin LoadBalance
:基于权重的轮询负载均衡机制,也可以不设置权重,以轮询的方式调用。如果设置了权重就加上权重的逻辑。
加上权重的逻辑,假设有7
个请求,那么调用顺序可能就是1,2,3,1,2,2,2
。
配置方式:
@DubboReference(interfaceClass = ServerRemoteService.class, interfaceName = "serverRemoteService",
version = "v0.1", group = "server", loadbalance = RoundRobinLoadBalance.NAME) // 轮询
private ServerRemoteService serverRemoteService;
3、LeastActive LoadBalance
:最少活跃数-负载均衡机制,会记录上一次请求完成的时间,每次调用都选择花费时间最少服务。
4、ConsistentHash LoadBalance
:一致性hash-负载均衡机制,根据hash值和hash分布选择调用哪一个服务。
以上几种负载均衡策略,实际项目要用到时自行研究下即可。
3.3、服务降级
什么是服务降级?
什么是服务降级,三言两句是说不清的。复杂的分布式或微服务系统中应用程序有数十个依赖关系(服务A依赖服务B,服务B又依赖服务C形成服务调用链)假如服务C出现了超时,整条调用链就会调用失败,最终导致服务雪崩效应。
因此为了避免雪崩等一系列问题,必须要拥有一种机制,可以在某个节点或服务出现问题时避免出现级联故障,从而避免整体服务调用失败。这种机制就是服务降级。
dubbo
的服务降级处理有两种机制,分别是屏蔽
与集群容错
。当然新版dubbo
服务治理内容都由动态配置实现,对流量治理,也远比想象中丰富与复杂,详细内容请参考官方文档【流量治理】模块。
1、屏蔽
屏蔽主要是在消费者中设置,临时屏蔽某个出错的非关键服务,从而保证核心业务正常运行。对某个服务设置屏蔽后消费者调用该服务都返回null
(实际上是直接不发起远程调用)。屏蔽的运用场景就是:假设某个服务器提供广告、创建订单服务,当服务器压力剧增情况下,可以根据实际业务以及流量,对【非核心广告服务】有策略的不处理或换一种简单的方式处理,从而释放服务器资源以保证【创建订单核心服务】正常运作或高效运作。
屏蔽某个服务:
configVersion: v0.1
scope: service # 作用范围 application 或 service
enabled: true # 覆盖规则是否生效(可不填缺省生效)
key: server:com.laizhenghua.common.api.ServerRemoteService:v0.1 # scope=service时,key取值为[{group}:]{service}[:{version}]的组合
configs:
- addresses: [0.0.0.0] # 0.0.0.0 for all addresses
side: consumer # consumer or addresses
parameters:
force: return null # 降级策略
dubbo-admin
中创建动态配置规则:
2、集群容错
在集群调用失败时,Dubbo 提供了多种容错方案,缺省为failover
重试。了解一下即可,一般很少使用自带的容错机制,都是整合第三方的容错框架,如Hystrix
等。
例如生产者更改为Failfast Cluster
容错方案:
多种容错方案一览: