服务注册与发现-Dubbo篇

待我称王封你为后i 2022-12-23 11:16 163阅读 0赞

> **关键词：**服务注册、服务发现、注册中心

--------------------

Dubbo源码版本：

<dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>dubbo</artifactId>
        <version>2.6.9</version>
    </dependency>

*（读Dubbo源码，关键是要搞清URL中属性protocol的值是什么，以及@Adaptive注解与getAdaptiveExtension方法的原理以及获取到的具体的对象。）*

**角色：**提供者（服务端）、消费者（客户端、服务调用者）、注册中心

消费者当需要调用服务提供者时，消费者要知道服务提供者的位置，即IP、端口以及接口等信息。在早期的一个消费者对一个提供者，消费者可以将提供者的地址写死在代码中。但是随着分布式、集群的大规模应用，更多的是多个消费者对多个提供者。因为在实际场景中，服务会因为某些原因出现不可用的状态，此时为了提高整个系统的可用性，需要消费者能够动态感知可用服务者的列表。这个感知的能力要么服务提供者将自己可用的信息一一告知每一个服务消费者，如果消费者的数量很多，这样显然是效率非常低的。还有一种就是服务提供者将自己的信息暴露在一个第三方的位置，消费者则去这个第三方的位置获取可用服务端列表。这个第三方的位置就是注册中心。

消费者要想调用服务提供者，首先服务提供者要进行服务注册，然后消费者再进行服务发现。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDUxODI3MQ_size_16_color_FFFFFF_t_70][]

Dubbo中三种角色对应的类：

**提供者：**

ServiceConfig

public class ServiceConfig<T> extends AbstractServiceConfig

ServiceBean

public class ServiceBean<T> extends ServiceConfig<T> implements InitializingBean, DisposableBean, ApplicationContextAware, ApplicationListener<ContextRefreshedEvent>, BeanNameAware, ApplicationEventPublisherAware

**消费者：**

ReferenceConfig

public class ReferenceConfig<T> extends AbstractReferenceConfig

ReferenceBean

public class ReferenceBean<T> extends ReferenceConfig<T> implements FactoryBean, ApplicationContextAware, InitializingBean, DisposableBean

**注册中心：**

RegistryConfig

public class RegistryConfig extends AbstractConfig

--------------------

#  **█ 服务注册** #

担任远程服务提供者的服务，在启动的时候，会将自身提供的接口服务列表注册到注册中心上。在Dubbo中，接口服务列表就是以接口和实现类方法以URL的形式对外暴露和注册。

### **使用：** ###

Dubbo提供了三种方式可以像注册中心注册服务，分别是XML配置、注解、以及API。不管哪种方式，服务注册的起点都是export方法。

**（1）XML配置**

结合Spring框架使用，依靠Spring的功能，**DubboNamespaceHandler**、**DubboBeanDefinitionParser**完成配置的解析与Bean的创建，此时每一个接口服务会被创建成ServiceBean对象，ServiceBean继承自ServiceConfig，具有ServiceConfig的功能，还会结合Spring功能， 在Spring启动完成后调用export方法对外暴露和注册服务。

**（2）注解**

注解和XML配置的功能差不多，都是依托于Spring使用的。在接口实现类标记**@Service**注解即可，注意此注解是：com.alibaba.dubbo.config.annotation.Service。**DubboComponentScanRegistrar**与**ServiceAnnotationBeanPostProcessor**完成注解的扫描与解析，根据注解配置创建ServiceBean对象。

package com.alibaba.dubbo.config.annotation;
    ......
    @Documented
    @Retention(RetentionPolicy.RUNTIME)
    @Target({ElementType.TYPE})
    @Inherited
    public @interface Service {
        Class<?> interfaceClass() default void.class;
    
        String interfaceName() default "";
    
        String version() default "";
    
        String group() default "";
    
        String path() default "";
    
        ......
    }

**（3）API**

当不结合Spring框架使用的时候，可以使用API方式。

ServiceConfig serviceConfig = new ServiceConfig();
    // 接口
    serviceConfig.setInterface(xxxx.class);
    serviceConfig.setId("serviceIdxxx");
    ......
    serviceConfig.export();

### **原理：** ###

Dubbo会将服务提供者中的某一个接口实现类作为整体，封装成一个ServiceConfig对象（XML配置<dubbo:service>或注解@Service或手动编写ServiceConfig），然后通过export方法暴露服务和完成向注册中心注册服务。ServiceBean继承了ServiceConfig，与Spring完成契合，实现将ServiceConfig对象注册成Spring容器中的bean。下面从ServiceConfig的export开始，一步步看Dubbo是如何完成服务注册的。*（在读源码之前，建议先学习Dubbo中**@SPI**，**@Adaptive**，**@Activate**三个注解的功能以及ExtensionLoader获取三个注解类的方法。尤其是ExtensionLoader.getAdaptiveExtension。Dubbo大量使用了此方法来获取扩展类对象，实现了根据参数动态获取不同的扩展类的功能。有兴趣的同学，请戳这里[《Dubbo之@Adaptive》][Dubbo_Adaptive]）*

**（1）export**

// 通过此方法开始服务暴露与注册
    public synchronized void export() {
        ......
        else {
                // 去暴露和注册服务
                this.doExport();
            }
    }

**（2）doExport**

