Dubbo源码通~服务暴露之远程暴露

最新推荐文章于 2022-09-26 11:00:03 发布

一只打杂的码农

最新推荐文章于 2022-09-26 11:00:03 发布

阅读量435

点赞数 1

分类专栏： Dubbo源码通文章标签：服务暴露远程暴露

本文链接：https://blog.csdn.net/lhqj1992/article/details/94663047

版权

Dubbo源码通专栏收录该内容

4 篇文章 0 订阅

订阅专栏

Dubbo服务暴露~远程暴露

远程暴露有两种情况：

配置了注册中心的，需要将服务注册到注册中心
未配置注册中心的，仅仅将服务按照远程协议暴露出来

1、未配置注册中心（用于服务消费者直连服务提供者）

具体步骤如下：

创建Invoker的步骤和Injvm的方式相同；
创建DelegateProviderMetaDataInvoker对象，持有Invoker和ServiceConfig对象；
创建Exporter对象，步骤和Injvm相同。

和本地暴露的区别：

Invoker对象是： DelegateProviderMetaDataInvoker
Exporter中的Protocol扩展类不同（根据服务暴露配置或者默认）

2、配置了注册中心

包含两个步骤：服务导出和服务注册

// NOTE1: 创建Invoker
Invoker<?> invoker = proxyFactory.getInvoker(ref, (Class) interfaceClass, registryURL.addParameterAndEncoded(Constants.EXPORT_KEY, url.toFullString()));

// NOTE: DelegateProviderMetaDataInvoker 用于持有 Invoker 和 ServiceConfig
DelegateProviderMetaDataInvoker wrapperInvoker = new DelegateProviderMetaDataInvoker(invoker, this);

// NOTE2: 导出服务，并生成 Exporter
Exporter<?> exporter = protocol.export(wrapperInvoker);

2.1、创建Invoker

与无注册中心服务暴露创建Invoker的过程基本相同路径：ProxyFactory$Adaptive => StubProxyFactoryWrapper => JavassistProxyFactory => Wrapper => AbstractProxyInvoker => DelegateProviderMetaDataInvoker。
内部的URL配置协议头为“registry”

registry://127.0.0.1:2181/org.apache.dubbo.registry.RegistryService?application=demo-provider&dubbo=2.0.2&......&pid=10421&qos.port=22222&registry=zookeeper&timestamp=1561639865358

2.2、创建Export并暴露

启动通信服务器，绑定服务端口，提供远程调用
向注册中心注册服务提供者，提供服务消费者从注册中心发现服务。

2.2.1、调用主路径

路径：由两个小链路构成一个大链路

链路1: Protocol$Adaptive => ProtocolFilterWrapper => ProtocolListenerWrapper => RegistryProtocol【RegistryFactory$Adaptive => ProxyFactory$Adaptive => Protocol$Adaptive => Cluster$Adaptive】=> Protocol$Adaptive
链路2： Protocol$Adaptive => ProtocolFilterWrapper => ProtocolListenerWrapper => DubboProtocol => DubboExporter => 服务注册
通信服务器启动：DubboProtocol => ExchangeServer => Transporters => NettyServer

创建RegistryProtocol扩展类时的内部属性关系图 (大佬的图)
注册中心服务暴露流程图

2.2.2、调用步骤描述

首先，传入的是注册中心的 URL（registryURL），通过 Protocol$Adaptive 获取到的是 RegistryProtocol 对象。
其次，RegistryProtocol 会在其 #export(…) 方法中，使用服务提供者的 URL ( 即注册中心的 URL 的 export 参数值)，再次调用 Protocol$Adaptive 获取到的是 DubboProtocol 对象，创建DubboExporter。
在DubboProtocol中启动通信服务器(默认为NettyServer)。
最后，向注册中心注册服务提供者的URL。

2.3、服务导出和通信服务器启动（走代码）

1、RegistryProtocol

