dubbo 服务暴露

首先需要澄清的是，服务暴露与服务注册是两个概念。在Spring Cloud Alibaba dubbo中服务暴露是在本地维护一个服务列表（具体的一个个接口服务），

服务注册是将本服务（整个微服务）的项目名称及对应IP、port注册到注册中心，服务消费方从注册中心拉取微服务列表，然后根据ip、port去对应服务机器上拉取暴露的接口服务列表。

这里会有个检查，消费方reference的接口服务如果在提供方的机器上未暴露，就报异常。

进入正题，在service解析那篇博文中提到的org.apache.dubbo.config.spring.beans.factory.annotation.ServiceClassPostProcessor后处理bean的postProcessBeanDefinitionRegistry

方法开始处添加了DubboBootstrapApplicationListener监听器处理ApplicationContextEvent。值得一提的是，在dubbo springboot自动配置包的org.apache.dubbo.spring.boot.autoconfigure.DubboAutoConfiguration

中setApplicationContext也给context添加了该监听器，好在监听器处理事件时启动org.apache.dubbo.config.bootstrap.DubboBootstrap限制了只能启动一次。

 org.apache.dubbo.config.spring.context.DubboBootstrapApplicationListener#onApplicationContextEvent

@Override
    public void onApplicationContextEvent(ApplicationContextEvent event) {
        if (event instanceof ContextRefreshedEvent) {
            // ContextRefreshedEvent事件时启动dubbo
            onContextRefreshedEvent((ContextRefreshedEvent) event);
        } else if (event instanceof ContextClosedEvent) {
            onContextClosedEvent((ContextClosedEvent) event);
        }
    }

    private void onContextRefreshedEvent(ContextRefreshedEvent event) {
        // 启动dubbo
        dubboBootstrap.start();
    }

    private void onContextClosedEvent(ContextClosedEvent event) {
        dubboBootstrap.stop();
    }

org.apache.dubbo.config.bootstrap.DubboBootstrap#start

public DubboBootstrap start() {
        // 限制只能启动一次
        if (started.compareAndSet(false, true)) {
            ready.set(false);
            // 初始化，后面另开篇幅讲
            initialize();
            if (logger.isInfoEnabled()) {
                logger.info(NAME + " is starting...");
            }
            // 1. export Dubbo Services
            // 暴露服务，本文的重点
            exportServices();

            // Not only provider register
            if (!isOnlyRegisterProvider() || hasExportedServices()) {
                // 2. export MetadataService
                exportMetadataService();
                //3. Register the local ServiceInstance if required
                registerServiceInstance();
            }
　　　　　　　// 消费端引用服务，后面另开博文讲
            referServices();
            // 异步导出的话就等所有future都返回后设置ready状态
            if (asyncExportingFutures.size() > 0) {
                new Thread(() -> {
                    try {
                        this.awaitFinish();
                    } catch (Exception e) {
                        logger.warn(NAME + " exportAsync occurred an exception.");
                    }
                    ready.set(true);
                    if (logger.isInfoEnabled()) {
                        logger.info(NAME + " is ready.");
                    }
                }).start();
            } else {
                ready.set(true);
                if (logger.isInfoEnabled()) {
                    logger.info(NAME + " is ready.");
                }
            }
            if (logger.isInfoEnabled()) {
                logger.info(NAME + " has started.");
            }
        }
        return this;
    }

 下面我们重点看下exportServices：

private void exportServices() {
        // 获取所有ServiceConfig并调用export()方法
        configManager.getServices().forEach(sc -> {
            // TODO, compatible with ServiceConfig.export()
            ServiceConfig serviceConfig = (ServiceConfig) sc;
            serviceConfig.setBootstrap(this);

            if (exportAsync) {
                ExecutorService executor = executorRepository.getServiceExporterExecutor();
                Future<?> future = executor.submit(() -> {
                    sc.export();
                    exportedServices.add(sc);
                });
                asyncExportingFutures.add(future);
            } else {
                sc.export();
                exportedServices.add(sc);
            }
        });
    }

那么问题来了，上面的configManager中ServiceConfig是什么时候加进去的呢？通过静态代码分析活断点调试可知在ServiceConfig的父类方法org.apache.dubbo.config.AbstractConfig#addIntoConfigManager中添加。

 下面看下export逻辑，org.apache.dubbo.config.ServiceConfig#export =》org.apache.dubbo.config.ServiceConfig#doExport =》org.apache.dubbo.config.ServiceConfig#doExportUrls