// 该方法大部分内容就是完成属性的初始化工作，比如协议、注册中心、监控中心等。这些配置也是Spring在启动的时候，根据XML配置
    // 或注解配置完成赋值的，比如<dubbo:protocol />
    protected synchronized void doExport() {
        if (this.unexported) {
            throw new IllegalStateException("Already unexported!");
        } else if (!this.exported) {
                ......
                // 暴露工作又转移到了这个方法
                this.doExportUrls();
                ......
            } else {
                throw new IllegalStateException("<dubbo:service interface=\"\" /> interface not allow null!");
            }
        }
    }

**（3）doExportUrls**

private void doExportUrls() {
        // 获取所有的注册中心
        List<URL> registryURLs = this.loadRegistries(true);
        // this.protocols是协议集合
        Iterator var2 = this.protocols.iterator();
        // 一个服务按照每一种协议都向所有的注册中心注册 
        while(var2.hasNext()) {
            ProtocolConfig protocolConfig = (ProtocolConfig)var2.next();
            // 进入此方法
            this.doExportUrlsFor1Protocol(protocolConfig, registryURLs);
        }
    
    }

**（4）doExportUrlsFor1Protocol**

private void doExportUrlsFor1Protocol(ProtocolConfig protocolConfig, List<URL> registryURLs) {
        ......
        if (!"none".toString().equalsIgnoreCase(scope)) {
            // 本地暴露服务
            if (!"remote".toString().equalsIgnoreCase(scope)) {
                this.exportLocal(url);
            }
            // 向注册中心注册服务
            if (!"local".toString().equalsIgnoreCase(scope)) {
                if (logger.isInfoEnabled()) {
                    logger.info("Export dubbo service " + this.interfaceClass.getName() + " to url " + url);
                }
                // 根据配置获取到的注册中心服务列表，依次向注册中心注册服务
                if (registryURLs != null && !registryURLs.isEmpty()) {
                    Iterator var25 = registryURLs.iterator();
    
                    while(var25.hasNext()) {
                        ......
                        // proxy的值决定了proxyFactory对象，该值要么在配置的时候指定，否则默认为javassist
                        proxy = url.getParameter("proxy");
                        if (StringUtils.isNotEmpty(proxy)) {
                            registryURL = registryURL.addParameter("proxy", proxy);
                            }
                        // 获取Invoker，下面进入proxyFactory.getInvoker看看
                        Invoker<?> invoker = proxyFactory.getInvoker(this.ref, this.interfaceClass, registryURL.addParameterAndEncoded("export", url.toFullString()));
                        DelegateProviderMetaDataInvoker wrapperInvoker = new DelegateProviderMetaDataInvoker(invoker, this);
                        // 协议对外暴露
                        Exporter<?> exporter = protocol.export(wrapperInvoker);
                        this.exporters.add(exporter);
                    }
                } 
                ......
            }
        }
    
        this.urls.add(url);
    }

Invoker<?> invoker = proxyFactory.getInvoker(this.ref, this.interfaceClass, registryURL.addParameterAndEncoded("export", url.toFullString()));其中proxyFactory是private static final ProxyFactory proxyFactory = (ProxyFactory)ExtensionLoader.getExtensionLoader(ProxyFactory.class).getAdaptiveExtension()，学习过[《Dubbo之Adaptive》][Dubbo_Adaptive]的同学应该知道这里的功能？看看ProxyFacoty，对于getInvoker等三个方法，会根据参数Invoker或URL中的proxy值来决定具体的ProxyFactory对象。即若proxy=javassist，则会调用JavassistProxyFactory中的getProxy方法。则上面这句代码，会根据registryURL中proxy的值来决定使用哪个ProxyFactory对象，proxy要么在XML或注解中指定，默认为JavassistProxyFactory：

@SPI("javassist")
    public interface ProxyFactory {
        @Adaptive({"proxy"})
        <T> T getProxy(Invoker<T> var1) throws RpcException;
    
        @Adaptive({"proxy"})
        <T> T getProxy(Invoker<T> var1, boolean var2) throws RpcException;
    
        @Adaptive({"proxy"})
        <T> Invoker<T> getInvoker(T var1, Class<T> var2, URL var3) throws RpcException;
    }

JavassistProxyFactory，在getInvoker中的Wrapper，根据接口，生成接口的包装类，完成方法的转发，可以将其理解成动态代理中的Handler，比如JDK动态代理中的InvocationHandler或CGLIB中的Callback，关于动态代理请戳[《JDK动态代理》][JDK][《CGLIB动态代理》][CGLIB]：

public class JavassistProxyFactory extends AbstractProxyFactory {
        public JavassistProxyFactory() {
        }
    
        public <T> T getProxy(Invoker<T> invoker, Class<?>[] interfaces) {
            return Proxy.getProxy(interfaces).newInstance(new InvokerInvocationHandler(invoker));
        }
    
        public <T> Invoker<T> getInvoker(T proxy, Class<T> type, URL url) {
            // 根据接口，生成接口的包装类，完成方法的转发，可以将其理解成动态代理中的Handler，比如JDK动态代理中的InvocationHandler
            // 或CGLIB中的Callback
            final Wrapper wrapper = Wrapper.getWrapper(proxy.getClass().getName().indexOf(36) < 0 ? proxy.getClass() : type);
            return new AbstractProxyInvoker<T>(proxy, type, url) {
                protected Object doInvoke(T proxy, String methodName, Class<?>[] parameterTypes, Object[] arguments) throws Throwable {
                    return wrapper.invokeMethod(proxy, methodName, parameterTypes, arguments);
                }
            };
        }
    }

**（5）protocol.export**

