Dubbo快速上手 -- 带你了解Dubbo使用、原理

转x33g5p2x  于2022-02-28 转载在 其他  
字(20.3k)|赞(0)|评价(0)|浏览(694)

📒博客首页：崇尚学技术的科班人
🍣今天给大家带来的文章是《Dubbo快速上手 -- 带你了解Dubbo使用、原理》🍣
🍣希望各位小伙伴们能够耐心的读完这篇文章🍣
🙏博主也在学习阶段，如若发现问题，请告知，非常感谢🙏
💗同时也非常感谢各位小伙伴们的支持💗

1、基础知识

1.1、分布式基础理论

（1）、什么是分布式系统？

  • 分布式系统是若干独立计算机的集合，这些计算机对于用户来说就像单个相关系统。
  • 分布式系统是建立在网络之上的软件系统。
  • 随着互联网的发展，网站应用的规模不断扩大，常规的垂直应用架构已无法应对，分布式服务架构以及流动计算架构势在必行，需要一个治理系统确保架构有条不紊的演进。

（2）、应用架构的发展演变

单一应用架构 -> 垂直应用架构 -> 分布式服务架构 -> 流动计算架构

（3）、RPC

  • 什么是RPC？

RPC是指远程过程调用，是一种进程间通信方式，它是一种技术的思想，而不是规范。它允许程序调用另一个地址空间（通常是共享网络的另一台机器上）的过程或函数，而不用程序员显式编码这个远程调用的细节。

  • RPC基本原理

  1. 由于业务需求，A 模块需要调用 B 模块的相关业务功能的话。那么 A 模块会将对应执行功能代码的函数参数通过网络连接进行传递给 B 模块。在这个需要传递对应数据的网络通信中，我们需要对数据进行序列化。
  2. B 模块在接收到数据之后会首先对数据进行反序列化，然后执行相关功能代码产生返回值，然后再将对应的返回值进行序列化，再通过网络通信传输给 A 模块。
  3. A 模块收到对应的执行结果之后会对返回值进行反序列化，从而 A 模块就获得了它想要获得的结果。
  4. RPC 的两个核心模块：通讯、序列化。

1.2、Dubbo

（1）、简介

Dubbo 是一款高性能、轻量级的开源 Java RPC。它提供了三大核心能力：面向接口的远程方法调用、智能容错和负载均衡、以及服务自动注册和发现。

（2）、基本概念

  • 角色概念
  1. 服务提供者：暴露服务的服务提供方，服务提供者在启动时，想注册中心注册自己提供的服务。
  2. 服务消费者：调用远程服务的服务消费方，服务消费者在启动时，向注册中心订阅自己所需的服务，服务消费者从提供者地址列表中基于软负载均衡算法，选一台提供者进行调用，如果调用失败，再选另一台调用。
  3. 注册中心：注册中心返回服务提供者地址列表给消费者，如果有变更，注册中心将基于长连接推送变更数据给消费者。
  4. 监控中心：服务消费者和提供者，在内存中累计调用次数和调用时间，定时每分钟发送一次统计数据到监控中心。
  • 调用关系说明
  1. 服务容器负责启动，加载，运行服务提供者。
  2. 服务提供者在启动时，向注册中心注册自己提供的服务。
  3. 服务消费者在启动时，向注册中心订阅自己所需的服务。
  4. 注册中心返回服务提供者地址列表给消费者，如果有变更，注册中心将基于长连接推送变更数据给消费者。
  5. 服务消费者从提供者地址列表中，基于如负载均衡算法，选一台提供者进行调用，如果调用失败，再选另一台调用。
  6. 服务消费者和提供者，在内存中累计调用次数和调用时间，定时每分钟发送一次统计数据到监控中心。

1.3、环境搭建

（1）、搭建 zookeeper 注册中心

windows 版本 zookeeper 下载地址

  • 下载成功之后，我们进行解压之后，我们需要对 conf 目录下的 zoo_sample.cfg 进行复制改名成 zoo.cfg，并修改其中的内容，修改为dataDir = ../data。
  1. # 在 bin 目录下执行以下代码启动
  2. zkServer.cmd
  4. # 使用客户端进行连接
  5. zkCli.cmd
  7. # 获取节点
  8. get /
  10. # 新增节点
  11. create /xiao 123456

（2）、安装 dubbo-admin 管理控制台

