完整流程图

一句话概括流程

在SpringIOC容器刷新完毕后 (export方法 ContenxtRefreshEvent)，根据配置参数组装成URL，通过 proxyFactory.getInvoker ，利用javassist进行对象代理，封装真正的实现类，然后通过URL参数选择对应的协议进行protocol.export（默认dubbo协议）。在Producer第一次暴露的时候会调用 createServer 来创建 Server（默认NettyServer），然后将 export 得到的 exporter 存入Map（后面处理请求时查找），然后向注册中心注册提供者的信息

具体可以概括为四点

• 组装URL
• 创建Invoker代理类，封装真正的实现类
• 打开NettyServer，通过URL选择对应的协议暴露（产生Exporter对象）
• Exporter对象中会去构建一个调用过滤链（org.apache.dubbo.rpc.protocol.ProtocolFilterWrapper#buildInvokerChain）
• 
  
• 向注册中心注册提供者信息

入口关键类 ServiceConfig

入口方法

服务暴露的入口方法 主要做的事情是：扫描ServiceConfig，逐个去进行服务的暴露

private void exportServices() {br    // 遍历servicebr    configManager.getServices().forEach(sc -> {br        // TODO, compatible with ServiceConfig.export()br        ServiceConfig serviceConfig = (ServiceConfig) sc;br        serviceConfig.setBootstrap(this);br        br        if (exportAsync) {br            ExecutorService executor = executorRepository.getServiceExporterExecutor();br            Future<?> future = executor.submit(() -> {br                sc.export();br                exportedServices.add(sc);br            });br            asyncExportingFutures.add(future);br        } else {br            sc.export();br            exportedServices.add(sc);br        }br    });br}

private void doExportUrls() {br  ServiceRepository repository = ApplicationModel.getServiceRepository();br  ServiceDescriptor serviceDescriptor = repository.registerService(getInterfaceClass());br  // 往内存中添加providerbr  repository.registerProvider(br    getUniqueServiceName(),br    ref,br    serviceDescriptor,br    this,br    serviceMetadatabr  );brbr  // 获取当前服务的注册中心URL（支持多注册中心）br  List<URL> registryURLs = ConfigValidationUtils.loadRegistries(this, true);brbr  // 遍历协议，并在每个协议下暴露服务br  for (ProtocolConfig protocolConfig : protocols) {br    String pathKey = URL.buildKey(getContextPath(protocolConfig)br                                  .map(p -> p + "/" + path)br                                  .orElse(path), group, version);br    // In case user specified path, register service one more time to map it to path.br    // 注册dubbo service(放入到map中)br    repository.registerService(pathKey, interfaceClass);br    // TODO, uncomment this line once service key is unifiedbr    serviceMetadata.setServiceKey(pathKey);br    // 暴露(将上面存入的dubbo service,生成invoker,再包装成export暴露)br    doExportUrlsFor1Protocol(protocolConfig, registryURLs);br  }br}

前面有一大段都是在进行URL的组装的，这边就不细讲了，具体的可以看下代码的注释

private void doExportUrlsFor1Protocol(ProtocolConfig protocolConfig, List<URL> registryURLs) {br        // ============================== URL组装前的准备 ==============================br        String name = protocolConfig.getName();br        if (StringUtils.isEmpty(name)) {br            name = DUBBO;br        }brbr        Map<String, String> map = new HashMap<String, String>();br        map.put(SIDE_KEY, PROVIDER_SIDE);brbr        ServiceConfig.appendRuntimeParameters(map);br        AbstractConfig.appendParameters(map, getMetrics());br        AbstractConfig.appendParameters(map, getApplication());br        AbstractConfig.appendParameters(map, getModule());br        // ... 此处省略URL组装前的准备流程br        // ============================== URL组装完成 ==============================br        br        // 构建URLbr        URL url = new URL(name, host, port, getContextPath(protocolConfig).map(p -> p + "/" + path).orElse(path), map);br        // url的内容br        // dubbo://10.167.10.19:20880/org.apache.dubbo.demo.DemoService?anyhost=true&application=dubbo-demo-api-provider&bind.ip=10.167.10.19&bind.port=20880&default=true&deprecated=false&dubbo=2.0.2&dynamic=true&generic=false&interface=org.apache.dubbo.demo.DemoService&methods=sayHello,sayHelloAsync&pid=43793&release=&side=provider×tamp=1631080120436brbr        // You can customize Configurator to append extra parametersbr        if (ExtensionLoader.getExtensionLoader(ConfiguratorFactory.class)br                .hasExtension(url.getProtocol())) {br            url = ExtensionLoader.getExtensionLoader(ConfiguratorFactory.class)br                    .getExtension(url.getProtocol()).getConfigurator(url).configure(url);br        }brbr        String scope = url.getParameter(SCOPE_KEY);br        // don't export when none is configuredbr        // 如果scope为SCOPE_NONE不暴露服务br        if (!SCOPE_NONE.equalsIgnoreCase(scope)) {brbr            // export to local if the config is not remote (export to remote only when config is remote)br            // 本地暴露br            if (!SCOPE_REMOTE.equalsIgnoreCase(scope)) {br                // 有一个本地暴露，只所以需要本地暴露是考虑到同一个服务内假如需要调用当前的dubbo接口，则可以直接走jvm内部(injvm),减少网络间的通讯br                // 修改url协议为injvmbr                exportLocal(url);br            }br            // export to remote if the config is not local (export to local only when config is local)br            // 远程暴露br            if (!SCOPE_LOCAL.equalsIgnoreCase(scope)) {br                // 注册中心不为空br                if (CollectionUtils.isNotEmpty(registryURLs)) {br                    // 遍历注册中心br                    for (URL registryURL : registryURLs) {br                        //if protocol is only injvm ,not registerbr                        if (LOCAL_PROTOCOL.equalsIgnoreCase(url.getProtocol())) {br                            continue;br                        }br                        url = url.addParameterIfAbsent(DYNAMIC_KEY, registryURL.getParameter(DYNAMIC_KEY));br                        URL monitorUrl = ConfigValidationUtils.loadMonitor(this, registryURL);br                        if (monitorUrl != null) {br                            url = url.addParameterAndEncoded(MONITOR_KEY, monitorUrl.toFullString());br                        }br                        if (logger.isInfoEnabled()) {br                            if (url.getParameter(REGISTER_KEY, true)) {br                                logger.info("Register dubbo service " + interfaceClass.getName() + " url " + url + " to registry " + registryURL);br                            } else {br                                logger.info("Export dubbo service " + interfaceClass.getName() + " to url " + url);br                            }br                        }brbr                        // For providers, this is used to enable custom proxy to generate invokerbr                        String proxy = url.getParameter(PROXY_KEY);br                        if (StringUtils.isNotEmpty(proxy)) {br                            registryURL = registryURL.addParameter(PROXY_KEY, proxy);br                        }brbr                        // 生成Invoker对象(动态代理创建 javassist)br                        Invoker<?> invoker = PROXY_FACTORY.getInvoker(ref, (Class) interfaceClass, registryURL.addParameterAndEncoded(EXPORT_KEY, url.toFullString()));br                        // 包装br                        DelegateProviderMetaDataInvoker wrapperInvoker = new DelegateProviderMetaDataInvoker(invoker, this);brbr                        // provider 需要将 invoker 封装成 expoter(并在此处进行注册)br                        Exporter<?> exporter = PROTOCOL.export(wrapperInvoker);br                        exporters.add(exporter);br                    }br                } else {br                    // 直连方式br                    if (logger.isInfoEnabled()) {br                        logger.info("Export dubbo service " + interfaceClass.getName() + " to url " + url);br                    }br                    Invoker<?> invoker = PROXY_FACTORY.getInvoker(ref, (Class) interfaceClass, url);br                    DelegateProviderMetaDataInvoker wrapperInvoker = new DelegateProviderMetaDataInvoker(invoker, this);brbr                    Exporter<?> exporter = PROTOCOL.export(wrapperInvoker);br                    exporters.add(exporter);br                }brbr                // 元数据存储br                MetadataUtils.publishServiceDefinition(url);br            }br        }br        this.urls.add(url);br    }

默认情况下 ，我们的scope为null，他会进行本地暴露+远程暴露 那么从上面的代码我们可以看出，主要是做了两件事情：

• URL的组装
• 本地暴露+远程暴露

为什么需要本地暴露呢？

因为有可能会存在自己的服务调用自己暴露的接口的情况，假如这种情况还走远程调用的话，效率肯定没有jvm内部的本地调用高

生成Invoker对象

Invoker<?> invoker = PROXY_FACTORY.getInvoker(ref, (Class) interfaceClass, registryURL.addParameterAndEncoded(EXPORT_KEY, url.toFullString()));

以Javassist为例（默认为Javassist）

@Overridebrpublic <T> Invoker<T> getInvoker(T proxy, Class<T> type, URL url) {br    // TODO Wrapper cannot handle this scenario correctly: the classname contains '#39;br    // 通过Javaassist封装成Wrapper类（Dubbo服务启动时生成，所以在运行时不会产生开销），减少反射的调用br    // Wrapper.getWrapper -> 反射获取对应的类信息，包装成Wrapper对象br    final Wrapper wrapper = Wrapper.getWrapper(proxy.getClass().getName().indexOf('#39;) < 0 ? proxy.getClass() : type);br    return new AbstractProxyInvoker<T>(proxy, type, url) {br        @Overridebr        // Wrapper最终调用最终调用服务提供者的接口实现类的方法br        protected Object doInvoke(T proxy, String methodName,br                                  Class<?>[] parameterTypes,br                                  Object[] arguments) throws Throwable {br            return wrapper.invokeMethod(proxy, methodName, parameterTypes, arguments);br        }br    };br}

为什么需要Wrapper类修饰

目的：减少反射调用的开销

暴露操作

Exporter<?> exporter = PROTOCOL.export(wrapperInvoker)

关于此处重点看两个类

RegisterProtocol

@Overridebrpublic <T> Exporter<T> export(final Invoker<T> originInvoker) throws RpcException {br    // 获取注册中心URLbr    URL registryUrl = getRegistryUrl(originInvoker);br    // url to export locallybr    // 获取提供者URLbr    URL providerUrl = getProviderUrl(originInvoker);brbr    // Subscribe the override databr    // FIXME When the provider subscribes, it will affect the scene : a certain JVM exposes the service and callbr    //  the same service. Because the subscribed is cached key with the name of the service, it causes thebr    //  subscription information to cover.br    final URL overrideSubscribeUrl = getSubscribedOverrideUrl(providerUrl);br    final OverrideListener overrideSubscribeListener = new OverrideListener(overrideSubscribeUrl, originInvoker);br    overrideListeners.put(overrideSubscribeUrl, overrideSubscribeListener);brbr    providerUrl = overrideUrlWithConfig(providerUrl, overrideSubscribeListener);br    //export invokerbr    // 选择具体的协议去暴露服务br    // 以DubboProtocol为例，最终调用到DubboProtocolbr    final ExporterChangeableWrapper<T> exporter = doLocalExport(originInvoker, providerUrl);brbr    // url to registrybr    // 获取注册中心br    final Registry registry = getRegistry(originInvoker);br    final URL registeredProviderUrl = getUrlToRegistry(providerUrl, registryUrl);brbr    // decide if we need to delay publishbr    boolean register = providerUrl.getParameter(REGISTER_KEY, true);br    if (register) {br        // 注册服务br        register(registryUrl, registeredProviderUrl);br    }brbr    // register stated url on provider modelbr    registerStatedUrl(registryUrl, registeredProviderUrl, register);brbrbr    exporter.setRegisterUrl(registeredProviderUrl);br    exporter.setSubscribeUrl(overrideSubscribeUrl);brbr    // Deprecated! Subscribe to override rules in 2.6.x or before.br    // 订阅br    registry.subscribe(overrideSubscribeUrl, overrideSubscribeListener);brbr    notifyExport(exporter);br    //Ensure that a new exporter instance is returned every time exportbr    return new DestroyableExporter<>(exporter);br}

DubboProtocol

@Overridebrpublic <T> Exporter<T> export(Invoker<T> invoker) throws RpcException {br    URL url = invoker.getUrl();brbr    // export service.br    // 创建ServiceKeybr    String key = serviceKey(url);br    // 将上层传入的Invoker对象封装成DubboExporter对象，然后记录到exporterMap集合中br    DubboExporter<T> exporter = new DubboExporter<T>(invoker, key, exporterMap);br    exporterMap.put(key, exporter);brbr    //export an stub service for dispatching eventbr    Boolean isStubSupportEvent = url.getParameter(STUB_EVENT_KEY, DEFAULT_STUB_EVENT);br    Boolean isCallbackservice = url.getParameter(IS_CALLBACK_SERVICE, false);br    if (isStubSupportEvent && !isCallbackservice) {br        String stubServiceMethods = url.getParameter(STUB_EVENT_METHODS_KEY);br        if (stubServiceMethods == null || stubServiceMethods.length() == 0) {br            if (logger.isWarnEnabled()) {br                logger.warn(new IllegalStateException("consumer [" + url.getParameter(INTERFACE_KEY) +br                        "], has set stubproxy support event ,but no stub methods founded."));br            }brbr        }br    }brbr    // 启动ProtocolServerbr    openServer(url);br    // 进行序列化的优化处理br    optimizeSerialization(url);brbr    return exporter;br}

打开一个服务

以当前的机器的（ip:port）为key，查看缓存中是否存在Server，没有则创建一个 不同协议暴露的端口不同，例如http协议可以选择8080端口之类的，dubbo协议为20880 默认 NettyServer

private ProtocolServer createServer(URL url) {
  url = URLBuilder.from(url)
          // send readonly event when server closes, it's enabled by default
          // readonlty请求是否阻塞等待
          .addParameterIfAbsent(CHANNEL_READONLYEVENT_SENT_KEY, Boolean.TRUE.toString())
          // enable heartbeat by default
          // 心跳间隔
          .addParameterIfAbsent(HEARTBEAT_KEY, String.valueOf(DEFAULT_HEARTBEAT))
          // Codec2扩展实现
          .addParameter(CODEC_KEY, DubboCodec.NAME)
          .build();
  // 检测SERVER_KEY参数指定的Transporter扩展实现是否合法
  String str = url.getParameter(SERVER_KEY, DEFAULT_REMOTING_SERVER);

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

  ExchangeServer server;
  try {
      // 通过Exchangers门面类，创建ExchangeServer对象
      // 处理consumer的请求
			// handler -> 对应netty的handler
      server = Exchangers.bind(url, requestHandler);
  } catch (RemotingException e) {
      throw new RpcException("Fail to start server(url: " + url + ") " + e.getMessage(), e);
  }

  // 检测CLIENT_KEY参数指定的Transporter扩展实现是否合法
  str = url.getParameter(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);
      }
  }

  // 将ExchangeServer封装成DubboProtocolServer返回
  return new DubboProtocolServer(server);
}

注册到注册中心

@Override
public Registry getRegistry(URL url) {
    if (destroyed.get()) {
        LOGGER.warn("All registry instances have been destroyed, failed to fetch any instance. " +
                "Usually, this means no need to try to do unnecessary redundant resource clearance, all registries has been taken care of.");
        return DEFAULT_NOP_REGISTRY;
    }

    url = URLBuilder.from(url)
            .setPath(RegistryService.class.getName())
            .addParameter(INTERFACE_KEY, RegistryService.class.getName())
            .removeParameters(EXPORT_KEY, REFER_KEY)
            .build();
    String key = createRegistryCacheKey(url);
    // Lock the registry access process to ensure a single instance of the registry
    LOCK.lock();
    try {
        Registry registry = REGISTRIES.get(key);
        if (registry != null) {
            return registry;
        }
        //create registry by spi/ioc
				// 创建注册中心实例
        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();
    }
}

@Overridebrpublic void register(URL url) {br    // 注册服务br    this.register(new com.alibaba.dubbo.common.URL(url));br}