Dubbo服务导出如何实现的？我们从中能够学习到什么？

Dubbo通过注解或者xml形式标识Dubbo服务，在Spring 容器发布刷新事件，会立即执行服务导出逻辑，示例如下：

import com.alibaba.dubbo.config.annotation.Service;
import org.springframework.beans.factory.annotation.Autowired;

import java.util.List;
import java.util.stream.Collectors;

/**
 * 价格服务
 **/
@Service
@Component
public class PriceFacade implements IPriceFacade {
}

Dubbo服务导出分为本地导出和远程导出，本地服务导出就是本地方法的调用，远程导出就是通过设置的通信方式进行远程服务调用，服务导出后，Dubbo还支持向不同的注册中心注册导出的服务。以下重点分析多协议多注册中心服务导出的过程，其大致流程如下：

简单总结服务导出的流程，就是Dubbo根据设置的协议导出服务，如果是远程服务导出，则根据设置的协议，例如TCP/IP或者HTTP协议进行远程通信。如果设置了服务注册中心，则会在服务导出后，向注册中心注册服务。

在Dubbo中，对于协议Protocol，通信Transporter，以及服务注册Registry的选择都是基于Dubbo SPI自适应机制实现的。如果，配置了服务导出的过滤器或者监听器，也会根据Dubbo SPI自动激活的机制加载对应的集合对象。Dubbo SPI的机制详解可以参考Dubbo SPI是什么？Dubbo SPI如何实现？我们从中能够学习到什么？。

多协议多注册中心

在Spring 容器发布刷新事件，会调用Dubbo配置ServiceConfig的export方法进行服务导出。在doExportUrls方法中执行多协议多注册中心的服务导出逻辑。在doExportUrlsFor1Protocol方法中，根据到协议导出服务，根据配置执行本地服务导出或远程服务导出，并且根据是否有注册中心的配置执行舒服注册逻辑，其部分源码如下：

// ServiceConfig.class
// 服务导出
public synchronized void export() {
        if (!shouldExport()) {
            return;
        }

        if (bootstrap == null) {
            bootstrap = DubboBootstrap.getInstance();
            bootstrap.init();
        }

        //------- 省略 ---------//

        if (shouldDelay()) {
            DELAY_EXPORT_EXECUTOR.schedule(this::doExport, getDelay(), TimeUnit.MILLISECONDS);
        } else {
            doExport();
        }

        exported();
    }

// ServiceConfig.class
// 多协议服务导出，多注册中心注册
protected synchronized void doExport() {
        if (unexported) {
            throw new IllegalStateException("The service " + interfaceClass.getName() + " has already unexported!");
        }
        if (exported) {
            return;
        }
        exported = true;

        if (StringUtils.isEmpty(path)) {
            path = interfaceName;
        }
        doExportUrls();
    }

// ServiceConfig.class
// 服务导出
private void doExportUrls() {
        ServiceRepository repository = ApplicationModel.getServiceRepository();
        ServiceDescriptor serviceDescriptor = repository.registerService(getInterfaceClass());
        repository.registerProvider(
                getUniqueServiceName(),
                ref,
                serviceDescriptor,
                this,
                serviceMetadata
        );
        // 注册中心URL
        List<URL> registryURLs = ConfigValidationUtils.loadRegistries(this, true);
        // 多协议
        for (ProtocolConfig protocolConfig : protocols) {
            String pathKey = URL.buildKey(getContextPath(protocolConfig)
                    .map(p -> p + "/" + path)
                    .orElse(path), group, version);
         repository.registerService(pathKey, interfaceClass);
            serviceMetadata.setServiceKey(pathKey);
            // 单个协议的服务导出
            doExportUrlsFor1Protocol(protocolConfig, registryURLs);
        }
    }

