Dubbo快速入门 —— 基于SpringBoot Starter 开发微服务应用案例 + 知识讲解

news2024/11/29 20:36:52

在这里插入图片描述

                                 💧 D u b b o 快速入门——基于 S p r i n g B o o t S t a r t e r 开发微服务应用案例 + 知识讲解 \color{#FF1493}{Dubbo快速入门 —— 基于SpringBoot Starter 开发微服务应用案例 + 知识讲解} Dubbo快速入门——基于SpringBootStarter开发微服务应用案例+知识讲解💧          

🌷 仰望天空，妳我亦是行人.✨
🦄 个人主页——微风撞见云的博客🎐
🐳 《数据结构与算法专栏》的文章图文并茂🦕生动形象🦖简单易学！欢迎大家来踩踩~🌺
🌊 《Java学习笔记专栏》的文章也在不断更新~ 💐
🪁 希望本文能够给读者带来一定的帮助🌸文章粗浅，敬请批评指正！🐥

文章目录

  • 前言
  • 基于SpringBoot Starter 开发微服务应用案例
    • 目标
    • 难度
    • 环境要求
    • 项目介绍
    • 快速部署
      • 1. 获取测试工程
      • 2. 启动一个简易的注册中心
      • 3. 本地打包 API 模块
      • 4. 启动服务提供者
      • 5. 启动服务消费者
    • 动手实践（从零代码开发版）
      • 1. 启动注册中心
      • 2. 初始化项目
      • 3. 添加 Maven 依赖
      • 4. 定义服务接口
      • 5. 定义服务端的实现
      • 6. 配置服务端 Yaml 配置文件
      • 7. 配置消费端 Yaml 配置文件
      • 8. 基于 Spring 配置服务端启动类
      • 9. 基于 Spring 配置消费端启动类
      • 10. 配置消费端请求任务
      • 11. 启动应用
  • 结束
  • =======================分隔符=======================
  • 关于Dubbo的一些重要知识点
    • dubbo配置
      • 1、配置原则
      • 2、重试次数
      • 3、超时时间
        • 1、Dubbo消费端
        • 2、Dubbo服务端
        • 3、配置原则
    • 高可用
      • 1、zookeeper宕机与dubbo直连
      • 2、集群下dubbo负载均衡配置
    • 整合hystrix，服务熔断与降级处理
      • 1、服务降级
      • 2、集群容错
      • 3、整合hystrix
        • 1、配置spring-cloud-starter-netflix-hystrix
        • 2、配置Provider端
        • 3、配置Consumer端
    • dubbo原理
      • 1、RPC原理
      • 2、netty通信原理
      • 3、dubbo原理
        • 1、dubbo原理 -框架设计
        • 2、dubbo原理 -启动解析、加载配置信息
        • 3、dubbo原理 -服务暴露
        • 4、dubbo原理 -服务引用
        • 5、dubbo原理 -服务调用
    • 结束
  • 🐳结语

前言

   💧本文是参考 Dubbo官网案例 以及 尚硅谷Dubbo教程 的学习文档，主要是方便自己复习，也供大家学习dubbo作一定的参考，如有问题欢迎指出.

   💧第一部分是 ：基于SpringBoot Starter 开发微服务应用案例

   💧第二部分是 ：关于Dubbo的一些重要知识点

基于SpringBoot Starter 开发微服务应用案例

目标

从零上手开发基于 dubbo-spring-boot-starter 开发微服务，了解 Dubbo x Spring Boot 配置方式。

难度

低

环境要求

  • 系统：Windows、Linux、MacOS
  • JDK 8 及以上（推荐使用 JDK17）
  • Git
  • IntelliJ IDEA（可选）
  • Docker （可选）

项目介绍

在本任务中，将分为 3 个子模块进行独立开发，模拟生产环境下的部署架构。

.  // apache/dubbo-samples/1-basic/dubbo-samples-spring-boot
├── dubbo-samples-spring-boot-interface       // 共享 API 模块
├── dubbo-samples-spring-boot-consumer        // 消费端模块
└── dubbo-samples-spring-boot-provider        // 服务端模块

如上所示，共有 3 个模块，其中 interface 模块被 consumer 和 provider 两个模块共同依赖，存储 RPC 通信使用的 API 接口。

.  // apache/dubbo-samples/1-basic/dubbo-samples-spring-boot
├── dubbo-samples-spring-boot-interface       // 共享 API 模块
│   ├── pom.xml
│   └── src
│       └── main
│           └── java
│               └── org
│                   └── apache
│                       └── dubbo
│                           └── springboot
│                               └── demo
│                                   └── DemoService.java // API 接口
├── dubbo-samples-spring-boot-consumer        // 消费端模块
│   ├── pom.xml
│   └── src
│       ├── main
│       │   ├── java
│       │   │   └── org
│       │   │       └── apache
│       │   │           └── dubbo
│       │   │               └── springboot
│       │   │                   └── demo
│       │   │                       └── consumer
│       │   │                           ├── ConsumerApplication.java // 消费端启动类
│       │   │                           └── Task.java                // 消费端模拟调用任务
│       │   └── resources
│       │       └── application.yml       // Spring Boot 配置文件
├── dubbo-samples-spring-boot-provider        // 服务端模块
│   ├── pom.xml
│   └── src
│       └── main
│           ├── java
│           │   └── org
│           │       └── apache
│           │           └── dubbo
│           │               └── springboot
│           │                   └── demo
│           │                       └── provider
│           │                           ├── DemoServiceImpl.java         // 服务端实现类
│           │                           └── ProviderApplication.java     // 服务端启动类
│           └── resources
│               └── application.yml       // Spring Boot 配置文件
└── pom.xml

如上为本教程接下来会使用到的项目的文件结构。

快速部署

本章将通过几个简单的命令，一步一步教你如何部署并运行一个基于 Dubbo x Spring Boot 的用例。

注：本章部署的代码细节可以在 apache/dubbo-samples 这个仓库中 1-basic/dubbo-samples-spring-boot 中找到，在下一章中也将展开进行讲解。

1. 获取测试工程

在开始整个教程之前，我们需要先获取测试工程的代码。Dubbo 的所有测试用例代码都存储在 apache/dubbo-samples 这个仓库中，以下这个命令可以帮你获取 Samples 仓库的所有代码。

git clone --depth=1 --branch master git@github.com:apache/dubbo-samples.git

2. 启动一个简易的注册中心

对于一个微服务化的应用来说，注册中心是不可或缺的一个组件。只有通过注册中心，消费端才可以成功发现服务端的地址信息，进而进行调用。

为了让本教程更易于上手，我们提供了一个基于 Apache Zookeeper 注册中心的简易启动器，如果您需要在生产环境部署注册中心，请参考生产环境初始化一文部署高可用的注册中心。

Windows:
./mvnw.cmd clean compile exec:java -pl tools/embedded-zookeeper

Linux / MacOS:
./mvnw clean compile exec:java -pl tools/embedded-zookeeper

Docker:
docker run --name some-zookeeper -p 2181:2181 --restart always -d zookeeper

3. 本地打包 API 模块

为了成功编译服务端、消费端模块，需要先在本地打包安装 dubbo-samples-spring-boot-interface 模块。

./mvnw clean install -pl 1-basic/dubbo-samples-spring-boot
./mvnw clean install -pl 1-basic/dubbo-samples-spring-boot/dubbo-samples-spring-boot-interface

4. 启动服务提供者

在启动了注册中心之后，下一步是启动一个对外提供服务的服务提供者。在 dubbo-samples 中也提供了对应的示例，可以通过以下命令快速拉起。

Windows:  
./mvnw.cmd clean compile exec:java -pl 1-basic/dubbo-samples-spring-boot/dubbo-samples-spring-boot-provider -Dexec.mainClass="org.apache.dubbo.springboot.demo.provider.ProviderApplication"  

Linux / MacOS:
./mvnw clean compile exec:java -pl 1-basic/dubbo-samples-spring-boot/dubbo-samples-spring-boot-provider -Dexec.mainClass="org.apache.dubbo.springboot.demo.provider.ProviderApplication"  

注：需要开一个独立的 terminal 运行，命令将会保持一直执行的状态。

在执行完上述命令以后，等待一会出现如下所示的日志（Current Spring Boot Application is await）即代表服务提供者启动完毕，标志着该服务提供者可以对外提供服务了。

2023-02-08 17:13:00.357  INFO 80600 --- [lication.main()] o.a.d.c.d.DefaultApplicationDeployer     :  [DUBBO] Dubbo Application[1.1](dubbo-springboot-demo-provider) is ready., dubbo version: 3.2.0-beta.4, current host: 30.221.128.96
2023-02-08 17:13:00.369  INFO 80600 --- [lication.main()] o.a.d.s.d.provider.ProviderApplication   : Started ProviderApplication in 9.114 seconds (JVM running for 26.522)
2023-02-08 17:13:00.387  INFO 80600 --- [pool-1-thread-1] .b.c.e.AwaitingNonWebApplicationListener :  [Dubbo] Current Spring Boot Application is await...

5. 启动服务消费者

最后一步是启动一个服务消费者来调用服务提供者，也即是 RPC 调用的核心，为服务消费者提供调用服务提供者的桥梁。

Windows:  
./mvnw.cmd clean compile exec:java -pl 1-basic/dubbo-samples-spring-boot/dubbo-samples-spring-boot-consumer -Dexec.mainClass="org.apache.dubbo.springboot.demo.consumer.ConsumerApplication"

Linux / MacOS:
./mvnw clean compile exec:java -pl 1-basic/dubbo-samples-spring-boot/dubbo-samples-spring-boot-consumer -Dexec.mainClass="org.apache.dubbo.springboot.demo.consumer.ConsumerApplication"

在执行完上述命令以后，等待一会出现如下所示的日志（Hello world），打印出的数据就是服务提供者处理之后返回的，标志着一次服务调用的成功。

2023-02-08 17:14:33.045  INFO 80740 --- [lication.main()] o.a.d.s.d.consumer.ConsumerApplication   : Started ConsumerApplication in 11.052 seconds (JVM running for 31.62)
Receive result ======> Hello world
2023-02-08 17:14:33.146  INFO 80740 --- [pool-1-thread-1] .b.c.e.AwaitingNonWebApplicationListener :  [Dubbo] Current Spring Boot Application is await...
Wed Feb 08 17:14:34 CST 2023 Receive result ======> Hello world
Wed Feb 08 17:14:35 CST 2023 Receive result ======> Hello world
Wed Feb 08 17:14:36 CST 2023 Receive result ======> Hello world
Wed Feb 08 17:14:37 CST 2023 Receive result ======> Hello world

动手实践（从零代码开发版）

本章将通过手把手的教程一步一步教你如何从零开发一个微服务应用。

1. 启动注册中心

对于一个微服务化的应用来说，注册中心是不可或缺的一个组件。只有通过注册中心，消费端才可以成功发现服务端的地址信息，进而进行调用。

为了让本教程更易于上手，我们提供了一个基于 Apache Zookeeper 注册中心的简易启动器，如果您需要在生产环境部署注册中心，请参考生产环境初始化一文部署高可用的注册中心。

Windows:
git clone --depth=1 --branch master git@github.com:apache/dubbo-samples.git
cd dubbo-samples
./mvnw.cmd clean compile exec:java -pl tools/embedded-zookeeper

Linux / MacOS:
git clone --depth=1 --branch master git@github.com:apache/dubbo-samples.git
cd dubbo-samples
./mvnw clean compile exec:java -pl tools/embedded-zookeeper

Docker:
docker run --name some-zookeeper -p 2181:2181 --restart always -d zookeeper

2. 初始化项目

从本小节开始，将基于 IntelliJ IDEA 进行工程的搭建以及测试。

在这里插入图片描述
如上图所示，可以建立一个基础的项目。

搭建了基础项目之后，我们还需要创建 dubbo-spring-boot-demo-interface 、dubbo-spring-boot-demo-provider 和 dubbo-spring-boot-demo-consumer 三个子模块。

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

创建了三个子模块之后，需要创建一下几个文件夹：

  • 在 dubbo-spring-boot-demo-consumer/src/main/java 下创建
    org.apache.dubbo.springboot.demo.consumer package

  • 在 dubbo-spring-boot-demo-interface/src/main/java 下创建
    org.apache.dubbo.springboot.demo package

  • 在 dubbo-spring-boot-demo-provider/src/main/java 下创建
    org.apache.dubbo.springboot.demo.provider package

在这里插入图片描述

3. 添加 Maven 依赖

在初始化完项目以后，我们需要先添加 Dubbo 相关的 maven 依赖。

对于多模块项目，首先需要在父项目的 pom.xml 里面配置依赖信息。
在这里插入图片描述

编辑 ./pom.xml 这个文件，添加下列配置。

 <properties>
        <dubbo.version>3.2.0-beta.4</dubbo.version>
        <spring-boot.version>2.7.8</spring-boot.version>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencyManagement>
        <dependencies>
            <!-- Spring Boot -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>

            <!-- Dubbo -->
            <dependency>
                <groupId>org.apache.dubbo</groupId>
                <artifactId>dubbo-bom</artifactId>
                <version>${dubbo.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>

            <dependency>
                <groupId>org.apache.dubbo</groupId>
                <artifactId>dubbo-dependencies-zookeeper-curator5</artifactId>
                <version>${dubbo.version}</version>
                <type>pom</type>
            </dependency>
        </dependencies>
    </dependencyManagement>


    <build>
        <pluginManagement>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                    <version>${spring-boot.version}</version>
                </plugin>
            </plugins>
        </pluginManagement>
    </build>

然后在 dubbo-spring-boot-consumer 和 dubbo-spring-boot-provider 两个模块 pom.xml 中进行具体依赖的配置。

在这里插入图片描述
编辑 ./dubbo-spring-boot-consumer/pom.xml 和 ./dubbo-spring-boot-provider/pom.xml 这两文件，都添加下列配置。

 <dependencies>
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo-samples-spring-boot-interface</artifactId>
            <version>${project.parent.version}</version>
        </dependency>

        <!-- dubbo -->
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo-spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo-dependencies-zookeeper-curator5</artifactId>
            <type>pom</type>
            <exclusions>
                <exclusion>
                    <artifactId>slf4j-reload4j</artifactId>
                    <groupId>org.slf4j</groupId>
                </exclusion>
            </exclusions>
        </dependency>

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

    </dependencies>

在这份配置中，定义了 dubbo 和 zookeeper（以及对应的连接器 curator）的依赖。

添加了上述的配置以后，可以通过 IDEA 的 Maven - Reload All Maven Projects 刷新依赖。

4. 定义服务接口

服务接口 Dubbo 中沟通消费端和服务端的桥梁。
在这里插入图片描述
在 dubbo-spring-boot-demo-interface 模块的 org.apache.dubbo.samples.api 下建立 DemoService 接口，定义如下：

package org.apache.dubbo.springboot.demo;

public interface DemoService {

    String sayHello(String name);
}

在 DemoService 中，定义了 sayHello 这个方法。后续服务端发布的服务，消费端订阅的服务都是围绕着 DemoService 接口展开的。

5. 定义服务端的实现

定义了服务接口之后，可以在服务端这一侧定义对应的实现，这部分的实现相对于消费端来说是远端的实现，本地没有相关的信息。

在这里插入图片描述
在dubbo-spring-boot-demo-provider 模块的 org.apache.dubbo.samples.provider 下建立 DemoServiceImpl 类，定义如下：

package org.apache.dubbo.springboot.demo.provider;

import org.apache.dubbo.config.annotation.DubboService;
import org.apache.dubbo.springboot.demo.DemoService;

@DubboService
public class DemoServiceImpl implements DemoService {

    @Override
    public String sayHello(String name) {
        return "Hello " + name;
    }
}

在 DemoServiceImpl 中，实现了 DemoService 接口，对于 sayHello 方法返回 Hello name。

注：在DemoServiceImpl 类中添加了 @DubboService 注解，通过这个配置可以基于 Spring Boot 去发布 Dubbo 服务。

6. 配置服务端 Yaml 配置文件

从本步骤开始至第 7 步，将会通过 Spring Boot 的方式配置 Dubbo 的一些基础信息。

首先，我们先创建服务端的配置文件。

在这里插入图片描述

在 dubbo-spring-boot-demo-provider 模块的 resources 资源文件夹下建立 application.yml 文件，定义如下：

dubbo:
  application:
    name: dubbo-springboot-demo-provider
  protocol:
    name: dubbo
    port: -1
  registry:
    address: zookeeper://${zookeeper.address:127.0.0.1}:2181

在这个配置文件中，定义了 Dubbo 的应用名、Dubbo 协议信息、Dubbo 使用的注册中心地址。

7. 配置消费端 Yaml 配置文件

同样的，我们需要创建消费端的配置文件。

在这里插入图片描述
在 dubbo-spring-boot-demo-consumer 模块的 resources 资源文件夹下建立 application.yml 文件，定义如下：

dubbo:
  application:
    name: dubbo-springboot-demo-consumer
  protocol:
    name: dubbo
    port: -1
  registry:
    address: zookeeper://${zookeeper.address:127.0.0.1}:2181

在这个配置文件中，定义了 Dubbo 的应用名、Dubbo 协议信息、Dubbo 使用的注册中心地址。

8. 基于 Spring 配置服务端启动类

除了配置 Yaml 配置文件之外，我们还需要创建基于 Spring Boot 的启动类。

首先，我们先创建服务端的启动类。

在这里插入图片描述
在这个启动类中，配置了一个 ProviderApplication 去读取我们前面第 6 步中定义的 application.yml 配置文件并启动应用。

9. 基于 Spring 配置消费端启动类

同样的，我们需要创建消费端的启动类。

在这里插入图片描述
在 dubbo-spring-boot-demo-consumer 模块的 org.apache.dubbo.springboot.demo.consumer 下建立 Application 类，定义如下：

package org.apache.dubbo.springboot.demo.consumer;

import org.apache.dubbo.config.spring.context.annotation.EnableDubbo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@EnableDubbo
public class ConsumerApplication {

    public static void main(String[] args) {
        SpringApplication.run(ConsumerApplication.class, args);
    }
}

在这个启动类中，配置了一个 ConsumerApplication 去读取我们前面第 7 步中定义的 application.yml 配置文件并启动应用。

10. 配置消费端请求任务

除了配置消费端的启动类，我们在 Spring Boot 模式下还可以基于 CommandLineRunner去创建
在这里插入图片描述
在 dubbo-spring-boot-demo-consumer 模块的 org.apache.dubbo.springboot.demo.consumer 下建立 Task 类，定义如下：

package org.apache.dubbo.springboot.demo.consumer;

import java.util.Date;

import org.apache.dubbo.config.annotation.DubboReference;
import org.apache.dubbo.springboot.demo.DemoService;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

@Component
public class Task implements CommandLineRunner {
    @DubboReference
    private DemoService demoService;

    @Override
    public void run(String... args) throws Exception {
        String result = demoService.sayHello("world");
        System.out.println("Receive result ======> " + result);

        new Thread(()-> {
            while (true) {
                try {
                    Thread.sleep(1000);
                    System.out.println(new Date() + " Receive result ======> " + demoService.sayHello("world"));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    Thread.currentThread().interrupt();
                }
            }
        }).start();
    }
}

在 Task 类中，通过@DubboReference 从 Dubbo 获取了一个 RPC 订阅，这个 demoService 可以像本地调用一样直接调用。在 run方法中创建了一个线程进行调用。

11. 启动应用

截止第 10 步，代码就已经开发完成了，本小节将启动整个项目并进行验证。

在这里插入图片描述

首先是启动 org.apache.dubbo.samples.provider.Application ，等待一会出现如下图所示的日志（Current Spring Boot Application is await）即代表服务提供者启动完毕，标志着该服务提供者可以对外提供服务了。

[Dubbo] Current Spring Boot Application is await...

然后是启动org.apache.dubbo.samples.client.Application ，等待一会出现如下图所示的日志（Hello world ）即代表服务消费端启动完毕并调用到服务端成功获取结果。
在这里插入图片描述

Receive result ======> Hello world

结束

到此，Dubbo快速入门 —— 基于 Spring Boot Starter 开发微服务应用 就已经结束了，下面来看看 Dubbo相关的学习内容。

=分隔符=

关于Dubbo的一些重要知识点

dubbo配置

1、配置原则

在这里插入图片描述

  • JVM 启动 -D 参数优先，这样可以使用户在部署和启动时进行参数重写，比如在启动时需改变协议的端口。 XML 次之，如果在 XML
  • 中有配置，则 dubbo.properties 中的相应配置项无效。 Properties 最后，相当于缺省值，只有 XML
  • 没有配置时，dubbo.properties 的相应配置项才会生效，通常用于共享公共配置，比如应用名。

2、重试次数

失败自动切换，当出现失败，重试其它服务器，但重试会带来更长延迟。可通过 retries=“2” 来设置重试次数(不含第一次)。

重试次数配置如下：

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

3、超时时间

由于网络或服务端不可靠，会导致调用出现一种不确定的中间状态（超时）。为了避免超时导致客户端资源（线程）挂起耗尽，必须设置超时时间。

1、Dubbo消费端

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

指定接口以及特定方法超时配置
<dubbo:reference interface="com.foo.BarService" timeout="2000">
    <dubbo:method name="sayHello" timeout="3000" />
</dubbo:reference>

2、Dubbo服务端

全局超时配置
<dubbo:provider timeout="5000" />

指定接口以及特定方法超时配置
<dubbo:provider interface="com.foo.BarService" timeout="2000">
    <dubbo:method name="sayHello" timeout="3000" />
</dubbo:provider>

3、配置原则

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

  1. 作服务的提供者，比服务使用方更清楚服务性能参数，如调用的超时时间，合理的重试次数，等等
  2. 在Provider配置后，Consumer不配置则会使用Provider的配置值，即Provider配置可以作为Consumer的缺省值。否则，Consumer会使用Consumer端的全局设置，这对于Provider不可控的，并且往往是不合理的

配置的覆盖规则：

  1. 方法级配置别优于接口级别，即小Scope优先
  2. Consumer端配置 优于 Provider配置 优于 全局配置，
  3. 最后是Dubbo Hard Code的配置值（见配置文档）
    在这里插入图片描述
    4、版本号
    当一个接口实现，出现不兼容升级时，可以用版本号过渡，版本号不同的服务相互间不引用。
    可以按照以下的步骤进行版本迁移：
  • 在低压力时间段，先升级一半提供者为新版本
  • 再将所有消费者升级为新版本
  • 然后将剩下的一半提供者升级为新版本
老版本服务提供者配置：
<dubbo:service interface="com.foo.BarService" version="1.0.0" />

新版本服务提供者配置：
<dubbo:service interface="com.foo.BarService" version="2.0.0" />

老版本服务消费者配置：
<dubbo:reference id="barService" interface="com.foo.BarService" version="1.0.0" />

新版本服务消费者配置：
<dubbo:reference id="barService" interface="com.foo.BarService" version="2.0.0" />

如果不需要区分版本，可以按照以下的方式配置：
<dubbo:reference id="barService" interface="com.foo.BarService" version="*" />

高可用

1、zookeeper宕机与dubbo直连

现象：zookeeper注册中心宕机，还可以消费dubbo暴露的服务。

原因：健壮性

  • 监控中心宕掉不影响使用，只是丢失部分采样数据
  • 数据库宕掉后，注册中心仍能通过缓存提供服务列表查询，但不能注册新服务
  • 注册中心对等集群，任意一台宕掉后，将自动切换到另一台
  • 注册中心全部宕掉后，服务提供者和服务消费者仍能通过本地缓存通讯
  • 服务提供者无状态，任意一台宕掉后，不影响使用
  • 服务提供者全部宕掉后，服务消费者应用将无法使用，并无限次重连等待服务提供者恢

高可用：通过设计，减少系统不能提供服务的时间；

2、集群下dubbo负载均衡配置

在集群负载均衡时，Dubbo 提供了多种均衡策略，缺省为 random 随机调用。
负载均衡策略

Random LoadBalance
随机，按权重设置随机概率。
在一个截面上碰撞的概率高，但调用量越大分布越均匀，而且按概率使用权重后也比较均匀，有利于动态调整提供者权重。

RoundRobin LoadBalance
轮循，按公约后的权重设置轮循比率。
存在慢的提供者累积请求的问题，比如：第二台机器很慢，但没挂，当请求调到第二台时就卡在那，久而久之，所有请求都卡在调到第二台上。

LeastActive LoadBalance
最少活跃调用数，相同活跃数的随机，活跃数指调用前后计数差。
使慢的提供者收到更少请求，因为越慢的提供者的调用前后计数差会越大。

ConsistentHash LoadBalance
一致性 Hash，相同参数的请求总是发到同一提供者。
当某一台提供者挂时，原本发往该提供者的请求，基于虚拟节点，平摊到其它提供者，不会引起剧烈变动。算法参见：http://en.wikipedia.org/wiki/Consistent_hashing
缺省只对第一个参数 Hash，如果要修改，请配置 <dubbo:parameter key="hash.arguments" value="0,1" />
缺省用 160 份虚拟节点，如果要修改，请配置 <dubbo:parameter key="hash.nodes" value="320" />

整合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 重试。

集群容错模式

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
广播调用所有提供者，逐个调用，任意一台报错则报错 [2]。
通常用于通知所有提供者更新缓存或日志等本地资源信息。

集群模式配置

按照以下示例在服务提供方和消费方配置集群模式

<dubbo:service cluster="failsafe" />
或
<dubbo:reference cluster="failsafe" />

3、整合hystrix

Hystrix 旨在通过控制那些访问远程系统、服务和第三方库的节点，从而对延迟和故障提供更强大的容错能力。Hystrix具备拥有回退机制和断路器功能的线程和信号隔离，请求缓存和请求打包，以及监控和配置等功能

1、配置spring-cloud-starter-netflix-hystrix

spring boot官方提供了对hystrix的集成，直接在pom.xml里加入依赖：

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

然后在Application类上增加@EnableHystrix来启用hystrix starter：

@SpringBootApplication
@EnableHystrix
public class ProviderApplication {

2、配置Provider端

在Dubbo的Provider上增加@HystrixCommand配置，这样子调用就会经过Hystrix代理。

@Service(version = "1.0.0")
public class HelloServiceImpl implements HelloService {
    @HystrixCommand(commandProperties = {
     @HystrixProperty(name = "circuitBreaker.requestVolumeThreshold", value = "10"),
     @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "2000") })
    @Override
    public String sayHello(String name) {
        // System.out.println("async provider received: " + name);
        // return "annotation: hello, " + name;
        throw new RuntimeException("Exception to show hystrix enabled.");
    }
}

3、配置Consumer端

对于Consumer端，则可以增加一层method调用，并在method上配置@HystrixCommand。当调用出错时，会走到fallbackMethod = "reliable"的调用里。

@Reference(version = "1.0.0")
    private HelloService demoService;

    @HystrixCommand(fallbackMethod = "reliable")
    public String doSayHello(String name) {
        return demoService.sayHello(name);
    }
    public String reliable(String name) {
        return "hystrix fallback value";
    }

dubbo原理

1、RPC原理

在这里插入图片描述
一次完整的RPC调用流程（同步调用，异步另说）如下：
1）服务消费方（client）调用以本地调用方式调用服务；
2）client stub接收到调用后负责将方法、参数等组装成能够进行网络传输的消息体；
3）client stub找到服务地址，并将消息发送到服务端；
4）server stub收到消息后进行解码；
5）server stub根据解码结果调用本地的服务；
6）本地服务执行并将结果返回给server stub；
7）server stub将返回结果打包成消息并发送至消费方；
8）client stub接收到消息，并进行解码；
9）服务消费方得到最终结果。

RPC框架的目标就是要2~8这些步骤都封装起来，这些细节对用户来说是透明的，不可见的。

2、netty通信原理

Netty是一个异步事件驱动的网络应用程序框架， 用于快速开发可维护的高性能协议服务器和客户端。它极大地简化并简化了TCP和UDP套接字服务器等网络编程。
BIO：(Blocking IO)
在这里插入图片描述
NIO (Non-Blocking IO)
在这里插入图片描述
Selector 一般称 为选择器 ，也可以翻译为 多路复用器，
Connect（连接就绪）、Accept（接受就绪）、Read（读就绪）、Write（写就绪）
Netty基本原理：
在这里插入图片描述

3、dubbo原理

1、dubbo原理 -框架设计

在这里插入图片描述

  • config 配置层：对外配置接口，以 ServiceConfig, ReferenceConfig 为中心，可以直接初始化配置类，也可以通过 spring 解析配置生成配置类
  • proxy 服务代理层：服务接口透明代理，生成服务的客户端 Stub 和服务器端 Skeleton, 以 ServiceProxy 为中心，扩展接口为 ProxyFactory
  • registry 注册中心层：封装服务地址的注册与发现，以服务 URL 为中心，扩展接口为 RegistryFactory, Registry, RegistryService
  • cluster 路由层：封装多个提供者的路由及负载均衡，并桥接注册中心，以 Invoker 为中心，扩展接口为 Cluster, Directory, Router, LoadBalance
  • monitor 监控层：RPC 调用次数和调用时间监控，以 Statistics 为中心，扩展接口为 MonitorFactory, Monitor, MonitorService
  • protocol 远程调用层：封装 RPC 调用，以 Invocation, Result 为中心，扩展接口为 Protocol, Invoker, Exporter
  • exchange 信息交换层：封装请求响应模式，同步转异步，以 Request, Response 为中心，扩展接口为 Exchanger, ExchangeChannel, ExchangeClient, ExchangeServer
  • transport 网络传输层：抽象 mina 和 netty 为统一接口，以 Message 为中心，扩展接口为 Channel, Transporter, Client, Server, Codec
  • serialize 数据序列化层：可复用的一些工具，扩展接口为 Serialization, ObjectInput, ObjectOutput, ThreadPool

2、dubbo原理 -启动解析、加载配置信息

在这里插入图片描述

3、dubbo原理 -服务暴露

在这里插入图片描述

4、dubbo原理 -服务引用

在这里插入图片描述

5、dubbo原理 -服务调用

在这里插入图片描述

结束

在这里插入图片描述

🐳结语

🐬初学一门技术时，总有些许的疑惑，别怕，它们是我们学习路上的点点繁星，帮助我们不断成长。

🐟文章粗浅，希望对大家有帮助！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/619992.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

7脚手架与jwt

7脚手架与jwt

1.引言 企业开发中的前端工程一般不会让程序员自己从零搭建&#xff0c;所以咱们要学会使用别人封装好的架子&#xff0c;或者低代码开发平台&#xff0c;这里 咱们快速上手一个第三方的脚手架。 参考资料 花裤衩 (panjiachen) - Gitee.com 2.安装步骤 # 克隆项目 git clon…
阅读更多...
【HashMap】为什么用自定义的类做HashMap的Key时需要重写hashcode方法和equals方法

【HashMap】为什么用自定义的类做HashMap的Key时需要重写hashcode方法和equals方法

【HashMap】为什么用自定义的类做HashMap的Key时需要重写hashcode方法和equals方法 【一】为什么有这个问题【二】Object类的中的hashcode方法和equals方法【三】重写hashcode【四】重写equals方法【五】hashmap中使用hashcode和equals方法 【一】为什么有这个问题 因为HashMa…
阅读更多...
致我们那年青春热血的高考

致我们那年青春热血的高考

#2023高考季# 本来试着去网上查一下当年的高考成绩&#xff0c;无奈查询密码实在想不起来&#xff0c;只能作罢。 2009年&#xff0c;我参加了高考。在这场考试中&#xff0c;我经历了各种复杂的情绪&#xff0c;紧张、焦虑、兴奋和期待&#xff0c;犹如坐过山车一样刺激。 我每…
阅读更多...
实验篇(7.2) 05. 通过浏览器访问远端内网服务器 (FortiClient-SSL) ❀ 远程访问

实验篇(7.2) 05. 通过浏览器访问远端内网服务器 (FortiClient-SSL) ❀ 远程访问

【简介】直接将内网服务器映射成公网IP&#xff0c;可以方便的从任何地方访问服务器的指定端口&#xff0c;但是这种方式下&#xff0c;服务器是公开且暴露的。那有没有即方便、又比较安全的远程访问服务器的方法呢&#xff1f;我们来看看SSL VPN的Web模式。 SSL VPN介绍 从概念…
阅读更多...
Linux 高级IO

Linux 高级IO

目录 传统艺能&#x1f60e;概念&#x1f60d;高级IO&#x1f602;五种 IO 模型&#x1f44c;阻塞 IO&#x1f64c;非阻塞 IO&#x1f60d;信号驱动IO&#x1f60a;多路转接IO&#x1f602; 异步IO&#x1f618;同步通信 VS 异步通信&#x1f601;同步通信 VS 同步与互斥&#…
阅读更多...
Java006——对第一个Java程序HelloWorld的简单认识

Java006——对第一个Java程序HelloWorld的简单认识

一、HelloWorld.java程序整体认识 public class HelloWorld { //创建一个名字叫HelloWorld的类&#xff08;Java中的类叫class&#xff09;public static void main(String[] args) {//主程序入口&#xff0c;类似C语言main函数System.out.println("He…
阅读更多...
黑客第一步：从认识这些DOS命令开始

黑客第一步：从认识这些DOS命令开始

文章目录 一、DOS是个啥&#xff1f;二、如何启动DOS命令行&#xff1f;1. 同时按下键盘winR键&#xff0c;打开运行框2. 在运行框输入命令cmd&#xff0c;然后点击确定&#xff0c;即可进入DOS命令行 三、常用的DOS命令 一、DOS是个啥&#xff1f; DOS&#xff08;Disk Opera…
阅读更多...
《精通特征工程》学习笔记（5）：数据(特征)降维

《精通特征工程》学习笔记（5）：数据(特征)降维

1.数据降维 通过自动数据收集和特征生成技术&#xff0c;可以快速获取大量特征&#xff0c;但不是所有特征都是有用的。数据降维就是在保留重要信息的同时消除那些“无信息量的信息”。 “无信息量”有多种定义方法&#xff0c;PCA 关注的是线性相关性&#xff0c;假设我们将…
阅读更多...
正态（高斯）分布什么时候等于杨辉三角（二项式）展开

正态（高斯）分布什么时候等于杨辉三角（二项式）展开

&#xff08;ab&#xff09;^10的杨辉三角展开项系数是1&#xff0c;10&#xff0c;45&#xff0c;120&#xff0c;200&#xff0c;252&#xff0c;200&#xff0c;120&#xff0c;45&#xff0c;10&#xff0c;1 这些系数11项的和等于1004&#xff0c;每项除以1004&#xff0c…
阅读更多...
数据结构与算法之美 | 递归(Recursion)

数据结构与算法之美 | 递归(Recursion)

什么叫做递归&#xff1f; 递归&#xff1a;去的过程叫“递”&#xff0c;回来的过程叫“归” 递归的三个条件 条件一&#xff1a;一个问题的解可以分解为几个子问题的解 条件二&#xff1a;这个问题与分解之后的子问题&#xff0c;除了数据规模不同&#xff0c;求解思路完全…
阅读更多...
CnOpenData全国养老机构数据

CnOpenData全国养老机构数据

一、数据简介 养老机构指为老年人提供集中居住和照料服务的机构&#xff0c;县级以上地方人民政府民政部门负责本行政区域内养老机构的指导、监督和管理。其他有关部门依照职责分工对养老机构实施监督。 与其他服务不同的是&#xff0c;养老服务是一种全人、全员、全程服务,养老…
阅读更多...
路径之谜 2016年国赛 深度优先搜索

路径之谜 2016年国赛 深度优先搜索

目录 解题思路 AC代码&#xff1a; 题目描述 小明冒充 XX 星球的骑士&#xff0c;进入了一个奇怪的城堡。 城堡里边什么都没有&#xff0c;只有方形石头铺成的地面。 假设城堡地面是 nn 个方格。如下图所示。 按习俗&#xff0c;骑士要从西北角走到东南角。可以横向或纵向…
阅读更多...
智能 CAN 总线/串口 RS-232485 协议转换器

智能 CAN 总线/串口 RS-232485 协议转换器

能CAN/串口协议转换器LCNET Pro RS-232/485提供一路RS-485、一路RS-232和一路CAN通道&#xff0c;实现CAN与串口RS-485或RS-232之间的双向数据智能转换。每个通道独立隔离&#xff0c;每路通道采用金升阳电源模块和信号隔离芯片实现2500VDC电气隔离&#xff0c;电源输入防反设计…
阅读更多...
NAT模式 LVS负载均衡群集部署

NAT模式 LVS负载均衡群集部署

NAT模式 LVS负载均衡群集部署 一.部署共享存储&#xff08;NFS服务器&#xff1a;192.168.80.102&#xff09;1.关闭防火墙&#xff0c;查看是否有rpcbind和nfs-utils的包2.创建两个共享文件目录3.将共享路径及网段添加到/etc/exports中&#xff08;设置为只可读&#xff09;4.…
阅读更多...
VulnHub项目：MONEYHEIST: CATCH US IF YOU CAN

VulnHub项目：MONEYHEIST: CATCH US IF YOU CAN

靶机名称&#xff1a; MONEYHEIST: CATCH US IF YOU CAN 地址&#xff1a;MoneyHeist: Catch Us If You Can ~ VulnHub 这个系列是一部剧改编&#xff0c;还是挺好看的&#xff0c;大家有兴趣可以去看看&#xff01; 废话不多说&#xff0c;直接上图开始&#xff01; 渗透…
阅读更多...
(单调栈) 496. 下一个更大元素 I——【Leetcode每日一题】

(单调栈) 496. 下一个更大元素 I——【Leetcode每日一题】

❓496. 下一个更大元素 I 难度&#xff1a;简单 nums1 中数字 x 的 下一个更大元素 是指 x 在 nums2 中对应位置 右侧 的 第一个 比 x 大的元素。 给你两个 没有重复元素 的数组 nums1 和 nums2 &#xff0c;下标从 0 开始计数&#xff0c;其中 nums1 是 nums2 的子集。 对…
阅读更多...
直播美颜技术：视频美颜sdk的快速集成与开发实践

直播美颜技术：视频美颜sdk的快速集成与开发实践

视频美颜sdk则是直播美颜技术的重要组成部分&#xff0c;它可以帮助开发者快速集成美颜功能&#xff0c;实现直播美颜。目前已经被广大平台、主播、平台用户所应用&#xff0c;在近几年甚至成了一个极其热门的讨论话题&#xff0c;毕竟它与人们的日常拍摄生活息息相关。 一、视…
阅读更多...
重磅：百亿人工心脏赛道再添新玩家，行业未来趋势明显

重磅：百亿人工心脏赛道再添新玩家，行业未来趋势明显

市场火热&#xff0c;资本加持 昨日&#xff0c;深圳核心医疗科技股份有限公司自主研发的Corheart 6植入式左心室辅助系统获得国家药品监督管理局批准上市。这是一枚完全国产&#xff0c;拥有完备自主知识产权的人工心脏。该产品正式获批上市&#xff0c;加之之前获批的永仁心…
阅读更多...
C++ 参数的三种传递方式和应用参加

C++ 参数的三种传递方式和应用参加

C 参数的三种传递方式分别是值传递、指针传递和引用传递。 值传递 值传递的实质 将实参的值&#xff08;a、b&#xff09;复制到形参(m、n)相应的存储单元中&#xff0c;即形参和实参分别占用不同的存储单元。 值传递的特点 值传递的特点是单向传递&#xff0c;即主调函数…
阅读更多...
「C/C++」C/C++ 回调函数

「C/C++」C/C++ 回调函数

✨博客主页&#xff1a;何曾参静谧的博客 &#x1f4cc;文章专栏&#xff1a;「C/C」C/C程序设计 相关术语 回调函数&#xff1a;是一种常用的编程技术&#xff0c;它可以将一个函数作为参数传递给另一个函数&#xff0c;并在后者执行过程中调用前者。回调函数通常用来处理异步…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023