其中protocol是private static final Protocol protocol = (Protocol)ExtensionLoader.getExtensionLoader(Protocol.class).getAdaptiveExtension();也是使用了Adaptive功能。会根据参数Invoker或URL中protocol的值来决定Protocol对象。默认为DubboProtocol。

@SPI("dubbo")
    public interface Protocol {
        int getDefaultPort();
    
        @Adaptive
        <T> Exporter<T> export(Invoker<T> var1) throws RpcException;
    
        @Adaptive
        <T> Invoker<T> refer(Class<T> var1, URL var2) throws RpcException;
    
        void destroy();
    }

虽然默认为DubboProtocol，但是在通过ExtensionLoader.getExtension(“dubbo”);来获取协议对象的时候，如果协议对象有包装类，则会将实际的DubboProtocol作为参数设置到包装类中，将包装类作为对象返回，所以protocol.export(wrapperInvoker);方法中，protocol是ProtocolFilterWrapper，进入ProtocolFilterWrapper中的export方法：

// 经过上面的代码proxyFactory.getInvoker，参数中URL传入的是注册中心的URL，所以URL中的protocol=refistry。
    // 所以这里的this.protocol实际上是RegistryProtocol，因为在接口Protocol中，export的方法上标注了@Adaptive注解，
    // 会根据Invoker中protocol的值来获取对应的扩展类，此时参数是注册中心地址封装的Invoker，protocol的值为registry
    public <T> Exporter<T> export(Invoker<T> invoker) throws RpcException {
        // 经过上面的步骤，此时满足"registry".equals(invoker.getUrl().getProtocol())条件，直接调用RegistryProtocol的export方法
        return "registry".equals(invoker.getUrl().getProtocol()) ? this.protocol.export(invoker) : this.protocol.export(buildInvokerChain(invoker, "service.filter", "provider"));
    }

RegistryProtocol.export

public <T> Exporter<T> export(Invoker<T> originInvoker) throws RpcException {
        RegistryProtocol.ExporterChangeableWrapper<T> exporter = this.doLocalExport(originInvoker);
        // 注册中心地址
        URL registryUrl = this.getRegistryUrl(originInvoker);
        // 根据originInvoker封装的URL中属性protocol值，来获取具体的Registry，没有指定的话就是DubboRegistry。可通过<dubbo:registry protocol='xxx'>
        // 或<dubbo:registry address='zookeeper://xxxx'>来指定。
        Registry registry = this.getRegistry(originInvoker);
        // 获取接口服务的地址，取的是originInvoker中URL的export值，从前面的这段代码：
        // Invoker<?> invoker = proxyFactory.getInvoker(this.ref, this.interfaceClass, registryURL.addParameterAndEncoded("export", url.toFullString()));
        // 可以看出，此时的URL是服务提供者的信息
        URL registeredProviderUrl = this.getRegisteredProviderUrl(originInvoker);
        boolean register = registeredProviderUrl.getParameter("register", true);
        ProviderConsumerRegTable.registerProvider(originInvoker, registryUrl, registeredProviderUrl);
        if (register) {
            // 注册服务
            this.register(registryUrl, registeredProviderUrl);
            ProviderConsumerRegTable.getProviderWrapper(originInvoker).setReg(true);
        }
    
        URL overrideSubscribeUrl = this.getSubscribedOverrideUrl(registeredProviderUrl);
        RegistryProtocol.OverrideListener overrideSubscribeListener = new RegistryProtocol.OverrideListener(overrideSubscribeUrl, originInvoker);
        this.overrideListeners.put(overrideSubscribeUrl, overrideSubscribeListener);
        // 订阅服务，动态感知服务变化
        registry.subscribe(overrideSubscribeUrl, overrideSubscribeListener);
        return new RegistryProtocol.DestroyableExporter(exporter, originInvoker, overrideSubscribeUrl, registeredProviderUrl);
    }

**（6）this.register**

下面的内容进入注册中心的功能了，将在注册中心内容中说明

public void register(URL registryUrl, URL registedProviderUrl) {
        Registry registry = this.registryFactory.getRegistry(registryUrl);
        registry.register(registedProviderUrl);
    }

--------------------

# **█ 注册中心** #

**RegistryService**定义了要作为注册中心需要提供的方法：

public interface RegistryService {
        void register(URL var1);
    
        void unregister(URL var1);
    
        void subscribe(URL var1, NotifyListener var2);
    
        void unsubscribe(URL var1, NotifyListener var2);
    
        List<URL> lookup(URL var1);
    }

Dubbo用接口**Registry**标志注册中心：

package com.alibaba.dubbo.registry;
    
    import com.alibaba.dubbo.common.Node;
    
    public interface Registry extends Node, RegistryService {
    }

抽象类**AbstractRegistry**实现了Registry接口，作为一个模板，实现了特定的公共方法，比如register、unregister等。

public abstract class AbstractRegistry implements Registry

抽象类**FailbackRegistry**继承了AbstractRegistry，在AbstractRegistry的基础上，提供了失败重试机制。

public abstract class FailbackRegistry extends AbstractRegistry

Dubbo默认提供了四种注册中心的实现，分别是**DubboRegistry**、**ZookeeperRegistry**、**RedisRegistry**、**MulticastRegistry**。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDUxODI3MQ_size_16_color_FFFFFF_t_70 1][]

**RegistryFactory**，创建Registry：

@SPI("dubbo")
    public interface RegistryFactory {
        // 通过URL的属性protocol值来确定Registry的类型
        @Adaptive({"protocol"})
        Registry getRegistry(URL var1);
    }