dubbo-admin下载地址

  1. # 解压之后在 src\main\resources\application.properties 指定zookeeper地址
  2. dubbo.registry.address=zookeeper://127.0.0.1:2181
  4. # 打包dubbo-admin
  5. mvn clean package -Dmaven.test.skip=true
  7. # 在 jar 的当前目录下运行
  8. java -jar dubbo-admin-0.0.1-SNAPSHOT.jar
  10. # 运行之后在 localhost:7001 进行访问，账户和密码都是 root

（3）、gmall-interface模块

  • UserAddress
  1. import java.io.Serializable;
  3. /**
  4.  * 用户地址
  5.  * @author xiao
  6.  *
  7.  */
  8. public class UserAddress implements Serializable {
  9. 	
  10. 	private Integer id;
  11.     private String userAddress; //用户地址
  12.     private String userId; //用户id
  13.     private String consignee; //收货人
  14.     private String phoneNum; //电话号码
  15.     private String isDefault; //是否为默认地址    Y-是     N-否
  16.     
  17.     public UserAddress() {
  18. 		super();
  19. 		// TODO Auto-generated constructor stub
  20. 	}
  21.     
  22. 	public UserAddress(Integer id, String userAddress, String userId, String consignee, String phoneNum,
  23. 			String isDefault) {
  24. 		super();
  25. 		this.id = id;
  26. 		this.userAddress = userAddress;
  27. 		this.userId = userId;
  28. 		this.consignee = consignee;
  29. 		this.phoneNum = phoneNum;
  30. 		this.isDefault = isDefault;
  31. 	}
  32. 	
  33. 	public Integer getId() {
  34. 		return id;
  35. 	}
  36. 	public void setId(Integer id) {
  37. 		this.id = id;
  38. 	}
  39. 	public String getUserAddress() {
  40. 		return userAddress;
  41. 	}
  42. 	public void setUserAddress(String userAddress) {
  43. 		this.userAddress = userAddress;
  44. 	}
  45. 	public String getUserId() {
  46. 		return userId;
  47. 	}
  48. 	public void setUserId(String userId) {
  49. 		this.userId = userId;
  50. 	}
  51. 	public String getConsignee() {
  52. 		return consignee;
  53. 	}
  54. 	public void setConsignee(String consignee) {
  55. 		this.consignee = consignee;
  56. 	}
  57. 	public String getPhoneNum() {
  58. 		return phoneNum;
  59. 	}
  60. 	public void setPhoneNum(String phoneNum) {
  61. 		this.phoneNum = phoneNum;
  62. 	}
  63. 	public String getIsDefault() {
  64. 		return isDefault;
  65. 	}
  66. 	public void setIsDefault(String isDefault) {
  67. 		this.isDefault = isDefault;
  68. 	}
  69.     
  70.     
  72. }
  • UserService
  1. import java.util.List;
  3. import com.xiao.gmall.bean.UserAddress;
  5. /**
  6.  * 用户服务
  7.  * @author xiao
  8.  *
  9.  */
  10. public interface UserService {
  11. 	
  12. 	/**
  13. 	 * 按照用户id返回所有的收货地址
  14. 	 * @param userId
  15. 	 * @return
  16. 	 */
  17. 	public List<UserAddress> getUserAddressList(String userId);
  19. }
  • OrderService
  1. import com.xiao.gmall.bean.UserAddress;
  3. import java.util.List;
  5. public interface OrderService {
  6. 	
  7. 	/**
  8. 	 * 初始化订单
  9. 	 * @param userId
  10. 	 */
  11. 	public List<UserAddress> initOrder(String userId);
  13. }

