前言

​ 前面我们研究了RPC的原理,市面上有很多基于RPC思想实现的框架,比如有Dubbo。今天就从Dubbo的SPI机制、服务注册与发现源码及网络通信过程去深入剖析下Dubbo。

Dubbo架构

概述

Dubbo是阿里巴巴公司开源的一个高性能优秀的服务框架,使得应用可通过高性能的RPC 实现服务的输出和输入功能,可以和Spring框架无缝集成。

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

调用流程:

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

架构体系

源码结构

  • dubbo-common:公共逻辑模块: 包括Util类和通用模型
  • dubbo-remoting 远程通信模块: 相当于dubbo协议的实现,如果RPC使用RMI协议则不需要使用此包
  • dubbo-rpc 远程调用模块: 抽象各种协议,以及动态代理,包含一对一的调用,不关心集群的原理。
  • dubbo-cluster 集群模块: 将多个服务提供方伪装成一个提供方,包括负载均衡,容错,路由等,集群的地址列表可以是静态配置的,也可以是注册中心下发的.
  • dubbo-registry 注册中心模块: 基于注册中心下发的集群方式,以及对各种注册中心的抽象
  • dubbo-monitor 监控模块: 统计服务调用次数,调用时间,调用链跟踪的服务.
  • dubbo-config 配置模块: 是dubbo对外的api,用户通过config使用dubbo,隐藏dubbo所有细节
  • dubbo-container 容器模块: 是一个standlone的容器,以简单的main加载spring启动,因为服务通常不需要Tomcat/Jboss等web容器的特性,没必要用web容器去加载服务.

整体设计

  • 图中左边淡蓝背景的为服务消费方使用的接口,右边淡绿色背景的为服务提供方使用的接口,位于中轴线上的为双方都用到的接口。
  • 图中从下至上分为十层,各层均为单向依赖,每一层都可以剥离上层被复用,其中,Service 和Config 层为API,其它各层均为SPI。
  • 图中绿色小块的为扩展接口,蓝色小块为实现类,图中只显示用于关联各层的实现类。
  • 图中蓝色虚线为初始化过程,即启动时组装链,红色实线为方法调用过程,即运行时调时链,紫色三角箭头为继承,可以把子类看作父类的同一个节点,线上的文字为调用的方法。

各层说明

  • 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

调用流程

对照上面的整体架构图可以大致分为以下步骤:

1、服务提供者启动,开启Netty服务,创建Zookeeper客户端,向注册中心注册服务。

2、服务消费者启动,通过Zookeeper向注册中心获取服务提供者列表,与服务提供者通过Netty建立长连接。

3、服务消费者通过接口开始远程调用服务,ProxyFactory通过初始化Proxy对象,Proxy通过创建动态代理对象。

4、动态代理对象通过invoke方法,层层包装生成一个Invoker对象,该对象包含了代理对象。

5、Invoker通过路由,负载均衡选择了一个最合适的服务提供者,在通过加入各种过滤器,协议层包装生成一个新的DubboInvoker对象。

6、再通过交换成将DubboInvoker对象包装成一个Reuqest对象,该对象通过序列化通过NettyClient传输到服务提供者的NettyServer端。

7、到了服务提供者这边,再通过反序列化、协议解密等操作生成一个DubboExporter对象,再层层传递处理,会生成一个服务提供端的Invoker对象.

8、这个Invoker对象会调用本地服务,获得结果再通过层层回调返回到服务消费者,服务消费者拿到结果后,再解析获得最终结果。

Dubbo中的SPI机制

什么是SPI

概述

在Dubbo 中,SPI 是一个非常重要的模块。基于SPI,我们可以很容易的对Dubbo 进行拓展。如果大家想要学习Dubbo 的源码,SPI 机制务必弄懂。接下来,我们先来了解一下Java SPI 与Dubbo SPI 的用法,然后再来分析Dubbo SPI 的源码。

SPI是Service Provider Interface 服务提供接口缩写,是一种服务发现机制。SPI的本质是将接口的实现类的全限定名定义在配置文件中,并有服务器读取配置文件,并加载实现类。这样就可以在运行的时候,动态为接口替换实现类。

JDK中的SPI

Java SPI 实际上是“基于接口的编程+策略模式+配置文件”组合实现的动态加载机制。

通过一个案例我们来认识下SPI

定义一个接口:

  1. package com.laowang;
  2. /**
  3. * @author 原
  4. * @date 2021/3/27
  5. * @since 1.0
  6. **/
  7. public interface User {
  8. String showName();
  9. }

定义两个实现类

  1. package com.laowang.impl;
  2. import com.laowang.User;
  3. /**
  4. * @author 原
  5. * @date 2021/3/27
  6. * @since 1.0
  7. **/
  8. public class Student implements User {
  9. @Override
  10. public String showName() {
  11. System.out.println("my name is laowang");
  12. return null;
  13. }
  14. }
  1. package com.laowang.impl;
  2. import com.laowang.User;
  3. /**
  4. * @author 原
  5. * @date 2021/3/27
  6. * @since 1.0
  7. **/
  8. public class Teacher implements User {
  9. @Override
  10. public String showName() {
  11. System.out.println("my name is zhangsan");
  12. return null;
  13. }
  14. }

在resources目录下创建文件夹META-INF.services,并在该文件夹下创建一个名称与User的全路径一致的文件com.laowang.User

在文件中写入,两个实现类的全路径名

编写测试类:

  1. package com.laowang;
  2. import java.util.ServiceLoader;
  3. /**
  4. * @author 原
  5. * @date 2021/3/27
  6. * @since 1.0
  7. **/
  8. public class SpiTest {
  9. public static void main(String[] args) {
  10. ServiceLoader<User> serviceLoader = ServiceLoader.load(User.class);
  11. serviceLoader.forEach(User::showName);
  12. }
  13. }

运行结果:

我们发现通过SPI机制,帮我们自动运行了两个实现类。

通过查看ServiceLoader源码:

其实通过读取配置文件中实现类的全路径类名,通过反射创建对象,并放入providers容器中。

总结:

调用过程

应用程序调用ServiceLoader.load方法,创建一个新的ServiceLoader,并实例化该类中的成员变量

应用程序通过迭代器接口获取对象实例,ServiceLoader先判断成员变量providers对象中(LinkedHashMap<String,S>类型)是否有缓存实例对象,如果有缓存,直接返回。如果没有缓存,执行类的装载,

优点

使用Java SPI 机制的优势是实现解耦,使得接口的定义与具体业务实现分离,而不是耦合在一起。应用进程可以根据实际业务情况启用或替换具体组件。

缺点

不能按需加载。虽然ServiceLoader 做了延迟载入,但是基本只能通过遍历全部获取,也就是接口的实现类得全部载入并实例化一遍。如果你并不想用某些实现类,或者某些类实例化很耗时,它也被载入并实例化了,这就造成了浪费。

获取某个实现类的方式不够灵活,只能通过Iterator 形式获取,不能根据某个参数来获取对应的实现类。

多个并发多线程使用ServiceLoader 类的实例是不安全的。