抽象类**AbstractRegistryFactory**实现RegistryFactory，作为模板类，提供了公共的默认方法实现：

public abstract class AbstractRegistryFactory implements RegistryFactory

与四个Registry对应，Dubbo也提供了四个RegistryFactory，分别用来获取对应的Registry，分别为：**DubboRegistryFactory**、**ZookeeperRegistryFactory**、**RedisRegistryFactory**、**MulticastRegistryFactory**。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDUxODI3MQ_size_16_color_FFFFFF_t_70 2][]

### **使用：** ###

对于注册中心的配置有四种方式：XML、properties、API

**（1）XML配置**，依然是**DubboNamespaceHandler**、**DubboBeanDefinitionParser**会根据配置，创建RegistryConfig对象。

// 这里以zookeeper作为注册中心为例，redis的则为：redis://localhost:6379
    <dubbo:registry address="zookeeper://localhost:2181" />

**（2）properties配置**

dubbo.registry.address=zookeeper://127.0.0.1:2181

**（3）API**

RegistryConfig registryConfig = new RegistryConfig();
    registryConfig.setAddress("zookeeper://127.0.0.1");

### **原理：** ###

*<以zookeeper为例，其他的比如redis，可自行替换>*

在ServiceConfig的doExportUrls方法中，加载注册中心，将RegistryConfig对应成一个个URL。

// 参数true表示是否为提供者，true：是
    List<URL> registryURLs = this.loadRegistries(true);

protected List<URL> loadRegistries(boolean provider) {
        // 去检查注册中心配置是否已加载
        this.checkRegistry();
        List<URL> registryList = new ArrayList();
        // this.registries为List<RegistryConfig> registries;
        if (this.registries != null && !this.registries.isEmpty()) {
            Iterator var3 = this.registries.iterator();
            ......
                // 将参数先放到map中
                Map<String, String> map = new HashMap();
                appendParameters(map, this.application);
                appendParameters(map, config);
                map.put("path", RegistryService.class.getName());
                map.put("dubbo", Version.getProtocolVersion());
                map.put("timestamp", String.valueOf(System.currentTimeMillis()));
                if (ConfigUtils.getPid() > 0) {
                    map.put("pid", String.valueOf(ConfigUtils.getPid()));
                }
    
                if (!map.containsKey("protocol")) {
                    if (ExtensionLoader.getExtensionLoader(RegistryFactory.class).hasExtension("remote")) {
                        map.put("protocol", "remote");
                    } else {
                        map.put("protocol", "dubbo");
                    }
                }
                // 根据<dubbo:registry address="">与map创建URL
                List<URL> urls = UrlUtils.parseURLs(address, map);
                Iterator var9 = urls.iterator();
    
                while(true) {
                    URL url;
                    do {
                        if (!var9.hasNext()) {
                            continue label70;
                        }
                        // 创建URL，属性protocol值为registry
                        url = (URL)var9.next();
                        url = url.addParameter("registry", url.getProtocol());
                        url = url.setProtocol("registry");
                    } while((!provider || !url.getParameter("register", true)) && (provider || !url.getParameter("subscribe", true)));
    
                    registryList.add(url);
                }
            }
        } else {
            return registryList;
        }
    }

UrlUtils.parseURLs

public static List<URL> parseURLs(String address, Map<String, String> defaults) {
        if (address != null && address.length() != 0) {
            // 当adress配置多个值时，按照;等分隔符分割
            String[] addresses = Constants.REGISTRY_SPLIT_PATTERN.split(address);
            if (addresses != null && addresses.length != 0) {
                List<URL> registries = new ArrayList();
                String[] var4 = addresses;
                int var5 = addresses.length;
    
                for(int var6 = 0; var6 < var5; ++var6) {
                    String addr = var4[var6];
                    // parseURL负责根据配置解析成URL
                    registries.add(parseURL(addr, defaults));
                }
    
                return registries;
            } else {
                return null;
            }
        } else {
            return null;
        }
    }

在parseURL中有这样一个方法，URL.valueOf(url)。会将zookeeper://127.0.0.1:2181这样的字符串，解析出protocol为zookeeper，host为127.0.0.1，port为2181。经过List<URL> urls = UrlUtils.parseURLs(address, map);方法获取到的内容是这样的：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDUxODI3MQ_size_16_color_FFFFFF_t_70 3][]

在loadRegistries，逻辑继续往下走，会将URL中的protocol设置成registry，最后得到的结果是这样的：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDUxODI3MQ_size_16_color_FFFFFF_t_70 4][]

Registry registry = this.getRegistry(originInvoker);originInvoker里面的URL的属性protocol还是为registry，经过getRegistryUrl方法之后，就是将protocol替换成map中存放的registry对应的值，从上图可以看到，值为zookeeper：

private URL getRegistryUrl(Invoker<?> originInvoker) {
        URL registryUrl = originInvoker.getUrl();
        if ("registry".equals(registryUrl.getProtocol())) {
            String protocol = registryUrl.getParameter("registry", "dubbo");
            registryUrl = registryUrl.setProtocol(protocol).removeParameter("registry");
        }
    
        return registryUrl;
    }

经过了Registry registry = this.getRegistry(originInvoker);，最后的结果为：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDUxODI3MQ_size_16_color_FFFFFF_t_70 5][]

**（6）this.register**

步骤紧接着上面的服务注册。经过了loadRegistries，URL registryUrl包含了配置的注册中心协议，以zookeeper为例，此时URL中属性protocol=zookeeper：

