Dubbo快速入门 —— 基于SpringBoot Starter 开发微服务应用案例 + 知识讲解_百度小程序_上海毫米网络优化公司

您的位置：上海毫米网络优化公司 > 小程序 > 百度小程序 >

相关推荐recommended

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

作者：mmseoamin日期：2023-12-25

Dubbo快速入门 —— 基于SpringBoot Starter 开发微服务应用案例 + 知识讲解,在这里插入图片描述,第1张

💧 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学习笔记》专栏的文章是本人在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 这个文件，添加下列配置。
        
        3.2.0-beta.4 2.7.8 17 17 UTF-8 org.springframework.boot spring-boot-dependencies ${spring-boot.version} pom import org.apache.dubbo dubbo-bom ${dubbo.version} pom import org.apache.dubbo dubbo-dependencies-zookeeper-curator5 ${dubbo.version} pom org.springframework.boot spring-boot-maven-plugin ${spring-boot.version}
        
        然后在 dubbo-spring-boot-consumer 和 dubbo-spring-boot-provider 两个模块 pom.xml 中进行具体依赖的配置。
        
        编辑 ./dubbo-spring-boot-consumer/pom.xml 和 ./dubbo-spring-boot-provider/pom.xml 这两文件，都添加下列配置。
        
        org.apache.dubbo dubbo-samples-spring-boot-interface ${project.parent.version} org.apache.dubbo dubbo-spring-boot-starter org.apache.dubbo dubbo-dependencies-zookeeper-curator5 pom slf4j-reload4j org.slf4j org.springframework.boot spring-boot-starter
        
        在这份配置中，定义了 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” 来设置重试次数(不含第一次)。
        
        重试次数配置如下：
        
        或或
        
        3、超时时间
        
        由于网络或服务端不可靠，会导致调用出现一种不确定的中间状态（超时）。为了避免超时导致客户端资源（线程）挂起耗尽，必须设置超时时间。
        
        1、Dubbo消费端
        
        全局超时配置指定接口以及特定方法超时配置
        
        2、Dubbo服务端
        
        全局超时配置指定接口以及特定方法超时配置
        
        3、配置原则
        
        dubbo推荐在Provider上尽量多配置Consumer端属性：
        
        作服务的提供者，比服务使用方更清楚服务性能参数，如调用的超时时间，合理的重试次数，等等
        在Provider配置后，Consumer不配置则会使用Provider的配置值，即Provider配置可以作为Consumer的缺省值。否则，Consumer会使用Consumer端的全局设置，这对于Provider不可控的，并且往往是不合理的
        
        配置的覆盖规则：
        
        方法级配置别优于接口级别，即小Scope优先
        Consumer端配置优于 Provider配置优于全局配置，
        最后是Dubbo Hard Code的配置值（见配置文档）
        4、版本号
        当一个接口实现，出现不兼容升级时，可以用版本号过渡，版本号不同的服务相互间不引用。
        可以按照以下的步骤进行版本迁移：
        
        在低压力时间段，先升级一半提供者为新版本
        再将所有消费者升级为新版本
        然后将剩下的一半提供者升级为新版本
        老版本服务提供者配置：新版本服务提供者配置：老版本服务消费者配置：新版本服务消费者配置：如果不需要区分版本，可以按照以下的方式配置：
        
        高可用
        
        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，如果要修改，请配置缺省用 160 份虚拟节点，如果要修改，请配置
        
        整合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" 来设置重试次数(不含第一次)。重试次数配置如下：或或
        
        Failfast Cluster 快速失败，只发起一次调用，失败立即报错。通常用于非幂等性的写操作，比如新增记录。
        
        Failsafe Cluster 失败安全，出现异常时，直接忽略。通常用于写入审计日志等操作。
        
        Failback Cluster 失败自动恢复，后台记录失败请求，定时重发。通常用于消息通知操作。
        
        Forking Cluster 并行调用多个服务器，只要一个成功即返回。通常用于实时性要求较高的读操作，但需要浪费更多服务资源。可通过 forks="2" 来设置最大并行数。
        
        Broadcast Cluster 广播调用所有提供者，逐个调用，任意一台报错则报错 [2]。通常用于通知所有提供者更新缓存或日志等本地资源信息。
        
        集群模式配置
        
        按照以下示例在服务提供方和消费方配置集群模式
        
        或
        
        3、整合hystrix
        
        Hystrix 旨在通过控制那些访问远程系统、服务和第三方库的节点，从而对延迟和故障提供更强大的容错能力。Hystrix具备拥有回退机制和断路器功能的线程和信号隔离，请求缓存和请求打包，以及监控和配置等功能
        
        1、配置spring-cloud-starter-netflix-hystrix
        
        spring boot官方提供了对hystrix的集成，直接在pom.xml里加入依赖：
        
        org.springframework.cloud spring-cloud-starter-netflix-hystrix 1.4.4.RELEASE
        
        然后在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原理 -服务调用
        
        结束
        
        🐳结语
        
        🐬初学一门技术时，总有些许的疑惑，别怕，它们是我们学习路上的点点繁星，帮助我们不断成长。
        
        🐟文章粗浅，希望对大家有帮助！
        
        内网网站搭建   中国互联网公司排名   南宁正规公众号网站建设推广   b2b平台都有哪些网站   推广自己的网站   网站搭建软件

上一篇：python csv读取方法及常用的csv读取代码

下一篇：Cannot load JDBC driver class ‘com.mysql.jdbc.Driver’