// ServiceConfig.class
// 单个协议的服务导出
private void doExportUrlsFor1Protocol(ProtocolConfig protocolConfig, List<URL> registryURLs) {
        String name = protocolConfig.getName();
        if (StringUtils.isEmpty(name)) {
            name = DUBBO;
        }

        //------- 省略参数设置部分 --------//
        // 服务导出
        if (!SCOPE_NONE.equalsIgnoreCase(scope)) {

            // 本地服务导出
            if (!SCOPE_REMOTE.equalsIgnoreCase(scope)) {
                exportLocal(url);
            }
            // 远程服务导出
            if (!SCOPE_LOCAL.equalsIgnoreCase(scope)) {
                // 包含注册中心配置
                if (CollectionUtils.isNotEmpty(registryURLs)) {
                    for (URL registryURL : registryURLs) {
                        if (LOCAL_PROTOCOL.equalsIgnoreCase(url.getProtocol())) {
                            continue;
                        }
                        url = url.addParameterIfAbsent(DYNAMIC_KEY, registryURL.getParameter(DYNAMIC_KEY));
                        // 监视器配置
                        URL monitorUrl = ConfigValidationUtils.loadMonitor(this, registryURL);
                        if (monitorUrl != null) {
                            url = url.addParameterAndEncoded(MONITOR_KEY, monitorUrl.toFullString());
                        } 
                        String proxy = url.getParameter(PROXY_KEY);
                        if (StringUtils.isNotEmpty(proxy)) {
                            registryURL = registryURL.addParameter(PROXY_KEY, proxy);
                        }
                        // 动态代理生成Invoker
                        Invoker<?> invoker = PROXY_FACTORY.getInvoker(ref, (Class) 
                        // Invoker包装类
interfaceClass, registryURL.addParameterAndEncoded(EXPORT_KEY, url.toFullString()));
                        DelegateProviderMetaDataInvoker wrapperInvoker = new DelegateProviderMetaDataInvoker(invoker, this);
                        // 协议导出服务
                        Exporter<?> exporter = PROTOCOL.export(wrapperInvoker);
                        exporters.add(exporter);
                    }
                }
// 没有注册中心直接导出服务
 else {
                    // 动态代理生成Invoker
                    Invoker<?> invoker = PROXY_FACTORY.getInvoker(ref, (Class) interfaceClass, url);
                    DelegateProviderMetaDataInvoker wrapperInvoker = new DelegateProviderMetaDataInvoker(invoker, this);
                    // 协议导出服务
                    Exporter<?> exporter = PROTOCOL.export(wrapperInvoker);
                    exporters.add(exporter);
                }

                WritableMetadataService metadataService = WritableMetadataService.getExtension(url.getParameter(METADATA_KEY, DEFAULT_METADATA_STORAGE_TYPE));
                if (metadataService != null) {
                    metadataService.publishServiceDefinition(url);
                }
            }
        }
        this.urls.add(url);
    }

动态代理Invoker

在服务导出过程中，使用动态代理的技术，把所有dubbo服务都转换为Invoker对象，通过调用invoke方法，Invoker统一了所有服务的调用方式，Invoker接口定义如下：

public interface Invoker<T> extends Node {

    /**
     * 调用服务Class对象
     */
    Class<T> getInterface();

    /**
     * 代理方法，invocation封装了服务调用参数
     */
    Result invoke(Invocation invocation) throws RpcException;

}

在Dubbo中，使用Javassist和JDK动态代理两种方式，实现了服务代理类生成，Dubbo默认使用Javassist方式。具体的动态代理定义可以参考代理（Proxy）是什么?为什么要使用代理模式？Spring与Dubbo如何运用代理模式的？。Javassist和JDK动态代理两种生成Invoker的源码如下：

/**
 * javassist
 */
public class JavassistProxyFactory extends AbstractProxyFactory {

    @Override
    @SuppressWarnings("unchecked")
    public <T> T getProxy(Invoker<T> invoker, Class<?>[] interfaces) {
        return (T) Proxy.getProxy(interfaces).newInstance(new InvokerInvocationHandler(invoker));
    }

    @Override
    public <T> Invoker<T> getInvoker(T proxy, Class<T> type, URL url) {
        // TODO Wrapper cannot handle this scenario correctly: the classname contains '$'
        final Wrapper wrapper = Wrapper.getWrapper(proxy.getClass().getName().indexOf('$') < 0 ? proxy.getClass() : type);
        return new AbstractProxyInvoker<T>(proxy, type, url) {
            @Override
            protected Object doInvoke(T proxy, String methodName,
                                      Class<?>[] parameterTypes,
                                      Object[] arguments) throws Throwable {
                return wrapper.invokeMethod(proxy, methodName, parameterTypes, arguments);
            }
        };
    }

}

