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

基本原理示意图：

小结：

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的工作流程：

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

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.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还有一些高可用的特性：

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