Dubbo基础（五）- Consumer的初始化过程A：配置读取及获取代理

最新推荐文章于 2024-04-22 08:30:00 发布
最新推荐文章于 2024-04-22 08:30:00 发布
阅读量997 收藏
点赞数 1
分类专栏： dubbo 文章标签： dubbo 中间件 消费者
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/anLA_/article/details/99660692
版权

前面花了三篇文章一起深入源码，分析了 Dubbo 服务提供者是如何 暴露服务的：

  1. 配置读取过程refresh过程
  2. 外部化配置初始化过程
  3. 服务暴露详解

Dubbo 是如何暴露一个服务呢？相信你读完上面三篇就懂了。

本文主要聚焦在配置读取以及代理对象获取，留下一个问题思考

  1. Consumer 在初始化过程中，会初始化哪些配置呢？

以上问题看完文章后相信大家就可以清楚，若有疑问，关注博主公众号：六点A君，回复标题获取最新答案><

示例

本篇主要讲解 Consumer，即消费者是如何运作的，还是以最开始的那个 例子代码作为 初始程序分析。
第一个例子 HelloDubbo

 ReferenceConfig<HelloService> reference = new ReferenceConfig<>();
        reference.setApplication(new ApplicationConfig("dubbo-consumer"));
        reference.setRegistry(new RegistryConfig("zookeeper://127.0.0.1:2181"));
        reference.setInterface(HelloService.class);
        HelloService service = reference.get();
        String message = service.hello("dubbo I am anla7856");
        System.out.println(message);

如上，开始使用一个 ReferenceConfig ，而后给它设置了 ApplicationConfig、RegistryConfig、interfaceClass 等，设置完之后，就调用
reference.get() 获取一个动态实例，而后直接像普通Java程序一样调用它的方法即可。

所以最重要的就是 ReferenceConfig的 get 方法，接下来透过源码，看看里面干了啥事。

ReferenceConfig 的 get

同样的，这也是一个 synchronized 修饰的方法，

    public synchronized T get() {
    // 检查配置
        checkAndUpdateSubConfigs();

        if (destroyed) {
            throw new IllegalStateException("The invoker of ReferenceConfig(" + url + ") has already destroyed!");
        }
        if (ref == null) {
            // 初始化
            init();
        }
        return ref;
    }

看看 checkAndUpdateSubConfigs 里面代码：

    public void checkAndUpdateSubConfigs() {
    // 检查 interfaceName 是否为空
        if (StringUtils.isEmpty(interfaceName)) {
            throw new IllegalStateException("<dubbo:reference interface=\"\" /> interface not allow null!");
        }
        // 在 completeCompoundConfigs 方法中设置 按照 配置优先级设置ReferenceConfig 的 application、module、registries、monitor 等参数
        completeCompoundConfigs();
        // 尝试加载 配置中心（ConfigCenter） 中数据，然后执行 剩下所有配置的 refresh 方法
        startConfigCenter();
        // 如果ConsumerConfig 不为空，那么就会初始一个默认的，并且刷新
        checkDefault();
        // 尝试刷新 ReferenceConfig
        this.refresh();
        // 判断是否为 泛化调用 generic ，如果是泛化调用，则会直接把 interfaceClass = GenericService.class，这样才不会发生类型转化错误
        // 如果不是 泛化调用，则会加载 当前传进来的 interfaceClass以及检查传入的方法（MethodConfig）是否在远程服务提供的接口里面。
        if (getGeneric() == null && getConsumer() != null) {
            setGeneric(getConsumer().getGeneric());
        }
        if (ProtocolUtils.isGeneric(getGeneric())) {
            interfaceClass = GenericService.class;
        } else {
            try {
                interfaceClass = Class.forName(interfaceName, true, Thread.currentThread()
                        .getContextClassLoader());
            } catch (ClassNotFoundException e) {
                throw new IllegalStateException(e.getMessage(), e);
            }
            checkInterfaceAndMethods(interfaceClass, methods);
        }
        // 检查 外部默认未见 地址，如果有配置则将配置加载进来，默认文件默认地址是可配置为 系统变量 dubbo.resolve.file 
        resolveFile();
        // 会去判断 ApplicationConfig 是否存在，不存在则会创建一个默认的 ApplicationConfig，然后会尝试设置 Dubbo 优雅关机的一些参数。
        checkApplication();
        // 检查是否 有 MetadataReportConfig， 没有则会默认创建一个。
        checkMetadataReport();
    }