（4）、user-service-provider模块

  • POM
  1. <dependencies>
  2.         <dependency>
  3.             <groupId>org.example</groupId>
  4.             <artifactId>gmall-interface</artifactId>
  5.             <version>1.0-SNAPSHOT</version>
  6.         </dependency>
  8.         <dependency>
  9.             <groupId>com.alibaba</groupId>
  10.             <artifactId>dubbo</artifactId>
  11.             <version>2.6.2</version>
  12.         </dependency>
  14.         <dependency>
  15.             <groupId>org.apache.curator</groupId>
  16.             <artifactId>curator-framework</artifactId>
  17.             <version>2.12.0</version>
  18.         </dependency>
  19.     </dependencies>
  • provider.xml
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
  5.        xsi:schemaLocation="http://www.springframework.org/schema/beans
  6.                http://www.springframework.org/schema/beans/spring-beans.xsd
  7.                http://code.alibabatech.com/schema/dubbo
  8.                http://code.alibabatech.com/schema/dubbo/dubbo.xsd">
  10.         <!--  1. 指定当前服务/应用的名称 （同样的服务名字相同，不要和别的服务同名）      -->
  11.         <dubbo:application name="user-service-provider"></dubbo:application>
  13.         <!--   2. 指定注册中心的位置     -->
  14. <!--        <dubbo:registry address="zookeeper://127.0.0.1:2181"></dubbo:registry>-->
  15.         <dubbo:registry protocol="zookeeper" address="127.0.0.1:2181"></dubbo:registry>
  17.         <!--   3. 指定通信规则（通信协议？通信端口）     -->
  18.         <dubbo:protocol name="dubbo" port="20880"></dubbo:protocol>
  20.         <!--   4. 暴露对应的服务 ref:指的就是接口的实现类  -->
  21.         <dubbo:service interface="com.xiao.gmall.service.UserService" ref="userServiceImpl"></dubbo:service>
  23.         <!--   5. 对应的实现类     -->
  24.         <bean id="userServiceImpl" class="com.xiao.gmall.service.impl.UserServiceImpl"></bean>
  25. </beans>
  • MainApplication
  1. import org.springframework.context.support.ClassPathXmlApplicationContext;
  3. import java.io.IOException;
  5. /**
  6.  * @author ：小肖
  7.  * @date ：Created in 2022/2/23 15:17
  8.  */
  9. public class MainApplication {
  10.     public static void main(String[] args) throws IOException {
  11.         ClassPathXmlApplicationContext ioc = new ClassPathXmlApplicationContext("provider.xml");
  12.         ioc.start();
  14.         System.in.read();
  15.     }
  16. }
  • UserServiceImpl
  1. import com.xiao.gmall.bean.UserAddress;
  2. import com.xiao.gmall.service.UserService;
  4. import java.util.Arrays;
  5. import java.util.List;
  7. /**
  8.  * @author ：小肖
  9.  * @date ：Created in 2022/2/23 9:33
  10.  */
  11. public class UserServiceImpl implements UserService {
  13.     @Override
  14.     public List<UserAddress> getUserAddressList(String userId) {
  15.         System.out.println("UserServiceImpl.....old...");
  16.         // TODO Auto-generated method stub
  17.         UserAddress address1 = new UserAddress(1, "北京市昌平区宏福科技园综合楼3层", "1", "李老师", "010-56253825", "Y");
  18.         UserAddress address2 = new UserAddress(2, "深圳市宝安区西部硅谷大厦B座3层（深圳分校）", "1", "王老师", "010-56253825", "N");
  19. 		/*try {
  20. 			Thread.sleep(4000);
  21. 		} catch (InterruptedException e) {
  22. 			// TODO Auto-generated catch block
  23. 			e.printStackTrace();
  24. 		}*/
  25.         return Arrays.asList(address1,address2);
  26.     }
  27. }