调用 doLocalExport 导出服务（对应NOTE 1）
向注册中心注册服务（对应NOTE 2）
~~向注册中心进行订阅 override 数据~~
创建并返回 DestroyableExporter（对应NOTE 3）

//☆☆--RegistryProtocol
public <T> Exporter<T> export(final Invoker<T> originInvoker) throws RpcException {
    // NOTE: 获取注册中心 URL
    URL registryUrl = getRegistryUrl(originInvoker);
    //NOTE: 服务暴露URL
    URL providerUrl = getProviderUrl(originInvoker);
    
    //NOTE:  获取订阅 URL(provider开头)
    final URL overrideSubscribeUrl = getSubscribedOverrideUrl(providerUrl);

    //NOTE: 使用 OverrideListener 对象，订阅配置规则
    final OverrideListener overrideSubscribeListener = new OverrideListener(overrideSubscribeUrl, originInvoker);
    overrideListeners.put(overrideSubscribeUrl, overrideSubscribeListener);

    providerUrl = overrideUrlWithConfig(providerUrl, overrideSubscribeListener);

    //NOTE 1:  创建Exporter，暴露服务
    final ExporterChangeableWrapper<T> exporter = doLocalExport(originInvoker, providerUrl);

    // NOTE: 根据 URL 加载 Registry 实现类，比如 ZookeeperRegistry(这里不是SPI 机制)
    final Registry registry = getRegistry(originInvoker);
    // NOTE: 获取已注册的服务提供者 URL
    final URL registeredProviderUrl = getRegisteredProviderUrl(providerUrl, registryUrl);
    //NOTE: 向本地注册表，注册服务提供者
    ProviderInvokerWrapper<T> providerInvokerWrapper = ProviderConsumerRegTable.registerProvider(originInvoker,
            registryUrl, registeredProviderUrl);
    //to judge if we need to delay publish
    boolean register = registeredProviderUrl.getParameter("register", true);
    if (register) {
        // NOTE 2: 向注册中心注册服务
        register(registryUrl, registeredProviderUrl);
        providerInvokerWrapper.setReg(true);
    }
    exporter.setRegisterUrl(registeredProviderUrl);
    exporter.setSubscribeUrl(overrideSubscribeUrl);
    
    // NOTE 3: 创建并返回 DestroyableExporter
    return new DestroyableExporter<>(exporter);
}

2、RegistryProtocol.doLocalExport

/**
 * 服务导出
 */
private <T> ExporterChangeableWrapper<T> doLocalExport(final Invoker<T> originInvoker, URL providerUrl) {
//NOTE：缓存
    String key = getCacheKey(originInvoker);
    ExporterChangeableWrapper<T> exporter = (ExporterChangeableWrapper<T>) bounds.get(key);
    if (exporter == null) {
        synchronized (bounds) {
            exporter = (ExporterChangeableWrapper<T>) bounds.get(key);
            if (exporter == null) {
                //NOTE：创建 Invoker 为委托类对象，将providerUrl和originInvoker封装
                final Invoker<?> invokerDelegete = new InvokerDelegate<T>(originInvoker, providerUrl);
                //NOTE: DubboProtocol export创建Exporter，进行服务暴露
                /**
                 * 使用【创建的 Exporter 对象】+【originInvoker】，创建 ExporterChangeableWrapper 对象。这样，originInvoker 就和 Exporter 对象，形成了绑定的关系
                 */
                exporter = new ExporterChangeableWrapper<T>((Exporter<T>) protocol.export(invokerDelegete), originInvoker);
                bounds.put(key, exporter);
            }
        }
    }
    return exporter;
}

3、DubboProtocol.export(invokerDelegete)

创建DubboExporter（对应NOTE 1）
创建并启动通信服务器
优化序列化