public void register(URL registryUrl, URL registedProviderUrl) {
        // 根据registryUrl获取对应的注册器
        Registry registry = this.registryFactory.getRegistry(registryUrl);
        registry.register(registedProviderUrl);
    }

上面代码中通过registryFactory去获取相对应的注册器去注册URL，registryFactory是在创建RegistryProtocol时，通过Set注入方式注入的，注入的是RegistryFactory的自适应扩展类，即RegistryFactory$Adaptive：

@SPI("dubbo")
    public interface RegistryFactory {
        @Adaptive({"protocol"})
        Registry getRegistry(URL var1);
    }

从上面的代码可知，this.registryFactory.getRegistry，会根据URL中的protocol属性来获取具体的SPI扩展类，从上面可以知道，此时的URL的protocol值为zookeeper，所以，获取到的Registry为ZookeeperRegistry。所以Registry registry = this.registryFactory.getRegistry(registryUrl);最终获取到的是ZookeeperRegistry：

**（7）registry.register**

即ZookeeperRegistry.register。register方法是继承自FailbackRegistry的：

// FailbackRegistry.register
    // 参数url是服务的url
    public void register(URL url) {
        // super.register调用的是AbstractRegistry.register
        //        public void register(URL url) {
        //            if (url == null) {
        //                throw new IllegalArgumentException("register url == null");
        //            } else {
        //                if (this.logger.isInfoEnabled()) {
        //                    this.logger.info("Register: " + url);
        //                }
        //
        //                this.registered.add(url);
        //            }
        //        }
        super.register(url);
        this.failedRegistered.remove(url);
        this.failedUnregistered.remove(url);
    
        try {
            // doRegister会由具体的子类实现，此时才真正进入DubboRegistry
            this.doRegister(url);
        } catch (Exception var6) {
            // 注册失败处理，比如注册中心地址错误，或地址对应的服务不在线
            Throwable t = var6;
            boolean check = this.getUrl().getParameter("check", true) && url.getParameter("check", true) && !"consumer".equals(url.getProtocol());
            boolean skipFailback = var6 instanceof SkipFailbackWrapperException;
            if (check || skipFailback) {
                if (skipFailback) {
                    t = var6.getCause();
                }
    
                throw new IllegalStateException("Failed to register " + url + " to registry " + this.getUrl().getAddress() + ", cause: " + ((Throwable)t).getMessage(), (Throwable)t);
            }
    
            this.logger.error("Failed to register " + url + ", waiting for retry, cause: " + var6.getMessage(), var6);
            // 加到failedRegistered集合中，会进行重试
            this.failedRegistered.add(url);
        }
    
    }

**（8）ZookeeperRegistry.doRegister**

protected void doRegister(URL url) {
        try {
            // 这里很简单，就是通过调用zookeeper api，创建一个节点
            this.zkClient.create(this.toUrlPath(url), url.getParameter("dynamic", true));
        } catch (Throwable var3) {
            throw new RpcException("Failed to register " + url + " to zookeeper " + this.getUrl() + ", cause: " + var3.getMessage(), var3);
        }
    }

--------------------

#  **█ 服务发现** #

服务提供者在注册中心注册完成之后，服务消费者去相同的注册中心去获取服务列表。服务消费者会将对应的服务绑定到**ReferenceConfig**上，ReferenceConfig有个子类是**ReferenceBean**，与Spring框架配合使用。

### **使用：** ###

和服务注册一样，Dubbo也提供了相同的三种方法去获取服务，XML配置、注解、API

**（1）XML配置**

// interface要与服务提供者使用同一个接口
    <dubbo:reference id="animalService" interface="study.rui.dubbo.AnimalService"/>

**（2）注解**

@Documented
    @Retention(RetentionPolicy.RUNTIME)
    @Target({ElementType.FIELD, ElementType.METHOD, ElementType.ANNOTATION_TYPE})
    public @interface Reference {
        Class<?> interfaceClass() default void.class;
    
        String interfaceName() default "";
    
        String version() default "";
    
        String group() default "";
    
        ......
    }

**（3）API**

ReferenceConfig referenceConfig = new ReferenceConfig();
    referenceConfig.setInterface(xxxx.class);
    referenceConfig.get();

### **原理：** ###

在结合Spring使用的时候，无论是通过XML<dubbo:reference>还是@Reference注解，最终会根据配置创建成一个个ReferenceBean放进Spring容器中。ReferenceBean不仅继承了ReferenceConfig，还实现了FactoryBean，所以当通过@Autowire注解自动注入的时候，会调用ReferenceBean的getObject方法来获取对象。

public Object getObject() throws Exception {
        return this.get();
    }

this.get()，调用的是ReferenceConfig的get方法。下面从ReferenceConfig.get开始，看看Dubbo服务发现过程。

**（1）ReferenceConfig.get**

public synchronized T get() {
        if (this.destroyed) {
            throw new IllegalStateException("Already destroyed!");
        } else {
            // ref就是接口对应的实现类，第一次调用的时候为null，会进入init方法进行初始化
            if (this.ref == null) {
                this.init();
            }
    
            return this.ref;
        }
    }

**（2）init**