/**
 * Jdk动态代理
 */
public class JdkProxyFactory extends AbstractProxyFactory {

    @Override
    @SuppressWarnings("unchecked")
    public <T> T getProxy(Invoker<T> invoker, Class<?>[] interfaces) {
        return (T) Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), interfaces, new InvokerInvocationHandler(invoker));
    }

    @Override
    public <T> Invoker<T> getInvoker(T proxy, Class<T> type, URL url) {
        return new AbstractProxyInvoker<T>(proxy, type, url) {
            @Override
            protected Object doInvoke(T proxy, String methodName,
                                      Class<?>[] parameterTypes,
                                      Object[] arguments) throws Throwable {
                Method method = proxy.getClass().getMethod(methodName, parameterTypes);
                return method.invoke(proxy, arguments);
            }
        };
    }

}

服务导出协议

在Dubbo中，支持不同协议的服务导出，主要的包括本地服务导出，基于TCP/IP,HTTP,RMI,THRIFT等等。定义了Protocol接口统一了对不同协议的封装，接口其服务导出，引用的定义如下：

public interface Protocol {

    /**
     * 导出服务
     */
    @Adaptive
    <T> Exporter<T> export(Invoker<T> invoker) throws RpcException;

    /**
     * 引用服务
     */
    @Adaptive
    <T> Invoker<T> refer(Class<T> type, URL url) throws RpcException;
}

 在Dubbo中，分别对不同基础协议定义了不同的实现类，如下：

• InjvmProtocol本地导出
• DubboProtocol默认协议设置，使用TCP/IP通信协议导出服务
• HttpProtocol，使用HTTP协议导出服务
• RestProtocol，基于Rest 风格导出服务
• HessianProtocol，RmiProtocol，ThriftProtocol，WebServiceProtocol，XmlRpcProtocol

其类结构图如下：

使用装饰模式（具体如何使用可以参考装饰器模式-Mybatis教你如何玩），对Protocol进行装饰，其实现的装饰类如下：

• ProtocolFilterWrapper，过滤器装饰类，对Protocol的export和refer方法，增加链式的过滤处理。例如，日志打印，并发访问控制，类加载转换等等操作。
• ProtocolListenerWrapper，事件监听装饰类，定义ExporterListener监听服务导出成功或者失败的事件。

其类结构图如下：

通信协议

不同的协议使用不同的通信方式进行服务的远程调用，主要包括TCP/IP，HTTP通信。DubboProtocol采用的TCP/IP协议通信，HttpProtocol采用HTTP协议进行通信。Dubbo定义Transporter接口，监听服务端口以及链接客户端，其接口定义如下：

public interface Transporter {

    /**
     * 启动服务端，绑定监听端口
     */
    @Adaptive({Constants.SERVER_KEY, Constants.TRANSPORTER_KEY})
    RemotingServer bind(URL url, ChannelHandler handler) throws RemotingException;

    /**
     * 链接服务端，创建客户端
     */
    @Adaptive({Constants.CLIENT_KEY, Constants.TRANSPORTER_KEY})
    Client connect(URL url, ChannelHandler handler) throws RemotingException;

}

采用mina和netty两种框架进行实现，其实现类分别为MinaTransporter，基于netty3的NettyTransporter 和基于netty4的NettyTransporter，其类结构图如下：

定义HttpBinder接口，定义基于HTTP通信协议，其接口定义如下：

public interface HttpBinder {

    /**
     * 绑定HTTP服务器
     */
    @Adaptive({Constants.SERVER_KEY})
    HttpServer bind(URL url, HttpHandler handler);

}

其实现类分别为JettyHttpBinder，ServletHttpBinder，TomcatHttpBinder，其类结构图如下：

注册中心

如果导出服务时，配置了注册中心，则Dubbo会根据SPI机制，动态的选择RegistryProtocol。RegistryProtocol使用了装饰模式，具体的服务导出逻辑，交由其设置的Protocol。在export中，定义向注册中心的逻辑。其部分源码如下：