//☆☆--DubboProtocol
public <T> Exporter<T> export(Invoker<T> invoker) throws RpcException {
    //对应的是providerUrl
    URL url = invoker.getUrl();
    // NOTE: 获取服务标识，由服务组名，服务名，服务版本号以及端口组成
    String key = serviceKey(url);

    //NOTE 1: 创建DubboExporter对象
    DubboExporter<T> exporter = new DubboExporter<T>(invoker, key, exporterMap);
    // NOTE: 将 <key, exporter> 键值对放入缓存中
    exporterMap.put(key, exporter);
    ......
    
    // NOTE 2 : 启动服务器(netty 通讯)
    openServer(url);
    
    // NOTE 3: 优化序列化
    optimizeSerialization(url);
    return exporter;
}

创建并启动通信服务器

private void openServer(URL url) {
    // NOTE: 取 host:port，并将其作为服务器实例的 key，用于标识当前的服务器实例。在同一台机器上，同一个端口上仅允许启动一个服务器实例。
    String key = url.getAddress();
    boolean isServer = url.getParameter(Constants.IS_SERVER_KEY, true);
    if (isServer) {
        ExchangeServer server = serverMap.get(key);
        if (server == null) {
            synchronized (this) {
                server = serverMap.get(key);
                if (server == null) {
                    serverMap.put(key, createServer(url));
                }
            }
        } else {
            server.reset(url);
        }
    }
}

/**
 * NOTE: 创建通信服务器(服务层)
 *  1、检测是否存在 server 参数所代表的 Transporter 拓展，不存在则抛出异常
 *  2、创建ExchangerServer服务器实例
 *  3、检测是否支持 client 参数所表示的 Transporter 拓展
 */
private ExchangeServer createServer(URL url) {
    url = url.addParameterIfAbsent(Constants.CHANNEL_READONLYEVENT_SENT_KEY, Boolean.TRUE.toString());
    //NOTE: 添加心跳检测配置到 url 中，默认60秒
    url = url.addParameterIfAbsent(Constants.HEARTBEAT_KEY, String.valueOf(Constants.DEFAULT_HEARTBEAT));
    // NOTE: 获取 server 参数，默认为 netty
    String str = url.getParameter(Constants.SERVER_KEY, Constants.DEFAULT_REMOTING_SERVER);

    // NOTE: 通过 SPI 检测是否存在 server 参数所代表的 Transporter 拓展，不存在则抛出异常
    ......代码省略

    // NOTE: 添加编码解码器参数(默认为'dubbo')
    url = url.addParameter(Constants.CODEC_KEY, DubboCodec.NAME);
    ExchangeServer server;
    try {
        //NOTE: 创建ExchangerServer服务器
        server = Exchangers.bind(url, requestHandler);
    } catch (RemotingException e) {
        throw new RpcException("Fail to start server(url: " + url + ") " + e.getMessage(), e);
    }
    
    //是否支持 client 参数所表示的 Transporter 拓展
    ......省略client的校验代码
    return server;
}

Exchangers.bind(url, requestHandler)

//☆☆--Exchangers
public static ExchangeServer bind(URL url, ExchangeHandler handler) throws RemotingException {
    url = url.addParameterIfAbsent(Constants.CODEC_KEY, "exchange");
    //获得Exchanger的扩展实现类：HeaderExchanger
    Exchanger exchanger =  ExtensionLoader.getExtensionLoader(Exchanger.class).getExtension(type);
    return exchanger.bind(url, handler);
}

//☆☆--HeaderExchanger
public class HeaderExchanger implements Exchanger {
    @Override
    public ExchangeServer bind(URL url, ExchangeHandler handler) throws RemotingException {
        // NOTE: 这里包含了多个调用，分别如下：
        // 1. 创建 HeaderExchangeHandler 对象
        // 2. 创建 DecodeHandler 对象
        // 3. 通过 Transporters 构建 Server 实例(默认NettyServer，NettyTransporter)
        // 4. 创建 HeaderExchangeServer 对象
        return new HeaderExchangeServer(Transporters.bind(url, new DecodeHandler(new HeaderExchangeHandler(handler))));
    }   
}