private void init() {
        if (!this.initialized) {
            this.initialized = true;
            if (this.interfaceName != null && this.interfaceName.length() != 0) {
                
                // 属性的配置等等
                ....
    
                this.checkApplication();
                this.checkStub(this.interfaceClass);
                this.checkMock(this.interfaceClass);
                
                // 根据配置将值封装到map中
                
                Map<String, String> map = new HashMap();
                Map<Object, Object> attributes = new HashMap();
                map.put("side", "consumer");
                map.put("dubbo", Version.getProtocolVersion());
                map.put("timestamp", String.valueOf(System.currentTimeMillis()));
                
                ......
                
                // 根据配置值创建代理对象
                this.ref = this.createProxy(map);
                ConsumerModel consumerModel = new ConsumerModel(this.getUniqueServiceName(), this, this.ref, this.interfaceClass.getMethods());
                ApplicationModel.initConsumerModel(this.getUniqueServiceName(), consumerModel);
            } else {
                throw new IllegalStateException("<dubbo:reference interface=\"\" /> interface not allow null!");
            }
        }
    }

**（3）createProxy**

private T createProxy(Map<String, String> map) {
        // 也是将消费者对应成URL
        URL tmpUrl = new URL("temp", "localhost", 0, map);
        boolean isJvmRefer;
        // 是否在JVM进行调用
        if (this.isInjvm() == null) {
            if (this.url != null && this.url.length() > 0) {
                isJvmRefer = false;
            } else if (InjvmProtocol.getInjvmProtocol().isInjvmRefer(tmpUrl)) {
                isJvmRefer = true;
            } else {
                isJvmRefer = false;
            }
        } else {
            isJvmRefer = this.isInjvm();
        }
        // 本地JVM调用
        if (isJvmRefer) {
            URL url = (new URL("injvm", "127.0.0.1", 0, this.interfaceClass.getName())).addParameters(map);
            this.invoker = refprotocol.refer(this.interfaceClass, url);
            if (logger.isInfoEnabled()) {
                logger.info("Using injvm service " + this.interfaceClass.getName());
            }
        } else {
            // 下面是远程从注册中心获取服务列表然后封装成消费者代理对象的逻辑
            URL u;
            URL url;
            // this.url是通过<dubbo:reference url="xxx">或@Reference(url="xxx")配置获得的，
            // 表示远程调用的时候，直接连接这个配置的url调用服务，不需要从注册中心获取服务列表连接了
            if (this.url != null && this.url.length() > 0) {
                String[] us = Constants.SEMICOLON_SPLIT_PATTERN.split(this.url);
                if (us != null && us.length > 0) {
                    String[] var14 = us;
                    int var16 = us.length;
    
                    for(int var18 = 0; var18 < var16; ++var18) {
                        String u = var14[var18];
                        URL url = URL.valueOf(u);
                        if (url.getPath() == null || url.getPath().length() == 0) {
                            url = url.setPath(this.interfaceName);
                        }
                        // 包装配置的url，添加到urls集合中，集合urls存放的是可用的服务列表调用地址
                        if ("registry".equals(url.getProtocol())) {
                            this.urls.add(url.addParameterAndEncoded("refer", StringUtils.toQueryString(map)));
                        } else {
                            this.urls.add(ClusterUtils.mergeUrl(url, map));
                        }
                    }
                }
            } else {
                // 获取所有注册中心信息，同服务暴露的时候一样。
                // 获取到的URL的属性protocol为registry
                List<URL> us = this.loadRegistries(false);
                if (us != null && !us.isEmpty()) {
                    // this.urls.add，添加到urls集合中
                    for(Iterator var5 = us.iterator(); var5.hasNext(); this.urls.add(u.addParameterAndEncoded("refer", StringUtils.toQueryString(map)))) {
                        u = (URL)var5.next();
                        // 这边是监控中心，后续会讲
                        url = this.loadMonitor(u);
                        if (url != null) {
                            map.put("monitor", URL.encode(url.toFullString()));
                        }
                    }
                }
    
                if (this.urls.isEmpty()) {
                    throw new IllegalStateException("No such any registry to reference " + this.interfaceName + " on the consumer " + NetUtils.getLocalHost() + " use dubbo version " + Version.getVersion() + ", please config <dubbo:registry address=\"...\" /> to your spring config.");
                }
            }
            // 服务列表就一个
            if (this.urls.size() == 1) {
                // 获取invoker
                this.invoker = refprotocol.refer(this.interfaceClass, (URL)this.urls.get(0));
            } else {
                // 如果服务有多个，也就是集群了，会进行负载均衡，集群容错等操作
                // 下面会对所有的服务列表进行包装
                List<Invoker<?>> invokers = new ArrayList();
                URL registryURL = null;
                Iterator var17 = this.urls.iterator();
    
                while(var17.hasNext()) {
                    url = (URL)var17.next();
                    invokers.add(refprotocol.refer(this.interfaceClass, url));
                    if ("registry".equals(url.getProtocol())) {
                        registryURL = url;
                    }
                }
                // 将Invoker列表包装到StaticDirectory中，再包装到cluster中，最后返回Invoker
                if (registryURL != null) {
                    u = registryURL.addParameterIfAbsent("cluster", "available");
                    this.invoker = cluster.join(new StaticDirectory(u, invokers));
                } else {
                    this.invoker = cluster.join(new StaticDirectory(invokers));
                }
            }
        }
    
        Boolean c = this.check;
        if (c == null && this.consumer != null) {
            c = this.consumer.isCheck();
        }
    
        if (c == null) {
            c = true;
        }
    
        if (c && !this.invoker.isAvailable()) {
            this.initialized = false;
            throw new IllegalStateException("Failed to check the status of the service " + this.interfaceName + ". No provider available for the service " + (this.group == null ? "" : this.group + "/") + this.interfaceName + (this.version == null ? "" : ":" + this.version) + " from the url " + this.invoker.getUrl() + " to the consumer " + NetUtils.getLocalHost() + " use dubbo version " + Version.getVersion());
        } else {
            if (logger.isInfoEnabled()) {
                logger.info("Refer dubbo service " + this.interfaceClass.getName() + " from url " + this.invoker.getUrl());
            }
            // 根据Invoker创建代理对象
            return proxyFactory.getProxy(this.invoker);
        }
    }

