Dubbo源码学习--服务引用

痛定思痛。 2022-05-27 01:22 242阅读 0赞

服务引用是服务的消费者向注册中心订阅服务提供者的消息，根据java的接口编程获取代理接口远程调用服务提供者。

<dubbo:application name="demo-consumer"/>
    
        
        <dubbo:registry address="zookeeper://127.0.0.1:2181"/>
    
        
        <dubbo:reference id="demoService" check="false" interface="com.alibaba.dubbo.demo.DemoService"/>

服务消费者配置如上配置，服务消费者初始化的Bean实体为ReferenceBean

![70][]

ReferenceBean除了继承了配置的抽象类来处理配置信息外，它还实现spring容器的一些接口，这里我们分析下FactoryBean, 首先它对于spring来说是个bean，参与Bean创建的所有生命周期，关键在于spring的bean工厂beanFactory.getBean(“demoService”)获取的bean的时候会判断下是不是FactoryBean的实例，如果是调factoryBean.getObject()返回，否则返回bean。

我们对于远程调用获取的demoService其实并不是想要ReferenceBean这个对象实例本身，我们是想获取对远程调用的代理，能够通过这个代理服务调用远程服务。这里就是通过factoryBean.getObject()来创建引用返回基于DemoService接口的代理给引用，对用户透明dubbo封装了复杂实现。

接下来我们对消费者的初始化流程通过代码来了解一下：

ReferenceBean在初始化的为bean的时候会调用afterPropertiesSet函数，在afterPropertiesSet中完成了消费者的一些配置的初始化操作