（5）、order-service-consumer模块

  • POM
  1. <dependencies>
  2.         <dependency>
  3.             <groupId>org.example</groupId>
  4.             <artifactId>gmall-interface</artifactId>
  5.             <version>1.0-SNAPSHOT</version>
  6.         </dependency>
  8.         <dependency>
  9.             <groupId>com.alibaba</groupId>
  10.             <artifactId>dubbo</artifactId>
  11.             <version>2.6.2</version>
  12.         </dependency>
  14.         <dependency>
  15.             <groupId>org.apache.curator</groupId>
  16.             <artifactId>curator-framework</artifactId>
  17.             <version>2.12.0</version>
  18.         </dependency>
  19.     </dependencies>
  • consumer.xml
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xmlns:context="http://www.springframework.org/schema/context"
  5.        xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
  6.        xsi:schemaLocation="http://www.springframework.org/schema/beans
  7.                http://www.springframework.org/schema/beans/spring-beans.xsd
  8.                http://code.alibabatech.com/schema/dubbo
  9.                http://code.alibabatech.com/schema/dubbo/dubbo.xsd
  10.                http://www.springframework.org/schema/context
  11.                http://www.springframework.org/schema/context/spring-context.xsd">
  13.     <!--   扫描包 -->
  14.     <context:component-scan base-package="com.xiao.gmall.service.impl"></context:component-scan>
  16.     <!--  1. 指定当前服务/应用的名称 （同样的服务名字相同，不要和别的服务同名）      -->
  17.     <dubbo:application name="order-service-consumer"></dubbo:application>
  19.     <dubbo:registry address="zookeeper://127.0.0.1:2181"></dubbo:registry>
  21.     <dubbo:reference interface="com.xiao.gmall.service.UserService" id="userService"></dubbo:reference>
  23. </beans>
  • MainApplication
  1. import com.xiao.gmall.service.OrderService;
  2. import org.springframework.context.support.ClassPathXmlApplicationContext;
  4. import java.io.IOException;
  6. /**
  7.  * @author ：小肖
  8.  * @date ：Created in 2022/2/23 15:34
  9.  */
  10. public class MainApplication {
  11.     public static void main(String[] args) throws IOException {
  12.         ClassPathXmlApplicationContext ioc = new ClassPathXmlApplicationContext("consumer.xml");
  13.         OrderService orderService = ioc.getBean(OrderService.class);
  14.         orderService.initOrder("1");
  16.         System.in.read();
  17.     }
  18. }
  • OrderServiceImpl
  1. /**
  2.  * 1、将服务提供者注册到注册中心（暴露服务）
  3.  * 		1）、导入dubbo依赖（2.6.2）\操作zookeeper的客户端(curator)
  4.  * 		2）、配置服务提供者
  5.  * 
  6.  * 2、让服务消费者去注册中心订阅服务提供者的服务地址
  7.  * @author xiao
  8.  *
  9.  */
  10. @Service
  11. public class OrderServiceImpl implements OrderService {
  13. 	@Autowired
  14. 	UserService userService;
  16. 	@Override
  17. 	public List<UserAddress> initOrder(String userId) {
  18. 		// TODO Auto-generated method stub
  19. 		System.out.println("用户id："+userId);
  20. 		//1、查询用户的收货地址
  21. 		List<UserAddress> addressList = userService.getUserAddressList(userId);
  22. 		for (UserAddress userAddress : addressList) {
  23. 			System.out.println(userAddress.getUserAddress());
  24. 		}
  25. 		return addressList;
  26. 	}
  27. 	
  28. 	
  30. }

（6）、测试结果

  • 控制台输出如下
  1. 用户id：1
  2. 北京市昌平区宏福科技园综合楼3层
  3. 深圳市宝安区西部硅谷大厦B座3层（深圳分校）

2、配置

（1）、配置文件加载顺序

虚拟机参数 > application.properties > dubbo.properties

（2）、启动时检查

  • 启动时检查：就是消费者启动的时候会进行对服务提供者的检查，如果服务提供者未在注册中心中注册的话，那么就会抛出异常。
  1. <!--  关闭某个服务的启动时检查  -->
  2. <dubbo:reference interface="com.xiao.gmall.service.UserService" id="userService" check="false"></dubbo:reference>
  4. <!--  全局统一配置关闭启动时检查  -->
  5. <dubbo:consumer check="false"/>
  6. <!--  关闭注册中心的启动时检查  -->
  7. <dubbo:registry check="false"/>

（3）、超时时间配置

  • 超时时间配置：为了防止线程发生大量的阻塞。
  • 精确优先（方法级优先，接口级次之，全局配置再次之）。
  • 消费者优先（如果级别一样，则消费方优先，提供方次之）。
  1. <!--  关闭某个服务的启动时检查 check="false" -->
  2.     <!--  消费者超时时间的配置  -->
  3.     <dubbo:reference interface="com.xiao.gmall.service.UserService" id="userService" timeout="5000">
  4.         <dubbo:method name="getUserAddressList" timeout="1000"></dubbo:method>
  5.     </dubbo:reference>
  6.     <!--消费者的超时时间的全局配置-->
  7.     <dubbo:consumer timeout="1000"></dubbo:consumer>
  1. <!--   4. 暴露对应的服务 ref:指的就是接口的实现类  -->
  2. <!--  服务提供者者超时时间的配置  -->
  3. <dubbo:service interface="com.xiao.gmall.service.UserService" ref="userServiceImpl" timeout="5000">
  4.         <dubbo:method name="getUserAddressList" timeout="1000"></dubbo:method>
  5. </dubbo:service>
  6. <!--服务提供者的超时时间的全局配置-->
  7. <dubbo:provider timeout="1000"></dubbo:provider>