加载不到实现类时抛出并不是真正原因的异常,错误很难定位。

Dubbo中的SPI

Dubbo 并未使用Java SPI,而是重新实现了一套功能更强的SPI 机制。Dubbo SPI 的相关逻辑被封装在了ExtensionLoader 类中,通过ExtensionLoader,我们可以加载指定的实现类。

栗子

与Java SPI 实现类配置不同,Dubbo SPI 是通过键值对的方式进行配置,这样我们可以按需加载指定的实现类。下面来演示Dubbo SPI 的用法:

Dubbo SPI 所需的配置文件需放置在META-INF/dubbo 路径下,与Java SPI 实现类配置不同,DubboSPI 是通过键值对的方式进行配置,配置内容如下。

  1. optimusPrime = org.apache.spi.OptimusPrime
  2. bumblebee = org.apache.spi.Bumblebee

在使用Dubbo SPI 时,需要在接口上标注@SPI 注解。

  1. @SPI
  2. public interface Robot {
  3. void sayHello();
  4. }

通过ExtensionLoader,我们可以加载指定的实现类,下面来演示Dubbo SPI :

  1. public class DubboSPITest {
  2. @Test
  3. public void sayHello() throws Exception {
  4. ExtensionLoader<Robot> extensionLoader =
  5. ExtensionLoader.getExtensionLoader(Robot.class);
  6. Robot optimusPrime = extensionLoader.getExtension("optimusPrime");
  7. optimusPrime.sayHello();
  8. Robot bumblebee = extensionLoader.getExtension("bumblebee");
  9. bumblebee.sayHello();
  10. }
  11. }

Dubbo SPI 除了支持按需加载接口实现类,还增加了IOC 和AOP 等特性,这些特性将会在接下来的源码分析章节中一一进行介绍。

源码分析

ExtensionLoader 的getExtensionLoader 方法获取一个ExtensionLoader 实例,然后再通过ExtensionLoader 的getExtension 方法获取拓展类对象。下面我们从ExtensionLoader 的getExtension 方法作为入口,对拓展类对象的获取过程进行详细的分析。

  1. public T getExtension(String name) {
  2. if (StringUtils.isEmpty(name)) {
  3. throw new IllegalArgumentException("Extension name == null");
  4. }
  5. if ("true".equals(name)) {
  6. // 获取默认的拓展实现类
  7. return getDefaultExtension();
  8. }
  9. // Holder,顾名思义,用于持有目标对象 就是从容器中获取,如果没有直接new一个Holder
  10. Holder<Object> holder = getOrCreateHolder(name);
  11. //获取目标对象实例
  12. Object instance = holder.get();
  13. // 如果目标对象实例为null 就需要通过双重检查创建实例
  14. if (instance == null) {
  15. synchronized (holder) {
  16. instance = holder.get();
  17. if (instance == null) {
  18. // 创建拓展实例
  19. instance = createExtension(name);
  20. // 设置实例到 holder 中
  21. holder.set(instance);
  22. }
  23. }
  24. }
  25. return (T) instance;
  26. }

