Dubbo源码深度解析(三)

weixin_lizhao

已于 2024-08-14 17:51:26 修改

阅读量592

点赞数 26

文章标签： dubbo java spring 后端网络

于 2024-08-07 18:02:54 首次发布

本文链接：https://blog.csdn.net/weixin_41338970/article/details/140956716

版权

接上篇博客《Dubbo源码深度解析(二)》继续讲。上篇博客主要讲的是Dubbo的SPI机制，以及Dubbo启动流程的初始化中的部分方法，本篇博客将继续讲剩下的方法。先看看初始化方法中剩下的几个方法，如下：

③ DubboBootstrap#loadRemoteConfigs()方法：

这两个方法，就是从配置中心获取的配置中，找出前缀为：dubbo.registries. 和 dubbo.protocols. ，如果你没有配置，那请忽略，如果你配置了，当然可以获取到，并保存起来，保存逻辑为：

可以知道，最终所有属性都是配置在ConfigManager的configsCache属性中。断点看看结果：

但是断点中看到的结果，为什么key为registry和protocol的不止一个呢？因为我在配置中心的dubbo.properties做了修改，修改如下：

这是为了测试前面说的前缀为 dubbo.registries. 和 dubbo.protocols. 的情况，说白了就是配置多个注册中心和多个协议，这是Dubbo支持的。当然，仅仅在配置中心这样配置还不够，因为这里涉及到了hessian协议，需要在service-provider模块中引入相关的依赖，如下：

        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo-rpc-hessian</artifactId>
            <version>2.7.10</version>
        </dependency>

dubbo协议的依赖我在之前已经引入了，因此无需添加它的依赖。同时，由于在配置中心中灵配置了另一个nacos配置中心的地址，因此需要再开一个nacos服务，端口为：8849，Idea配置如下：

重新启动服务提供方，发现在两个nacos服务上，在服务管理>服务列表，都可以查到，服务提供方的服务，先看看端口是8848的nacos服务，如下：

查看详情，结果为：

再看看端口是8849的nacos服务，如下：

查看详情，结果为：

我发现，当前版本的Dubbo，如果使用hessian协议的话，服务无法使用netty4？看了下HessianProtocol，发现绑定服务的是这个属性，代码如下：

只能使用Jetty、Tomcat或者Servlet，看看接口全限定名的文件，也是如此，如下：

那我们现在测一下，由于添加了hessian协议，因此在service-comsumer模块中也要加相关依赖，如下：

 <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo-rpc-hessian</artifactId>
            <version>2.7.10</version>
        </dependency>

然后指定要使用的协议，再启动服务消费方，调用一个对外暴露的接口：http://localhost:9000/hello/getName/Tim，结果如下：

如果使用dubbo协议呢？跟上面类似，如下：

虽然是报500，原因是我断点导致的超时，不打断点正常调用，是没问题的。至于为什么会调用到这里来，后面详细讲，因为这才是我要讲的重点。

④ DubboBootstrap#checkGlobalConfigs()方法，校验的逻辑，非核心流程，跳过。

⑤ DubboBootstrap#startMetadataCenter()方法：

说白了就是获取元数据的配置信息，通过调用MetadataReportFactory#getMetadataReport()方法，获取MetadataReport对象，并放入MetadataReportInstance的静态属性metadataReports，缓存起来，供后续使用。

元数据中心是dubbo2.7版本之后新增的功能，主要是为了减轻注册中心的压力，将部分存储在注册中心的内容放到元数据中心。元数据中心的数据只是给自己使用的，改动不需要告知对端，比如服务端修改了元数据，不需要通知消费端。这样注册中心存储的数据减少，同时大大降低了因为配置修改导致注册中心频繁通知监听者，从而大大减轻注册中心的压力。因此也可以在元数据中配置注册中心中心。当然要看到其效果，要先注释掉注册中心相关的配置，代码如下：

除此之外，还要加上依赖，如下：

        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo-metadata-report-nacos</artifactId>
            <version>2.7.10</version>
        </dependency>

然后启动服务提供方服务，看看结果：

⑥ DubboBootstrap#startMetadataCenter()方法：

⑦ DubboBootstrap#initEventListener()方法：