**（4）refprotocol.refer**

refprotocol为private static final Protocol refprotocol = (Protocol)ExtensionLoader.getExtensionLoader(Protocol.class).getAdaptiveExtension();

@SPI("dubbo")
    public interface Protocol {
        ......
        // 或根据URL的属性protocol的值来决定具体的子类实现方法
        @Adaptive
        <T> Invoker<T> refer(Class<T> var1, URL var2) throws RpcException;
    }

URL中的属性protocol为registry，则获取到的是RegistryProtocol，但是RegistryProtocol存在包装类，这里的逻辑和服务暴露的时候一样，实际获取到的是DubboProtocol的包装类：**ProtocolFilterWrapper**。

// ProtocolFilterWrapper.refer
    // 此时URL中的属性protocol值是registry，走this.protocol.refer(type, url)逻辑
    // this.protocol为RegistryProtocol
    public <T> Invoker<T> refer(Class<T> type, URL url) throws RpcException {
        return "registry".equals(url.getProtocol()) ? this.protocol.refer(type, url) : buildInvokerChain(this.protocol.refer(type, url), "reference.filter", "consumer");
    }

**（5）this.protocol.refer**

即RegistryProtocol.refer

public <T> Invoker<T> refer(Class<T> type, URL url) throws RpcException {
        // URL的parameterMap中的registry为zookeeper，则此时url的protocol会被改成zookeeper
        url = url.setProtocol(url.getParameter("registry", "dubbo")).removeParameter("registry");
        // 获取注册器，在注册中心里面已经说明了，这里获取到的是ZookeeperRegistry
        Registry registry = this.registryFactory.getRegistry(url);
        // 参数type不是RegistryService，而是具体的服务接口类型
        if (RegistryService.class.equals(type)) {
            return this.proxyFactory.getInvoker(registry, type, url);
        } else {
            // 进到这里的逻辑
            Map<String, String> qs = StringUtils.parseQueryString(url.getParameterAndDecoded("refer"));
            // group配置，可通过<dubbo:reference group="">指定，默认为dubbo
            String group = (String)qs.get("group");
            return group == null || group.length() <= 0 || Constants.COMMA_SPLIT_PATTERN.split(group).length <= 1 && !"*".equals(group) ? this.doRefer(this.cluster, registry, type, url) : this.doRefer(this.getMergeableCluster(), registry, type, url);
        }
    }

**（6）doRefer**

private <T> Invoker<T> doRefer(Cluster cluster, Registry registry, Class<T> type, URL url) {
        // 封装成RegistryDirectory，RegistryDirectory继承了NotifyListener，能够订阅注册中心
        RegistryDirectory<T> directory = new RegistryDirectory(type, url);
        directory.setRegistry(registry);
        directory.setProtocol(this.protocol);
        Map<String, String> parameters = new HashMap(directory.getUrl().getParameters());
        // 订阅服务
        URL subscribeUrl = new URL("consumer", (String)parameters.remove("register.ip"), 0, type.getName(), parameters);
        // 注册消费者
        if (!"*".equals(url.getServiceInterface()) && url.getParameter("register", true)) {
            URL registeredConsumerUrl = this.getRegisteredConsumerUrl(subscribeUrl, url);
            registry.register(registeredConsumerUrl);
            directory.setRegisteredConsumerUrl(registeredConsumerUrl);
        }
        // 订阅providers,configurators,routers三个节点
        directory.subscribe(subscribeUrl.addParameter("category", "providers,configurators,routers"));
        Invoker invoker = cluster.join(directory);
        ProviderConsumerRegTable.registerConsumer(invoker, url, subscribeUrl, directory);
        return invoker;
    }

**（7）****directory.subscribe**

获取注册中心的接口的服务列表。即调用**RegistryDirectory**的subscribe方法。RegistryDirectory中持有的registry是**ZookeeperRegistry**：

// RegistryDirectory#subscribe
    public void subscribe(URL url) {
        setConsumerUrl(url);
        // 调用ZookeeperRegistry的subscribe
        registry.subscribe(url, this);
    }

ZookeeperRegistry的subscribe是继承自**FailbackRegistry**：

// ZookeeperRegistry#subscribe
    public void subscribe(URL url, NotifyListener listener) {
        // 调用 AbstractRegistry
        // 初始化url对应的Set<NotifyListener>
        super.subscribe(url, listener);
        removeFailedSubscribed(url, listener);
        try {
            // Sending a subscription request to the server side
            doSubscribe(url, listener);
        } 
        ......
        }

doSubscribe：

doSubscribe由具体的子类，即调用ZookeeperRegistry的doSubscribe：