上面代码的逻辑比较简单,首先检查缓存,缓存未命中则创建拓展对象。下面我们来看一下创建拓展对象的过程是怎样的。

  1. private T createExtension(String name) {
  2. // 从配置文件中加载所有的拓展类,可得到“配置项名称”到“配置类”的映射关系表
  3. Class<?> clazz = getExtensionClasses().get(name);
  4. if (clazz == null) {
  5. throw findException(name);
  6. }
  7. try {
  8. //从容器中获取对应的实例对象 如果不存在就通过反射创建
  9. T instance = (T) EXTENSION_INSTANCES.get(clazz);
  10. if (instance == null) {
  11. // 通过反射创建实例
  12. EXTENSION_INSTANCES.putIfAbsent(clazz, clazz.newInstance());
  13. instance = (T) EXTENSION_INSTANCES.get(clazz);
  14. }
  15. // 向实例中注入依赖 下面是IOC和AOP的实现
  16. injectExtension(instance);
  17. Set<Class<?>> wrapperClasses = cachedWrapperClasses;
  18. if (CollectionUtils.isNotEmpty(wrapperClasses)) {
  19. // 循环创建 Wrapper 实例
  20. for (Class<?> wrapperClass : wrapperClasses) {
  21. // 将当前 instance 作为参数传给 Wrapper 的构造方法,并通过反射创建Wrapper 实例。
  22. // 然后向 Wrapper 实例中注入依赖,最后将 Wrapper 实例再次赋值给instance 变量
  23. instance = injectExtension(
  24. (T)
  25. wrapperClass.getConstructor(type).newInstance(instance));
  26. }
  27. }

createExtension 方法的逻辑稍复杂一下,包含了如下的步骤:

  1. 通过getExtensionClasses 获取所有的拓展类

  2. 通过反射创建拓展对象

  3. 向拓展对象中注入依赖

  4. 将拓展对象包裹在相应的Wrapper 对象中

以上步骤中,第一个步骤是加载拓展类的关键,第三和第四个步骤是Dubbo IOC 与AOP 的具体实现。由于此类设计源码较多,这里简单的总结下ExtensionLoader整个执行逻辑:

  1. getExtension(String name) #根据key获取拓展对象
  2. -->createExtension(String name) #创建拓展实例
  3. -->getExtensionClasses #根据路径获取所有的拓展类
  4. -->loadExtensionClasses #加载拓展类
  5. -->cacheDefaultExtensionName #解析@SPI注解
  6. -->loadDirectory #方法加载指定文件夹配置文件
  7. -->loadResource #加载资源
  8. -->loadClass #加载类,并通过 loadClass 方法对类进行缓存

Dubbo的SPI如何实现IOC和AOP的

Dubbo IOC

Dubbo IOC 是通过setter 方法注入依赖。Dubbo 首先会通过反射获取到实例的所有方法,然后再遍历方法列表,检测方法名是否具有setter 方法特征。若有,则通过ObjectFactory 获取依赖对象,最后通过反射调用setter 方法将依赖设置到目标对象中。整个过程对应的代码如下:

  1. private T injectExtension(T instance) {
  2. try {
  3. if (objectFactory != null) {
  4. //获取实例的所有方法
  5. for (Method method : instance.getClass().getMethods()) {
  6. //isSetter做的事:检测方法是否以 set 开头,且方法仅有一个参数,且方法访问级别为 public
  7. if (isSetter(method)) {
  8. /**
  9. * Check {@link DisableInject} to see if we need auto injection for this property
  10. */
  11. if (method.getAnnotation(DisableInject.class) != null) {
  12. continue;
  13. }
  14. Class<?> pt = method.getParameterTypes()[0];
  15. if (ReflectUtils.isPrimitives(pt)) {
  16. continue;
  17. }
  18. try {
  19. String property = getSetterProperty(method);
  20. //获取依赖对象
  21. Object object = objectFactory.getExtension(pt, property);
  22. if (object != null) {
  23. //设置属性
  24. method.invoke(instance, object);
  25. }
  26. } catch (Exception e) {
  27. logger.error("Failed to inject via method " + method.getName()
  28. + " of interface " + type.getName() + ": " + e.getMessage(), e);
  29. }
  30. }
  31. }
  32. }
  33. } catch (Exception e) {
  34. logger.error(e.getMessage(), e);
  35. }
  36. return instance;
  37. }

Dubbo Aop

在说这个之前,我们得先知道装饰者模式

装饰者模式:在不改变原类文件以及不使用继承的情况下,动态地将责任附加到对象上,从而实现动态拓展一个对象的功能。它是通过创建一个包装对象,也就是装饰来包裹真实的对象。

在用Spring的时候,我们经常会用到AOP功能。在目标类的方法前后插入其他逻辑。比如通常使用Spring AOP来实现日志,监控和鉴权等功能。Dubbo的扩展机制,是否也支持类似的功能呢?答案是yes。在Dubbo中,有一种特殊的类,被称为Wrapper类。通过装饰者模式,使用包装类包装原始的扩展点实例。在原始扩展点实现前后插入其他逻辑,实现AOP功能。

一般来说装饰者模式有下面几个参与者:

Component:装饰者和被装饰者共同的父类,是一个接口或者抽象类,用来定义基本行为

ConcreteComponent:定义具体对象,即被装饰者

Decorator:抽象装饰者,继承自Component,从外类来扩展ConcreteComponent。对于ConcreteComponent来说,不需要知道Decorator的存在,Decorator是一个接口或抽象类

ConcreteDecorator:具体装饰者,用于扩展ConcreteComponent

  1. //获取所有需要包装的类
  2. Set<Class<?>> wrapperClasses = cachedWrapperClasses;

我们再看看cachedWrapperClasses是什么?

  1. private Set<Class<?>> cachedWrapperClasses;

是一个set集合,那么集合是什么时候添加元素的呢?

  1. /**
  2. * cache wrapper class
  3. * <p>
  4. * like: ProtocolFilterWrapper, ProtocolListenerWrapper
  5. */
  6. private void cacheWrapperClass(Class<?> clazz) {
  7. if (cachedWrapperClasses == null) {
  8. cachedWrapperClasses = new ConcurrentHashSet<>();
  9. }
  10. cachedWrapperClasses.add(clazz);
  11. }

通过这个方法添加的,再看看谁调用了这个私有方法:

  1. /**
  2. * test if clazz is a wrapper class
  3. * <p>
  4. * which has Constructor with given class type as its only argument
  5. */
  6. private boolean isWrapperClass(Class<?> clazz) {
  7. try {
  8. clazz.getConstructor(type);
  9. return true;
  10. } catch (NoSuchMethodException e) {
  11. return false;
  12. }
  13. }

原来是通过isWrapperClass这个方法,判断有没有其他对象中的构造方法中持有本对象,如果有,dubbo就认为这是个装饰类,调用装饰者类的构造方法,并返回实例对象

然后通过实例化这个包装类代替需要加载的这个类。这样执行的方法就是包装类的方法。

Dubbo中的动态编译

我们知道在Dubbo 中,很多拓展都是通过SPI 机制 进行加载的,比如Protocol、Cluster、LoadBalance、ProxyFactory 等。有时,有些拓展并不想在框架启动阶段被加载,而是希望在拓展方法被调用时,根据运行时参数进行加载,即根据参数动态加载实现类。

这种在运行时,根据方法参数才动态决定使用具体的拓展,在dubbo中就叫做扩展点自适应实例。其实是一个扩展点的代理,将扩展的选择从Dubbo启动时,延迟到RPC调用时。Dubbo中每一个扩展点都有一个自适应类,如果没有显式提供,Dubbo会自动为我们创建一个,默认使用Javaassist。

自适应拓展机制的实现逻辑是这样的

  1. 首先Dubbo 会为拓展接口生成具有代理功能的代码;
  2. 通过javassist 或jdk 编译这段代码,得到Class 类;
  3. 通过反射创建代理类;
  4. 在代理类中,通过URL对象的参数来确定到底调用哪个实现类;

javassist

Javassist是一个开源的分析、编辑和创建Java字节码的类库。是由东京工业大学的数学和计算机科学系的Shigeru Chiba (千叶滋)所创建的。它已加入了开放源代码JBoss 应用服务器项目,通过使用Javassist对字节码操作为JBoss实现动态AOP框架。javassist是jboss的一个子项目,其主要的优点,在于简单,而且快速。直接使用java编码的形式,而不需要了解虚拟机指令,就能动态改变类的结构,或者动态生成类。

  1. /**
  2. * Javassist是一个开源的分析、编辑和创建Java字节码的类库
  3. * 能动态改变类的结构,或者动态生成类
  4. */
  5. public class CompilerByJavassist {
  6. public static void main(String[] args) throws Exception {
  7. // ClassPool:class对象容器
  8. ClassPool pool = ClassPool.getDefault();
  9. // 通过ClassPool生成一个User类
  10. CtClass ctClass = pool.makeClass("com.itheima.domain.User");
  11. // 添加属性 -- private String username
  12. CtField enameField = new CtField(pool.getCtClass("java.lang.String"),
  13. "username", ctClass);
  14. enameField.setModifiers(Modifier.PRIVATE);
  15. ctClass.addField(enameField);
  16. // 添加属性 -- private int age
  17. CtField enoField = new CtField(pool.getCtClass("int"), "age", ctClass);
  18. enoField.setModifiers(Modifier.PRIVATE);
  19. ctClass.addField(enoField);
  20. //添加方法
  21. ctClass.addMethod(CtNewMethod.getter("getUsername", enameField));
  22. ctClass.addMethod(CtNewMethod.setter("setUsername", enameField));
  23. ctClass.addMethod(CtNewMethod.getter("getAge", enoField));
  24. ctClass.addMethod(CtNewMethod.setter("setAge", enoField));
  25. // 无参构造器
  26. CtConstructor constructor = new CtConstructor(null, ctClass);
  27. constructor.setBody("{}");
  28. ctClass.addConstructor(constructor);
  29. // 添加构造函数
  30. //ctClass.addConstructor(new CtConstructor(new CtClass[] {}, ctClass));
  31. CtConstructor ctConstructor = new CtConstructor(new CtClass[]
  32. {pool.get(String.class.getName()),CtClass.intType}, ctClass);
  33. ctConstructor.setBody("{\n this.username=$1; \n this.age=$2;\n}");
  34. ctClass.addConstructor(ctConstructor);
  35. // 添加自定义方法
  36. CtMethod ctMethod = new CtMethod(CtClass.voidType, "printUser",new
  37. CtClass[] {}, ctClass);
  38. // 为自定义方法设置修饰符
  39. ctMethod.setModifiers(Modifier.PUBLIC);
  40. // 为自定义方法设置函数体
  41. StringBuffer buffer2 = new StringBuffer();
  42. buffer2.append("{\nSystem.out.println(\"用户信息如下\");\n")
  43. .append("System.out.println(\"用户名=\"+username);\n")
  44. .append("System.out.println(\"年龄=\"+age);\n").append("}");
  45. ctMethod.setBody(buffer2.toString());
  46. ctClass.addMethod(ctMethod);
  47. //生成一个class
  48. Class<?> clazz = ctClass.toClass();
  49. Constructor cons2 =
  50. clazz.getDeclaredConstructor(String.class,Integer.TYPE);
  51. Object obj = cons2.newInstance("itheima",20);
  52. //反射 执行方法
  53. obj.getClass().getMethod("printUser", new Class[] {})
  54. .invoke(obj, new Object[] {});
  55. // 把生成的class文件写入文件
  56. byte[] byteArr = ctClass.toBytecode();
  57. FileOutputStream fos = new FileOutputStream(new File("D://User.class"));
  58. fos.write(byteArr);
  59. fos.close();
  60. }
  61. }

源码分析

Adaptive注解

  1. @Documented
  2. @Retention(RetentionPolicy.RUNTIME)
  3. @Target({ElementType.TYPE, ElementType.METHOD})
  4. public @interface Adaptive {
  5. String[] value() default {};
  6. }

Adaptive 可注解在类或方法上。

标注在类上:Dubbo 不会为该类生成代理类。

标注在方法上:Dubbo 则会为该方法生成代理逻辑,表示当前方法需要根据 参数URL 调用对应的扩展点实现。

dubbo中每一个扩展点都有一个自适应类,如果没有显式提供,Dubbo会自动为我们创建一个,默认使用Javaassist。 先来看下创建自适应扩展类的代码

  1. //1、看下extensionLoader的获取方法
  2. ExtensionLoader<Robot>extensionLoader=ExtensionLoader.getExtensionLoader(Robot.class);
  3. //2、最终调用的是ExtensionLoader的构造方法
  4. private ExtensionLoader(Class<?> type) {
  5. this.type = type;
  6. objectFactory = (type == ExtensionFactory.class ? null : ExtensionLoader.getExtensionLoader(ExtensionFactory.class).getAdaptiveExtension());
  7. }
  8. //3、getAdaptiveExtension()看看干了什么事
  9. public T getAdaptiveExtension() {
  10. //获取自适应扩展类,如果没有就开始初始化一个
  11. Object instance = cachedAdaptiveInstance.get();
  12. if (instance == null) {
  13. if (createAdaptiveInstanceError == null) {
  14. synchronized (cachedAdaptiveInstance) {
  15. instance = cachedAdaptiveInstance.get();
  16. if (instance == null) {
  17. try {
  18. //这里创建了一个自适应扩展类
  19. instance = createAdaptiveExtension();
  20. cachedAdaptiveInstance.set(instance);
  21. } catch (Throwable t) {
  22. createAdaptiveInstanceError = t;
  23. throw new IllegalStateException("Failed to create adaptive instance: " + t.toString(), t);
  24. }
  25. }
  26. }
  27. } else {
  28. throw new IllegalStateException("Failed to create adaptive instance: " + createAdaptiveInstanceError.toString(), createAdaptiveInstanceError);
  29. }
  30. }
  31. return (T) instance;
  32. }
  33. //看看createAdaptiveExtension()
  34. private T createAdaptiveExtension() {
  35. try {
  36. return injectExtension((T) getAdaptiveExtensionClass().newInstance());
  37. } catch (Exception e) {
  38. throw new IllegalStateException("Can't create adaptive extension " + type + ", cause: " + e.getMessage(), e);
  39. }
  40. }
  41. //再进到getAdaptiveExtensionClass()
  42. private Class<?> getAdaptiveExtensionClass() {
  43. getExtensionClasses();
  44. if (cachedAdaptiveClass != null) {
  45. return cachedAdaptiveClass;
  46. }
  47. return cachedAdaptiveClass = createAdaptiveExtensionClass();
  48. }
  49. //继续追进去createAdaptiveExtensionClass()
  50. private Class<?> createAdaptiveExtensionClass() {
  51. String code = new AdaptiveClassCodeGenerator(type, cachedDefaultName).generate();
  52. ClassLoader classLoader = findClassLoader();
  53. org.apache.dubbo.common.compiler.Compiler compiler = ExtensionLoader.getExtensionLoader(org.apache.dubbo.common.compiler.Compiler.class).getAdaptiveExtension();
  54. return compiler.compile(code, classLoader);
  55. }
  56. //看看compiler
  57. @SPI("javassist")
  58. public interface Compiler {
  59. /**
  60. * Compile java source code.
  61. *
  62. * @param code Java source code
  63. * @param classLoader classloader
  64. * @return Compiled class
  65. */
  66. Class<?> compile(String code, ClassLoader classLoader);
  67. }
  68. //其实到这里就知道了,通过生成一个类的字符串,再通过javassist生成一个对象

createAdaptiveExtensionClassCode()方法中使用一个StringBuilder来构建自适应类的Java源码。方法实现比较长,这里就不贴代码了。这种生成字节码的方式也挺有意思的,先生成Java源代码,然后编译,加载到jvm中。通过这种方式,可以更好的控制生成的Java类。而且这样也不用care各个字节码生成框架的api等。因为xxx.java文件是Java通用的,也是我们最熟悉的。只是代码的可读性不强,需要一点一点构建xx.java的内容。

服务暴露与发现

服务暴露

名词解释

在Dubbo 的核心领域模型中:

  • Invoker 是实体域,它是Dubbo 的核心模型,其它模型都向它靠扰,或转换成它,它代表一个可执行体,可向它发起invoke 调用,它有可能是一个本地的实现,也可能是一个远程的实现,也可能一个集群实现。在服务提供方,Invoker用于调用服务提供类。在服务消费方,Invoker用于执行远程调用。
  • Protocol 是服务域,它是Invoker 暴露和引用的主功能入口,它负责Invoker 的生命周期管理。

    export:暴露远程服务

    refer:引用远程服务
  • proxyFactory:获取一个接口的代理类

    getInvoker:针对server端,将服务对象,如DemoServiceImpl包装成一个Invoker对象

    getProxy:针对client端,创建接口的代理对象,例如DemoService的接口。
  • Invocation 是会话域,它持有调用过程中的变量,比如方法名,参数等

整体流程

在详细探讨服务暴露细节之前 , 我们先看一下整体duubo的服务暴露原理

在整体上看,Dubbo 框架做服务暴露分为两大部分 , 第一步将持有的服务实例通过代理转换成Invoker, 第二步会把Invoker 通过具体的协议 ( 比如Dubbo ) 转换成Exporter, 框架做了这层抽象也大大方便了功能扩展 。

服务提供方暴露服务的蓝色初始化链,时序图如下:

源码分析

服务导出的入口方法是ServiceBean 的onApplicationEvent。onApplicationEvent 是一个事件响应方法,该方法会在收到Spring 上下文刷新事件后执行服务导出操作。方法代码如下:

  1. @Override
  2. public void onApplicationEvent(ContextRefreshedEvent event) {
  3. if (!isExported() && !isUnexported()) {
  4. if (logger.isInfoEnabled()) {
  5. logger.info("The service ready on spring started. service: " + getInterface());
  6. }
  7. export();
  8. }
  9. }

通过export最终找到doExportUrls()方法

  1. private void doExportUrls() {
  2. //加载配置文件中的所有注册中心,并且封装为dubbo内部的URL对象列表
  3. List<URL> registryURLs = loadRegistries(true);
  4. //循环所有协议配置,根据不同的协议,向注册中心中发起注册
  5. for (ProtocolConfig protocolConfig : protocols) {
  6. String pathKey = URL.buildKey(getContextPath(protocolConfig).map(p -> p + "/" + path).orElse(path), group, version);
  7. ProviderModel providerModel = new ProviderModel(pathKey, ref, interfaceClass);
  8. ApplicationModel.initProviderModel(pathKey, providerModel);
  9. //服务暴露方法
  10. doExportUrlsFor1Protocol(protocolConfig, registryURLs);
  11. }
  12. }

doExportUrlsFor1Protocol()方法代码老多了,我们只关系核心的地方

  1. ...
  2. if (!SCOPE_NONE.equalsIgnoreCase(scope)) {
  3. //本地暴露,将服务数据记录到本地JVM中
  4. if (!SCOPE_REMOTE.equalsIgnoreCase(scope)) {
  5. exportLocal(url);
  6. }
  7. //远程暴露,向注册中心发送数据
  8. if (!SCOPE_LOCAL.equalsIgnoreCase(scope)) {
  9. if (!isOnlyInJvm() && logger.isInfoEnabled()) {
  10. logger.info("Export dubbo service " + interfaceClass.getName() + " to url " + url);
  11. }
  12. if (CollectionUtils.isNotEmpty(registryURLs)) {
  13. for (URL registryURL : registryURLs) {
  14. //if protocol is only injvm ,not register
  15. if (LOCAL_PROTOCOL.equalsIgnoreCase(url.getProtocol())) {
  16. continue;
  17. }
  18. url = url.addParameterIfAbsent(DYNAMIC_KEY, registryURL.getParameter(DYNAMIC_KEY));
  19. URL monitorUrl = loadMonitor(registryURL);
  20. if (monitorUrl != null) {
  21. url = url.addParameterAndEncoded(MONITOR_KEY, monitorUrl.toFullString());
  22. }
  23. if (logger.isInfoEnabled()) {
  24. logger.info("Register dubbo service " + interfaceClass.getName() + " url " + url + " to registry " + registryURL);
  25. }
  26. // For providers, this is used to enable custom proxy to generate invoker
  27. String proxy = url.getParameter(PROXY_KEY);
  28. if (StringUtils.isNotEmpty(proxy)) {
  29. registryURL = registryURL.addParameter(PROXY_KEY, proxy);
  30. }
  31. // 为服务提供类(ref)生成 Invoker
  32. Invoker<?> invoker = proxyFactory.getInvoker(ref, (Class) interfaceClass, registryURL.addParameterAndEncoded(EXPORT_KEY, url.toFullString()));
  33. // DelegateProviderMetaDataInvoker 用于持有 Invoker 和ServiceConfig
  34. DelegateProviderMetaDataInvoker wrapperInvoker = new DelegateProviderMetaDataInvoker(invoker, this);
  35. // 导出服务,并生成 Exporter
  36. Exporter<?> exporter = protocol.export(wrapperInvoker);
  37. exporters.add(exporter);
  38. }
  39. } else {
  40. //不存在注册中心,仅导出服务
  41. ....
  42. }
  43. /**
  44. * @since 2.7.0
  45. * ServiceData Store
  46. */
  47. MetadataReportService metadataReportService = null;
  48. if ((metadataReportService = getMetadataReportService()) != null) {
  49. metadataReportService.publishProvider(url);
  50. }
  51. }
  52. }
  53. this.urls.add(url);

上面代码根据url 中的scope 参数决定服务导出方式,分别如下:

scope = none,不导出服务

scope != remote,导出到本地

scope != local,导出到远程

不管是导出到本地,还是远程。进行服务导出之前,均需要先创建Invoker,这是一个很重要的步骤。因此下面先来分析Invoker 的创建过程。Invoker 是由ProxyFactory 创建而来,Dubbo 默认的ProxyFactory 实现类是JavassistProxyFactory。下面我们到JavassistProxyFactory 代码中,探索Invoker 的创建过程。如下:

  1. @Override
  2. public <T> Invoker<T> getInvoker(T proxy, Class<T> type, URL url) {
  3. // 为目标类创建warpper
  4. final Wrapper wrapper = Wrapper.getWrapper(proxy.getClass().getName().indexOf('$') < 0 ? proxy.getClass() : type);
  5. //创建匿名才invoker对象,并实现doinvoke方法
  6. return new AbstractProxyInvoker<T>(proxy, type, url) {
  7. @Override
  8. protected Object doInvoke(T proxy, String methodName,
  9. Class<?>[] parameterTypes,
  10. Object[] arguments) throws Throwable {
  11. // 调用 Wrapper 的 invokeMethod 方法,invokeMethod 最终会调用目标方法
  12. return wrapper.invokeMethod(proxy, methodName, parameterTypes, arguments);
  13. }
  14. };
  15. }

Invoke创建成功之后,接下来我们来看本地导出

  1. /**
  2. * always export injvm
  3. */
  4. private void exportLocal(URL url) {
  5. URL local = URLBuilder.from(url)
  6. .setProtocol(LOCAL_PROTOCOL) // 设置协议头为 injvm
  7. .setHost(LOCALHOST_VALUE)//本地ip:127.0.0.1
  8. .setPort(0)
  9. .build();
  10. // 创建 Invoker,并导出服务,这里的 protocol 会在运行时调用 InjvmProtocol 的export 方法
  11. Exporter<?> exporter = protocol.export(
  12. proxyFactory.getInvoker(ref, (Class) interfaceClass, local));
  13. exporters.add(exporter);
  14. logger.info("Export dubbo service " + interfaceClass.getName() + " to local registry url : " + local);
  15. }

exportLocal 方法比较简单,首先根据URL 协议头决定是否导出服务。若需导出,则创建一个新的URL并将协议头、主机名以及端口设置成新的值。然后创建Invoker,并调用InjvmProtocol 的export 方法导出服务。下面我们来看一下InjvmProtocol 的export 方法都做了哪些事情。

  1. @Override
  2. public <T> Exporter<T> export(Invoker<T> invoker) throws RpcException {
  3. return new InjvmExporter<T>(invoker, invoker.getUrl().getServiceKey(), exporterMap);
  4. }

如上,InjvmProtocol 的export 方法仅创建了一个InjvmExporter,无其他逻辑。到此导出服务到本地就分析完了。

再看看导出服务到远程

接下来,我们继续分析导出服务到远程的过程。导出服务到远程包含了服务导出与服务注册两个过程。先来分析服务导出逻辑。我们把目光移动到RegistryProtocol 的export 方法上。

  1. @Override
  2. public <T> Exporter<T> export(final Invoker<T> originInvoker) throws RpcException {
  3. // 获取注册中心 URL
  4. URL registryUrl = getRegistryUrl(originInvoker);
  5. URL providerUrl = getProviderUrl(originInvoker);
  6. final URL overrideSubscribeUrl = getSubscribedOverrideUrl(providerUrl);
  7. final OverrideListener overrideSubscribeListener = new OverrideListener(overrideSubscribeUrl, originInvoker);
  8. overrideListeners.put(overrideSubscribeUrl, overrideSubscribeListener);
  9. providerUrl = overrideUrlWithConfig(providerUrl, overrideSubscribeListener);
  10. //导出服务
  11. final ExporterChangeableWrapper<T> exporter = doLocalExport(originInvoker, providerUrl);
  12. // 根据 URL 加载 Registry 实现类,比如 ZookeeperRegistry
  13. final Registry registry = getRegistry(originInvoker);
  14. //获取已注册的服务提供者 URL,
  15. final URL registeredProviderUrl = getRegisteredProviderUrl(providerUrl, registryUrl);
  16. ProviderInvokerWrapper<T> providerInvokerWrapper = ProviderConsumerRegTable.registerProvider(originInvoker,
  17. registryUrl, registeredProviderUrl);
  18. //to judge if we need to delay publish
  19. boolean register = registeredProviderUrl.getParameter("register", true);
  20. if (register) {
  21. // 向注册中心注册服务
  22. register(registryUrl, registeredProviderUrl);
  23. providerInvokerWrapper.setReg(true);
  24. }
  25. // 向注册中心进行订阅 override 数据
  26. registry.subscribe(overrideSubscribeUrl, overrideSubscribeListener);
  27. exporter.setRegisterUrl(registeredProviderUrl);
  28. exporter.setSubscribeUrl(overrideSubscribeUrl);
  29. // 创建并返回 DestroyableExporter
  30. return new DestroyableExporter<>(exporter);
  31. }

上面代码看起来比较复杂,主要做如下一些操作:

  1. 调用doLocalExport 导出服务
  2. 向注册中心注册服务
  3. 向注册中心进行订阅override 数据
  4. 创建并返回DestroyableExporter

看看doLocalExport 做了什么

  1. private <T> ExporterChangeableWrapper<T> doLocalExport(final Invoker<T> originInvoker, URL providerUrl) {
  2. String key = getCacheKey(originInvoker);
  3. return (ExporterChangeableWrapper<T>) bounds.computeIfAbsent(key, s -> {
  4. Invoker<?> invokerDelegate = new InvokerDelegate<>(originInvoker, providerUrl);
  5. //protocol和配置的协议相关(dubbo:DubboProtocol)
  6. return new ExporterChangeableWrapper<>((Exporter<T>) protocol.export(invokerDelegate), originInvoker);
  7. });
  8. }

接下来,我们把重点放在Protocol 的export 方法上。假设运行时协议为dubbo,此处的protocol 变量会在运行时加载DubboProtocol,并调用DubboProtocol 的export 方法。

  1. public <T> Exporter<T> export(Invoker<T> invoker) throws RpcException {
  2. URL url = invoker.getUrl();
  3. // export service.获取服务标识,理解成服务坐标也行。由服务组名,服务名,服务版本号以及端口组成。比如:demoGroup/com.alibaba.dubbo.demo.DemoService:1.0.1:20880
  4. String key = serviceKey(url);
  5. //创建DubboExporter
  6. DubboExporter<T> exporter = new DubboExporter<T>(invoker, key, exporterMap);
  7. exporterMap.put(key, exporter); //key:接口 (DemoService)
  8. //export an stub service for dispatching event
  9. Boolean isStubSupportEvent = url.getParameter(STUB_EVENT_KEY, DEFAULT_STUB_EVENT);
  10. Boolean isCallbackservice = url.getParameter(IS_CALLBACK_SERVICE, false);
  11. if (isStubSupportEvent && !isCallbackservice) {
  12. String stubServiceMethods = url.getParameter(STUB_EVENT_METHODS_KEY);
  13. if (stubServiceMethods == null || stubServiceMethods.length() == 0) {
  14. if (logger.isWarnEnabled()) {
  15. logger.warn(new IllegalStateException("consumer [" + url.getParameter(INTERFACE_KEY) +
  16. "], has set stubproxy support event ,but no stub methods founded."));
  17. }
  18. } else {
  19. stubServiceMethodsMap.put(url.getServiceKey(), stubServiceMethods);
  20. }
  21. }
  22. //启动服务
  23. openServer(url);
  24. //优化序列器
  25. optimizeSerialization(url);
  26. return exporter;
  27. }

如上,我们重点关注DubboExporter 的创建以及openServer 方法,其他逻辑看不懂也没关系,不影响理解服务导出过程。下面分析openServer 方法。

  1. private void openServer(URL url) {
  2. // find server.
  3. String key = url.getAddress();
  4. //client can export a service which's only for server to invoke
  5. boolean isServer = url.getParameter(IS_SERVER_KEY, true);
  6. if (isServer) {
  7. //访问缓存
  8. ExchangeServer server = serverMap.get(key);
  9. if (server == null) {
  10. synchronized (this) {
  11. server = serverMap.get(key);
  12. if (server == null) {
  13. //创建服务器实例
  14. serverMap.put(key, createServer(url));
  15. }
  16. }
  17. } else {
  18. // server supports reset, use together with override
  19. server.reset(url);
  20. }
  21. }
  22. }

接下来分析服务器实例的创建过程。如下

  1. private ExchangeServer createServer(URL url) {
  2. url = URLBuilder.from(url)
  3. // send readonly event when server closes, it's enabled by default
  4. .addParameterIfAbsent(CHANNEL_READONLYEVENT_SENT_KEY, Boolean.TRUE.toString())
  5. // enable heartbeat by default
  6. .addParameterIfAbsent(HEARTBEAT_KEY, String.valueOf(DEFAULT_HEARTBEAT))
  7. .addParameter(CODEC_KEY, DubboCodec.NAME)
  8. .build();
  9. String str = url.getParameter(SERVER_KEY, DEFAULT_REMOTING_SERVER);
  10. // 通过 SPI 检测是否存在 server 参数所代表的 Transporter 拓展,不存在则抛出异常
  11. if (str != null && str.length() > 0 && !ExtensionLoader.getExtensionLoader(Transporter.class).hasExtension(str)) {
  12. throw new RpcException("Unsupported server type: " + str + ", url: " + url);
  13. }
  14. ExchangeServer server;
  15. try {
  16. // 创建 ExchangeServer
  17. server = Exchangers.bind(url, requestHandler);
  18. } catch (RemotingException e) {
  19. throw new RpcException("Fail to start server(url: " + url + ") " + e.getMessage(), e);
  20. }
  21. // 获取 client 参数,可指定 netty,mina
  22. str = url.getParameter(CLIENT_KEY);
  23. if (str != null && str.length() > 0) {
  24. // 获取所有的 Transporter 实现类名称集合,比如 supportedTypes = [netty, mina]
  25. Set<String> supportedTypes = ExtensionLoader.getExtensionLoader(Transporter.class).getSupportedExtensions();
  26. // 检测当前 Dubbo 所支持的 Transporter 实现类名称列表中,
  27. // 是否包含 client 所表示的 Transporter,若不包含,则抛出异常
  28. if (!supportedTypes.contains(str)) {
  29. throw new RpcException("Unsupported client type: " + str);
  30. }
  31. }
  32. return server;
  33. }

如上,createServer 包含三个核心的逻辑。

第一是检测是否存在server 参数所代表的Transporter 拓展,不存在则抛出异常。

第二是创建服务器实例。

第三是检测是否支持client 参数所表示的Transporter 拓展,不存在也是抛出异常。两次检测操作所对应的代码较直白了,无需多说。但创建服务器的操作目前还不是很清晰,我们继续往下看。

  1. public static ExchangeServer bind(URL url, ExchangeHandler handler) throws RemotingException {
  2. if (url == null) {
  3. throw new IllegalArgumentException("url == null");
  4. }
  5. if (handler == null) {
  6. throw new IllegalArgumentException("handler == null");
  7. }
  8. url = url.addParameterIfAbsent(Constants.CODEC_KEY, "exchange");
  9. // 获取 Exchanger,默认为 HeaderExchanger。
  10. // 紧接着调用 HeaderExchanger 的 bind 方法创建 ExchangeServer 实例
  11. return getExchanger(url).bind(url, handler);
  12. }

上面代码比较简单,就不多说了。下面看一下HeaderExchanger 的bind 方法。

  1. public ExchangeServer bind(URL url, ExchangeHandler handler) throws RemotingException {
  2. // 创建 HeaderExchangeServer 实例,该方法包含了多个逻辑,分别如下:
  3. // 1. new HeaderExchangeHandler(handler)
  4. // 2. new DecodeHandler(new HeaderExchangeHandler(handler))
  5. // 3. Transporters.bind(url, new DecodeHandler(new
  6. HeaderExchangeHandler(handler)))
  7. return new HeaderExchangeServer(Transporters.bind(url, new ChannelHandler[]{new DecodeHandler(new HeaderExchangeHandler(handler))}));
  8. }