@SuppressWarnings({"unchecked"})
        public void afterPropertiesSet() throws Exception {
    		//获取consumer标签相关配置
            if (getConsumer() == null) {
                Map<String, ConsumerConfig> consumerConfigMap = applicationContext == null ? null : BeanFactoryUtils.beansOfTypeIncludingAncestors(applicationContext, ConsumerConfig.class, false, false);
                if (consumerConfigMap != null && consumerConfigMap.size() > 0) {
                    ConsumerConfig consumerConfig = null;
                    for (ConsumerConfig config : consumerConfigMap.values()) {
                        if (config.isDefault() == null || config.isDefault().booleanValue()) {
                            if (consumerConfig != null) {
                                throw new IllegalStateException("Duplicate consumer configs: " + consumerConfig + " and " + config);
                            }
                            consumerConfig = config;
                        }
                    }
                    if (consumerConfig != null) {
                        setConsumer(consumerConfig);
                    }
                }
            }
    		//获取application标签相关配置
            if (getApplication() == null
                    && (getConsumer() == null || getConsumer().getApplication() == null)) {
                Map<String, ApplicationConfig> applicationConfigMap = applicationContext == null ? null : BeanFactoryUtils.beansOfTypeIncludingAncestors(applicationContext, ApplicationConfig.class, false, false);
                if (applicationConfigMap != null && applicationConfigMap.size() > 0) {
                    ApplicationConfig applicationConfig = null;
                    for (ApplicationConfig config : applicationConfigMap.values()) {
                        if (config.isDefault() == null || config.isDefault().booleanValue()) {
                            if (applicationConfig != null) {
                                throw new IllegalStateException("Duplicate application configs: " + applicationConfig + " and " + config);
                            }
                            applicationConfig = config;
                        }
                    }
                    if (applicationConfig != null) {
                        setApplication(applicationConfig);
                    }
                }
            }
    		//获取module标签相关配置
            if (getModule() == null
                    && (getConsumer() == null || getConsumer().getModule() == null)) {
                Map<String, ModuleConfig> moduleConfigMap = applicationContext == null ? null : BeanFactoryUtils.beansOfTypeIncludingAncestors(applicationContext, ModuleConfig.class, false, false);
                if (moduleConfigMap != null && moduleConfigMap.size() > 0) {
                    ModuleConfig moduleConfig = null;
                    for (ModuleConfig config : moduleConfigMap.values()) {
                        if (config.isDefault() == null || config.isDefault().booleanValue()) {
                            if (moduleConfig != null) {
                                throw new IllegalStateException("Duplicate module configs: " + moduleConfig + " and " + config);
                            }
                            moduleConfig = config;
                        }
                    }
                    if (moduleConfig != null) {
                        setModule(moduleConfig);
                    }
                }
            }
    		//获取registry相关的标签配置
            if ((getRegistries() == null || getRegistries().isEmpty())
                    && (getConsumer() == null || getConsumer().getRegistries() == null || getConsumer().getRegistries().isEmpty())
                    && (getApplication() == null || getApplication().getRegistries() == null || getApplication().getRegistries().isEmpty())) {
                Map<String, RegistryConfig> registryConfigMap = applicationContext == null ? null : BeanFactoryUtils.beansOfTypeIncludingAncestors(applicationContext, RegistryConfig.class, false, false);
                if (registryConfigMap != null && registryConfigMap.size() > 0) {
                    List<RegistryConfig> registryConfigs = new ArrayList<RegistryConfig>();
                    for (RegistryConfig config : registryConfigMap.values()) {
                        if (config.isDefault() == null || config.isDefault().booleanValue()) {
                            registryConfigs.add(config);
                        }
                    }
                    if (registryConfigs != null && !registryConfigs.isEmpty()) {
                        super.setRegistries(registryConfigs);
                    }
                }
            }
    		//获取monitor相关的标签配置
            if (getMonitor() == null
                    && (getConsumer() == null || getConsumer().getMonitor() == null)
                    && (getApplication() == null || getApplication().getMonitor() == null)) {
                Map<String, MonitorConfig> monitorConfigMap = applicationContext == null ? null : BeanFactoryUtils.beansOfTypeIncludingAncestors(applicationContext, MonitorConfig.class, false, false);
                if (monitorConfigMap != null && monitorConfigMap.size() > 0) {
                    MonitorConfig monitorConfig = null;
                    for (MonitorConfig config : monitorConfigMap.values()) {
                        if (config.isDefault() == null || config.isDefault().booleanValue()) {
                            if (monitorConfig != null) {
                                throw new IllegalStateException("Duplicate monitor configs: " + monitorConfig + " and " + config);
                            }
                            monitorConfig = config;
                        }
                    }
                    if (monitorConfig != null) {
                        setMonitor(monitorConfig);
                    }
                }
            }
    		//如果配置了初始化，在ReferenceBean构造完成之后就初始化消费者
            Boolean b = isInit();
            if (b == null && getConsumer() != null) {
                b = getConsumer().isInit();
            }
            if (b != null && b.booleanValue()) {
                getObject();
            }
        }

在getObject中获取代理类

//获取代理类
      public Object getObject() throws Exception {
            return get();
        }

在get方法中会调用init函数，完成消费者代理类的初始化操作

public synchronized T get() {
            if (destroyed) {
                throw new IllegalStateException("Already destroyed!");
            }
    		//初始化消费者，
            if (ref == null) {
                init();
            }
            return ref;
        }

init方法中会初始化一些消费者相关的配置信息，在createProxy中完成消费者注册和订阅服务提供者，返回代理类

