学习笔记 - dubbo

一. 基础知识

分布式基础理论

什么是分布式系统

分布式系统原理与范型定义: 分布式系统是若干独立计算机的集合, 这些计算机对于用户来说就像是单个相关系统

分布式系统(Distributed System)是建立在网络之上的软件系统

随着互联网的发展, 网站应用的规模不断扩大, 常规的额垂直应用架构已无法应对, 分布式服务架构以及流动计算架构是在必行, 亟需一个治理系统确保架构有条不紊的演进

发展演变

单一应用架构

当网站流量很小时, 只需一个应用, 将所有功能都部署在一起, 以减少部署节点和成本.

此时, 用于简化增删改查工作量的数据访问框架(ORM)是关键

适用于小型网站, 小型管理系统, 将所有功能都部署到一个功能里, 简单易用

缺点:

1. 性能扩展比较难
2. 协同开发问题
3. 不利于升级维护

垂直应用架构

当访问量逐渐增大，单一应用增加机器带来的加速度越来越小，将应用拆成互不相干的几个应用，以提升效率。此时，用于加速前端页面开发的Web框架(MVC)是关键

通过切分业务来实现各个模块独立部署，降低了维护和部署的难度，团队各司其职更易管理，性能扩展也更方便，更有针对性。

缺点： 公用模块无法重复利用，开发性的浪费

分布式服务架构

当垂直应用越来越多，应用之间交互不可避免，将核心业务抽取出来，作为独立的服务，逐渐形成稳定的服务中心，使前端应用能更快速的响应多变的市场需求。此时，用于提高业务复用及整合的**分布式服务框架(RPC)**是关键

流动计算架构

当服务越来越多，容量的评估，小服务资源的浪费等问题逐渐显现，此时需增加一个调度中心基于访问压力实时管理集群容量，提高集群利用率。此时，用于提高机器利用率的资源调度和治理中心(SOA)[ Service Oriented Architecture]是关键

RPC

什么叫RPC

RPC: Remote Procedure Call 是指远程过程调用, 是一种进程间通信方式, 他是一种技术的思想, 而不是规范.

它允许程序调用另一个地址空间(通常是共享网络的另一台机器上)的过程或函数, 而不用程序员显示编码这个远程调用的细节

程序员无论是调用本地的还是远程的函数, 本质上编写的调用代码基本相同

RPC基本原理

RPC两个核心模块: 通讯和序列化

RPC框架有很多: Dubbo, gRPC, Thrift, HSF(High Speed Service Framework)

Dubbo核心概念

简介

Apache Dubbo是一款高性能, 轻量级的开源Java RPC框架, 他提供了三大核心能力:

• 面向 接口的远程方法调用
• 智能容错和负载均衡
• 服务自动注册和发现
  • 为了能够更好的感知服务, 我们需要引用注册中心, 将服务全都注册到注册中心中, 这样调用的时候, 就可以根据负载均衡的机制找到合适的机器进行服务调用

官网: http://dubbo.apache.org/

架构设计图:

1. Container是dubbo容器, dubbo启动的时候, 会初始化服务提供者

2. Provider是服务提供者, 当项目启动的时候, 服务提供者会先注册到注册中心

3. Consumer是服务消费者, 当项目启动的时候, 服务消费者会去注册中心订阅服务, 获取已经注册到注册中心的服务

4. registry是注册中心, 当有服务提供者新注册或者宕机导致服务提供者不能继续提供服务的时候, 注册中心会通知服务消费者, 这样服务消费者在调用的时候, 就不会调用那些不能够继续提供服务的接口

   • 注册中心返回服务提供者地址列表给消费者，如果有变更，注册中心将基于长连接推送变更数据给消费者。

5. 在正常使用的时候, 服务消费者会根据自己在注册中心得到的信息, 直接远程调用对应的服务

   • 服务消费者，从提供者地址列表中，基于软负载均衡算法，选一台提供者进行调用，如果调用失败，再选另一台调用

6. Monitor是监控中心, 每隔一段时间, 服务调用的时间, 调用的结果都会传进监控中心

   • 服务消费者和提供者，在内存中累计调用次数和调用时间，定时每分钟发送一次统计数据到监控中心

注册中心

Dubbo 服务发现扩展了多种注册中心组件支持，如 Nacos、Zookeeper、Consul、Redis、kubernetes 等，可以通过配置切换不同实现

