经典RPC框架 - Dubbo-2.7.x

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)是关键。这种架构适用于小型网站、小型管理系统、简单易用。

缺点:

  1. 性能扩展比较难
  2. 协同开发问题(不利于协同开发)
  3. 不利于维护(例如功能调整上线时需要重新打包、停应用等)

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就是要像调用本地的函数一样去调远程函数。

基本原理示意图:
RPC基本原理图
小结:

client stubserver 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的介绍就不重复啰嗦了,官方文档已经说的很明白了。
dubbo的角色划分
节点角色说明

节点角色说明
Provider暴露服务的服务提供方
Consumer调用远程服务的服务消费方
Registry服务注册与发现的注册中心
Monitor统计服务的调用次数和调用时间的监控中心
Container服务运行容器

了解个节点的含义后我们再来看Dubbo的工作流程:

  1. start服务容器负责启动,加载,运行服务提供者。
  2. register服务提供者在启动时,向注册中心注册自己提供的服务。
  3. subscribe服务消费者在启动时,向注册中心订阅自己所需的服务。
  4. notify注册中心返回服务提供者地址列表给消费者,如果有变更,注册中心将基于长连接推送变更数据给消费者。
  5. invoke服务消费者,从提供者地址列表中,基于软负载均衡算法,选一台提供者进行调用,如果调用失败,再选另一台调用。
  6. 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的客户端Curatordubbo-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>

注意:官方明确指出Dubbodubbo-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-serverDubboUserService.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后,apachedubbo-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 servenpm 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.jslintOnSave配置项改成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框架配置模块的写法永远支持三种写法:

  1. XML配置文件
  2. properties配置文件
  3. 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.0v2.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.0v2.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还有一些高可用的特性:

  1. 监控中心宕机并不影响使用,只是会丢失部分采样数据
  2. 数据库宕机后,注册中心仍能通过缓存提供服务列表查询,但不能注册新服务。
  3. 注册中心对等集群,任意一台宕机,将自动切换到另外一台。
  4. 服务提供者无状态,任意一台宕机后,不影响使用
  5. 服务提供者全部宕机后,服务消费者应用将无法使用,并无限次重连等待服务提供者恢复

因此得出的结论就是:注册中心只是保存一些服务提供者的一些信息。远程调用时也可以不使用注册中心,即通过直连的方式进行通讯。

例如(直连就是使用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

小结:

  1. 即使注册中心宕机了,Dubbo也能通过本地缓存调用服务提供者提供的的方法
  2. 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容错方案:

在这里插入图片描述

多种容错方案一览:
在这里插入图片描述

详见官方文档:https://cn.dubbo.apache.org/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/service/fault-tolerent-strategy/

4、Dubbo原理


END

  • 0
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

lambda.

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值