private void init() {
            if (initialized) {
                return;
            }
            initialized = true;
            if (interfaceName == null || interfaceName.length() == 0) {
                throw new IllegalStateException("<dubbo:reference interface=\"\" /> interface not allow null!");
            }
            // get consumer's global configuration
            checkDefault();
            appendProperties(this);
            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);
            }
            String resolve = System.getProperty(interfaceName);
            String resolveFile = null;
            if (resolve == null || resolve.length() == 0) {
                resolveFile = System.getProperty("dubbo.resolve.file");
                if (resolveFile == null || resolveFile.length() == 0) {
                    File userResolveFile = new File(new File(System.getProperty("user.home")), "dubbo-resolve.properties");
                    if (userResolveFile.exists()) {
                        resolveFile = userResolveFile.getAbsolutePath();
                    }
                }
                if (resolveFile != null && resolveFile.length() > 0) {
                    Properties properties = new Properties();
                    FileInputStream fis = null;
                    try {
                        fis = new FileInputStream(new File(resolveFile));
                        properties.load(fis);
                    } catch (IOException e) {
                        throw new IllegalStateException("Unload " + resolveFile + ", cause: " + e.getMessage(), e);
                    } finally {
                        try {
                            if (null != fis) fis.close();
                        } catch (IOException e) {
                            logger.warn(e.getMessage(), e);
                        }
                    }
                    resolve = properties.getProperty(interfaceName);
                }
            }
            if (resolve != null && resolve.length() > 0) {
                url = resolve;
                if (logger.isWarnEnabled()) {
                    if (resolveFile != null && resolveFile.length() > 0) {
                        logger.warn("Using default dubbo resolve file " + resolveFile + " replace " + interfaceName + "" + resolve + " to p2p invoke remote service.");
                    } else {
                        logger.warn("Using -D" + interfaceName + "=" + resolve + " to p2p invoke remote service.");
                    }
                }
            }
    		//消费者注册时的一些信息
            if (consumer != null) {
                if (application == null) {
                    application = consumer.getApplication();
                }
                if (module == null) {
                    module = consumer.getModule();
                }
                if (registries == null) {
                    registries = consumer.getRegistries();
                }
                if (monitor == null) {
                    monitor = consumer.getMonitor();
                }
            }
            if (module != null) {
                if (registries == null) {
                    registries = module.getRegistries();
                }
                if (monitor == null) {
                    monitor = module.getMonitor();
                }
            }
            if (application != null) {
                if (registries == null) {
                    registries = application.getRegistries();
                }
                if (monitor == null) {
                    monitor = application.getMonitor();
                }
            }
            checkApplication();
            checkStubAndMock(interfaceClass);
    		//将消费者的一些配置信息添加到map中
            Map<String, String> map = new HashMap<String, String>();
            Map<Object, Object> attributes = new HashMap<Object, Object>();
            map.put(Constants.SIDE_KEY, Constants.CONSUMER_SIDE);
            map.put(Constants.DUBBO_VERSION_KEY, Version.getVersion());
            map.put(Constants.TIMESTAMP_KEY, String.valueOf(System.currentTimeMillis()));
            if (ConfigUtils.getPid() > 0) {
                map.put(Constants.PID_KEY, String.valueOf(ConfigUtils.getPid()));
            }
            if (!isGeneric()) {
                String revision = Version.getVersion(interfaceClass, version);
                if (revision != null && revision.length() > 0) {
                    map.put("revision", revision);
                }
    
                String[] methods = Wrapper.getWrapper(interfaceClass).getMethodNames();
                if (methods.length == 0) {
                    logger.warn("NO method found in service interface " + interfaceClass.getName());
                    map.put("methods", Constants.ANY_VALUE);
                } else {
                    map.put("methods", StringUtils.join(new HashSet<String>(Arrays.asList(methods)), ","));
                }
            }
            map.put(Constants.INTERFACE_KEY, interfaceName);
            appendParameters(map, application);
            appendParameters(map, module);
            appendParameters(map, consumer, Constants.DEFAULT_KEY);
            appendParameters(map, this);
            String prefix = StringUtils.getServiceKey(map);
            if (methods != null && !methods.isEmpty()) {
                for (MethodConfig method : methods) {
                    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");
                        }
                    }
                    appendAttributes(attributes, method, prefix + "." + method.getName());
                    checkAndConvertImplicitConfig(method, map, attributes);
                }
            }
    
            String hostToRegistry = ConfigUtils.getSystemProperty(Constants.DUBBO_IP_TO_REGISTRY);
            if (hostToRegistry == null || hostToRegistry.length() == 0) {
                hostToRegistry = NetUtils.getLocalHost();
            } else if (isInvalidLocalHost(hostToRegistry)) {
                throw new IllegalArgumentException("Specified invalid registry ip from property:" + Constants.DUBBO_IP_TO_REGISTRY + ", value:" + hostToRegistry);
            }
            map.put(Constants.REGISTER_IP_KEY, hostToRegistry);
    
            //attributes are stored by system context.
            StaticContext.getSystemContext().putAll(attributes);
    		//根据消费者配置信息完成消费者代理类的初始化操作
            ref = createProxy(map);
            ConsumerModel consumerModel = new ConsumerModel(getUniqueServiceName(), this, ref, interfaceClass.getMethods());
            ApplicationModel.initConsumerModel(getUniqueServiceName(), consumerModel);
        }