Dubbo推荐使用zooKeeper注册中心

zooKeeper注册中心

Zookeeper 是 Apache Hadoop 的子项目，是一个树型的目录服务，支持变更推送，适合作为 Dubbo 服务的注册中心，工业强度较高，可用于生产环境，并推荐使用

流程说明：

• 服务提供者启动时: 向 /dubbo/com.foo.BarService/providers 目录下写入自己的 URL 地址
• 服务消费者启动时: 订阅 /dubbo/com.foo.BarService/providers 目录下的提供者 URL 地址。并向 /dubbo/com.foo.BarService/consumers 目录下写入自己的 URL 地址
• 监控中心启动时: 订阅 /dubbo/com.foo.BarService 目录下的所有提供者和消费者 URL 地址。

支持以下功能：

• 当提供者出现断电等异常停机时，注册中心能自动删除提供者信息
• 当注册中心重启时，能自动恢复注册数据，以及订阅请求
• 当会话过期时，能自动恢复注册数据，以及订阅请求
• 当设置 <dubbo:registry check="false" /> 时，记录失败注册和订阅请求，后台定时重试
• 可通过 <dubbo:registry username="admin" password="1234" /> 设置 zookeeper 登录信息
• 可通过 <dubbo:registry group="dubbo" /> 设置 zookeeper 的根节点，不配置将使用默认的根节点。
• 支持 * 号通配符 <dubbo:reference group="*" version="*" />，可订阅服务的所有分组和所有版本的提供者

zooKeeper配置文件解析

##Zookeeper 中最核心的时间单位，单位是 毫秒, 它用于决定心跳频率、超时计算等
tickTime=2000
##Leader 和 Follower 之间建立连接时，允许最多有多少个 tickTime 时间单位, 用来控制集群启动时，Follower 同步数据的最长等待时间
##10 * 2s = 最多允许 20 秒用于连接初始化
initLimit=10
##Leader 和 Follower 之间发送消息的同步时间限制，单位也是 tickTime, 用于限制 Leader 等待 Follower 响应的最大时长，超时就认为这个节点不可用了
##5 * 2s = 10 秒
syncLimit=5
##Zookeeper 的数据文件目录, 存储内存中的数据快照（snapshot）和事务日志（log）
dataDir=/tmp/zookeeper
##Zookeeper 客户端连接的端口号, 客户端（如 Kafka、Storm）通过这个端口连接 Zookeeper
clientPort=2181
##每个 Zookeeper 服务端允许的最大客户端连接数, 防止客户端过多导致资源耗尽
##默认值为60, 注释掉了就使用默认值
#maxClientCnxns=60

##最多保留 3 个快照文件（snapshot）和对应的事务日志文件, 防止 dataDir 目录空间无限膨胀。
#autopurge.snapRetainCount=3

##自动清理的周期，单位为小时, 1 表示每小时清理一次。0 表示不启用自动清理
#autopurge.purgeInterval=1

##配置 Zookeeper 启用 Prometheus 的指标采集（Metrics Exporter）
##使用 Prometheus 的指标导出器
#metricsProvider.className=org.apache.zookeeper.metrics.prometheus.PrometheusMetricsProvider
##绑定所有网卡
#metricsProvider.httpHost=0.0.0.0
##暴露指标的 HTTP 端口
#metricsProvider.httpPort=7000
##是否导出 JVM 信息（内存、GC、线程等）, 默认是关闭的，如需监控 Zookeeper 状态，可启用
#metricsProvider.exportJvmInfo=true

##在集群部署时，通常会加入如下配置
#server.1=192.168.1.101:2888:3888
#server.2=192.168.1.102:2888:3888
#server.3=192.168.1.103:2888:3888
#含义：配置 Zookeeper 集群的每个节点。
#2888：Follower 与 Leader 通信端口。
#3888：用于选举 Leader。
#若你配置了这类项，需要在每个节点的 dataDir 中添加 myid 文件，其内容为 1、2、3 对应上面的编号。

dubbo-admin

下载地址: https://github.com/apache/dubbo-admin

dubbo 2.5版本之前都是war包, 需要放到tomcat上运行, 2.6版本之后, 都是jar包, 打包直接运行就可以(dubbo-admin启动依赖zooKeeper, 因此启动的时候, 需要确定zooKeeper是否启动)

但是在运行之前, 需要在application.properties中修改zooKeeper的地址(注册中心的地址)