//☆☆--Transporters
public static Server bind(URL url, ChannelHandler... handlers) throws RemotingException {
    if (handlers.length == 1) {
        handler = handlers[0];
    } else {//如果 handlers 元素数量大于1，则创建 ChannelHandler 分发器
        handler = new ChannelHandlerDispatcher(handlers);
    }
    // NOTE: 获取自适应 Transporter 实例，并调用实例方法(默认为NettyTransporter)
    return getTransporter().bind(url, handler);
}

//☆☆--NettyTransporter
public class NettyTransporter implements Transporter {
    @Override
    public Server bind(URL url, ChannelHandler listener) throws RemotingException {
        // NOTE: 创建Netty Server 并调用内部的doOpen()方法启动服务 
        return new NettyServer(url, listener);
    }
}

2.4、服务注册（走代码）

调用DubboProtocol创建Exporter后，会根据

exporter = new ExporterChangeableWrapper<T>((Exporter<T>) protocol.export(invokerDelegete), originInvoker);

获得注册中心实例
向注册中心注册服务提供者URL

2.4.1、获得注册中心实例（工厂）

根据registryUrl获取对应的Registry扩展类（以ZookeeperRegistry为例）
在这里插入图片描述

//RegistryProtocol
Registry registry = registryFactory.getRegistry(registryUrl);

//根据registryUrl获得对应的Registry：ZookeeperRegistry、DubboRegistry等
private Registry getRegistry(final Invoker<?> originInvoker) {
    URL registryUrl = getRegistryUrl(originInvoker);
    return registryFactory.getRegistry(registryUrl);
}

//☆☆--AbstractRegistryFactory
public Registry getRegistry(URL url) {
    url = url.setPath(RegistryService.class.getName())
            .addParameter(Constants.INTERFACE_KEY, RegistryService.class.getName())
            .removeParameters(Constants.EXPORT_KEY, Constants.REFER_KEY);
    String key = url.toServiceStringWithoutResolving();
    // 创建Registry时，需要加锁
    LOCK.lock();
    try {
        Registry registry = REGISTRIES.get(key);
        if (registry != null) {
            return registry;
        }
        //创建Registry
        registry = createRegistry(url);
        if (registry == null) {
            throw new IllegalStateException("Can not create registry " + url);
        }
        REGISTRIES.put(key, registry);
        return registry;
    } finally {
        // Release the lock
        LOCK.unlock();
    }
}

创建注册中心：ZookeeperRegistry

public class ZookeeperRegistryFactory extends AbstractRegistryFactory {

    private ZookeeperTransporter zookeeperTransporter;

    public void setZookeeperTransporter(ZookeeperTransporter zookeeperTransporter) {
        this.zookeeperTransporter = zookeeperTransporter;
    }

    @Override
    public Registry createRegistry(URL url) {
     //创建ZookeeperRegistry（内部默认的zkClient为：CuratorZookeeperClient）
        return new ZookeeperRegistry(url, zookeeperTransporter);
    }

}

2.4.2、向注册中心注册服务

注册中心注册服务其实就是将服务提供者的信息，封装到URL中，在注册中心（zk）上创建一个个节点。

 public void register(URL registryUrl, URL registeredProviderUrl) {
    Registry registry = registryFactory.getRegistry(registryUrl);
    // 注册服务
    registry.register(registeredProviderUrl);
}

15616491735842

主路径 ：RegistryProtocol => FailbackRegistry => ZookeeperRegistry => CuratorZookeeperClient

//☆☆---ZookeeperRegistry
 public void doRegister(URL url) {
    try {
        // NOTE:  通过 Zookeeper 客户端创建节点，节点路径由 toUrlPath 方法生成，路径格式如下:
        //  ${group}/${serviceInterface}/providers/${url}
        // NOTE:  比如: /dubbo/org.apache.dubbo.DemoService/providers/dubbo%3A%2F%2F127.0.0.1....
        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);
    }
}

zkClient中创建节点