HeaderExchanger 的bind 方法包含的逻辑比较多,但目前我们仅需关心Transporters 的bind 方法逻

辑即可。该方法的代码如下:

  1. public static Server bind(URL url, ChannelHandler... handlers) throws RemotingException {
  2. if (url == null) {
  3. throw new IllegalArgumentException("url == null");
  4. } else if (handlers != null && handlers.length != 0) {
  5. Object handler;
  6. if (handlers.length == 1) {
  7. handler = handlers[0];
  8. } else {
  9. // 如果 handlers 元素数量大于1,则创建 ChannelHandler 分发器
  10. handler = new ChannelHandlerDispatcher(handlers);
  11. }
  12. // 获取自适应 Transporter 实例,并调用实例方法
  13. return getTransporter().bind(url, (ChannelHandler)handler);
  14. } else {
  15. throw new IllegalArgumentException("handlers == null");
  16. }
  17. }

如上,getTransporter() 方法获取的Transporter 是在运行时动态创建的,类名为TransporterAdaptive,也就是自适应拓展类。TransporterAdaptive 会在运行时根据传入的URL 参数决定加载什么类型的Transporter,默认为NettyTransporter。调用 NettyTransporter.bind(URL,ChannelHandler) 方法。创建一个 NettyServer 实例。调用 NettyServer.doOPen() 方法,服务器被开启,服务也被暴露出来了。