默认端口为7001

用户名/密码: 默认为root/root

工程架构设计原则

1. 分包
   • 建议将服务接口，服务模型，服务异常等均放在 API 包中，因为服务模型及异常也是 API 的一部分，同时，这样做也符合分包原则：重用发布等价原则(REP)，共同重用原则(CRP)
   • 如果需要，也可以考虑在 API 包中放置一份 spring 的引用配置，这样使用方，只需在 spring 加载过程中引用此配置即可，配置建议放在模块的包目录下，以免冲突，如：com/alibaba/china/xxx/dubbo-reference.xml
2. 粒度
   • 服务接口尽可能大粒度，每个服务方法应代表一个功能，而不是某功能的一个步骤，否则将面临分布式事务问题，Dubbo 暂未提供分布式事务支持
   • 服务接口建议以业务场景为单位划分，并对相近业务做抽象，防止接口数量爆炸
   • 不建议使用过于抽象的通用接口，如：Map query(Map)，这样的接口没有明确语义，会给后期维护带来不便

dubbo-简单案例

1. 需求

   • 某个电商系统，订单服务需要调用用户服务获取某个用户的所有地址；

   • 我们现在 需要创建两个服务模块进行测试

     模块	功能
     订单服务web模块	创建订单等
     用户服务service模块	查询用户地址等

   • 测试预期结果：订单服务web模块在A服务器，用户服务模块在B服务器，A可以远程调用B的功能

