Dobbo源码解析 - 图1

注册服务的过程

  1. ###加载注册中心链接
  2. //加载注册中心,用于链接,dubbo支持多注册中心
  3. //注册中心 <dubbo:registry address="zookeeper://127.0.0.1:2181"/>
  4. List<URL> registryURLs = ConfigValidationUtils.loadRegistries(this, true);
  6. //协议,可以暴露多协议，用,分开
  7. //dubbo 协议、端口号 <dubbo:protocol name="dubbo" port="2181"/>
  8. ProtocolConfig
  11. ###服务导出
  12. //解析配置
  13. Map<String, String> map = new HashMap<String, String>();
  14. "side" -> "provider"
  15. "metadata-type" -> "remote"
  16. "application" -> "family-provider"
  17. "release" -> ""
  18. "deprecated" -> "false"
  19. "dubbo" -> "2.0.2"
  20. "pid" -> "9812"
  21. "dynamic" -> "true"
  22. "interface" -> "org.apache.dubbo.service.EsProductService"
  23. "generic" -> "false"
  24. "timestamp" -> "1591705088689"
  26. //封装成URL dubbo协议、端口、
  27. //dubbo://192.168.56.1:20880/org.apache.dubbo.service.EsProductService?
  28. //anyhost=true&application=family-provider&
  29. //bind.ip=192.168.56.1&bind.port=20880&deprecated=false&dubbo=2.0.2&dynamic=true&generic=false&
  30. //interface=org.apache.dubbo.service.EsProductService&metadata-type=remote&
  31. //methods=searchPage&pid=11384&release=&side=provider&timestamp=1591706038181
  32. URL url = new URL(name, host, port, getContextPath(protocolConfig).map(p -> p + "/" + path).orElse(path), map);
  34. //创建invoker
  35. //ref服务实例对象、interfaceClass接口、url注册中心：将dubbo服务注册到添加中心
  36. //dubbo://192.168.56.1:20880/org.apache.dubbo.service.EsProductService?
  37. //anyhost=true&application=family-provider&bind.ip=192.168.56.1&
  38. //bind.port=20880&deprecated=false&dubbo=2.0.2&dynamic=true&generic=false&
  39. //interface=org.apache.dubbo.service.EsProductService&metadata-type=remote&
  40. //methods=searchPage&pid=5660&release=&side=provider&timestamp=1591708521903
  41. Invoker<?> invoker = PROXY_FACTORY.getInvoker(ref, (Class) interfaceClass, 
  42.                                               registryURL.addParameterAndEncoded(EXPORT_KEY, url.toFullString()));
  43. //建立通信
  44. Exporter<?> exporter = PROTOCOL.export(wrapperInvoker);
  46. //提供发现能力 RegistryProtocol
  47. //通过url 加载 Registery,建立链接 final Registry registry = getRegistry(originInvoker);
  48. //将url 注册 到（zk）远程 final URL registeredProviderUrl = getUrlToRegistry(providerUrl, registryUrl);
  49. //创建监听 监听对象：
  50. //final OverrideListener overrideSubscribeListener = new OverrideListener(overrideSubscribeUrl, originInvoker);
  51. //overrideListeners.put(overrideSubscribeUrl, overrideSubscribeListener);
  52. //向注册中心订阅
  53. //registry.subscribe(overrideSubscribeUrl, overrideSubscribeListener);
  54. public <T> Exporter<T> export(final Invoker<T> originInvoker);
  57. //服务暴露 DubboProtocol
  58. //将我们的Invoker对象 包装为 DubboExporter 对象
  59. //启动服务,创建Netty服务,此时启动了一个IP+Port的Netty服务,可以提供远程服务调用的能力
  60. public <T> Exporter<T> export(Invoker<T> invoker);
  61. ###以上代码只是提供了一个（IP+PORT+Bean+Method）服务,但是这时候消费端是不知道有这么一个服务的

RegistryProtocol

  1. @Override
  2. public <T> Exporter<T> export(final Invoker<T> originInvoker) throws RpcException {
  3.     URL registryUrl = getRegistryUrl(originInvoker);
  4.     // url to export locally
  5.     URL providerUrl = getProviderUrl(originInvoker);
  7.     // 订阅override数据
  8.     // FIXME 提供者订阅时，会影响同一JVM即暴露服务，又引用同一服务的的场景，
  9.     // 因为subscribed以服务名为缓存的key，导致订阅信息覆盖。
  10.     final URL overrideSubscribeUrl = getSubscribedOverrideUrl(providerUrl);
  11.     final OverrideListener overrideSubscribeListener = new OverrideListener(overrideSubscribeUrl, originInvoker);
  12.     overrideListeners.put(overrideSubscribeUrl, overrideSubscribeListener);
  14.     providerUrl = overrideUrlWithConfig(providerUrl, overrideSubscribeListener);
  15.     // 在本地暴露服务
  16.     final ExporterChangeableWrapper<T> exporter = doLocalExport(originInvoker, providerUrl);
  18.     //registry provider
  19.     // 拿到zookeeper的注册信息
  20.     final Registry registry = getRegistry(originInvoker);
  21.     // 获取需要暴露provider的url对象，dubbo的注册订阅通信都是以url作为参数传递的
  22.     final URL registeredProviderUrl = getUrlToRegistry(providerUrl, registryUrl);
  24.     // decide if we need to delay publish
  25.     boolean register = providerUrl.getParameter(REGISTER_KEY, true);
  26.     if (register) {
  27.         //注册服务到注册中心zooker
  28.         register(registryUrl, registeredProviderUrl);
  29.     }
  31.     // register stated url on provider model
  32.     registerStatedUrl(registryUrl, registeredProviderUrl, register);
  34.     // 暴露的同时订阅服务，另外会在zk上创建configurators节点信息
  35.     registry.subscribe(overrideSubscribeUrl, overrideSubscribeListener);
  37.     exporter.setRegisterUrl(registeredProviderUrl);
  38.     exporter.setSubscribeUrl(overrideSubscribeUrl);
  40.     notifyExport(exporter);
  41.     //保证每次export都返回一个新的exporter实例
  42.     return new DestroyableExporter<>(exporter);
  43. }