服务注册

本节内容以Zookeeper 注册中心作为分析目标,其他类型注册中心大家可自行分析。下面从服务注册

的入口方法开始分析,我们把目光再次移到RegistryProtocol 的export 方法上。如下:

进入到register()方法

  1. public void register(URL registryUrl, URL registeredProviderUrl) {
  2. //获得注册中心实例
  3. Registry registry = registryFactory.getRegistry(registryUrl);
  4. //进行注册
  5. registry.register(registeredProviderUrl);
  6. }

看看getRegistry()方法

  1. @Override
  2. public Registry getRegistry(URL url) {
  3. url = URLBuilder.from(url)
  4. .setPath(RegistryService.class.getName())
  5. .addParameter(INTERFACE_KEY, RegistryService.class.getName())
  6. .removeParameters(EXPORT_KEY, REFER_KEY)
  7. .build();
  8. String key = url.toServiceStringWithoutResolving();
  9. // Lock the registry access process to ensure a single instance of the registry
  10. LOCK.lock();
  11. try {
  12. Registry registry = REGISTRIES.get(key);
  13. if (registry != null) {
  14. return registry;
  15. }
  16. //create registry by spi/ioc
  17. registry = createRegistry(url);
  18. if (registry == null) {
  19. throw new IllegalStateException("Can not create registry " + url);
  20. }
  21. REGISTRIES.put(key, registry);
  22. return registry;
  23. } finally {
  24. // Release the lock
  25. LOCK.unlock();
  26. }
  27. }