在 checkAndUpdateSubConfigs 中是检查和初始化配置，里面包括 消费者涉及的包括ConfigCenter、ReferenceConfig等多个配置。

  1. 检查 interfaceName 是否为空
  2. 在 completeCompoundConfigs 方法中设置 按照 配置优先级设置ReferenceConfig 的 application、module、registries、monitor 等参数
  3. 在 startConfigCenter 中，尝试加载 配置中心（ConfigCenter） 中数据，然后执行 剩下所有配置的 refresh 方法
  4. 在 checkDefault 中，如果ConsumerConfig 不为空，那么就会初始一个默认的，并且刷新
  5. 调用 this.refresh尝试刷新 ReferenceConfig
  6. 判断是否为 泛化调用 generic ，如果是泛化调用，则会直接把 interfaceClass = GenericService.class，这样才不会发生类型转化错误
  7. 如果不是 泛化调用，则会加载 当前传进来的 interfaceClass以及检查传入的方法（MethodConfig）是否在远程服务提供的接口里面。
  8. resolveFile 检查 外部默认未见 地址，如果有配置则将配置加载进来，默认文件默认地址是可配置为 系统变量 dubbo.resolve.file
  9. checkApplication 会去判断 ApplicationConfig 是否存在，不存在则会创建一个默认的 ApplicationConfig，然后会尝试设置 Dubbo 优雅关机的一些参数。
  10. checkMetadataReport 则会检查是否 有 MetadataReportConfig， 没有则会默认创建一个。

其实具体这一段加载配置逻辑和 服务提供者 ServiceConfig 中基本一致，具体分析在服务提供者初始化博主已经给出了详细的分析：
可以去文章顶部直接点击查看即可。

init

过完了前期配置的初始化以及检查之后，就会进入 init方法，并且会把 对应的 ref 变量初始化。当然，ref 只是一个接口，多次执行get 仅仅会初始化一次 ref变量。

    private void init() {
    	// 初始化
        if (initialized) {
            return;
        }
        // 检查是否有 local 或者 stub方法，如果使得化，就去寻找并加载 interface+Local(Stub)，而后验证 Stub/Local 类与interface 类
        checkStubAndLocal(interfaceClass);
        // 检查 interface是否配置了 Mock功能，如果配置了 Mock ，则会根据相应的Mock 配置去初始化 MockInvoker，这是一个过滤器，
        // Dubbo里面第一个过滤器，在功能上直接决定了Dubbo 一些重要功能，Mock 就是一个例子。
        checkMock(interfaceClass);
        // 声明一个Map存下所有配置
        Map<String, String> map = new HashMap<String, String>();
		// 说明是 consumer 这边的
        map.put(SIDE_KEY, CONSUMER_SIDE);
		// 增加运行时信息，例如 dubbo 版本，以及 timestamp 等。
        appendRuntimeParameters(map);
        // 检查 是否为泛化调用
        if (!isGeneric()) {
            String revision = Version.getVersion(interfaceClass, version);
            if (revision != null && revision.length() > 0) {
                map.put(REVISION_KEY, revision);
            }
			
            String[] methods = Wrapper.getWrapper(interfaceClass).getMethodNames();
            if (methods.length == 0) {
                logger.warn("No method found in service interface " + interfaceClass.getName());
                map.put(METHODS_KEY, ANY_VALUE);
            } else {
                map.put(METHODS_KEY, StringUtils.join(new HashSet<String>(Arrays.asList(methods)), COMMA_SEPARATOR));
            }
        }
        // 设置 interface
        map.put(INTERFACE_KEY, interfaceName);
        // 设置metrics中参数
        appendParameters(map, metrics);
        // 设置application中参数
        appendParameters(map, application);
        // 设置module 中参数
        appendParameters(map, module);
        // 设置 consumer 中参数
        appendParameters(map, consumer);
        // 设置当前config， 即ReferenceConfig
        appendParameters(map, this);
        Map<String, Object> attributes = null;
        // 判断有否 retry 参数
        if (CollectionUtils.isNotEmpty(methods)) {
            attributes = new HashMap<String, Object>();
            for (MethodConfig methodConfig : methods) {
                appendParameters(map, methodConfig, methodConfig.getName());
                String retryKey = methodConfig.getName() + ".retry";
                if (map.containsKey(retryKey)) {
                    String retryValue = map.remove(retryKey);
                    if ("false".equals(retryValue)) {
                        map.put(methodConfig.getName() + ".retries", "0");
                    }
                }
                attributes.put(methodConfig.getName(), convertMethodConfig2AyncInfo(methodConfig));
            }
        }
		// 判断是否有DUBBO_IP_TO_REGISTRY参数，如果有，则判断该配置是否符合规范
        String hostToRegistry = ConfigUtils.getSystemProperty(DUBBO_IP_TO_REGISTRY);
        if (StringUtils.isEmpty(hostToRegistry)) {
            hostToRegistry = NetUtils.getLocalHost();
        } else if (isInvalidLocalHost(hostToRegistry)) {
            throw new IllegalArgumentException("Specified invalid registry ip from property:" + DUBBO_IP_TO_REGISTRY + ", value:" + hostToRegistry);
        }
        map.put(REGISTER_IP_KEY, hostToRegistry);
		// 创建一个代理对象
        ref = createProxy(map);
		// 构造一个 serviceKey
        String serviceKey = URL.buildKey(interfaceName, group, version);
        // 初始化一个ApplicationModel 对象
        ApplicationModel.initConsumerModel(serviceKey, buildConsumerModel(serviceKey, attributes));
        initialized = true;
    }

