Dubbo学习总结(九)dubbo服务引用

水深无声 2024-02-19 15:40 12阅读 0赞

**服务引用：**

spring在解析配置文件的时候将dubbo:reference标签解析成了ReferenceBean类，该类实现了InitializingBean与FactoryBean接口，并且实现了其中的方法，用户服务引用。 FactoryBean是spring中的工厂bean，通过实现getObject()方法获取IOC容器中的对象。

Dubbo 服务引用的时机有两个，第一个是在 Spring 容器调用 ReferenceBean 的 afterPropertiesSet 方法时引用服务，第二个是在 ReferenceBean 对应的服务被注入到其他类中时引用。这两个引用服务的时机区别在于，第一个是饿汉式的，第二个是懒汉式的。默认情况下，Dubbo 使用懒汉式引用服务。当服务被注入到其他类中时，Spring 会第一时间调用 getObject 方法，并由该方法执行服务引用逻辑。按照惯例，在进行具体工作之前，需先进行配置检查与收集工作。接着根据收集到的信息决定服务用的方式，有三种，第一种是引用本地 (JVM) 服务，第二是通过直联方式引用远程服务，第三是通过注册中心引用远程服务。不管是哪种引用方式，最后都会得到一个 Invoker 实例。为了暴露该实例，需要通过代理工厂类 (ProxyFactory) 为服务接口生成代理类，并让代理类去调用 Invoker 逻辑。

往spring容器中注入该服务对象。ReferenceBean 对应的服务被注入到其他类中时引用。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU0OTU3OA_size_16_color_FFFFFF_t_70][]

![20190110093342432.png][]

项目启动的时候调用getObject进行服务引用。

public Object getObject() throws Exception {
        return get();
    }
    
    public synchronized T get() {
        if (destroyed) {
            throw new IllegalStateException("Already destroyed!");
        }
        // 检测 ref 是否为空，为空则通过 init 方法创建
        if (ref == null) {
            // init 方法主要用于处理配置，以及调用 createProxy 生成代理类
            init();
        }
        return ref;
    }

执行init()方法：