2. 创建模块

   1. gmall-interface：公共接口层（model，service，exception…）

      // 定义公共接口，也可以导入公共依赖
      
      // 用户类
      public class UserAddress implements Serializable{
          private Integer id;
          private String userAddress;
          private String userId;
          private String consignee;
          private String phoneNum;
          private String isDefault;
      }
      
      // Service接口 - UserService
      public List<UserAddress> getUserAddressList(String userId)
      

   2. gmall-user: 用户模块(对用户接口的实现)

        <dependencies>
        	<dependency>
        		<groupId>com.atguigu.dubbo</groupId>
        		<artifactId>gmall-interface</artifactId>
        		<version>0.0.1-SNAPSHOT</version>
        	</dependency>
        </dependencies>
          
      public class UserServiceImpl implements UserService {
      		
      	@Override
      	public List<UserAddress> getUserAddressList(String userId) {
      		// TODO Auto-generated method stub
      		return userAddressDao.getUserAddressById(userId);
      	}
      
      }
      

   3. gmall-order-web：订单模块（调用用户模块）

      <dependencies>
        	<dependency>
        		<groupId>com.atguigu.dubbo</groupId>
        		<artifactId>gmall-interface</artifactId>
        		<version>0.0.1-SNAPSHOT</version>
        	</dependency>
      </dependencies>
        
      public class OrderService {
      	
      	UserService userService;
      	
      	/**
      	 * 初始化订单，查询用户的所有地址并返回
      	 * @param userId
      	 * @return
      	 */
      	public List<UserAddress> initOrder(String userId){
      		return userService.getUserAddressList(userId);
      	}
      
      }
      

      现在这样是无法进行调用的。我们gmall-order-web引入了gmall-interface，但是interface的实现是gmall-user，我们并没有引入，而且实际他可能还在别的服务器中

   4. 使用dubbo改造

      1. 改造gmall-user作为服务提供者

         1. 引入dubbo

            <!-- 引入dubbo -->
            		<dependency>
            			<groupId>com.alibaba</groupId>
            			<artifactId>dubbo</artifactId>
            			<version>2.6.2</version>
            		</dependency>
            	<!-- 	由于我们使用zookeeper作为注册中心，所以需要操作zookeeper
            				dubbo 2.6以前的版本引入zkclient操作zookeeper 
            				dubbo 2.6及以后的版本引入curator操作zookeeper
            				下面两个zk客户端根据dubbo版本2选1即可
            	-->
            		<dependency>
            			<groupId>com.101tec</groupId>
            			<artifactId>zkclient</artifactId>
            			<version>0.10</version>
            		</dependency>
            		<!-- curator-framework -->
            		<dependency>
            			<groupId>org.apache.curator</groupId>
            			<artifactId>curator-framework</artifactId>
            			<version>2.12.0</version>
            		</dependency>
            

         2. 配置提供者

            <!--当前应用的名字  -->
            <dubbo:application name="gmall-user"></dubbo:application>
            <!--指定注册中心的地址  -->
            <dubbo:registry address="zookeeper://118.24.44.169:2181" />
            <!--使用dubbo协议，将服务暴露在20880端口  -->
            <dubbo:protocol name="dubbo" port="20880" />
            <!-- 指定需要暴露的服务 -->
            <dubbo:service interface="com.atguigu.gmall.service.UserService" ref="userServiceImpl" />
            

         3. 启动服务

      2. 改造gmall-order-web作为服务消费者

         1. 引入dubbo

            <!-- 引入dubbo -->
            <dependency>
              <groupId>com.alibaba</groupId>
              <artifactId>dubbo</artifactId>
              <version>2.6.2</version>
            </dependency>
            <!-- 由于我们使用zookeeper作为注册中心，所以需要引入zkclient和curator操作zookeeper -->
            <dependency>
              <groupId>com.101tec</groupId>
              <artifactId>zkclient</artifactId>
              <version>0.10</version>
            </dependency>
            <!-- curator-framework -->
            <dependency>
              <groupId>org.apache.curator</groupId>
              <artifactId>curator-framework</artifactId>
              <version>2.12.0</version>
            </dependency>
            

         2. 配置消费者信息

            <!-- 应用名 -->
            <dubbo:application name="gmall-order-web"></dubbo:application>
            <!-- 指定注册中心地址 -->
            <dubbo:registry address="zookeeper://118.24.44.169:2181" />
            <!-- 生成远程服务代理，可以和本地bean一样使用demoService -->
            <dubbo:reference id="userService" interface="com.atguigu.gmall.service.UserService"></dubbo:reference>
            

      3. 测试调用

   5. 注解版

      1. 服务提供方

         <dubbo:application name="gmall-user"></dubbo:application>
             <dubbo:registry address="zookeeper://118.24.44.169:2181" />
             <dubbo:protocol name="dubbo" port="20880" />
         <dubbo:annotation package="com.atguigu.gmall.user.impl"/>
           
         import com.alibaba.dubbo.config.annotation.Service;
         import com.atguigu.gmall.bean.UserAddress;
         import com.atguigu.gmall.service.UserService;
         import com.atguigu.gmall.user.mapper.UserAddressMapper;
         
         @Service //使用dubbo提供的service注解，注册暴露服务
         public class UserServiceImpl implements UserService {
         
         	@Autowired
         	UserAddressMapper userAddressMapper;
         }
         

      2. 服务消费方

         <dubbo:application name="gmall-order-web"></dubbo:application>
         <dubbo:registry address="zookeeper://118.24.44.169:2181" />
         <dubbo:annotation package="com.atguigu.gmall.order.controller"/>
         
         @Controller
         public class OrderController {
         	
         	@Reference  //使用dubbo提供的reference注解引用远程服务
         	UserService userService;
         }
         

   6. 整合SpringBoot

      1. 引入spring-boot-starter以及dubbo和curator的依赖

         <dependency>
             <groupId>com.alibaba.boot</groupId>
             <artifactId>dubbo-spring-boot-starter</artifactId>
             <version>0.2.0</version>
         </dependency>
         

         注意starter版本适配:

         versions	Java	SpringBoot	Dubbo
         0.2.0	1.8+	2.0.x	2.6.2+
         0.1.1	1.7+	1.5.x	2.6.2+

      2. 配置application.properties

         提供者配置：
         dubbo.application.name=gmall-user
         dubbo.registry.protocol=zookeeper
         dubbo.registry.address=192.168.67.159:2181
         dubbo.scan.base-package=com.atguigu.gmall
         dubbo.protocol.name=dubbo
         application.name就是服务名，不能跟别的dubbo提供端重复
         registry.protocol 是指定注册中心协议
         registry.address 是注册中心的地址加端口号
         protocol.name 是分布式固定是dubbo,不要改。
         base-package  注解方式要扫描的包
         消费者配置：
         dubbo.application.name=gmall-order-web
         dubbo.registry.protocol=zookeeper
         dubbo.registry.address=192.168.67.159:2181
         dubbo.scan.base-package=com.atguigu.gmall
         dubbo.protocol.name=dubbo
         

      3. dubbo注解

         @Service、@Reference

         【如果没有在配置中写dubbo.scan.base-package,还需要使用@EnableDubbo注解】