// 实现Protocol接口
public class RegistryProtocol implements Protocol {

// 被装饰的Protocol
private Protocol protocol;


 @Override
    public <T> Exporter<T> export(final Invoker<T> originInvoker) throws RpcException {

        // 注册中心配置
        URL registryUrl = getRegistryUrl(originInvoker);
        URL providerUrl = getProviderUrl(originInvoker);

        final URL overrideSubscribeUrl = getSubscribedOverrideUrl(providerUrl);
        final OverrideListener overrideSubscribeListener = new OverrideListener(overrideSubscribeUrl, originInvoker);
        overrideListeners.put(overrideSubscribeUrl, overrideSubscribeListener);

        providerUrl = overrideUrlWithConfig(providerUrl, overrideSubscribeListener);
        // 使用protocol导出服务
        final ExporterChangeableWrapper<T> exporter = doLocalExport(originInvoker, providerUrl);
        final Registry registry = getRegistry(originInvoker);
        final URL registeredProviderUrl = getUrlToRegistry(providerUrl, registryUrl);
        boolean register = providerUrl.getParameter(REGISTER_KEY, true);
        if (register) {
            // 向设置的注册中心注册服务
            register(registryUrl, registeredProviderUrl);
        }
        registerStatedUrl(registryUrl, registeredProviderUrl, register);
        registry.subscribe(overrideSubscribeUrl, overrideSubscribeListener);
        exporter.setRegisterUrl(registeredProviderUrl);
        exporter.setSubscribeUrl(overrideSubscribeUrl);
        notifyExport(exporter);
        return new DestroyableExporter<>(exporter);
    }

    private <T> ExporterChangeableWrapper<T> doLocalExport(final Invoker<T> originInvoker, URL providerUrl) {
        String key = getCacheKey(originInvoker);

        return (ExporterChangeableWrapper<T>) bounds.computeIfAbsent(key, s -> {
            Invoker<?> invokerDelegate = new InvokerDelegate<>(originInvoker, providerUrl);

            // 使用被装饰的protocol导出服务
            return new ExporterChangeableWrapper<>((Exporter<T>) protocol.export(invokerDelegate), originInvoker);
        });
    }

/**
 * 使用Registry向注册中心注册服务
 */
private void register(URL registryUrl, URL registeredProviderUrl) {
        Registry registry = registryFactory.getRegistry(registryUrl);
        registry.register(registeredProviderUrl);
    }
}

在Dubbo中，定义Registry接口，向注册中心注册服务，其接口定义如下：

public interface Registry extends Node, RegistryService {
    default void reExportRegister(URL url) {
        register(url);
    }

    default void reExportUnregister(URL url) {
        unregister(url);
    }
}

 其具体的实现类包括，NacosRegistry，ZookeeperRegistry，SofaRegistry和RedisRegistry，其类结构图如下：

 

我们从中能够学习到什么 

设计模式的使用

• 装饰模式，Protocol协议的装饰，具体实现可以参考装饰器模式-Mybatis教你如何玩。
• 责任链模式，ProtocolFilterWrapper，对Protocol进行过滤装饰时，采用链表的形式实现了责任链的过滤。具体的责任链设计可以参考责任链如何设计？Tomcat和Netty分别是如何实现过滤器链和事件链？
• 事件监听模式，ProtocolFilterWrapper，对Protocol成功导出服务和导出服务失败进行事件的监听。具体的事件监听设计可以参考事件驱动模式-Tomcat和zookeeper教你如何玩

动态代理的使用

使用Javassit或者JDK动态代理技术生成Invoker实例，统一了对所有服务方法的执行，并且方便对Invoker进行其他逻辑的装饰。具体的动态代理理解可以参考代理（Proxy）是什么?为什么要使用代理模式？Spring与Dubbo如何运用代理模式的？

通信协议的使用

在远程服务绑定服务时，使用了mina与netty框架，实现了对TCP/IP协议，基于NIO进行远程服务通信，NIO的详细使用可以参考Netty如何实现常见的两种线程模式？dubbo基于Netty发布服务时如何选择线程模式？