以上init方法逻辑如下：

  1. 检查是否已经初始化过了。
  2. 执行 checkStubAndLocal ，检查是否有 local 或者 stub 方法，如果使得化，就去寻找并加载 interface+Local(Stub)，而后验证 Stub/Local 类与interface 类。
  3. 执行checkMock ，检查 interface是否配置了 Mock功能，如果配置了 Mock ，则会根据相应的Mock 配置去初始化 MockInvoker，这是一个过滤器，Dubbo里面第一个过滤器，在功能上直接决定了Dubbo 一些重要功能，Mock 就是一个例子。
  4. 判断是否为 generic 泛化调用，是泛化调用则不做操作，不是则需要填充 版本 version，如果是方法级别暴露，则需要将需要的方法记录在map里面
  5. 填充其他一些信息，诸如application、module、metrics 等信息。
  6. 解析并填充 retries 参数。
  7. 如果配置了 DUBBO_IP_TO_REGISTRY ，则需要检查 这个所传参数合法性。
  8. 执行 createProxy ，构造一个 反射对象ref 。

createProxy

前期检查和设置完配置之后，就可以创建一个代理对象了。

    private T createProxy(Map<String, String> map) {
    	// 判断是否为 jvm应用 
        if (shouldJvmRefer(map)) {
        // 构造一个 127.0.0.1 的 url
            URL url = new URL(LOCAL_PROTOCOL, LOCALHOST_VALUE, 0, interfaceClass.getName()).addParameters(map);
            // 构造并初始乎一个 invoker
            invoker = REF_PROTOCOL.refer(interfaceClass, url);
            if (logger.isInfoEnabled()) {
                logger.info("Using injvm service " + interfaceClass.getName());
            }
        } else {
        // 清除当前urls内容，否则在 retry时候会再次加入到url中，导致OOM异常
            urls.clear(); // reference retry init will add url to urls, lead to OOM
            // 解析并分割 url中内容，如果有多个则需要将其拆分并放入到urls中
            if (url != null && url.length() > 0) { // user specified URL, could be peer-to-peer address, or register center's address.
                String[] us = SEMICOLON_SPLIT_PATTERN.split(url);
                if (us != null && us.length > 0) {
                    for (String u : us) {
                        URL url = URL.valueOf(u);
                        if (StringUtils.isEmpty(url.getPath())) {
                            url = url.setPath(interfaceName);
                        }
                        if (REGISTRY_PROTOCOL.equals(url.getProtocol())) {
                            urls.add(url.addParameterAndEncoded(REFER_KEY, StringUtils.toQueryString(map)));
                        } else {
                            urls.add(ClusterUtils.mergeUrl(url, map));
                        }
                    }
                }
            } else { 
            	// 尝试去 register's center 加载配置
                if (!LOCAL_PROTOCOL.equalsIgnoreCase(getProtocol())){
                // 检查注册中心，没有并新增，如果没有配置中心，则将配置中心初始化为配置中心
                    checkRegistry();
                    List<URL> us = loadRegistries(false);
                    if (CollectionUtils.isNotEmpty(us)) {
                        for (URL u : us) {
                            URL monitorUrl = loadMonitor(u);
                            if (monitorUrl != null) {
                                map.put(MONITOR_KEY, URL.encode(monitorUrl.toFullString()));
                            }
                            urls.add(u.addParameterAndEncoded(REFER_KEY, StringUtils.toQueryString(map)));
                        }
                    }
                    if (urls.isEmpty()) {
                        throw new IllegalStateException("No such any registry to reference " + interfaceName + " on the consumer " + NetUtils.getLocalHost() + " use dubbo version " + Version.getVersion() + ", please config <dubbo:registry address=\"...\" /> to your spring config.");
                    }
                }
            }

            if (urls.size() == 1) {
            // 如果url只有一个，则将 其初始化 invoker
                invoker = REF_PROTOCOL.refer(interfaceClass, urls.get(0));
            } else {
            // 如果有多个invoker，则需要将所有invokers给加入到 urls
                List<Invoker<?>> invokers = new ArrayList<Invoker<?>>();
                URL registryURL = null;
                for (URL url : urls) {
                    invokers.add(REF_PROTOCOL.refer(interfaceClass, url));
                    if (REGISTRY_PROTOCOL.equals(url.getProtocol())) {
                        registryURL = url; // use last registry url
                    }
                }
                if (registryURL != null) { // registry url is available
                    // 当 register's 的CLUSTER 可用，增加一个 RegistryAwareCluster
                    URL u = registryURL.addParameter(CLUSTER_KEY, RegistryAwareCluster.NAME);
                    // 此时包装顺序则为: RegistryAwareClusterInvoker(StaticDirectory) -> FailoverClusterInvoker(RegistryDirectory, will execute route) -> Invoker
                    invoker = CLUSTER.join(new StaticDirectory(u, invokers));
                } else { 
                	// 直接的invoker
                    invoker = CLUSTER.join(new StaticDirectory(invokers));
                }
            }
        }
		// 如果需要检查，则判断invoker是否可用
        if (shouldCheck() && !invoker.isAvailable()) {
            throw new IllegalStateException("Failed to check the status of the service " + interfaceName + ". No provider available for the service " + (group == null ? "" : group + "/") + interfaceName + (version == null ? "" : ":" + version) + " from the url " + invoker.getUrl() + " to the consumer " + NetUtils.getLocalHost() + " use dubbo version " + Version.getVersion());
        }
        if (logger.isInfoEnabled()) {
            logger.info("Refer dubbo service " + interfaceClass.getName() + " from url " + invoker.getUrl());
        }
        /**
         * @since 2.7.0
         * ServiceData Store
         */
         // 设置metadata report信息
        MetadataReportService metadataReportService = null;
        if ((metadataReportService = getMetadataReportService()) != null) {
            URL consumerURL = new URL(CONSUMER_PROTOCOL, map.remove(REGISTER_IP_KEY), 0, map.get(INTERFACE_KEY), map);
            metadataReportService.publishConsumer(consumerURL);
        }
        // create service proxy
        // 使用代理工厂创建一个代理，封装invoker 创建一个代理对象
        return (T) PROXY_FACTORY.getProxy(invoker);
    }