进入createRegistry()方法

  1. @Override
  2. public Registry createRegistry(URL url) {
  3. return new ZookeeperRegistry(url, zookeeperTransporter);
  4. }
  1. public ZookeeperRegistry(URL url, ZookeeperTransporter zookeeperTransporter) {
  2. super(url);
  3. if (url.isAnyHost()) {
  4. throw new IllegalStateException("registry address == null");
  5. }
  6. //// 获取组名,默认为 dubbo
  7. String group = url.getParameter(GROUP_KEY, DEFAULT_ROOT);
  8. if (!group.startsWith(PATH_SEPARATOR)) {
  9. group = PATH_SEPARATOR + group;
  10. }
  11. this.root = group;
  12. // 创建 Zookeeper 客户端,默认为 CuratorZookeeperTransporter
  13. zkClient = zookeeperTransporter.connect(url);
  14. // 添加状态监听器
  15. zkClient.addStateListener(state -> {
  16. if (state == StateListener.RECONNECTED) {
  17. try {
  18. recover();
  19. } catch (Exception e) {
  20. logger.error(e.getMessage(), e);
  21. }
  22. }
  23. });
  24. }

在上面的代码代码中,我们重点关注ZookeeperTransporter 的connect 方法调用,这个方法用于创建

Zookeeper 客户端。创建好Zookeeper 客户端,意味着注册中心的创建过程就结束了。