private void doExportUrls() {
        ServiceRepository repository = ApplicationModel.getServiceRepository();
        ServiceDescriptor serviceDescriptor = repository.registerService(getInterfaceClass());
        repository.registerProvider(
                getUniqueServiceName(),
                ref,
                serviceDescriptor,
                this,
                serviceMetadata
        );
        // 获取所有注册中心URL，这里会将URL的Protocol设置为registry，这是后面适配具体的PROTOCOL.export的依据，
        // 对应的就是org.apache.dubbo.registry.integration.RegistryProtocol#export
        List<URL> registryURLs = ConfigValidationUtils.loadRegistries(this, true);
        // 循环所有协议，这里也是dubbo支持多协议多注册中心的原理所在
        for (ProtocolConfig protocolConfig : protocols) {
            String pathKey = URL.buildKey(getContextPath(protocolConfig)
                    .map(p -> p + "/" + path)
                    .orElse(path), group, version);
            // In case user specified path, register service one more time to map it to path.
            repository.registerService(pathKey, interfaceClass);
            // TODO, uncomment this line once service key is unified
            serviceMetadata.setServiceKey(pathKey);
            doExportUrlsFor1Protocol(protocolConfig, registryURLs);
        }
    }

org.apache.dubbo.config.ServiceConfig#doExportUrlsFor1Protocol中重点看如下地方：

 

 

 org.apache.dubbo.registry.integration.RegistryProtocol#export：

public <T> Exporter<T> export(final Invoker<T> originInvoker) throws RpcException {
        URL registryUrl = getRegistryUrl(originInvoker);
        // url to export locally
        // 服务接口地址，用于本地创建server处理接口调用请求
        URL providerUrl = getProviderUrl(originInvoker);

        // Subscribe the override data
        // FIXME When the provider subscribes, it will affect the scene : a certain JVM exposes the service and call
        //  the same service. Because the subscribed is cached key with the name of the service, it causes the
        //  subscription information to cover.
        final URL overrideSubscribeUrl = getSubscribedOverrideUrl(providerUrl);
        final OverrideListener overrideSubscribeListener = new OverrideListener(overrideSubscribeUrl, originInvoker);
        overrideListeners.put(overrideSubscribeUrl, overrideSubscribeListener);

        providerUrl = overrideUrlWithConfig(providerUrl, overrideSubscribeListener);
        //export invoker
        // 这里创建的NettyServer，默认为dubbo协议，通过org.apache.dubbo.rpc.protocol.dubbo.DubboProtocol#export暴露
        // dubbo处理Netty网络请求部分后面单独写一遍博文
        final ExporterChangeableWrapper<T> exporter = doLocalExport(originInvoker, providerUrl);

        // url to registry
        final Registry registry = getRegistry(originInvoker);
        final URL registeredProviderUrl = getUrlToRegistry(providerUrl, registryUrl);

        // decide if we need to delay publish
        boolean register = providerUrl.getParameter(REGISTER_KEY, true);
        if (register) {
            // 注册，代码见下方
            register(registryUrl, registeredProviderUrl);
        }

        // register stated url on provider model
        registerStatedUrl(registryUrl, registeredProviderUrl, register);


        exporter.setRegisterUrl(registeredProviderUrl);
        exporter.setSubscribeUrl(overrideSubscribeUrl);

        // Deprecated! Subscribe to override rules in 2.6.x or before.
        registry.subscribe(overrideSubscribeUrl, overrideSubscribeListener);

        notifyExport(exporter);
        //Ensure that a new exporter instance is returned every time export
        return new DestroyableExporter<>(exporter);
    }

private void register(URL registryUrl, URL registeredProviderUrl) {
        // spring could alibaba dubbo对应注册中心的协议为spring-cloud
        // 所以这里对应的是com.alibaba.cloud.dubbo.registry.SpringCloudRegistryFactory#getRegistry
        // 该方法实际为父类方法，核心是调用子类的createRegistry方法创建registry
        Registry registry = registryFactory.getRegistry(registryUrl);
        registry.register(registeredProviderUrl);
    }

com.alibaba.cloud.dubbo.registry.SpringCloudRegistryFactory#createRegistry：

public Registry createRegistry(URL url) {
        init();

        DubboCloudProperties dubboCloudProperties = applicationContext
                .getBean(DubboCloudProperties.class);

        Registry registry = null;
        // 根据dubbo.cloud配置的registryType创建对应对象，默认为DubboCloudRegistry
        switch (dubboCloudProperties.getRegistryType()) {
        case SPRING_CLOUD_REGISTRY_PROPERTY_VALUE:
            registry = new SpringCloudRegistry(url, discoveryClient,
                    dubboServiceMetadataRepository, dubboMetadataConfigServiceProxy,
                    jsonUtils, dubboGenericServiceFactory, applicationContext);
            break;
        default:
            registry = new DubboCloudRegistry(url, discoveryClient,
                    dubboServiceMetadataRepository, dubboMetadataConfigServiceProxy,
                    jsonUtils, dubboGenericServiceFactory, applicationContext);
            break;
        }

        return registry;
    }

回到上面的org.apache.dubbo.registry.integration.RegistryProtocol#register方法，调用registry的register方法，这里就是DubboCloudRegistry.register()，最终调用com.alibaba.cloud.dubbo.registry.DubboCloudRegistry#doRegister方法：

 repository实际就是维护了一个allExportedURLs暴露的接口服务列表供消费方查询：