到这里为止，DubboBootstrap#initialize()方法算是讲完了，回到DubboBootstrap#start()方法，代码如下：

再看看DubboBootstrap#exportServices()方法，代码如下：

从ConfigManager中取出所有ServiceConfigBase对象，也就是ServiceBean，看看类的继承层级：

ServiceBean是什么时候被放入ConfigManager中的呢？也就是我前面说的，在这里被放入的，代码如下：

回到DubboBootstrap#exportServices()方法，遍历获取到的所有ServiceConfig，调用ServiceConfig#export()方法，代码如下：

看看ServiceConfig#checkAndUpdateSubConfigs()方法，代码如下(代码较长，只截取核心)：

到这里为止，已经给ServiceConfig对象设置好了协议的配置和注册中心的配置，这部分配置也是我在DubboConfiguration中配置好了。当然也包括接口，也设置好了，主要是通过interfaceName属性，基于类加载器加载并设置的，而interfaceName属性也是之前在ServiceClassPostProcessor中设置的，具体代码为：

再看看ServiceBean的 ref属性是如何赋值的，这就需要回到ServiceClassPostProcessor#buildServiceBeanDefinition()方法，代码如下：

重点就是给ref设置的属性为RuntimeBeanReference对象，并且名字为“helloServiceImpl”，RuntimeBeanReference是Spring提供的，最终给ref属性注入的对象那个肯定不是RuntimeBeanReference，而是在这里做了处理，代码如下(Spring属性注入的部分源码)：

有这个调用链路可知，最终获取的是RuntimeBeanReference的beanName，通过beanName从Spring容器中拿到HelloServiceImpl对象，通过反射，赋值给ServiceBean的ref属性。打断点看看，结果如下：

重点来了，也就是ServiceConfig#doExport()方法，代码如下：

回到ServiceConfig#doExportUrls()方法，遍历所有的协议，代码如下：

如果我配置了，是这样的效果：

针对group、version，是可以起到隔离服务的作用的，比如version，如果服务提供方有多个结点的话，可以在服务消费方指定version，服务消费反感发起请求，就会@DubboReference上配置的version找对应的节点，如果找到的节点有多个的话，则会通过负载均衡找到一个节点。再看看ServiceRepository#registerService()方法，代码如下：

再看看ServiceConfig#doExportUrlsFor1Protocol()方法(核心)，代码如下(以打断点为主，涉及到的参数太多了，不可能一个个去看)：