搞懂了服务注册的本质,那么接下来我们就可以去阅读服务注册的代码了。

  1. public void doRegister(URL url) {
  2. try {
  3. // 通过 Zookeeper 客户端创建节点,节点路径由 toUrlPath 方法生成,路径格式如下:
  4. // /${group}/${serviceInterface}/providers/${url}
  5. // 比如 /dubbo/org.apache.dubbo.DemoService/providers/dubbo%3A%2F%2F127.0.0.1......
  6. zkClient.create(toUrlPath(url), url.getParameter(DYNAMIC_KEY, true));
  7. } catch (Throwable e) {
  8. throw new RpcException("Failed to register " + url + " to zookeeper " + getUrl() + ", cause: " + e.getMessage(), e);
  9. }
  10. }
  1. @Override
  2. public void create(String path, boolean ephemeral) {
  3. if (!ephemeral) {
  4. // 如果要创建的节点类型非临时节点,那么这里要检测节点是否存在
  5. if (checkExists(path)) {
  6. return;
  7. }
  8. }
  9. int i = path.lastIndexOf('/');
  10. if (i > 0) {
  11. // 递归创建上一级路径
  12. create(path.substring(0, i), false);
  13. }
  14. // 根据 ephemeral 的值创建临时或持久节点
  15. if (ephemeral) {
  16. createEphemeral(path);
  17. } else {
  18. createPersistent(path);
  19. }
  20. }

