Dubbo原始碼解析之服務釋出與註冊

寒武沒有紀發表於2018-11-02

準備

dubbo版本：2.5.4

Spring自定義擴充套件

dubbo 是基於 spring 配置來實現服務釋出，並基於 spring 的擴充套件機制定義了一套自定義標籤，要實現自定義擴充套件， spring 中提供了 NamespaceHandler 、BeanDefinitionParser 兩個類用於實現擴充套件

NamespaceHandler ：註冊一系列 BeanDefinitionParser ，利用他們進行解析
BeanDefinitionParser ：用於解析每個 element 內容
Spring 預設會載入jar包下的 META-INF/spring.handlers 檔案尋找對應的 NamespaceHandler（Dubbo-config 模組下 dubbo-config-spring ）。

檢視 DubboNamespaceHandler 類

public class DubboNamespaceHandler extends NamespaceHandlerSupport {

	static {
		Version.checkDuplicate(DubboNamespaceHandler.class);
	}

	public void init() {
	    registerBeanDefinitionParser("application", new DubboBeanDefinitionParser(ApplicationConfig.class, true));
        registerBeanDefinitionParser("module", new DubboBeanDefinitionParser(ModuleConfig.class, true));
        registerBeanDefinitionParser("registry", new DubboBeanDefinitionParser(RegistryConfig.class, true));
        registerBeanDefinitionParser("monitor", new DubboBeanDefinitionParser(MonitorConfig.class, true));
        registerBeanDefinitionParser("provider", new DubboBeanDefinitionParser(ProviderConfig.class, true));
        registerBeanDefinitionParser("consumer", new DubboBeanDefinitionParser(ConsumerConfig.class, true));
        registerBeanDefinitionParser("protocol", new DubboBeanDefinitionParser(ProtocolConfig.class, true));
        registerBeanDefinitionParser("service", new DubboBeanDefinitionParser(ServiceBean.class, true));
        registerBeanDefinitionParser("reference", new DubboBeanDefinitionParser(ReferenceBean.class, false));
        registerBeanDefinitionParser("annotation", new DubboBeanDefinitionParser(AnnotationBean.class, true));
    }

}

通過 DubboBeanDefinitionParser 將 dubbo 自定義標籤解析為相應 Bean 物件。同時為了 spring 啟動時，相應地啟動 provider 釋出服務註冊服務的過程，以及讓客戶端在啟動時自動訂閱發現服務，新增了兩個 bean ，ServiceBean 及 ReferenceBean ，分別繼承 ServiceConfig 和 ReferenceConfig 。

ServiceBean 實現了InitializingBean 、DisposableBean 、ApplicationContextAware 、ApplicationListener 、BeanNameAware

InitializingBean：bean 初始化過程中會呼叫 afterPropertiesSet 方法
DisposableBean：bean 銷燬時，spring 容器會自動執行 destory 方法，比如釋放資源
ApplicationContextAware：當 spring 容器初始化時會自動將 ApplicationContext 注入進來
ApplicationListener：ApplicationEvent 事件監聽，spring 容器啟動後會發一個事件通知
BeanNameAware：獲得自身初始化時 bean 的 id 屬性

服務釋出過程

先上時序圖，幫助跟蹤過程走向。
Dubbo釋出服務

serviceBean 是服務釋出入口，在 bean 初始化時會執行其 afterPropertiesSet 方法，在該方法最後會執行 export 方法進行釋出

// ServiceConfig
public synchronized void export() {
    if (provider != null) {
        if (export == null) {
            export = provider.getExport();
        }
        if (delay == null) {
            delay = provider.getDelay();
        }
    }
    if (export != null && ! export.booleanValue()) {
        return;
    }
    if (delay != null && delay > 0) {
        Thread thread = new Thread(new Runnable() {
            public void run() {
                try {
                    Thread.sleep(delay);
                } catch (Throwable e) {
                }
                doExport();
            }
        });
        thread.setDaemon(true);
        thread.setName("DelayExportServiceThread");
        thread.start();
    } else {
        doExport();
    }
}

接著呼叫 doExportUrls 方法

private void doExportUrls() {
    List<URL> registryURLs = loadRegistries(true);// 是否獲得註冊中心配置
    for (ProtocolConfig protocolConfig : protocols) {
        // 執行協議釋出
        doExportUrlsFor1Protocol(protocolConfig, registryURLs);
    }
}