com.alibaba.cloud.dubbo.metadata.repository.DubboServiceMetadataRepository#exportURL

 上面暴露过程看完了，由上面得知，dubbo.registry. address配置的spring-cloud协议时，表明将dubbo的注册中心指向spring cloud，DubboCloudRegistry仅仅是在本地维护服务接口列表，那么spring cloud的注册中心SDK又是怎么注册到server的呢？依托的是dubbo cloud的自动配置类com.alibaba.cloud.dubbo.autoconfigure.DubboServiceRegistrationNonWebApplicationAutoConfiguration

ApplicationStartedEvent事件是在spring boot启动完容器后发布的：

org.springframework.boot.SpringApplication#run(java.lang.String...)

 对应事件发布listener的started方法org.springframework.boot.context.event.EventPublishingRunListener#started

 

这里有个时序的问题，本地export服务是在org.springframework.context.support.AbstractApplicationContext#finishRefresh时发布的ContextRefreshedEvent事件时处理，注册到注册中心是在此之后，因为如果先注册到注册中心后，消费方来服务方机器拉取暴露的服务列表时会check，如果没有对应服务就抛出异常。而下方要说的nacos本身的自动注册是在org.springframework.boot.web.servlet.context.ServletWebServerApplicationContext#finishRefresh方法中：

回到上面注册到注册中心的地方，org.springframework.cloud.client.serviceregistry.ServiceRegistry就是spring cloud规范中服务注册标准接口，这样就能把dubbo和spring cloud联系起来了，以nacos为注册中心，spring-cloud-starter-alibaba-nacos-discovery为客户端SDK，该starter中对应的ServiceRegistry实现就是com.alibaba.cloud.nacos.registry.NacosServiceRegistry。

通过引入spring-cloud-starter-dubbo和spring-cloud-starter-alibaba-nacos-discovery就可以把spring cloud、dubbo、nacos三者联系起来了。

因为Spring Cloud Alibaba Dubbo和Spring Cloud Alibaba Nacos都是为了靠拢Spring Cloud生态，作为原生dubbo和nacos与Spring Cloud的桥梁，实现Spring Cloud的标准接口，两者均可单独集成，dubbo的这个服务自动注册和spring-cloud-starter-alibaba-nacos-discovery中自带的自动注册类似，com.alibaba.cloud.nacos.registry.NacosServiceRegistryAutoConfiguration最终也是通过com.alibaba.cloud.nacos.registry.NacosServiceRegistry实现服务注册。

使用方法是配置spring.cloud.service-registry.auto-registration.enabled=true或者启动类加EnableDiscoveryClient注解，autoRegister配置为true，

对应selector就会加上“org.springframework.cloud.client.serviceregistry.AutoServiceRegistrationConfiguration”

public String[] selectImports(AnnotationMetadata metadata) {
        String[] imports = super.selectImports(metadata);

        AnnotationAttributes attributes = AnnotationAttributes.fromMap(
                metadata.getAnnotationAttributes(getAnnotationClass().getName(), true));

        boolean autoRegister = attributes.getBoolean("autoRegister");
        // 自动注册，即为把当前微服务注册到注册中心
        if (autoRegister) {
            List<String> importsList = new ArrayList<>(Arrays.asList(imports));
            // 添加自动注册类，到时候会生成对应bean
            importsList.add(
                    "org.springframework.cloud.client.serviceregistry.AutoServiceRegistrationConfiguration");
            imports = importsList.toArray(new String[0]);
        }
        else {
            Environment env = getEnvironment();
            if (ConfigurableEnvironment.class.isInstance(env)) {
                ConfigurableEnvironment configEnv = (ConfigurableEnvironment) env;
                LinkedHashMap<String, Object> map = new LinkedHashMap<>();
                // 不自动注册
                map.put("spring.cloud.service-registry.auto-registration.enabled", false);
                MapPropertySource propertySource = new MapPropertySource(
                        "springCloudDiscoveryClient", map);
                configEnv.getPropertySources().addLast(propertySource);
            }

        }

        return imports;
    }

以上configuration会触发com.alibaba.cloud.nacos.registry.NacosServiceRegistryAutoConfiguration自动配置：

    // 自动创建NacosAutoServiceRegistration到IOC容器，该类父类AbstractAutoServiceRegistration是
    // spring cloud自动服务注册标准类，实现了ApplicationListener接口，监听WebServerInitializedEvent事件，
    // 当应用初始化完成后调用bind方法，最终还是通过这里构建时候传入的NacosServiceRegistry实现注册
    @Bean
    @ConditionalOnBean(AutoServiceRegistrationProperties.class)
    public NacosAutoServiceRegistration nacosAutoServiceRegistration(
            NacosServiceRegistry registry,
            AutoServiceRegistrationProperties autoServiceRegistrationProperties,
            NacosRegistration registration) {
        return new NacosAutoServiceRegistration(registry,
                autoServiceRegistrationProperties, registration);
    }

org.springframework.cloud.client.serviceregistry.AbstractAutoServiceRegistration#register：

protected void register() {
        this.serviceRegistry.register(getRegistration());
    }