上面代码主要包括以下几个逻辑：

  1. 检查是否是 injvm 应用
  2. 将配置中的url直连的配置，全部解析并加入到 List 中备用
  3. 初始 url，并构造Invoker对象。并加入集群容错相关配置。
  4. 初始化 MetadataReportService信息
  5. 调用代理创建一个代理 对象
总结

本文主要介绍了Consumer 初始化的一些逻辑，包括：

  1. 检查并初始化 ReferenceConfig 中一些配置
  2. 使用代理工厂初始化 ref 对象

当然，Consumer 初始化过程和 Provider 初始化过程，在配置读取方面，十分类似，可能本文对一些初始化配置相关方法没有细究，因为这些都是可以从 前几篇 Provider初始化中读取。

下一篇文章将主要围绕调用来看，即当获取到了一个代理对象后，执行方法，又是以一种怎样的逻辑呢？
下一篇例子在本篇例子实例基础上，将启动多 Provider 实例进行研究。

觉得博主写的有用，不妨关注博主公众号: 六点A君。
哈哈哈，Dubbo小吃街不迷路：
在这里插入图片描述

6点A君
关注
专栏目录
realmeq参数配置详情_Dubbo配置参考手册之dubbo:consumer
weixin_33989935的博客
12-30 539
概述服务消费者缺省值配置，配置类为org.apache.dubbo.config.ConsumerConfig 。同时该标签为dubbo:reference标签的缺省值设置。dubbo:consumer标签一共支持18个属性，均为可选属性。属性详情timeout远程服务调用超时时间，单位毫秒。对应URL中的参数为default.timeout，int类型，缺省值为1000，属于性能调优类属性。re...
Java基础教程：dubbo源码解析-高可用集群
CZ-001的博客
09-19 216
为了避免单点故障，现在的应用通常至少会部署在两台服务器上，这样就组成了集群。集群就是单机的多实例，在多个服务器上部署多个服务，每个服务就是一个节点，部署N个节点，处理业务的能力就提升 N倍（大约），这些节点的集合就叫做集群。目前的管理控制台已经发布0.1版本，结构上采取了前后端分离的方式，前端使用Vue和Vuetify分别作为Javascript框架和UI框架，后端采用Spring Boot框架。既可以按照标准的Maven方式进行打包，部署，也可以采用前后端分离的部署方式，方便开发，功能上，目前具备了服务查
Dubbo消费者配置
wddblog的博客
03-27 544
如果在XML中配置了某项，那么dubbo.properties中的相应配置项将无效。在Dubbo框架中，消费者配置通常通过XML配置文件完成，如dubbo-consumer.xml。此外，你还可以在这里配置特定的消费者属性，如负载均衡策略、超时时间等。这包括注册中心的地址、协议等。：方法配置，用于为特定的服务方法指定配置信息。：协议配置，虽然这通常在服务提供者端配置，但在某些情况下，消费者端也可能需要指定协议信息。最后，确保你的消费者应用能够正确地加载这个配置文件，并启动Dubbo消费者来消费服务。
dubbo之服务消费者配置
wang0907的博客
12-02 3616
1：写在前面 在这篇文章 中我们分析了服务提供者配置的相关源码，本文一起来看下服务消费者配置相关的源码，还是看一个通过API 方式配置服务消费者的实例代码： public class ConsumerWithApiConfigMain { public static void main(String[] args) { // 当前应用配置 ApplicationConfig application = new ApplicationConfig();
Dubbo源码分析（二）：Dubbo之消费端（Consumer）
freedomwind2009的专栏
03-19 879
通观全部Dubbo代码，有两个很重要的对象就是Invoker和Exporter，Dubbo会根据用户配置的协议调用不同协议的Invoker，再通过ReferenceFonfig将Invoker的引用关联到Reference的ref属性上提供给消费端调用。当用户调用一个Service接口的一个方法后由于Dubbo使用javassist动态代理，会调用Invoker的Invoke方法从而初始化一个RP
Dubbo 消费者配置及启动(二)
分享我的点点滴滴，在成长路上与你同行！
09-30 784
一、消费者简介    （1）服务消费者    （2）服务发现和接口代理    （3）负载均衡和服务容错策略 二、调用过程 三、应用类型    Java Application、Web应用    Maven: com.alibaba dubbo 2.5.5 四、配置消费者XML 五、my-provi
Java基础教程：dubbo源码解析-服务暴露与发现
CZ-001的博客
09-19 226
dubbo是一个简单易用的RPC框架，通过简单的提供者，消费者配置就能完成无感的网络调用。那么在dubbo中是如何将提供者的服务暴露出去，消费者又是如何获取到提供者相关信息的呢？这就是本章我们要讨论的内容。Dubbo 现在的设计是完全无侵入，也就是使用者只依赖于配置契约。在 Dubbo 中，可以使用 XML 配置相关信息，也可以用来引入服务或者导出服务。配置完成，启动工程，Spring 会读取配置文件，生成注入相关Bean。那 Dubbo 如何实现自定义 XML 被 Spring 加载读取呢？
【Dubbo】-- 服务引入原理分析
十年磨一剑，沉淀……
08-05 474
Dubbo-- 服务引入（启动阶段） 服务消费端应该做哪些事情 生成一个代理对象（帮我们实现网络通信的细节） 建立通信连接（netty） 从zk去获取目标地址（订阅节点的变化） 负载均衡 容错 mock降级策略 序列化 引用远程服务的两种方式： dubbo直连（开发，测试环境） 基于注册中心 重点分析通过注册中心引用服务的过程，主要包括从注册中心获取配置，Invoker创建，代理类创建...
dubbo2.0-源码阅读
01-03
在深入理解Dubbo源码之前，需要掌握一系列基础知识，这将有助于更好地理解Dubbo的设计与实现。 1. **Java语言编程**：熟悉Java语言的基本语法和面向对象特性，对于理解Dubbo中的各种类、接口以及方法非常重要。 2. ...
dubbo 配置 loadbalance 不生效？撸一把源码（csdn）————程序.pdf
12-01
`initLoadBalance`方法会根据invoker列表和invocation来初始化负载均衡器，它会通过`ExtensionLoader`获取指定方法的`loadbalance`策略。`getExtensionLoader`是Dubbo的SPI（Service Provider Interface）机制，用于...
dubbo中消费者配置文件
yinbucheng的博客
07-24 3285
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dubbo="http://code.alibabatech.com/schema/dubbo" xsi:schemaLocation="http://www.springframework.org/schema/beans         http://www.spring
Dubbo服务提供者和消费者配置
web13524385009的博客
09-06 1997
框架用户指南地址： http://dubbo.io/User+Guide-zh.htm#UserGuide-zh-%E8%83%8C%E6%99%AF。服务配置，用于暴露一个服务，定义服务的元信息，一个服务可以用多个协议暴露，一个服务也可以注册到多个注册中心。消费方缺省配置，当ReferenceConfig某属性没有配置时，采用此缺省值，可选。协议配置，用于配置提供服务的协议信息，协议由提供方指定，消费方被动接受。监控中心配置，用于配置连接监控中心相关信息，可选。模块配置，用于配置当前模块信息，可选。
dubbo ，dubbo-provider、dubbo-consumer 配置参数说明
m0_67391401的博客
08-14 1173
线程池队列大小，当线程池满时，排队等待执行的队列大小，建议不要设置，当线程程池时应立即失败，重试其它服务提供机器，而不是排队，除非有特殊需求。服务是否动态注册，如果设为false，注册后将显示后disable状态，需人工启用，并且服务提供者停止时，也不会自动取消册，需人工禁用。IO线程池，接收网络读写中断，以及序列化和反序列化，不处理业务，业务线程池参见threads配置，此线程池和CPU相关，不建议配置。dubbo协议缺省为hessian2，rmi协议缺省为java，http协议缺省为json。...
Dubbo配置文件解密：从dubbo-consumer.xml到dubbo-provider.xml一网打尽【十】
todoitbo的博客
01-19 806
本文将深入研究Dubbo中的配置文件，特别是消费者配置文件dubbo-consumer.xml和提供者配置文件dubbo-provider.xml。我们将解析它们的内部结构、关键属性和工作原理，帮助你更好地配置Dubbo服务，实现高性能的分布式应用。
Dubbo入门（三）Consumer的编写
jwang的博客
03-31 2007
前言 本章讲解dubbo中另外一个重要角色Consumer的编写 方法 1.概念 既然我们在上个章节创建了dubbo的服务提供者provider，那么必然是要有消费者进行消费的。 本章将根据dubbo流程图进一步探寻。 consumer可以是java工程也可以是web工程，本次使用java工程进行讲解。 2.编写步骤 1）新建maven的jar工程 2）编写...
dubbo注解式配置
m0_67393828的博客
04-01 432
1、pom依赖： com.alibaba.boot dubbo-spring-boot-starter 0.2.0 com.101tec zkclient 0.10 org.apache.zookeeper zookeeper 3.4.11 pom 复制代码 2、配置文件配置 #=Dubbo===== dubbo: application: name: dubbo-provider/dubbo-consumer registry: address: zookeeper://xx.xx.xx.xx:xx pr
Dubbo使用xml方式配置provider与consumer总结
weixin_44794056的博客
08-13 2225
Dubbo使用xml方式配置provider与consumer总结 zookeeper安装配置及dubbo-admin安装配置自行百度； springboot项目（使用注解方式可以自行百度）； 添加如下maven依赖 <dependency> <groupId>com.alibaba</groupId> <artifactId>dubbo</artifactId> <version>2.5.3</ver
Dubbo源码解读-Consumer调用流程解析
最新发布
胖墩儿没腹肌
04-22 2395
消费端依赖代理对象，代理调用的入口为MockClusterInvoker.invoke持有集群容错类Cluster,默认FailOverCluster。MockClusterInvoker实现了Mock调用的原理从Url上获取配置的mock信息如果没有mock走远程RPC。获取服务列表（订阅事件，服务列表本地缓存）获取负载均衡算法。抽象类AbstractClusterInvoker调用子类具体集群容错类的doInvoke（），实现远程服务调用。调用负载均衡算法选择一个Invoker.
For artifact {org.apache.dubbo:dubbo-spring-boot-starter:null:jar}: The version cannot be empty.
05-17
它表示 org.apache.dubbo:dubbo-spring-boot-starter 这个 artifact 的版本号为空。需要在 pom.xml 文件中指定该 artifact 的版本号。您可以尝试在 pom.xml 文件中添加如下的依赖项： ``` <groupId>org.apache....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值