doExportUrlsFor1Protocol

private void doExportUrlsFor1Protocol(ProtocolConfig protocolConfig, List<URL> registryURLs) {
    /**
     * 只保留核心程式碼
     */
    String scope = url.getParameter(Constants.SCOPE_KEY);
    if (! Constants.SCOPE_NONE.toString().equalsIgnoreCase(scope)) {
        if (!Constants.SCOPE_REMOTE.toString().equalsIgnoreCase(scope)) {
            exportLocal(url);
        }
        if (! Constants.SCOPE_LOCAL.toString().equalsIgnoreCase(scope) ){
            if (logger.isInfoEnabled()) {
                logger.info("Export dubbo service " + interfaceClass.getName() + " to url " + url);
            }
            // registryURLs
            // registrys://...
            if (registryURLs != null && registryURLs.size() > 0
                    && url.getParameter("register", true)) {
                for (URL registryURL : registryURLs) {
                    url = url.addParameterIfAbsent("dynamic", registryURL.getParameter("dynamic"));
                    URL monitorUrl = loadMonitor(registryURL);
                    if (monitorUrl != null) {
                        url = url.addParameterAndEncoded(Constants.MONITOR_KEY, monitorUrl.toFullString());
                    }
                    if (logger.isInfoEnabled()) {
                        logger.info("Register dubbo service " + interfaceClass.getName() + " url " + url + " to registry " + registryURL);
                    }
                    // 通過proxyFactory獲取Invoker物件
                    Invoker<?> invoker = proxyFactory.getInvoker(ref, (Class) interfaceClass, registryURL.addParameterAndEncoded(Constants.EXPORT_KEY, url.toFullString()));
  					// 註冊服務 
                    // protocol = ExtensionLoader.getExtensionLoader(Protocol.class).getAdaptiveExtension();
                    // 這裡的protocol是Protocol$Adpative介面卡物件
                    Exporter<?> exporter = protocol.export(invoker);
                    exporters.add(exporter);
                }
            } else {
                Invoker<?> invoker = proxyFactory.getInvoker(ref, (Class) interfaceClass, url);

                Exporter<?> exporter = protocol.export(invoker);
                exporters.add(exporter);
            }
        }
    }
    this.urls.add(url);
}

會呼叫動態生成的介面卡類Protocol$Adpative

public class Protocol$Adpative implements com.alibaba.dubbo.rpc.Protocol {
    public void destroy() {
        throw new UnsupportedOperationException("method public abstract void com.alibaba.dubbo.rpc.Protocol.destroy() of interface com.alibaba.dubbo.rpc.Protocol is not adaptive method!");
    }

    public int getDefaultPort() {
        throw new UnsupportedOperationException("method public abstract int com.alibaba.dubbo.rpc.Protocol.getDefaultPort() of interface com.alibaba.dubbo.rpc.Protocol is not adaptive method!");
    }

    public com.alibaba.dubbo.rpc.Exporter export(com.alibaba.dubbo.rpc.Invoker arg0) throws com.alibaba.dubbo.rpc.RpcException {
        if (arg0 == null) throw new IllegalArgumentException("com.alibaba.dubbo.rpc.Invoker argument == null");
        if (arg0.getUrl() == null)
            throw new IllegalArgumentException("com.alibaba.dubbo.rpc.Invoker argument getUrl() == null");
        com.alibaba.dubbo.common.URL url = arg0.getUrl();
        String extName = (url.getProtocol() == null ? "dubbo" : url.getProtocol());
        if (extName == null)
            throw new IllegalStateException("Fail to get extension(com.alibaba.dubbo.rpc.Protocol) name from url(" + url.toString() + ") use keys([protocol])");
        // 獲取指定名稱的擴充套件點
        com.alibaba.dubbo.rpc.Protocol extension = (com.alibaba.dubbo.rpc.Protocol) ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.rpc.Protocol.class).getExtension(extName);
        return extension.export(arg0);
    }

    public com.alibaba.dubbo.rpc.Invoker refer(Class arg0, com.alibaba.dubbo.common.URL arg1) throws com.alibaba.dubbo.rpc.RpcException {
        if (arg1 == null) throw new IllegalArgumentException("url == null");
        com.alibaba.dubbo.common.URL url = arg1;
        String extName = (url.getProtocol() == null ? "dubbo" : url.getProtocol());
        if (extName == null)
            throw new IllegalStateException("Fail to get extension(com.alibaba.dubbo.rpc.Protocol) name from url(" + url.toString() + ") use keys([protocol])");
        com.alibaba.dubbo.rpc.Protocol extension = (com.alibaba.dubbo.rpc.Protocol) ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.rpc.Protocol.class).getExtension(extName);
        return extension.refer(arg0, arg1);
    }
}