//AbstractZookeeperClient
public void create(String path, boolean ephemeral) {
    if (!ephemeral) {
        if (checkExists(path)) {
            return;
        }
    }
    //NOTE: 层层解析，创建zk节点
    int i = path.lastIndexOf('/');
    if (i > 0) {
        create(path.substring(0, i), false);
    }
    //NOTE: 是否创建临时节点
    if (ephemeral) {
        createEphemeral(path);
    } else {
        createPersistent(path);
    }
}

//CuratorZookeeperClient
public void createEphemeral(String path) {
    try {
    // 通过 Curator 框架创建节点
client.create().withMode(CreateMode.EPHEMERAL).forPath(path);
    } catch (NodeExistsException e) {
    } catch (Exception e) {
        throw new IllegalStateException(e.getMessage(), e);
    }
}

3、总结

服务远程暴露，创建Invoker简单，但后续的服务导出流程比较长，主要在创建Exporter和服务注册过程很复杂。而且在RegistryProtocol和DubboProtocol执行逻辑中，都会用类似ProtocolFilterWrapper或者ProtocolListenerWrapper这种封装类来实现AoP增加一些功能。在服务注册过中，路径特别深，有一些我还没有深入，比如ExchangerServer的创建、Transporter的创建、Registry的创建细节。理解服务远程暴露主要包含：

将服务封装成一个Exoprter进行服务导出；
将服务提供者关联的URL配置信息，在注册中心按照目录结构创建一个个节点。（节点的信息是按照GIV的形式来构建的）

4、附件

RegistryProtocol内部注入的属性：RegistryFactory、Cluster

4.1、RegistryFactory$Adaptive

package org.apache.dubbo.registry;
import org.apache.dubbo.common.extension.ExtensionLoader;

public class RegistryFactory$Adaptive implements org.apache.dubbo.registry.RegistryFactory {

    public org.apache.dubbo.registry.Registry getRegistry(org.apache.dubbo.common.URL arg0) {
        if (arg0 == null) {
            throw new IllegalArgumentException("url == null");
        }

        org.apache.dubbo.common.URL url = arg0;
        String extName = ((url.getProtocol() == null) ? "dubbo" : url.getProtocol());

        if (extName == null) {
            throw new IllegalStateException(
                "Fail to get extension(org.apache.dubbo.registry.RegistryFactory) name from url(" +
                url.toString() + ") use keys([protocol])");
        }

        org.apache.dubbo.registry.RegistryFactory extension = (org.apache.dubbo.registry.RegistryFactory)ExtensionLoader.getExtensionLoader(org.apache.dubbo.registry.RegistryFactory.class).getExtension(extName);
        return extension.getRegistry(arg0);
    }
}

4.2、Cluster$Adaptive

package org.apache.dubbo.rpc.cluster;
import org.apache.dubbo.common.extension.ExtensionLoader;

public class Cluster$Adaptive implements org.apache.dubbo.rpc.cluster.Cluster {

    public org.apache.dubbo.rpc.Invoker join(org.apache.dubbo.rpc.cluster.Directory arg0)
        throws org.apache.dubbo.rpc.RpcException {
        if (arg0 == null) {
            throw new IllegalArgumentException(
                "org.apache.dubbo.rpc.cluster.Directory argument == null");
        }

        if (arg0.getUrl() == null) {
            throw new IllegalArgumentException(
                "org.apache.dubbo.rpc.cluster.Directory argument getUrl() == null");
        }

        org.apache.dubbo.common.URL url = arg0.getUrl();
        String extName = url.getParameter("cluster", "failover");

        if (extName == null) {
            throw new IllegalStateException(
                "Fail to get extension(org.apache.dubbo.rpc.cluster.Cluster) name from url(" +
                url.toString() + ") use keys([cluster])");
        }

        org.apache.dubbo.rpc.cluster.Cluster extension = (org.apache.dubbo.rpc.cluster.Cluster) ExtensionLoader.getExtensionLoader(org.apache.dubbo.rpc.cluster.Cluster.class).getExtension(extName);

        return extension.join(arg0);
    }
}