（4）、重试次数

  • retries：重试次数，不包含第一次调用。
  • 幂等（设置重试次数）【查询、删除、修改】；非幂等（不能设置重试次数）【新增】
  1. <dubbo:reference interface="com.xiao.gmall.service.UserService" id="userService" retries="3"></dubbo:reference>

（5）、多版本

  • 我们可以在消费者对新旧版本功能对象进行都生成，并用 version 进行管理区别调用。
  1. <dubbo:reference interface="com.xiao.gmall.service.UserService" id="userService" version="1.0.0"></dubbo:reference>

（6）、本地存根

  • UserServiceStub
  1. import com.xiao.gmall.bean.UserAddress;
  2. import com.xiao.gmall.service.UserService;
  3. import org.springframework.util.StringUtils;
  5. import java.util.List;
  7. /**
  8.  * @author ：小肖
  9.  * @date ：Created in 2022/2/23 23:06
  10.  */
  11. public class UserServiceStub implements UserService {
  13.     private final UserService userService;
  15.     public UserServiceStub(UserService userService) {
  16.         this.userService = userService;
  17.     }
  19.     @Override
  20.     public List<UserAddress> getUserAddressList(String userId) {
  21.         System.out.println("UserServiceStub....");
  22.         if(!StringUtils.isEmpty(userId)){
  23.             return userService.getUserAddressList(userId);
  24.         }
  25.         return null;
  26.     }
  27. }
  • 配置
  1. <dubbo:reference interface="com.xiao.gmall.service.UserService" id="userService" stub="com.xiao.gmall.service.impl.UserServiceStub"></dubbo:reference>

（7）、SpringBoot与dubbo整合的三种方式

  1. 导入 dubbo-starter，在 application.properties 配置属性，使用 @Service【暴露服务】使用 @Reference【引用服务】
  2. 保留 dubbo xml 配置文件：导入 dubbo-starter，使用 @ImportResource 导入 dubbo 的配置文件即可
  3. 使用注解 API 的方式：将每一个组件手动创建到容器中,让 dubbo 来扫描其他的组件。
  • 对应的 config 配置类
  1. import java.util.ArrayList;
  2. import java.util.List;
  4. import org.springframework.context.annotation.Bean;
  5. import org.springframework.context.annotation.Configuration;
  7. import com.alibaba.dubbo.config.ApplicationConfig;
  8. import com.alibaba.dubbo.config.MethodConfig;
  9. import com.alibaba.dubbo.config.MonitorConfig;
  10. import com.alibaba.dubbo.config.ProtocolConfig;
  11. import com.alibaba.dubbo.config.ProviderConfig;
  12. import com.alibaba.dubbo.config.RegistryConfig;
  13. import com.alibaba.dubbo.config.ServiceConfig;
  14. import com.atguigu.gmall.service.UserService;
  16. @Configuration
  17. public class MyDubboConfig {
  18. 	
  19. 	@Bean
  20. 	public ApplicationConfig applicationConfig() {
  21. 		ApplicationConfig applicationConfig = new ApplicationConfig();
  22. 		applicationConfig.setName("boot-user-service-provider");
  23. 		return applicationConfig;
  24. 	}
  25. 	
  26. 	//<dubbo:registry protocol="zookeeper" address="127.0.0.1:2181"></dubbo:registry>
  27. 	@Bean
  28. 	public RegistryConfig registryConfig() {
  29. 		RegistryConfig registryConfig = new RegistryConfig();
  30. 		registryConfig.setProtocol("zookeeper");
  31. 		registryConfig.setAddress("127.0.0.1:2181");
  32. 		return registryConfig;
  33. 	}
  34. 	
  35. 	//<dubbo:protocol name="dubbo" port="20882"></dubbo:protocol>
  36. 	@Bean
  37. 	public ProtocolConfig protocolConfig() {
  38. 		ProtocolConfig protocolConfig = new ProtocolConfig();
  39. 		protocolConfig.setName("dubbo");
  40. 		protocolConfig.setPort(20882);
  41. 		return protocolConfig;
  42. 	}
  43. 	
  44. 	/**
  45. 	 *<dubbo:service interface="com.atguigu.gmall.service.UserService" 
  46. 		ref="userServiceImpl01" timeout="1000" version="1.0.0">
  47. 		<dubbo:method name="getUserAddressList" timeout="1000"></dubbo:method>
  48. 	</dubbo:service>
  49. 	 */
  50. 	@Bean
  51. 	public ServiceConfig<UserService> userServiceConfig(UserService userService){
  52. 		ServiceConfig<UserService> serviceConfig = new ServiceConfig<>();
  53. 		serviceConfig.setInterface(UserService.class);
  54. 		serviceConfig.setRef(userService);
  55. 		serviceConfig.setVersion("1.0.0");
  56. 		
  57. 		//配置每一个method的信息
  58. 		MethodConfig methodConfig = new MethodConfig();
  59. 		methodConfig.setName("getUserAddressList");
  60. 		methodConfig.setTimeout(1000);
  61. 		
  62. 		//将method的设置关联到service配置中
  63. 		List<MethodConfig> methods = new ArrayList<>();
  64. 		methods.add(methodConfig);
  65. 		serviceConfig.setMethods(methods);
  66. 		
  67. 		//ProviderConfig
  68. 		//MonitorConfig
  69. 		
  70. 		return serviceConfig;
  71. 	}
  73. }