private void doExportUrlsFor1Protocol(ProtocolConfig protocolConfig, List<URL> registryURLs) {
        String name = protocolConfig.getName();
        if (StringUtils.isEmpty(name)) {
            name = DUBBO;
        }
        // 将配置的参数设置到map中，没有配置的，设置默认值
        Map<String, String> map = new HashMap<String, String>();
        map.put(SIDE_KEY, PROVIDER_SIDE);

        ServiceConfig.appendRuntimeParameters(map);
        AbstractConfig.appendParameters(map, getMetrics());
        AbstractConfig.appendParameters(map, getApplication());
        AbstractConfig.appendParameters(map, getModule());
        // remove 'default.' prefix for configs from ProviderConfig
        // appendParameters(map, provider, Constants.DEFAULT_KEY);
        AbstractConfig.appendParameters(map, provider);
        AbstractConfig.appendParameters(map, protocolConfig);
        AbstractConfig.appendParameters(map, this);
        MetadataReportConfig metadataReportConfig = getMetadataReportConfig();
        if (metadataReportConfig != null && metadataReportConfig.isValid()) {
            map.putIfAbsent(METADATA_KEY, REMOTE_METADATA_STORAGE_TYPE);
        }
        if (CollectionUtils.isNotEmpty(getMethods())) {
            for (MethodConfig method : getMethods()) {
                AbstractConfig.appendParameters(map, method, method.getName());
                String retryKey = method.getName() + ".retry";
                if (map.containsKey(retryKey)) {
                    String retryValue = map.remove(retryKey);
                    if ("false".equals(retryValue)) {
                        map.put(method.getName() + ".retries", "0");
                    }
                }
                List<ArgumentConfig> arguments = method.getArguments();
                if (CollectionUtils.isNotEmpty(arguments)) {
                    for (ArgumentConfig argument : arguments) {
                        // convert argument type
                        if (argument.getType() != null && argument.getType().length() > 0) {
                            Method[] methods = interfaceClass.getMethods();
                            // visit all methods
                            if (methods.length > 0) {
                                for (int i = 0; i < methods.length; i++) {
                                    String methodName = methods[i].getName();
                                    // target the method, and get its signature
                                    if (methodName.equals(method.getName())) {
                                        Class<?>[] argtypes = methods[i].getParameterTypes();
                                        // one callback in the method
                                        if (argument.getIndex() != -1) {
                                            if (argtypes[argument.getIndex()].getName().equals(argument.getType())) {
                                                AbstractConfig.appendParameters(map, argument, method.getName() + "." + argument.getIndex());
                                            } else {
                                                throw new IllegalArgumentException("Argument config error : the index attribute and type attribute not match :index :" + argument.getIndex() + ", type:" + argument.getType());
                                            }
                                        } else {
                                            // multiple callbacks in the method
                                            for (int j = 0; j < argtypes.length; j++) {
                                                Class<?> argclazz = argtypes[j];
                                                if (argclazz.getName().equals(argument.getType())) {
                                                    AbstractConfig.appendParameters(map, argument, method.getName() + "." + j);
                                                    if (argument.getIndex() != -1 && argument.getIndex() != j) {
                                                        throw new IllegalArgumentException("Argument config error : the index attribute and type attribute not match :index :" + argument.getIndex() + ", type:" + argument.getType());
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        } else if (argument.getIndex() != -1) {
                            AbstractConfig.appendParameters(map, argument, method.getName() + "." + argument.getIndex());
                        } else {
                            throw new IllegalArgumentException("Argument config must set index or type attribute.eg: <dubbo:argument index='0' .../> or <dubbo:argument type=xxx .../>");
                        }

                    }
                }
            } // end of methods for
        }

        if (ProtocolUtils.isGeneric(generic)) {
            map.put(GENERIC_KEY, generic);
            map.put(METHODS_KEY, ANY_VALUE);
        } else {
            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)), ","));
            }
        }

        /**
         * Here the token value configured by the provider is used to assign the value to ServiceConfig#token
         */
        if (ConfigUtils.isEmpty(token) && provider != null) {
            token = provider.getToken();
        }

        if (!ConfigUtils.isEmpty(token)) {
            if (ConfigUtils.isDefault(token)) {
                map.put(TOKEN_KEY, UUID.randomUUID().toString());
            } else {
                map.put(TOKEN_KEY, token);
            }
        }
        //init serviceMetadata attachments
        serviceMetadata.getAttachments().putAll(map);

        // export service
        String host = findConfigedHosts(protocolConfig, registryURLs, map);  // 获取当前服务的ip地址
        Integer port = findConfigedPorts(protocolConfig, name, map);
        // dubbo://192.168.217.1:20880/com.szl.service.api.HelloService?anyhost=true&application=service-provider&bind.ip=192.168.217.1
        // &bind.port=20880&deprecated=false&dubbo=2.0.2&dynamic=true&generic=false&interface=com.szl.service.api.HelloService&methods=sayHello
        // &pid=5252&qos.enable=false&release=&server=netty4&side=provider&timestamp=1653840932266
        URL url = new URL(name, host, port, getContextPath(protocolConfig).map(p -> p + "/" + path).orElse(path), map);

        // You can customize Configurator to append extra parameters
        if (ExtensionLoader.getExtensionLoader(ConfiguratorFactory.class)
                .hasExtension(url.getProtocol())) {
            url = ExtensionLoader.getExtensionLoader(ConfiguratorFactory.class)
                    .getExtension(url.getProtocol()).getConfigurator(url).configure(url);
        }

        String scope = url.getParameter(SCOPE_KEY);
        // don't export when none is configured
        if (!SCOPE_NONE.equalsIgnoreCase(scope)) {

            // export to local if the config is not remote (export to remote only when config is remote)
            if (!SCOPE_REMOTE.equalsIgnoreCase(scope)) {
                exportLocal(url);
            }
            // export to remote if the config is not local (export to local only when config is local)
            if (!SCOPE_LOCAL.equalsIgnoreCase(scope)) {
                if (CollectionUtils.isNotEmpty(registryURLs)) {
                    for (URL registryURL : registryURLs) {
                        //if protocol is only injvm ,not register
                        if (LOCAL_PROTOCOL.equalsIgnoreCase(url.getProtocol())) {
                            continue;
                        }
                        url = url.addParameterIfAbsent(DYNAMIC_KEY, registryURL.getParameter(DYNAMIC_KEY));
                        URL monitorUrl = ConfigValidationUtils.loadMonitor(this, registryURL);
                        if (monitorUrl != null) {
                            url = url.addParameterAndEncoded(MONITOR_KEY, monitorUrl.toFullString());
                        }
                        if (logger.isInfoEnabled()) {
                            if (url.getParameter(REGISTER_KEY, true)) {
                                logger.info("Register dubbo service " + interfaceClass.getName() + " url " + url + " to registry " + registryURL);
                            } else {
                                logger.info("Export dubbo service " + interfaceClass.getName() + " to url " + url);
                            }
                        }

                        // For providers, this is used to enable custom proxy to generate invoker
                        String proxy = url.getParameter(PROXY_KEY);
                        if (StringUtils.isNotEmpty(proxy)) {
                            registryURL = registryURL.addParameter(PROXY_KEY, proxy);
                        }
                        // 生成 invoker对象
                        Invoker<?> invoker = PROXY_FACTORY.getInvoker(ref, (Class) interfaceClass, registryURL.addParameterAndEncoded(EXPORT_KEY, url.toFullString()));
                        DelegateProviderMetaDataInvoker wrapperInvoker = new DelegateProviderMetaDataInvoker(invoker, this);

                        Exporter<?> exporter = PROTOCOL.export(wrapperInvoker);
                        exporters.add(exporter);
                    }
                } else {
                    if (logger.isInfoEnabled()) {
                        logger.info("Export dubbo service " + interfaceClass.getName() + " to url " + url);
                    }
                    // 生成代理对象
                    Invoker<?> invoker = PROXY_FACTORY.getInvoker(ref, (Class) interfaceClass, url);
                    DelegateProviderMetaDataInvoker wrapperInvoker = new DelegateProviderMetaDataInvoker(invoker, this);

                    Exporter<?> exporter = PROTOCOL.export(wrapperInvoker);
                    exporters.add(exporter);
                }

                MetadataUtils.publishServiceDefinition(url);
            }
        }
        this.urls.add(url);
    }

我先给@DubboService注解添加以下信息，如下：

因此可以知道，如果不设置scope，则会暴露对外两个地址，一个是本地(测试用，无需调用远程服务)，使用的是"injvm"协议；一个是远程，默认使用的是"dubbo"协议；如果设置scope为“remote"，则默认只会使用"dubbo"协议；如果设置scope为“local"，则默认只会使用"injvm"协议；OK，继续往下看：

上图中漏了一点：在调用PROXY_FACTORY.getInvoker()方法中，又执行了：registryURL.addParameterAndEncoded(EXPORT_KEY, url.toFullString())方法，该方法就是将url进行编码，并将其加入到registryURL的export属性中，如下：

限于篇幅，先讲到这里，剩下的内容将在下一篇博客中继续讲解，如有错误，恳请指正，谢谢！下一篇博客地址为：《Dubbo源码深度解析(四)》

weixin_lizhao

关注

26
点赞
踩
11

收藏

觉得还不错? 一键收藏
0
评论
Dubbo源码深度解析(三)

针对group、version，是可以起到隔离服务的作用的，比如version，如果服务提供方有多个结点的话，可以在服务消费方指定version，服务消费反感发起请求，就会@DubboReference上配置的version找对应的节点，如果找到的节点有多个的话，则会通过负载均衡找到一个节点。因此可以知道，如果不设置scope，则会暴露对外两个地址，一个是本地(测试用，无需调用远程服务)，使用的是"injvm"协议；虽然是报500，原因是我断点导致的超时，不打断点正常调用，是没问题的。
复制链接

扫一扫