getExtension

public T getExtension(String name) {
    if (name != null && name.length() != 0) {
        if ("true".equals(name)) {
            return this.getDefaultExtension();
        } else {
            Holder<Object> holder = (Holder)this.cachedInstances.get(name);
            if (holder == null) {
                this.cachedInstances.putIfAbsent(name, new Holder());
                holder = (Holder)this.cachedInstances.get(name);
            }

            Object instance = holder.get();
            if (instance == null) {
                synchronized(holder) {
                    instance = holder.get();
                    if (instance == null) {
                        // 建立指定名稱的擴張點>>
                        instance = this.createExtension(name);
                        holder.set(instance);
                    }
                }
            }

            return instance;
        }
    } else {
        throw new IllegalArgumentException("Extension name == null");
    }
}

createExtension

private T createExtension(String name) {
    Class<?> clazz = (Class)this.getExtensionClasses().get(name);
    if (clazz == null) {
        throw this.findException(name);
    } else {
        try {
            T instance = EXTENSION_INSTANCES.get(clazz);
            if (instance == null) {
                EXTENSION_INSTANCES.putIfAbsent(clazz, clazz.newInstance());
                instance = EXTENSION_INSTANCES.get(clazz);
            }
			// 獲取例項進行依賴注入
            this.injectExtension(instance);
            // cachedWrapperClasses在loadFile中設定
            Set<Class<?>> wrapperClasses = this.cachedWrapperClasses;
            Class wrapperClass;
            if (wrapperClasses != null && wrapperClasses.size() > 0) {
                // 獲取帶有指定型別引數的構造方法建立例項，進行依賴注入
                for(Iterator var5 = wrapperClasses.iterator(); var5.hasNext(); instance = this.injectExtension(wrapperClass.getConstructor(this.type).newInstance(instance))) {
                    wrapperClass = (Class)var5.next();
                }
            }

            return instance;
        } catch (Throwable var7) {
            throw new IllegalStateException("Extension instance(name: " + name + ", class: " + this.type + ")  could not be instantiated: " + var7.getMessage(), var7);
        }
    }
}

上面方法主要步驟

根據name獲取對應class
根據class建立例項
獲取例項進行依賴注入
獲取帶有指定型別引數的構造方法建立例項，進行依賴注入

以Protocol為例：

在dubbo-rpc-api的resources路徑下，可以找到com.alibaba.dubbo.rcp.Protocol檔案中有存在filter/listener

filter=com.alibaba.dubbo.rpc.protocol.ProtocolFilterWrapper
listener=com.alibaba.dubbo.rpc.protocol.ProtocolListenerWrapper

而ProtocolFilterWrapper、ProtocolListenerWrapper都存在以Protocol為引數的構造方法

public ProtocolFilterWrapper(Protocol protocol){}

public ProtocolListenerWrapper(Protocol protocol){}

遍歷cachedWrapperClass對DubboProtocol 進行包裝，會通過ProtocolFilterWrapper、ProtocolListenerWrapper進行包裝。

因為在方法doExportUrlsFor1Protocol中傳入的是registryURL，因此Protocol$Adpative的export方法最終會呼叫RegistryProtocol的export方法

RegistryProtocol