在createProxy中首先根据消费者的相关配置将消费者添加到注册中心，并订阅相关通知，最终返回invoker调用者，将invoker包装成代理类返回到spring容器中

在createProxy中首先根据消费者的相关配置将消费者添加到注册中心，并订阅相关通知，最终返回invoker调用者，将invoker包装成代理类返回到spring容器中
     
     private T createProxy(Map<String, String> map) {
    		//获取消费者url信息
            URL tmpUrl = new URL("temp", "localhost", 0, map);
            final boolean isJvmRefer;
    		//判断是否是同一个jvm，如果是则可以直接本地调用
            if (isInjvm() == null) {
                if (url != null && url.length() > 0) { // if a url is specified, don't do local reference
                    isJvmRefer = false;
                } else if (InjvmProtocol.getInjvmProtocol().isInjvmRefer(tmpUrl)) {
                    // by default, reference local service if there is
                    isJvmRefer = true;
                } else {
                    isJvmRefer = false;
                }
            } else {
                isJvmRefer = isInjvm().booleanValue();
            }
    
            if (isJvmRefer) {
                URL url = new URL(Constants.LOCAL_PROTOCOL, NetUtils.LOCALHOST, 0, interfaceClass.getName()).addParameters(map);
                invoker = refprotocol.refer(interfaceClass, url);
                if (logger.isInfoEnabled()) {
                    logger.info("Using injvm service " + interfaceClass.getName());
                }
            } else {
                if (url != null && url.length() > 0) { // user specified URL, could be peer-to-peer address, or register center's address.
                    String[] us = Constants.SEMICOLON_SPLIT_PATTERN.split(url);
                    if (us != null && us.length > 0) {
                        for (String u : us) {
                            URL url = URL.valueOf(u);
                            if (url.getPath() == null || url.getPath().length() == 0) {
                                url = url.setPath(interfaceName);
                            }
                            if (Constants.REGISTRY_PROTOCOL.equals(url.getProtocol())) {
                                urls.add(url.addParameterAndEncoded(Constants.REFER_KEY, StringUtils.toQueryString(map)));
                            } else {
                                urls.add(ClusterUtils.mergeUrl(url, map));
                            }
                        }
                    }
                } else { // assemble URL from register center's configuration
                    List<URL> us = loadRegistries(false);
                    if (us != null && !us.isEmpty()) {
                        for (URL u : us) {
                            URL monitorUrl = loadMonitor(u);
                            if (monitorUrl != null) {
                                map.put(Constants.MONITOR_KEY, URL.encode(monitorUrl.toFullString()));
                            }
                            urls.add(u.addParameterAndEncoded(Constants.REFER_KEY, StringUtils.toQueryString(map)));
                        }
                    }
                    if (urls == null || 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) {
                    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));
                    }
                }
            }
    
            Boolean c = check;
            if (c == null && consumer != null) {
                c = consumer.isCheck();
            }
            if (c == null) {
                c = true; // default true
            }
            if (c && !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());
            }
            // create service proxy
    		//根据调用器创建代理类
            return (T) proxyFactory.getProxy(invoker);
        }

## 创建代理的过程： ##

1.      获取消费者配置

2.      获取配置的注册中心，通过配置中心配置拼装URL，线上应该是个配置中心集群

3.      遍历注册中心List<URL>集合