好了,到此关于服务注册的过程就分析完了。整个过程可简单总结为:先创建注册中心实例,之后再通过注册中心实例注册服务。

总结

  1. 在有注册中心,需要注册提供者地址的情况下,ServiceConfig 解析出的URL 格式为:registry:// registry-host/org.apache.dubbo.registry.RegistryService?export=URL.encode("dubbo://service-host/{服务名}/{版本号}")
  2. 基于Dubbo SPI 的自适应机制,通过URL registry:// 协议头识别,就调用RegistryProtocol#export() 方法
  3. 将具体的服务类名,比如 DubboServiceRegistryImpl ,通过ProxyFactory 包装成Invoker 实例
  4. 调用doLocalExport 方法,使用DubboProtocol 将Invoker 转化为Exporter 实例,并打开Netty 服务端监听客户请求
  5. 创建Registry 实例,连接Zookeeper,并在服务节点下写入提供者的URL 地址,注册服务
  6. 向注册中心订阅override 数据,并返回一个Exporter 实例
  7. 根据URL 格式中的 "dubbo://service-host/{服务名}/{版本号}" 中协议头 dubbo:// 识别,调用DubboProtocol#export() 方法,开发服务端口
  8. RegistryProtocol#export() 返回的Exporter 实例存放到ServiceConfig 的 List<Exporter>exporters

Java进阶专题(二十六) 将近2万字的Dubbo原理解析,彻底搞懂dubbo的更多相关文章

  1. Java进阶专题(二十六) 数据库原理研究与优化

    前言 在一个大数据量的系统中,这些数据的存储.处理.搜索是一个非常棘手的问题. 比如存储问题:单台服务器的存储能力及数据处理能力都是有限的, 因此需要增加服务器, 搭建集群来存储海量数据. 读写性能问 ...

  2. Java进阶专题(二十) 消息中间件架构体系(2)-- RabbitMQ研究

    前言 接上文,这个继续介绍RabbitMQ,并理解其底层原理. 介绍 RabbitMQ是由erlang语言开发,基于AMQP(Advanced Message Queue 高级消息队列协议)协议实现的 ...

  3. Java进阶专题(二十二) 从零开始搭建一个微服务架构系统 (上)

    前言 "微服务"一词源于 Martin Fowler的名为 Microservices的,博文,可以在他的官方博客上找到http:/ /martinfowler . com/art ...

  4. Java进阶专题(二十五) 分布式锁原理与实现

    前言 ​ 现如今很多系统都会基于分布式或微服务思想完成对系统的架构设计.那么在这一个系统中,就会存在若干个微服务,而且服务间也会产生相互通信调用.那么既然产生了服务调用,就必然会存在服务调用延迟或失败 ...

  5. Java进阶专题(二十八) Service Mesh初体验

    前言 ​ ⽬前,微服务的架构⽅式在企业中得到了极⼤的发展,主要原因是其解决了传统的单体架构中存在的问题.当单体架构拆分成微服务架构就可以⾼枕⽆忧了吗? 显然不是的.微服务架构体系中同样也存在很多的挑战 ...

  6. Java进阶专题(二十七) 将近2万字的Dubbo原理解析,彻底搞懂dubbo (下)

    ...接上文 服务发现 服务发现流程 整体duubo的服务消费原理 Dubbo 框架做服务消费也分为两大部分 , 第一步通过持有远程服务实例生成Invoker,这个Invoker 在客户端是核心的远程 ...

  7. SpringBoot进阶教程(二十六)整合Redis之共享Session

    集群现在越来越常见,当我们项目搭建了集群,就会产生session共享问题.因为session是保存在服务器上面的.那么解决这一问题,大致有三个方案,1.通过nginx的负载均衡其中一种ip绑定来实现( ...

  8. Java开发学习(二十六)----SpringMVC返回响应结果

    SpringMVC接收到请求和数据后,进行了一些处理,当然这个处理可以是转发给Service,Service层再调用Dao层完成的,不管怎样,处理完以后,都需要将结果告知给用户. 比如:根据用户ID查 ...

  9. Java开发学习(二十八)----拦截器(Interceptor)详细解析

    一.拦截器概念 讲解拦截器的概念之前,我们先看一张图: (1)浏览器发送一个请求会先到Tomcat的web服务器 (2)Tomcat服务器接收到请求以后,会去判断请求的是静态资源还是动态资源 (3)如 ...

随机推荐

  1. Adaptive Threshold

    Adaptive Threshold 1. Otsu's Binarization: Using a discriminant analysis to partition the image into ...

  2. web online code editor All In One

    web online code editor All In One 在线代码编辑器 Monaco Editor 摩纳哥编辑器 ️ 22.1k The Monaco Editor is the code ...

  3. news of javascript

    news of javascript https://javascriptweekly.com/ https://javascriptweekly.com/issues https://www.inf ...

  4. NGK公链账本技术浅析

    NGK公链账本是一个去中心化加密账本,运行在分布式网络上.分布式账本是区块链技术中最重要的组成部分之一.NGK作为公链资产,在公链中起到桥梁作用,可以促进其他资产(法币.数字资产.股权以及实物资产)交 ...

  5. 08.手写KNN算法测试

    导入库 import numpy as np from sklearn import datasets import matplotlib.pyplot as plt 导入数据 iris = data ...

  6. 经典面试题:在浏览器地址栏输入一个 URL 后回车,背后发生了什么

    尽人事,听天命.博主东南大学硕士在读,热爱健身和篮球,乐于分享技术相关的所见所得,关注公众号 @ 飞天小牛肉,第一时间获取文章更新,成长的路上我们一起进步 本文已收录于 CS-Wiki(Gitee 官 ...

  7. DOM的理解

    https://www.cnblogs.com/djtang/p/11538420.html  dom的理解 https://blog.csdn.net/jiuqiyuliang/article/de ...

  8. Django Admin 配置和定制基本功能(基本二次开发配置)

    一 列表显示页面  1. list_display,列表时,定制显示的列 @admin.register(models.UserInfo) class UserAdmin(admin.ModelAdm ...

  9. Gc root 定义

    常说的GC(Garbage Collector) roots,特指的是垃圾收集器(Garbage Collector)的对象,GC会收集那些不是GC roots且没有被GC roots引用的对象.一个 ...

  10. Windows 环境下搭建 RocketMQ

    Apache 官网: http://rocketmq.apache.org/ RocketMQ 的 Github 地址: English:https://github.com/apache/rocke ...