public <T> Exporter<T> export(Invoker<T> originInvoker) throws RpcException {
    // 執行本地釋出>>
    final RegistryProtocol.ExporterChangeableWrapper<T> exporter = this.doLocalExport(originInvoker);
    final Registry registry = this.getRegistry(originInvoker);
    final URL registedProviderUrl = this.getRegistedProviderUrl(originInvoker);
    registry.register(registedProviderUrl);
    final URL overrideSubscribeUrl = this.getSubscribedOverrideUrl(registedProviderUrl);
    final RegistryProtocol.OverrideListener overrideSubscribeListener = new RegistryProtocol.OverrideListener(overrideSubscribeUrl);
    this.overrideListeners.put(overrideSubscribeUrl, overrideSubscribeListener);
    registry.subscribe(overrideSubscribeUrl, overrideSubscribeListener);
    return new Exporter<T>() {
        public Invoker<T> getInvoker() {
            return exporter.getInvoker();
        }

        public void unexport() {
            try {
                exporter.unexport();
            } catch (Throwable var4) {
                RegistryProtocol.logger.warn(var4.getMessage(), var4);
            }

            try {
                registry.unregister(registedProviderUrl);
            } catch (Throwable var3) {
                RegistryProtocol.logger.warn(var3.getMessage(), var3);
            }

            try {
                RegistryProtocol.this.overrideListeners.remove(overrideSubscribeUrl);
                registry.unsubscribe(overrideSubscribeUrl, overrideSubscribeListener);
            } catch (Throwable var2) {
                RegistryProtocol.logger.warn(var2.getMessage(), var2);
            }

        }
    };
}

private <T> RegistryProtocol.ExporterChangeableWrapper<T> doLocalExport(Invoker<T> originInvoker) {
    String key = this.getCacheKey(originInvoker);
    RegistryProtocol.ExporterChangeableWrapper<T> exporter = (RegistryProtocol.ExporterChangeableWrapper)this.bounds.get(key);
    if (exporter == null) {
        Map var4 = this.bounds;
        synchronized(this.bounds) {
            exporter = (RegistryProtocol.ExporterChangeableWrapper)this.bounds.get(key);
            if (exporter == null) {
                Invoker<?> invokerDelegete = new RegistryProtocol.InvokerDelegete(originInvoker, this.getProviderUrl(originInvoker));
                // 這裡的protocol不僅僅是Procotol$Adaptive，而是經過Wrapper包裝
                // ProtocolFilterWrapper、ProtocolListenerWrapper
                exporter = new RegistryProtocol.ExporterChangeableWrapper(this.protocol.export(invokerDelegete), originInvoker);
                this.bounds.put(key, exporter);
            }
        }
    }

    return exporter;
}

ProtocolFilterWrapper

public <T> Exporter<T> export(Invoker<T> invoker) throws RpcException {
    if (Constants.REGISTRY_PROTOCOL.equals(invoker.getUrl().getProtocol())) {
        return protocol.export(invoker);
    }
    return protocol.export(buildInvokerChain(invoker, Constants.SERVICE_FILTER_KEY, Constants.PROVIDER));
}

private static <T> Invoker<T> buildInvokerChain(final Invoker<T> invoker, String key, String group) {
    Invoker<T> last = invoker;
    List<Filter> filters = ExtensionLoader.getExtensionLoader(Filter.class).getActivateExtension(invoker.getUrl(), key, group);
    if (filters.size() > 0) {
        for (int i = filters.size() - 1; i >= 0; i --) {
            final Filter filter = filters.get(i);
            final Invoker<T> next = last;
            last = new Invoker<T>() {

                public Class<T> getInterface() {
                    return invoker.getInterface();
                }

                public URL getUrl() {
                    return invoker.getUrl();
                }

                public boolean isAvailable() {
                    return invoker.isAvailable();
                }

                public Result invoke(Invocation invocation) throws RpcException {
                    return filter.invoke(next, invocation);
                }

                public void destroy() {
                    invoker.destroy();
                }

                @Override
                public String toString() {
                    return invoker.toString();
                }
            };
        }
    }
    return last;
}

ProtocolListenerWrapper

public <T> Exporter<T> export(Invoker<T> invoker) throws RpcException {
    if (Constants.REGISTRY_PROTOCOL.equals(invoker.getUrl().getProtocol())) {
        return protocol.export(invoker);
    }
    return new ListenerExporterWrapper<T>(protocol.export(invoker), 
            Collections.unmodifiableList(ExtensionLoader.getExtensionLoader(ExporterListener.class)
                    .getActivateExtension(invoker.getUrl(), Constants.EXPORTER_LISTENER_KEY)));
}

最後會呼叫DubboProtocol的export方法