DubboProtocol

  1. @Override
  2. public <T> Exporter<T> export(Invoker<T> invoker) throws RpcException {
  3.     URL url = invoker.getUrl();
  5.     // export service.
  6.     String key = serviceKey(url);
  7.     DubboExporter<T> exporter = new DubboExporter<T>(invoker, key, exporterMap);
  8.     exporterMap.put(key, exporter);
  10.     // 这里会判断是否是stub服务,默认false
  11.     Boolean isStubSupportEvent = url.getParameter(STUB_EVENT_KEY, DEFAULT_STUB_EVENT);
  12.     // 判断是否是callback服务
  13.     Boolean isCallbackservice = url.getParameter(IS_CALLBACK_SERVICE, false);
  14.     if (isStubSupportEvent && !isCallbackservice) {
  15.         String stubServiceMethods = url.getParameter(STUB_EVENT_METHODS_KEY);
  16.         if (stubServiceMethods == null || stubServiceMethods.length() == 0) {
  17.             if (logger.isWarnEnabled()) {
  18.                 logger.warn(new IllegalStateException("consumer [" + url.getParameter(INTERFACE_KEY) +
  19.                                                       "], has set stubproxy support event ,but no stub methods founded."));
  20.             }
  22.         }
  23.     }
  24.     // 开启Netty服务
  25.     openServer(url);
  26.     optimizeSerialization(url);
  28.     return exporter;
  29. }
  1. 服务暴露
  2.     将xxxService这个实例对象转换成AbstractProxyInvoker
  3.     将Invoker对象 包装为 DobboExporter
  4.     创建Transporter
  5.     创建Server(NettyServer)
  7. 服务注册
  8.     连接Zookeeper
  9.     创建Provier下的临时节点（绑定服务器节点的URL）
  10.     监听Zookeeper的configurators节点

RPC原理

为什么要用Dubbo

1.各个应用节点中的url管理维护困难、依赖关系很模糊 -注册中心
2.每个应用节点的性能、并发量、响应时间、没办法评估 -监控中心

protocol 协议

webservice、Thrift、hessain、http、dubbo、rmi

发布服务

dubbo【协议】://ip:20880【端口】/com.xxx.provider.service.xxxService【接口名称】?参数【服务端配置】

URL

  1. dubbo://192.168.56.1:20880/com.city.service.DemoService?
  2. anyhost=true&
  3. application=hello-world-app&
  4. bind.ip=192.168.56.1&
  5. bind.port=20880&
  6. dubbo=2.6.0&
  7. generic=false&
  8. interface=com.city.service.DemoService&methods=sayHello&
  9. pid=11508&
  10. side=provider&
  11. timestamp=1591614320441

配置参数

  1. 发布服务参数介绍
  2. dubbo.application.name = 提供方应用信息，用于计算依赖关系
  3. dubbo.registry.address = 注册中心,N/A表示不使用注册中心
  5. dubbo.protocol.name = 使用的协议
  6. dubbo.protocol.port = 端口号
  8. dubbo.service.interface = 提供服务的接口名称
  9. dubbo.service.ref = 服务的引用实现

zk节点

  1. zk 存放节点路径
  3. /dubbo/com.city.common.service.EsProductService/configurators
  4. /dubbo/com.city.common.service.EsProductService/providers
  5. providers 下面挂着url
  7. 临时节点:url
  8. 持久化节点：/dubbo/com.city.common.service.EsProductService/providers
  9.            /dubbo/com.city.common.service.EsProductService/configurators

调用服务

  1. 基于spring 配置文件拓展
  2. NamespaceHander 注册BeanDefinitonParser,利用它来解析
  3. BeanDefintionParser 解析配置文件元素
  5. spring 默认加载jar 包下/META-INF/spring.handlers 找到对象的NamespaceHander
  7. ServiceConfig<T> implements 
  8. InitializingBean, 当spring容器初始化完后,会调用afterPropertiesSet方法
  9. DisposableBean, 当容器被销毁的时候会调用destroy方法
  10. ApplicationContextAware, spring容器初始化以后主动注入ApplicationContext对象
  11. BeanNameAware, 获取bean本身id属性
  12. ApplicationEventPublisherAware 事件通知

Dobbo源码解析 - 图2