3、高可用

3.1、zookeeper宕机与dubbo直连

  1. 监控中心宕掉不影响使用，只是丢失部分采样数据
  2. 数据库宕掉后，注册中心仍能通过缓存提供服务列表查询，但不能注册新服务
  3. 注册中心对等集群，任意一台宕掉后，将自动切换到另一台
  4. 注册中心全部宕掉后，服务提供者和服务消费者仍能通过本地缓存通讯
  5. 服务提供者无状态，任意一台宕掉后，不影响使用
  6. 服务提供者全部宕掉后，服务消费者应用将无法使用，并无限次重连等待服务提供者恢复
  • 与 dubbo 直连
  1. @Reference(url = "127.0.0.1:20880") // 与dubbo直连
  2. UserService userService;

3.2、负载均衡策略与配置

  1. Random LoadBalance：随机，按权重设置随机概率。
  2. RoundRobin LoadBalance：轮循，按公约后的权重设置轮循比率。
  3. LeastActive LoadBalance：最少活跃调用数，相同活跃数的随机，活跃数指调用前后计数差。使慢的提供者收到更少请求，因为越慢的提供者的调用前后计数差会越大。
  4. ConsistentHash LoadBalance：一致性 Hash，相同参数的请求总是发到同一提供者。
  1. <!--服务提供方-->
  2. <dubbo:service interface="com.xiao.gmall.service.UserService" ref="userServiceImpl" loadbalance="random"></dubbo:service>
  4. <dubbo:provider loadbalance="random"></dubbo:provider>
  6. <!--消费者方-->
  7. <dubbo:reference interface="com.xiao.gmall.service.UserService" id="userService" loadbalance="random" stub="com.xiao.gmall.service.impl.UserServiceStub"></dubbo:reference>
  9. <dubbo:consumer loadbalance="random"></dubbo:consumer>

3.3、服务降级

  • 服务降级：当服务器压力剧增的情况下，根据实际业务情况及流量，对一些服务和页面有策略的不处理或换种简单的方式处理，从而释放服务器资源以保证核心交易正常运作或高效运作。
  • mock=force:return+null 表示消费方对该服务的方法调用都直接返回 null 值，不发起远程调用。用来屏蔽不重要服务不可用时对调用方的影响。
  • mock=fail:return+null 表示消费方对该服务的方法调用在失败后，再返回 null 值，不抛异常。用来容忍不重要服务不稳定时对调用方的影响。

  • 这里我们通过 dubbo 提供的监控中心进行配置。

3.4、整合 Hystrix

  • 引入依赖
  1. <dependency>
  2.     <groupId>org.springframework.cloud</groupId>
  3.     <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
  4.     <version>1.4.4.RELEASE</version>
  5. </dependency>
  • 开启注解
  1. // 在主启动类上添加
  2. @EnableHystrix
  • 标识注解
  1. // 在所需要容错的方法上添加
  2. @HystrixCommand
  • fallback方法
  1. @HystrixCommand(fallback = "hello")

4、原理

4.1、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. 服务消费方得到最终结果。

4.2、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