public <T> Exporter<T> export(Invoker<T> invoker) throws RpcException {
    URL url = invoker.getUrl();
    String key = serviceKey(url);
    DubboExporter<T> exporter = new DubboExporter(invoker, key, this.exporterMap);
    this.exporterMap.put(key, exporter);
    Boolean isStubSupportEvent = url.getParameter("dubbo.stub.event", false);
    Boolean isCallbackservice = url.getParameter("is_callback_service", false);
    if (isStubSupportEvent && !isCallbackservice) {
        String stubServiceMethods = url.getParameter("dubbo.stub.event.methods");
        if (stubServiceMethods != null && stubServiceMethods.length() != 0) {
            this.stubServiceMethodsMap.put(url.getServiceKey(), stubServiceMethods);
        } else if (this.logger.isWarnEnabled()) {
            this.logger.warn(new IllegalStateException("consumer [" + url.getParameter("interface") + "], has set stubproxy support event ,but no stub methods founded."));
        }
    }
	// 暴露服務
    this.openServer(url);
    return exporter;
}

openServer

// DubboProtocol
private void openServer(URL url) {
    String key = url.getAddress();
    boolean isServer = url.getParameter(Constants.IS_SERVER_KEY,true);
    if (isServer) {
       ExchangeServer server = serverMap.get(key);
       if (server == null) {
          // 如果沒有則建立服務並放入serverMap
          serverMap.put(key, createServer(url));
       } else {
          server.reset(url);
       }
    }
}

// DubboProtocol
private ExchangeServer createServer(URL url) {
    //預設開啟server關閉時傳送readonly事件
    url = url.addParameterIfAbsent(Constants.CHANNEL_READONLYEVENT_SENT_KEY, Boolean.TRUE.toString());
    //預設開啟heartbeat
    url = url.addParameterIfAbsent(Constants.HEARTBEAT_KEY, String.valueOf(Constants.DEFAULT_HEARTBEAT));
    String str = url.getParameter(Constants.SERVER_KEY, Constants.DEFAULT_REMOTING_SERVER);

    if (str != null && str.length() > 0 && ! ExtensionLoader.getExtensionLoader(Transporter.class).hasExtension(str))
        throw new RpcException("Unsupported server type: " + str + ", url: " + url);

    url = url.addParameter(Constants.CODEC_KEY, Version.isCompatibleVersion() ? COMPATIBLE_CODEC_NAME : DubboCodec.NAME);
    ExchangeServer server;
    try {
        server = Exchangers.bind(url, requestHandler);
    } catch (RemotingException e) {
        throw new RpcException("Fail to start server(url: " + url + ") " + e.getMessage(), e);
    }
    str = url.getParameter(Constants.CLIENT_KEY);
    if (str != null && str.length() > 0) {
        Set<String> supportedTypes = ExtensionLoader.getExtensionLoader(Transporter.class).getSupportedExtensions();
        if (!supportedTypes.contains(str)) {
            throw new RpcException("Unsupported client type: " + str);
        }
    }
    return server;
}

Exchangers

public static ExchangeServer bind(URL url, ExchangeHandler handler) throws RemotingException {
    if (url == null) {
        throw new IllegalArgumentException("url == null");
    }
    if (handler == null) {
        throw new IllegalArgumentException("handler == null");
    }
    url = url.addParameterIfAbsent(Constants.CODEC_KEY, "exchange");
    // 呼叫HeaderExchanger的bind方法
    return getExchanger(url).bind(url, handler);
}

public static Exchanger getExchanger(URL url) {
    String type = url.getParameter(Constants.EXCHANGER_KEY, Constants.DEFAULT_EXCHANGER);
    return getExchanger(type);
}

public static Exchanger getExchanger(String type) {
    // 獲取指定名稱擴充套件點，預設名稱為header，因此會返回HeaderExchanger例項
    return ExtensionLoader.getExtensionLoader(Exchanger.class).getExtension(type);
}

HeaderExchanger

public ExchangeServer bind(URL url, ExchangeHandler handler) throws RemotingException {
    return new HeaderExchangeServer(Transporters.bind(url, new DecodeHandler(new HeaderExchangeHandler(handler))));
}

Transporters

public static Server bind(URL url, ChannelHandler... handlers) throws RemotingException {
    if (url == null) {
        throw new IllegalArgumentException("url == null");
    }
    if (handlers == null || handlers.length == 0) {
        throw new IllegalArgumentException("handlers == null");
    }
    ChannelHandler handler;
    if (handlers.length == 1) {
        handler = handlers[0];
    } else {
        handler = new ChannelHandlerDispatcher(handlers);
    }
    return getTransporter().bind(url, handler);
}

public static Transporter getTransporter() {
    // 獲取自適應的Transporter實現
    return ExtensionLoader.getExtensionLoader(Transporter.class).getAdaptiveExtension();
}