private void init() {
             
             。。。。。各种检查。。。。。。。
    		// // 存储 attributes 到系统上下文中
            StaticContext.getSystemContext().putAll(attributes);
    		// 创建代理类
            ref = createProxy(map);
    		// 根据服务名，ReferenceConfig，代理类构建 ConsumerModel，
          // 并将 ConsumerModel 存入到 ApplicationModel 中
            ConsumerModel consumerModel = new ConsumerModel(getUniqueServiceName(), this, ref, interfaceClass.getMethods());
            ApplicationModel.initConsumerModel(getUniqueServiceName(), consumerModel);
        }
    
        @SuppressWarnings({"unchecked", "rawtypes", "deprecation"})
        private T createProxy(Map<String, String> map) {
            URL tmpUrl = new URL("temp", "localhost", 0, map);
            final boolean isJvmRefer;
            if (isInjvm() == null) {
    		     // url 配置被指定，则不做本地引用
                if (url != null && url.length() > 0) {   
    			// 根据 url 的协议、scope 以及 injvm 等参数检测是否需要本地引用
                 // 比如如果用户显式配置了 scope=local，此时 isInjvmRefer 返回 true
                    isJvmRefer = false;
                } else {
                    // by default, reference local service if there is
                    isJvmRefer = InjvmProtocol.getInjvmProtocol().isInjvmRefer(tmpUrl);
                }
            } else {
    		   // 获取 injvm 配置值
                isJvmRefer = isInjvm();
            }
             // 本地引用
            if (isJvmRefer) {
    		    // 生成本地引用 URL，协议为 injvm
                URL url = new URL(Constants.LOCAL_PROTOCOL, NetUtils.LOCALHOST, 0, interfaceClass.getName()).addParameters(map);
                invoker = refprotocol.refer(interfaceClass, url);// 调用 refer 方法构建 InjvmInvoker 实例
                if (logger.isInfoEnabled()) {
                    logger.info("Using injvm service " + interfaceClass.getName());
                }
    		// 远程引用	
            } else {
    		    //url 不为空，表明用户可能想进行点对点调用
                if (url != null && url.length() > 0) { // user specified URL, could be peer-to-peer address, or register center's address.
                    ..............
                } else {// 加载注册中心 url
                    List<URL> us = loadRegistries(false);
                    ..............
            }
            //创建 Invoker
                 //Invoker 是 Dubbo 的核心模型，代表一个可执行体。在服务提供方，Invoker 用于调用服务提供类。
                // 在服务消费方，Invoker 用于执行远程调用。Invoker 是由 Protocol 实现类构建而来。
                //最常用的两个，分别是 RegistryProtocol 和 DubboProtocol
                if (urls.size() == 1) {
                    invoker = refprotocol.refer(interfaceClass, urls.get(0));
                } else {
                    List<Invoker<?>> invokers = new ArrayList<Invoker<?>>();
                    URL registryURL = null;
                    for (URL url : urls) {
                        invokers.add(refprotocol.refer(interfaceClass, url));
                        if (Constants.REGISTRY_PROTOCOL.equals(url.getProtocol())) {
                            registryURL = url; // use last registry url
                        }
                    }
                    if (registryURL != null) { // registry url is available
                        // use AvailableCluster only when register's cluster is available
                        URL u = registryURL.addParameter(Constants.CLUSTER_KEY, AvailableCluster.NAME);
                        invoker = cluster.join(new StaticDirectory(u, invokers));
                    } else { // not a registry url
                        invoker = cluster.join(new StaticDirectory(invokers));
                    }
                }
            ......................
            // 生成代理类
            return (T) proxyFactory.getProxy(invoker);
        }

创建Invoker：在服务消费方，Invoker 用于执行远程调用。Invoker 是由 Protocol 实现类构建而来

DubboProtocol：

public <T> Invoker<T> refer(Class<T> serviceType, URL url) throws RpcException {
        optimizeSerialization(url);
        // 创建 DubboInvoker
        DubboInvoker<T> invoker = new DubboInvoker<T>(serviceType, url, getClients(url), invokers);
        invokers.add(invoker);
        return invoker;
    }

RegistryProtocol：

public <T> Invoker<T> refer(Class<T> type, URL url) throws RpcException {
        // 取 registry 参数值，并将其设置为协议头
        url = url.setProtocol(url.getParameter(Constants.REGISTRY_KEY, Constants.DEFAULT_REGISTRY)).removeParameter(Constants.REGISTRY_KEY);
        // 获取注册中心实例
        Registry registry = registryFactory.getRegistry(url);
        if (RegistryService.class.equals(type)) {
            return proxyFactory.getInvoker((T) registry, type, url);
        }
    
        // 将 url 查询字符串转为 Map
        Map<String, String> qs = StringUtils.parseQueryString(url.getParameterAndDecoded(Constants.REFER_KEY));
        // 获取 group 配置
        String group = qs.get(Constants.GROUP_KEY);
        if (group != null && group.length() > 0) {
            if ((Constants.COMMA_SPLIT_PATTERN.split(group)).length > 1
                    || "*".equals(group)) {
                // 通过 SPI 加载 MergeableCluster 实例，并调用 doRefer 继续执行服务引用逻辑
                return doRefer(getMergeableCluster(), registry, type, url);
            }
        }
        
        // 调用 doRefer 继续执行服务引用逻辑
        return doRefer(cluster, registry, type, url);
    }
    private <T> Invoker<T> doRefer(Cluster cluster, Registry registry, Class<T> type, URL url) {
        // 创建 RegistryDirectory 实例
        RegistryDirectory<T> directory = new RegistryDirectory<T>(type, url);
        // 设置注册中心和协议
        directory.setRegistry(registry);
        directory.setProtocol(protocol);
        Map<String, String> parameters = new HashMap<String, String>(directory.getUrl().getParameters());
        // 生成服务消费者链接
        URL subscribeUrl = new URL(Constants.CONSUMER_PROTOCOL, parameters.remove(Constants.REGISTER_IP_KEY), 0, type.getName(), parameters);
    
        // 注册服务消费者，在 consumers 目录下新节点
        if (!Constants.ANY_VALUE.equals(url.getServiceInterface())
                && url.getParameter(Constants.REGISTER_KEY, true)) {
            registry.register(subscribeUrl.addParameters(Constants.CATEGORY_KEY, Constants.CONSUMERS_CATEGORY,
                    Constants.CHECK_KEY, String.valueOf(false)));
        }
    
        // 订阅 providers、configurators、routers 等节点数据
        directory.subscribe(subscribeUrl.addParameter(Constants.CATEGORY_KEY,
                Constants.PROVIDERS_CATEGORY
                        + "," + Constants.CONFIGURATORS_CATEGORY
                        + "," + Constants.ROUTERS_CATEGORY));
    
        // 一个注册中心可能有多个服务提供者，因此这里需要将多个服务提供者合并为一个
        Invoker invoker = cluster.join(directory);
        ProviderConsumerRegTable.registerConsumer(invoker, url, subscribeUrl, directory);
        return invoker;
    }

首先程序在执行：

invoker = refprotocol.refer(interfaceClass, urls.get(0));

先进入RegistryProtocol的refer方法执行订阅服务，同时进入DubboProtocol。

directory.subscribe(subscribeUrl.addParameter(Constants.CATEGORY_KEY,
                    Constants.PROVIDERS_CATEGORY
                            + "," + Constants.CONFIGURATORS_CATEGORY
                            + "," + Constants.ROUTERS_CATEGORY));

DubboProtocol执行getClients(url)与服务提供者建立连接。

DubboInvoker<T> invoker = new DubboInvoker<T>(serviceType, url, getClients(url), invokers);

经过层层包装，最终返回Invoker 对象，该对象包含了服务调用者调用的真正对象，也就是接口实现者相关数据。

并且将保存其关联关系：

ProviderConsumerRegTable.registerConsumer(invoker, url, subscribeUrl, directory);

![20190110112350392.png][]

创建代理对象完成：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU0OTU3OA_size_16_color_FFFFFF_t_70 1][]

流程总结：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU0OTU3OA_size_16_color_FFFFFF_t_70 2][]

调试代码：[点击][Link 1]

参考来源：[http://dubbo.apache.org/zh-cn/docs/user/configuration/xml.html][http_dubbo.apache.org_zh-cn_docs_user_configuration_xml.html]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU0OTU3OA_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/29/e92cf5fdfa234eb88e96297c0104ab15.png
[20190110093342432.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/29/b405003301cd48df8a9a0fabaccdf7c1.png
[20190110112350392.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/29/ed68d4cf59fb4e428b4b37e8c42a475c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU0OTU3OA_size_16_color_FFFFFF_t_70 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/29/8e3de7bde889499d89b9104eab65f466.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU0OTU3OA_size_16_color_FFFFFF_t_70 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/29/6b5dd53959304a5badb96e20a1f6e1a9.png
[Link 1]: https://github.com/timeday/springboot-dubbo
[http_dubbo.apache.org_zh-cn_docs_user_configuration_xml.html]: http://dubbo.apache.org/zh-cn/docs/user/configuration/xml.html