4.3、dubbo原理 – 启动解析、加载配置文件

  1. public class DubboNamespaceHandler extends NamespaceHandlerSupport {
  2.     
  4.     public void init() {
  5.         this.registerBeanDefinitionParser("application", new DubboBeanDefinitionParser(ApplicationConfig.class, true));
  6.         this.registerBeanDefinitionParser("module", new DubboBeanDefinitionParser(ModuleConfig.class, true));
  7.         this.registerBeanDefinitionParser("registry", new DubboBeanDefinitionParser(RegistryConfig.class, true));
  8.         this.registerBeanDefinitionParser("monitor", new DubboBeanDefinitionParser(MonitorConfig.class, true));
  9.         this.registerBeanDefinitionParser("provider", new DubboBeanDefinitionParser(ProviderConfig.class, true));
  10.         this.registerBeanDefinitionParser("consumer", new DubboBeanDefinitionParser(ConsumerConfig.class, true));
  11.         this.registerBeanDefinitionParser("protocol", new DubboBeanDefinitionParser(ProtocolConfig.class, true));
  12.         this.registerBeanDefinitionParser("service", new DubboBeanDefinitionParser(ServiceBean.class, true));
  13.         this.registerBeanDefinitionParser("reference", new DubboBeanDefinitionParser(ReferenceBean.class, false));
  14.         this.registerBeanDefinitionParser("annotation", new AnnotationBeanDefinitionParser());
  15.     }
  16. }
  • 当启动的时候，DubboNamespaceHandler会进行对各式各样的 DubboBeanDefinitionParser 进行初始化，然后这些 DubboBeanDefinitionParser 会进行配置文件的读取和加载。

4.4、dubbo原理 – 服务暴露

  • 触发 export() 暴露服务
  1. public class ServiceBean<T> extends ServiceConfig<T> implements InitializingBean, DisposableBean, ApplicationContextAware, ApplicationListener<ContextRefreshedEvent>, BeanNameAware {
  2.  
  3.     public void onApplicationEvent(ContextRefreshedEvent event) {
  4.       		//...
  5.             this.export();
  6.             //...
  7.     }
  8. }
  • doExportUrls()
  1. public class ServiceConfig<T> extends AbstractServiceConfig {
  2.     public synchronized void export() {
  3.         //...
  4.          this.doExport();
  5.         //...    
  6.     }
  7. }
  • doExportUrlsFor1Protocol()
  1. public class ServiceConfig<T> extends AbstractServiceConfig {
  2.     private void doExportUrls() {
  3.        //...
  4.         this.doExportUrlsFor1Protocol(protocolConfig, registryURLs);
  5.         //...
  7.     }	
  8. }
  • getInvoker()
  1. public class ServiceConfig<T> extends AbstractServiceConfig {
  2.     private void doExportUrlsFor1Protocol(ProtocolConfig protocolConfig, List<URL> registryURLs){
  3.     		//...
  4.     	   Invoker<?> invoker = proxyFactory.getInvoker(this.ref, this.interfaceClass, registryURL.addParameterAndEncoded("export", url.toFullString()));
  5.     	   //...
  6. 	}
  7. }
  • openServer()
  1. public class DubboProtocol extends AbstractProtocol {
  2. 	public <T> Exporter<T> export(Invoker<T> invoker) throws RpcException {
  3. 		//...
  4. 		this.openServer(url);
  5. 		//...
  6.  	}
  7. }
  • registerProvider()
  1. public class ProviderConsumerRegTable {
  2.     public static ConcurrentHashMap<String, Set<ProviderInvokerWrapper>> providerInvokers = new ConcurrentHashMap();
  3.     public static ConcurrentHashMap<String, Set<ConsumerInvokerWrapper>> consumerInvokers = new ConcurrentHashMap();
  4.     public static void registerProvider(Invoker invoker, URL registryUrl, URL providerUrl) {
  5.         ProviderInvokerWrapper wrapperInvoker = new ProviderInvokerWrapper(invoker, registryUrl, providerUrl);
  6.         String serviceUniqueName = providerUrl.getServiceKey();
  7.         Set<ProviderInvokerWrapper> invokers = (Set)providerInvokers.get(serviceUniqueName);
  8.         if (invokers == null) {
  9.             providerInvokers.putIfAbsent(serviceUniqueName, new ConcurrentHashSet());
  10.             invokers = (Set)providerInvokers.get(serviceUniqueName);
  11.         }
  13.         invokers.add(wrapperInvoker);
  14.     }
  15. }

4.5、dubbo原理 – 服务引用

4.6、dubbo原理 – 服务调用

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://blog.csdn.net/weixin_56727438/article/details/123076169

内容来源于网络，如有侵权，请联系作者删除！

Javarpc分布式后端

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com