NettyTransporter

public Server bind(URL url, ChannelHandler listener) throws RemotingException {
    return new NettyServer(url, listener);
}

NettyServer

protected void doOpen() throws Throwable {
    NettyHelper.setNettyLoggerFactory();
    ExecutorService boss = Executors.newCachedThreadPool(new NamedThreadFactory("NettyServerBoss", true));
    ExecutorService worker = Executors.newCachedThreadPool(new NamedThreadFactory("NettyServerWorker", true));
    ChannelFactory channelFactory = new NioServerSocketChannelFactory(boss, worker, getUrl().getPositiveParameter(Constants.IO_THREADS_KEY, Constants.DEFAULT_IO_THREADS));
    bootstrap = new ServerBootstrap(channelFactory);
    
    final NettyHandler nettyHandler = new NettyHandler(getUrl(), this);
    channels = nettyHandler.getChannels();
    // https://issues.jboss.org/browse/NETTY-365
    // https://issues.jboss.org/browse/NETTY-379
    // final Timer timer = new HashedWheelTimer(new NamedThreadFactory("NettyIdleTimer", true));
    bootstrap.setPipelineFactory(new ChannelPipelineFactory() {
        public ChannelPipeline getPipeline() {
            NettyCodecAdapter adapter = new NettyCodecAdapter(getCodec() ,getUrl(), NettyServer.this);
            ChannelPipeline pipeline = Channels.pipeline();
            /*int idleTimeout = getIdleTimeout();
            if (idleTimeout > 10000) {
                pipeline.addLast("timer", new IdleStateHandler(timer, idleTimeout / 1000, 0, 0));
            }*/
            pipeline.addLast("decoder", adapter.getDecoder());
            pipeline.addLast("encoder", adapter.getEncoder());
            pipeline.addLast("handler", nettyHandler);
            return pipeline;
        }
    });
    // bind
    channel = bootstrap.bind(getBindAddress());
}

服務註冊過程

Dubbo釋出服務

回到RegistryProtocol的export方法

public <T> Exporter<T> export(final Invoker<T> originInvoker) throws RpcException {
    // 本地釋出
    final ExporterChangeableWrapper<T> exporter = doLocalExport(originInvoker);
    // 獲取註冊中心
    final Registry registry = getRegistry(originInvoker);
    final URL registedProviderUrl = getRegistedProviderUrl(originInvoker);
    // 註冊服務
    registry.register(registedProviderUrl);
    final URL overrideSubscribeUrl = getSubscribedOverrideUrl(registedProviderUrl);
    final OverrideListener overrideSubscribeListener = new OverrideListener(overrideSubscribeUrl);
    overrideListeners.put(overrideSubscribeUrl, overrideSubscribeListener);
    registry.subscribe(overrideSubscribeUrl, overrideSubscribeListener);
    return new Exporter<T>() {
        public Invoker<T> getInvoker() {
            return exporter.getInvoker();
        }
        public void unexport() {
           try {
              exporter.unexport();
           } catch (Throwable t) {
               logger.warn(t.getMessage(), t);
            }
            try {
               registry.unregister(registedProviderUrl);
            } catch (Throwable t) {
               logger.warn(t.getMessage(), t);
            }
            try {
               overrideListeners.remove(overrideSubscribeUrl);
               registry.unsubscribe(overrideSubscribeUrl, overrideSubscribeListener);
            } catch (Throwable t) {
               logger.warn(t.getMessage(), t);
            }
        }
    };
}

根據invoker地址獲取registry例項

private Registry getRegistry(final Invoker<?> originInvoker){
    // registryUrl = registry://172.16.105.128:2181/......
    URL registryUrl = originInvoker.getUrl();
    if (Constants.REGISTRY_PROTOCOL.equals(registryUrl.getProtocol())) {
        String protocol = registryUrl.getParameter(Constants.REGISTRY_KEY, Constants.DEFAULT_DIRECTORY);
        // registryUrl轉換為 zookeeper://172.16.105.128:2181/......
        registryUrl = registryUrl.setProtocol(protocol).removeParameter(Constants.REGISTRY_KEY);
    }
    return registryFactory.getRegistry(registryUrl);
}

RegistryFactory是一個擴充套件點且在getRegistry方法上存在一個@Adaptive註解，說明會動態生成一個自適應的介面卡，所以就是RegistryFactory$Adpative

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