二. Dubbo配置

配置生效顺序

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

重试次数

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

重试次数配置如下：
<dubbo:service retries="2" />
或
<dubbo:reference retries="2" />
或
<dubbo:reference>
    <dubbo:method name="findFoo" retries="2" />
</dubbo:reference>

超时时间

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

dubbo消费端

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

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

dubbo服务端

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

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

配置原则

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

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

配置覆盖的原则

1. 方法级配置优于接口级别, 即小范围的优先
2. Consumer端配置优于Provider端配置, 优于全局配置
3. 最后是Dubbo Hard Code的配置值

版本号

当一个接口实现，出现不兼容升级时，可以用版本号过渡，版本号不同的服务相互间不引用。

可以按照以下的步骤进行版本迁移：

1. 在低压力时间段，先升级一半提供者为新版本
2. 再将所有消费者升级为新版本
3. 然后将剩下的一半提供者升级为新版本

老版本服务提供者配置：
<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="*" />

三. 高可用

zookeeper宕机与dubbo直连

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

原因:

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

集群下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，服务熔断与降级处理

服务降级

服务降级: 当服务器压力剧增的情况下, 根据实际业务情况及流量, 对一些服务和页面有策略的不处理或换一种简单的方式处理, 从而释放服务器资源以保证核心交易正常运作或高效运作

可以通过服务降级功能, 临时屏蔽某个出错的非关键服务, 并定义降级后的返回策略

向注册中心写入动态配置覆盖规则：

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 值，不抛异常。用来容忍不重要服务不稳定时对调用方的影响。

集群容错

在集群调用失败时，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" />

整合hystrix

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

配置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 {
  
}

配置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.");
    }
}

配置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原理

RPC原理

一次完整的RPC调用流程(同步调用, 异步另说)如下:

1. 服务消费方(client)调用以本地调用方式调用服务
2. client stub接收到调用后负责将方法, 参数等组装成能够进行网络传输的消息体
3. client stub找到服务地址, 并将消息发送到服务端
4. server stub收到消息后进行解码
5. server stub根据解码结果调用本地的服务
6. 本地服务执行并将结果打包成消息并发送至消费方
7. server stub将返回结果打包成消息并发发送至消费方
8. client stub接收到消息, 并进行解码
9. 服务消费方得到最终结果

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

netty通信原理

Netty是一个异步事件驱动的网络应用程序框架， 用于快速开发可维护的高性能协议服务器和客户端。它极大地简化并简化了TCP和UDP套接字服务器等网络编程。

BIO：(Blocking IO)

NIO (Non-Blocking IO)

• Selector 一般称 为选择器 ，也可以翻译为 多路复用器，
• Connect（连接就绪）、Accept（接受就绪）、Read（读就绪）、Write（写就绪）

BIO与NIO的区别

特性	BIO（Blocking I/O）	NIO（Non-blocking I/O）
编程模型	同步阻塞	同步非阻塞
每个连接	一个线程处理	单线程可以处理多个连接
核心类	InputStream, OutputStream, Socket等	Channel, Selector, Buffer等
适合场景	连接数少、处理简单	连接数多、请求高并发
底层机制区别	1. 每个请求（连接）都需要一个独立线程来处理。 2. 当读取或写入操作未准备好时，线程会被阻塞。 3. 缺点：线程开销大，不适合高并发场景	1. 使用单线程 + Selector（选择器）来监听多个通道（Channel）。 2. 通道可以是非阻塞的，不会阻塞线程。 3. 核心组件： 3.1. Channel: 类似流，但可以是非阻塞的。 3.2. Selector: 可以监听多个通道上的事件（如连接、读、写） 3.3. Buffer: 读写数据时的容器
并发性能	低：每连接一个线程，线程开销大	高：单线程处理多个连接
编程复杂度	简单：逻辑清晰	复杂：需处理事件、状态、缓冲区
线程资源消耗	高	低
数据处理	直接阻塞读取写入	需要缓冲区、状态管理

Java 7 引入了 AIO（Asynchronous I/O），即异步非阻塞 IO。

• 真正异步，由系统内核完成读写通知。
• 核心类：AsynchronousSocketChannel 等。
• 编码更复杂，适用于极高并发的系统，使用不如 Netty 广泛

Dubbo原理

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

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

dubbo原理-服务暴露

dubbo原理-服务引用

dubbo原理-服务调用