加载监控中心URL，如果配置了监控中心在注册中心url加上MONITOR\_KEY

根据配置的引用服务参数给注册中URL上加上REFER\_KEY

4.      遍历注册中心List<URL>集合，这里注册中心url包含了monitorUrl和referUrl

protocol.refer(interface,url)调用protocol引用服务返回invoker可执行对象（这个invoker并不是简单的DubboInvoker, 而是由RegistryProtocol构建基于目录服务的集群策略Invoker, 这个invoker可以通过目录服务list出真正可调用的远程服务invoker）

对于注册中心Url设置集群策略为AvailableCluster， 由AvailableCluster将所有对象注册中调用的invoker伪装成一个invoker

5.      通过代理工厂创建远程服务代理返回给使用着proxyFactory.getProxy(invoker);

## procotol.refer(interface, url) 引用服务的过程 ##

1.      经过ProtocolListenerWrapper， ProtocolFilterWrapper由于是注册中心url调用RegistryProtocol.refer

2.      获取注册中心协议zookeeper, redis, 还是dubbo， 并根据注册中心协议通过注册器工厂RegistryFactory.getRegistry(url)获取注册器Registry用来跟注册中心交互

3.      根据配置的group分组

4.      创建注册服务目录RegistryDirectory并设置注册器

5.      构建订阅服务的subscribeUrl

6.      通过注册器registry向注册中心注册subscribeUrl消费端url

7.      目录服务registryDirectory.subscribe(subscribeUrl)订阅服务（这里我们以开源版本zookeeper为注册中心为例来讲解， dubbo协议的注册中心有点不一样）

其实内部也是通过注册器registry.subscribe(url,this) 这里this就是registryDirectory它实现了NotifyListener。

服务提供者在向zookeeper注册服务/dubbo/com.alibaba.dubbo.demo.DemoService/providers/节点下写下自己的URL地址

服务消费者向zookeepr注册服务/dubbo/com.alibaba.dubbo.demo.DemoService/consumers/节点下写下自己的URL地址

服务消费者向zookeeper 订阅服务/dubbo/com.alibaba.dubbo.demo.DemoService/ providers /节点下所有服务提供者URL地址

Zookeeper通过watcher机制实现对节点的监听，节点数据变化通过节点上的watcher回调客户端， 重新生成对服务的refer

在订阅的过程中通过获取/dubbo/com.alibaba.dubbo.demo.DemoService/providers /下的所有服务提供者的urls(类似dubbo://10.33. 37.8:20880/com.alibaba.dubbo.demo.DemoService?anyhost=true&application=demo-consumer&check=false&dubbo=2.0.0&generic=false&interface=com.alibaba.dubbo.demo.DemoService&methods=sayHello&owner=william&pid=7356&side=consumer&timestamp=1416971340626)，主动回调NotifyListener来根据urls生成对服务提供者的引用生成可执行invokers,供目录服务持有

8.      通过cluster.join(directory) 合并invoker并提供集群调用策略

## DubboProtocol.refer过程: ##

1.      经过ProtocolListenerWrapper， ProtocolFilterWrapper构建监听器链和过滤器链。

2.      DubboProtocol根据url获取ExchangeClient对象，如果是share存在就返回不存在创建新对象不是share直接创建。ExchangeClient是底层通信的客户端，对于通信层的创建功能不在这里讲解。

3.      创建DubboInvoker, 这个invoker对象包含对远程服务提供者的长链接，是真正执行远程服务调用的可执行对象

4.      将创建的invoker返回给目录服务

官方文档的应用服务的序列图

![Center][]

发布服务活动图：

![Center 1][]

引用： https://blog.csdn.net/quhongwei\_zhanqiu/article/details/41651487

[70]: /images/20220527/9c7e3401968f48b1bb4e3173c713c11c.png
[Center]: /images/20220527/957835b2255149cb8ef7f3aa89a81e94.png
[Center 1]: /images/20220527/ca36917fbaba483b83d5834b7f5653f8.png