RegistryFactory$Adpative

public class RegistryFactory$Adpative implements com.alibaba.dubbo.registry.RegistryFactory {
    
    public com.alibaba.dubbo.registry.Registry getRegistry(com.alibaba.dubbo.common.URL arg0) {
        if (arg0 == null) throw new IllegalArgumentException("url == null");
        com.alibaba.dubbo.common.URL url = arg0;
        String extName = (url.getProtocol() == null ? "dubbo" : url.getProtocol());
        if (extName == null)
            throw new IllegalStateException("Fail to get extension(com.alibaba.dubbo.registry.RegistryFactory) name from url(" + url.toString() + ") use keys([protocol])");
        // 這裡extName為zookeeper
        com.alibaba.dubbo.registry.RegistryFactory extension = (com.alibaba.dubbo.registry.RegistryFactory) ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.registry.RegistryFactory.class).getExtension(extName);
        // extension為ZookeeperRegistryFactory
        return extension.getRegistry(arg0);
    }
}

公共邏輯在父類AbstractRegistryFactory中實現，並定義模板方法

public Registry getRegistry(URL url) {
    url = url.setPath(RegistryService.class.getName()).addParameter("interface", RegistryService.class.getName()).removeParameters(new String[]{"export", "refer"});
    String key = url.toServiceString();
    LOCK.lock();

    Registry var4;
    try {
        // 從快取中獲取指定key的Registry，沒有則建立
        Registry registry = (Registry)REGISTRIES.get(key);
        if (registry == null) {
            // 建立Registry
            registry = this.createRegistry(url);
            if (registry == null) {
                throw new IllegalStateException("Can not create registry " + url);
            }

            REGISTRIES.put(key, registry);
            var4 = registry;
            return var4;
        }

        var4 = registry;
    } finally {
        LOCK.unlock();
    }

    return var4;
}

// 模板方法
protected abstract Registry createRegistry(URL var1);

ZookeeperRegistryFactory

public Registry createRegistry(URL url) {
    return new ZookeeperRegistry(url, this.zookeeperTransporter);
}

回到RegistryProtocol的export方法，檢視register註冊服務方法

public <T> Exporter<T> export(final Invoker<T> originInvoker) throws RpcException {
    // 本地釋出
    final ExporterChangeableWrapper<T> exporter = doLocalExport(originInvoker);
    // 獲取註冊中心
    final Registry registry = getRegistry(originInvoker);
    final URL registedProviderUrl = getRegistedProviderUrl(originInvoker);
    // 註冊服務>>
    registry.register(registedProviderUrl);
    final URL overrideSubscribeUrl = getSubscribedOverrideUrl(registedProviderUrl);
    final OverrideListener overrideSubscribeListener = new OverrideListener(overrideSubscribeUrl);
    overrideListeners.put(overrideSubscribeUrl, overrideSubscribeListener);
    registry.subscribe(overrideSubscribeUrl, overrideSubscribeListener);
    return new Exporter<T>() {
        public Invoker<T> getInvoker() {
            return exporter.getInvoker();
        }
        public void unexport() {
           try {
              exporter.unexport();
           } catch (Throwable t) {
               logger.warn(t.getMessage(), t);
            }
            try {
               registry.unregister(registedProviderUrl);
            } catch (Throwable t) {
               logger.warn(t.getMessage(), t);
            }
            try {
               overrideListeners.remove(overrideSubscribeUrl);
               registry.unsubscribe(overrideSubscribeUrl, overrideSubscribeListener);
            } catch (Throwable t) {
               logger.warn(t.getMessage(), t);
            }
        }
    };
}

跟蹤到ZookeeperRegistry，不存在register方法，而是在其父類FailbackRegistry中

public void register(URL url) {
    super.register(url); // 將其新增到已註冊map中
    failedRegistered.remove(url);
    failedUnregistered.remove(url);
    try {
        // 執行註冊
        doRegister(url);
    } catch (Exception e) {
        Throwable t = e;
        // 如果開啟了啟動時檢測，則直接丟擲異常
        boolean check = getUrl().getParameter(Constants.CHECK_KEY, true)
                && url.getParameter(Constants.CHECK_KEY, true)
                && ! Constants.CONSUMER_PROTOCOL.equals(url.getProtocol());
        boolean skipFailback = t instanceof SkipFailbackWrapperException;
        if (check || skipFailback) {
            if(skipFailback) {
                t = t.getCause();
            }
            throw new IllegalStateException("Failed to register " + url + " to registry " + getUrl().getAddress() + ", cause: " + t.getMessage(), t);
        } else {
            logger.error("Failed to register " + url + ", waiting for retry, cause: " + t.getMessage(), t);
        }
        // 將失敗的註冊請求記錄到失敗列表，定時重試
        failedRegistered.add(url);
    }
}