protected void doSubscribe(final URL url, final NotifyListener listener) {
        try {
            // 获取所有接口对应的服务提供者列表
            // 监控中心或Dubbo Admin会进行此操作
            if (Constants.ANY_VALUE.equals(url.getServiceInterface())) {
                ......
            } else {// 单独的服务消费者只会获取接口对应的服务提供者列表
                List<URL> urls = new ArrayList<URL>();
                // toCategoriesPath获取zookeeper的节点路径 比如/dubbo/www.rui.com.AnimalService/provider
                // 一次可获取多个节点路径的内容，所以是数组，比如既获取provider，又获取consumer
                for (String path : toCategoriesPath(url)) {
                    ConcurrentMap<NotifyListener, ChildListener> listeners = zkListeners.get(url);
                    if (listeners == null) {
                        zkListeners.putIfAbsent(url, new ConcurrentHashMap<NotifyListener, ChildListener>());
                        listeners = zkListeners.get(url);
                    }
                    // 子节点监听器
                    ChildListener zkListener = listeners.get(listener);
                    if (zkListener == null) {
                        // 定义childChanged方法，当服务发生变化，即zookeeper的节点发生变化了
                        // 会触发zookeeper的watcher机制通知所有的节点订阅者
                        listeners.putIfAbsent(listener, new ChildListener() {
                            @Override
                            public void childChanged(String parentPath, List<String> currentChilds) {
                                ZookeeperRegistry.this.notify(url, listener, toUrlsWithEmpty(url, parentPath, currentChilds));
                            }
                        });
                        zkListener = listeners.get(listener);
                    }
                    // 这里虽然调用了create，但实际不会去执行创建zookeeper节点的逻辑
                    // 只是将路径加到了persistentExistNodePath集合中
                    // false表示节点不是临时节点
                    zkClient.create(path, false);
                    // 获取所有的服务提供者URL
                    List<String> children = zkClient.addChildListener(path, zkListener);
                    if (children != null) {
                        urls.addAll(toUrlsWithEmpty(url, path, children));
                    }
                }
                // 刷新本地缓存
                notify(url, listener, urls);
            }
        } catch (Throwable e) {
            throw new RpcException("Failed to subscribe " + url + " to zookeeper " + getUrl() + ", cause: " + e.getMessage(), e);
        }
    }

zkClient.addChildListener：

addChileListener是**AbstractZookeeperClient**实现的方法，在addChileListener方法中，调用了addTargetChildListener方法。addTargetChildListener是抽象方法，具体的逻辑由子类实现。AbstractZookeeperClient有两个子类：**CuratorZookeeperClient**、**ZkclientZookeeperClient**。以CuratorZookeeperClient中的addTargetChildListener为例：

// CuratorZookeeperClient#addTargetChildListener
    // 获取节点下所有的子节点，并注册watcher监听子节点编号
    public List<String> addTargetChildListener(String path, CuratorWatcher listener) {
        try {
            return client.getChildren().usingWatcher(listener).forPath(path);
        } catch (NoNodeException e) {
            return null;
        } catch (Exception e) {
            throw new IllegalStateException(e.getMessage(), e);
        }
    }

至此，服务消费者获取到接口对应的服务列表。

**（8）cluster.join**

@SPI("failover")
    public interface Cluster {
        @Adaptive
        <T> Invoker<T> join(Directory<T> var1) throws RpcException;
    }

**Cluster**集群，负责负载均衡与集群容错。调用join方法时，会根据**Directory**中URL中的cluster的值调用具体的实现类。默认为fallover。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDUxODI3MQ_size_16_color_FFFFFF_t_70 6][]

以**FailOverCluster**为例，查看join方法，就是创建对应的**FailoverClusterInvoker**，将服务列表作为参数：

public <T> Invoker<T> join(Directory<T> directory) throws RpcException {
        return new FailoverClusterInvoker(directory);
    }

**（9）proxyFactory.getProxy**

根据Invoker利用Javassist等技术生成代理对象，这边可以对应理解成动态代理的原理。

--------------------

注册中心中关于服务提供者、消费者的体现，以zookeeper为例：

![20201124210038327.png][]

最顶级的节点：dubbo，为分组名，可通过配置group指定，比如<dubbo:service group="xxxx">。

第二级节点：接口全限定名，比如：study.rui.dubbo.AnimalService。

第三级节点：有四个节点configurators, consumers, providers, routers，分别表示接口所对应的配置中心、服务消费者、服务提供者、路由。

第四级节点：查看服务提供者providers，可以看见接口的服务提供者访问地址。通过此地址进行远程调用。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDUxODI3MQ_size_16_color_FFFFFF_t_70]: /images/20221120/bd0a5b4534e94600b50dab7c819cc95c.png
[Dubbo_Adaptive]: https://blog.csdn.net/weixin_50518271/article/details/108554441
[JDK]: https://blog.csdn.net/weixin_50518271/article/details/109139400
[CGLIB]: https://blog.csdn.net/weixin_50518271/article/details/109187289
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDUxODI3MQ_size_16_color_FFFFFF_t_70 1]: /images/20221120/7c11e2cd85e74d789790a41927bede1c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDUxODI3MQ_size_16_color_FFFFFF_t_70 2]: /images/20221120/349e6dcc2fc9436eb487385422ed275e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDUxODI3MQ_size_16_color_FFFFFF_t_70 3]: /images/20221120/17a05a03516b4b8dbf1175d0c11e7ac3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDUxODI3MQ_size_16_color_FFFFFF_t_70 4]: /images/20221120/5f6508e0c20740d4a3f5fac6c28a7399.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDUxODI3MQ_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20201124205018985.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDUxODI3MQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDUxODI3MQ_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20201124205925493.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDUxODI3MQ==,size_16,color_FFFFFF,t_70
[20201124210038327.png]: https://img-blog.csdnimg.cn/20201124210038327.png