ZookeeperRegistry

protected void doRegister(URL url) {
    try {
        // 呼叫zkclient在zookeeper中建立節點
       zkClient.create(toUrlPath(url), url.getParameter(Constants.DYNAMIC_KEY, true));
    } catch (Throwable e) {
        throw new RpcException("Failed to register " + url + " to zookeeper " + getUrl() + ", cause: " + e.getMessage(), e);
    }
}

至此，整個服務釋出和註冊過程完成。

Dubbo原始碼之服務端的釋出
2019-03-28
原始碼服務端
Dubbo原始碼解析之服務匯出過程
2019-04-03
原始碼
Dubbo原始碼解析之服務叢集
2019-04-11
原始碼
Dubbo原理和原始碼解析之服務引用
2020-12-11
原始碼
Dubbo原始碼解析之服務引入過程
2019-04-04
原始碼
Dubbo原始碼解析之服務呼叫過程
2019-04-08
原始碼
Dubbo服務暴露原始碼解析②
2020-12-26
原始碼
Apache Dubbo 原始碼搭建與解讀（八）—— Dubbo 註冊中心之ZooKeeper
2020-10-15
Apache原始碼
Dubbo原始碼解析之服務端接收訊息
2018-11-04
原始碼服務端
Dubbo原始碼學習之-服務匯出
2019-08-04
原始碼
Dubbo原始碼之服務引用
2019-03-28
原始碼
Dubbo服務呼叫過程原始碼解析④
2020-12-27
原始碼
Dubbo2.7.3版本原始碼學習系列六: Dubbo服務匯出原始碼解析
2020-11-01
原始碼
Dubbo原始碼分析之服務引用
2018-04-23
原始碼
Dubbo原始碼分析之服務暴露
2018-04-23
原始碼
服務註冊與發現之ETCD
2021-06-14
springcloud之服務註冊與發現
2018-05-31
SpringGCCloud
Dubbo原始碼解析之客戶端初始化及服務呼叫
2018-11-04
原始碼客戶端
註冊中心 Eureka 原始碼解析 —— 應用例項註冊發現（一）之註冊
2019-03-03
原始碼
Dubbo原始碼解析之SPI
2018-10-31
原始碼
微服務SpringCloud之服務註冊與發現
2019-06-30
微服務SpringGCCloud
SpringCloud之服務註冊
2021-09-09
SpringGCCloud
微服務Consul系列之服務註冊與發現
2019-04-09
微服務
微服務架構 | *3.5 Nacos 服務註冊與發現的原始碼分析
2022-01-19
微服務架構原始碼
dubbo服務者原始碼分期
2020-04-05
原始碼
spring cloud gateway之服務註冊與發現
2019-03-04
SpringCloudGateway
Spring Cloud Eureka原始碼分析之服務註冊的流程與資料儲存設計！
2021-12-14
SpringCloud原始碼
Laravel-admin 原始碼分析系列 1——註冊服務與安裝分析
2019-08-03
Laravel原始碼
微服務架構之「服務註冊」
2019-04-08
微服務架構
Dubbo系列之（二）Registry註冊中心-註冊（1）
2020-08-09
Dubbo系列之（二）Registry註冊中心-註冊（2）
2020-08-13
Dubbo+Nacos實現服務註冊和發現
2020-08-14
dubbo原始碼解析之負載均衡
2020-06-29
原始碼負載
Dubbo原始碼解析之SPI機制
2019-04-02
原始碼
dubbo原始碼解析之ExtensionLoader類（二）
2018-10-14
原始碼
dubbo原始碼解析之基礎篇
2018-10-14
原始碼
服務註冊中心之Eureka使用
2021-10-11
Spring原始碼之預設標籤解析及BeanDefinition註冊
2022-04-08
Spring原始碼Bean

Dubbo原始碼解析之服務釋出與註冊

準備

Spring自定義擴充套件

服務釋出過程

服務註冊過程

相關文章