Dubbo（十二）源码解析 之 服务发布

其他 2020-10-15 04:34:49 阅读次数: 0

源码解析 之 服务发布

1. 查找服务发布的入口

在这里插入图片描述

之前已经分析过标签解析了，现在我们看下这个标签解析后封装的类：

public class ServiceBean<T> extends ServiceConfig<T> implements InitializingBean, DisposableBean, ApplicationContextAware, ApplicationListener<ContextRefreshedEvent>, BeanNameAware,ApplicationEventPublisherAware {
    
    
	...
}

ServiceBean实现的众多接口中，我们需要关注ApplicationListener，它是一个监听器，可以监听任意ApplicationEvent事件

public interface ApplicationListener<E extends ApplicationEvent> extends EventListener {
    
    

	/**
	 * Handle an application event.
	 * @param event the event to respond to
	 */
	void onApplicationEvent(E event);

}

看下ServiceBean对ApplicationListener的实现：

// org.apache.dubbo.config.spring.ServiceBean#onApplicationEvent
// 当Spring容器刷新时会触发其执行
// 刷新Spring容器的时机非常多，但是有一个场景一定会刷新，就是Spring容器刚创建的时候
@Override
public void onApplicationEvent(ContextRefreshedEvent event) {
    
    
    // 若当前service尚未发布，也没有取消发布，则进行发布
    if (!isExported() && !isUnexported()) {
    
    
        if (logger.isInfoEnabled()) {
    
    
            logger.info("The service ready on spring started. service: " + getInterface());
        }
        // 发布服务
        export();
    }
}

看到ServiceBean会监听Spring容器的刷新事件，看下真正的服务发布方法export：

//org.apache.dubbo.config.spring.ServiceBean#export
public void export() {
    
    
    super.export();
    // 发布成功后发布Export事件
    // Publish ServiceBeanExportedEvent
    publishExportEvent();
}

主要关注super.export方法，其实现在父类ServiceConfig：

//org.apache.dubbo.config.ServiceConfig#export
public synchronized void export() {
    
    
    // 检查并更新子配置，之前分析IOC注入逻辑时候跟过，主要分析的是动态配置中心的获取流程
    // 现在不看了，直接往下走
    checkAndUpdateSubConfigs();

    // 若配置的是不发布服务，则直接结束
    if (!shouldExport()) {
    
    
        return;
    }

    // 判断是否延迟发布
    if (shouldDelay()) {
    
    
        // 如果延迟发布则定义定时任务     this::doExport Lambda中的实例方法引用
        DELAY_EXPORT_EXECUTOR.schedule(this::doExport, getDelay(), TimeUnit.MILLISECONDS);
    } else {
    
    
        // 直接发布
        doExport();
    }
}

看下shouldExport方法，判断是否发布：

//org.apache.dubbo.config.ServiceConfig#shouldExport
private boolean shouldExport() {
    
    
    Boolean export = getExport();
    // default value is true
    return export == null ? true : export;
}
//org.apache.dubbo.config.ServiceConfig#getExport
public Boolean getExport() {
    
    
    // 若<dubbo:service/>的export属性不为null，则直接返回
    // 若<dubbo:service/>的export属性为null，且<dubbo:provider/>标签不为null，
    // 则取<dubbbo:provider/>的export属性
    // 即<dubbo:service/>优先级比<dubbbo:provider/>高
    return (export == null && provider != null) ? provider.getExport() : export;
}

看下shouldDelay，是否延迟发布：

//org.apache.dubbo.config.ServiceConfig#shouldDelay
private boolean shouldDelay() {
    
    
    Integer delay = getDelay();
    return delay != null && delay > 0;
}
//org.apache.dubbo.config.ServiceConfig#getDelay
public Integer getDelay() {
    
    
    return (delay == null && provider != null) ? provider.getDelay() : delay;
}

现在我们看核心方法doExport，发布服务：

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就是service name
	    //会作为URL里面的路径，在dubbo中表示服务类型
        path = interfaceName;
    }

    doExportUrls();
}

继续跟doExportUrls，这个方法就是真正发布的动作。

//org.apache.dubbo.config.ServiceConfig#doExportUrls
private void doExportUrls() {
    
    
    // 加载多注册中心（形成标准化的注册中心URL）
    List<URL> registryURLs = loadRegistries(true);
    // 遍历当前service的所有服务暴露协议
    for (ProtocolConfig protocolConfig : protocols) {
    
    
        String pathKey = URL.buildKey(getContextPath(protocolConfig).map(p -> p + "/" + path).orElse(path), group, version);
        ProviderModel providerModel = new ProviderModel(pathKey, ref, interfaceClass);
        ApplicationModel.initProviderModel(pathKey, providerModel);
        // 使用一个协议将service暴露到所有注册中心
        doExportUrlsFor1Protocol(protocolConfig, registryURLs);
    }
}

2. 服务发布流程概要

服务发布概括的说，分下面几步：

  • 1.加载所有的注册中心

  • 2.获取服务配置的所有协议，并遍历（每种协议都会将服务发布一次到所有注册中心）

  • 3.根据Service、注册中心、暴露协议等各种信息 形成注册的URL（Dubbo两大设计原则之一：URL 作为配置信息的统一格式）

  • 4.对URL进行服务暴露，其中服务暴露分本地暴露和远程暴露

    • 4.1本地暴露
      • 先用该URL构建Invoker
      • 再使用injvm伪协议对Invoker进行暴露
      • 服务暴露最终会形成Exporter
    • 4.2 远程暴露（分有注册中心、没注册中心两种情况）
      • 先用该URL构建Invoker
      • 再使用的上面第2步遍历的配置的协议进行暴露
      • 服务暴露最终会形成Exporter

  • 5.其中关于有/没注册中心的情况

    • 没有注册中心，直接使用配置的协议进行暴露
    • 有注册中心会用RegistryProtocol进行服务暴露（相比于没有注册中心情况，只是多做了注册到注册中心的动作，最终还是会用配置的协议进行暴露）

  • 6.其中关于配置的协议暴露，我们会专门分析Dubbo协议的服务暴露。

3. 流程分析

3.1 加载所有的注册中心

继续看doExportUrls方法：

//org.apache.dubbo.config.ServiceConfig#doExportUrls
private void doExportUrls() {
    
    
    // 加载多注册中心（形成标准化的注册中心URL）
    List<URL> registryURLs = loadRegistries(true);
    // 遍历当前service的所有服务暴露协议
    for (ProtocolConfig protocolConfig : protocols) {
    
    
        String pathKey = URL.buildKey(getContextPath(protocolConfig).map(p -> p + "/" + path).orElse(path), group, version);
        ProviderModel providerModel = new ProviderModel(pathKey, ref, interfaceClass);
        ApplicationModel.initProviderModel(pathKey, providerModel);
        // 使用一个协议将service暴露到所有注册中心
        doExportUrlsFor1Protocol(protocolConfig, registryURLs);
    }
}

我们先分析加载注册中心的逻辑，看loadRegistries方法，其中入参是一个布尔值，true代表当前是提供者：

//org.apache.dubbo.config.AbstractInterfaceConfig#loadRegistries
//provider：代表当前是provider还是consummer，consummer也会调用这个方法，后面分析订阅可以看到
protected List<URL> loadRegistries(boolean provider) {
    
    
    // check && override if necessary
    List<URL> registryList = new ArrayList<URL>();
    // 若注册中心不为空
    if (CollectionUtils.isNotEmpty(registries)) {
    
    
        // 遍历所有注册中心
        for (RegistryConfig config : registries) {
    
    
            // 获取<dubbo:registry/>的address属性
            String address = config.getAddress();
            // 若没有设置address属性，则对所有ip均成立
            if (StringUtils.isEmpty(address)) {
    
    
	            //0.0.0.0，广播地址
                address = ANYHOST_VALUE;
            }
            // 若当前不是直连     NO_AVAILABLE值为N/A
            if (!RegistryConfig.NO_AVAILABLE.equalsIgnoreCase(address)) {
    
    
                // 该map中用于存放要组装url的数据    xxx://xxx/xxx&xxx&xxxx
                Map<String, String> map = new HashMap<String, String>();
                // 将<dubbo:application/>中的属性写入到map
                appendParameters(map, application);
                // 将<dubbo:registry/>中的属性写入到map
                appendParameters(map, config);
                // 将path写入到map
                // 这里path值为org.apache.dubbo.registry.RegistryService
                // dubbo中所有配置都是用URL来表示的，而用URL的path代表服务名
                map.put(PATH_KEY, RegistryService.class.getName());
                // 将运行时的一些参数写入到map，例如dubbo协议版本、dubbo版本号、时间戳、PID
                appendRuntimeParameters(map);
                if (!map.containsKey(PROTOCOL_KEY)) {
    
    
                	//如果注册中心没有指定协议，默认是dubbo协议
                    map.put(PROTOCOL_KEY, DUBBO_PROTOCOL);
                }
                // 从一个地址解析出多个URL
                // 即处理注册中心集群的情况
                // 并会在URL上拼接map中的属性
                List<URL> urls = UrlUtils.parseURLs(address, map);

                for (URL url : urls) {
    
    
	                // 将原来的类似于 zookeeper://zkOS:2181?...&..&..格式的地址
	                // 格式化为 registry://zkOS:2181?....&xxx& registry=zookeeper
	                // 即不管连接的哪一个注册中心，格式都是registry://xxxxx?& registry=xxx
	                // 用registry属性代表了注册中心类型
                    url = URLBuilder.from(url)
                            .addParameter(REGISTRY_KEY, url.getProtocol())
                            .setProtocol(REGISTRY_PROTOCOL)
                            .build();
                    // 若当前为提供者，且需要注册，  或  当前为消费者，且需要订阅
                    // 则记录下这个URL
                    // <dubbo:service/>标签的register属性为true，代表需要注册，没有指定则取默认值true
                    // <dubbo:reference/>标签的subscribe属性为true，代表需要订阅，没有指定则取默认值true
                    if ((provider && url.getParameter(REGISTER_KEY, true))
                            || (!provider && url.getParameter(SUBSCRIBE_KEY, true))) {
    
    
                        registryList.add(url);
                    }
                }
            }
        }
    }
    //返回的就是需要注册的注册中心集合
    return registryList;
}

主要看下解析地址，拼接map中属性的方法UrlUtils.parseURLs(address, map)：

//org.apache.dubbo.common.utils.UrlUtils#parseURLs
public static List<URL> parseURLs(String address, Map<String, String> defaults) {
    
    
    if (address == null || address.length() == 0) {
    
    
        return null;
    }
    // 使用分隔符分隔地址为多个地址
    String[] addresses = REGISTRY_SPLIT_PATTERN.split(address);
    if (addresses == null || addresses.length == 0) {
    
    
        return null; //here won't be empty
    }
    List<URL> registries = new ArrayList<URL>();
    // 分隔出的每个地址形成URL后存放起来
    for (String addr : addresses) {
    
    
    	//parseURL里会对Map中的数据进行一些处理，最终形成URL，就不跟了
        registries.add(parseURL(addr, defaults));
    }
    return registries;
}

DEBUG：看一下url的转换
在这里插入图片描述

往下走：
在这里插入图片描述
在这里插入图片描述

3.2 获取服务配置的所有协议，并遍历（每种协议都会将服务发布一次到所有注册中心）

回到doExportUrls方法：

//org.apache.dubbo.config.ServiceConfig#doExportUrls
private void doExportUrls() {
    
    
    // 加载多注册中心（形成标准化的注册中心URL）
    List<URL> registryURLs = loadRegistries(true);
    // 遍历当前service的所有服务暴露协议
    for (ProtocolConfig protocolConfig : protocols) {
    
    
        String pathKey = URL.buildKey(getContextPath(protocolConfig).map(p -> p + "/" + path).orElse(path), group, version);
        ProviderModel providerModel = new ProviderModel(pathKey, ref, interfaceClass);
        ApplicationModel.initProviderModel(pathKey, providerModel);
        // 使用一个协议将service暴露到所有注册中心
        doExportUrlsFor1Protocol(protocolConfig, registryURLs);
    }
}

这里没什么好说的，一眼就看出遍历当前服务配置要发布的所有协议。

(1) pathKey生成逻辑

这里我们主要看一下pathKey生成的内容是啥，看String pathKey = URL.buildKey(getContextPath(protocolConfig).map(p -> p + "/" + path).orElse(path), group, version);这一行方法：

这个pathKey 就是将来该服务写入到ZK的提供者临时节点的节点名字，可以看到由path服务名、group组号和version版本号组成，代表服务名称。

拆开来分析，先看getContextPath(protocolConfig)方法：

//org.apache.dubbo.config.ServiceConfig#getContextPath
private Optional<String> getContextPath(ProtocolConfig protocolConfig) {
    
    
	// protocolConfig就是暴露协议标签封装的对象
    // 获取<dubbo:protocol/>的contextPath属性
    String contextPath = protocolConfig.getContextpath();
    if (StringUtils.isEmpty(contextPath) && provider != null) {
    
    
        // 获取<dubbo:provider/>的contextPath属性
        contextPath = provider.getContextpath();
    }
    //Optional是jdk8提供的，代表"可选的对象"
    return Optional.ofNullable(contextPath);
}

<dubbo:protocol/>和<dubbo:provider/>都可以配置contextpath属性：在这里插入图片描述
contextPath属性代表的是应用的上下文路径

getContextPath(protocolConfig)返回的是Optional对象，Optional.map(p -> p + "/" + path).orElse(path)方法中，map中的p代表的就是Optional中封装的对象，如果封装的对象不空就会执行map方法，做了一个字符串拼接，如果封装的对象为空，map方法就不会执行，而执行orElse的时候，如果封装的对象不为空，直接返回封装的对象，否则返回path，即Optional中封装的对象不为空，最终结果为p + "/" + path，空，最终结果为path。

大部分情况都不会配置这个contextPath，所以这里path一般都是服务接口名。

看下合并的方法

//org.apache.dubbo.common.URL#buildKey
public static String buildKey(String path, String group, String version) {
    
    
    StringBuilder buf = new StringBuilder();
    if (group != null && group.length() > 0) {
    
    
        buf.append(group).append("/");
    }
    buf.append(path);
    if (version != null && version.length() > 0) {
    
    
        buf.append(":").append(version);
    }
    //group/xx.xxx.xxxService/:0.0.0
    return buf.toString();
}

(2) 初始化提供者模型

pathKey生成以后，接下来看下ApplicationModel.initProviderModel(pathKey, providerModel)方法：

//org.apache.dubbo.config.ServiceConfig#doExportUrls
private void doExportUrls() {
    
    
    // 加载多注册中心（形成标准化的注册中心URL）
    List<URL> registryURLs = loadRegistries(true);
    // 遍历当前service的所有服务暴露协议
    for (ProtocolConfig protocolConfig : protocols) {
    
    
        String pathKey = URL.buildKey(getContextPath(protocolConfig).map(p -> p + "/" + path).orElse(path), group, version);
        ProviderModel providerModel = new ProviderModel(pathKey, ref, interfaceClass);
        ApplicationModel.initProviderModel(pathKey, providerModel);
        // 使用一个协议将service暴露到所有注册中心
        doExportUrlsFor1Protocol(protocolConfig, registryURLs);
    }
}

先看下ProviderModel：

/**
 * ProviderModel which is about published services
 * 关于已发布的服务的ProviderModel
 */
public class ProviderModel {
    
    
    private final String serviceName;
    private final Object serviceInstance;
    private final Class<?> serviceInterfaceClass;
    private final Map<String, List<ProviderMethodModel>> methods = new HashMap<String, List<ProviderMethodModel>>();

    public ProviderModel(String serviceName, Object serviceInstance, Class<?> serviceInterfaceClass) {
    
    
        if (null == serviceInstance) {
    
    
            throw new IllegalArgumentException("Service[" + serviceName + "]Target is NULL.");
        }
		//服务名称
        this.serviceName = serviceName;
        //服务提供者
        this.serviceInstance = serviceInstance;
        //服务接口
        this.serviceInterfaceClass = serviceInterfaceClass;
		//初始化方法，将方法转成ProviderMethodModel
        initMethod();
    }
    ...
}

在看下ApplicationModel#initProviderModel方法，ApplicationModel统一维护了提供者模型和消费者模型：

/**
 * Represent a application which is using Dubbo and store basic metadata info for using
 * during the processing of RPC invoking.
 *
 * ApplicationModel includes many ProviderModel which is about published services
 * and many Consumer Model which is about subscribed services.
 *
 * adjust project structure in order to fully utilize the methods introduced here.
 */
public class ApplicationModel {
    
    
	...
    /**
     * full qualified class name -> provided service
     */
    private static final ConcurrentMap<String, ProviderModel> PROVIDED_SERVICES = new ConcurrentHashMap<>();
    /**
     * full qualified class name -> subscribe service
     */
    private static final ConcurrentMap<String, ConsumerModel> CONSUMED_SERVICES = new ConcurrentHashMap<>();
	...
    public static void initProviderModel(String serviceName, ProviderModel providerModel) {
    
    
        if (PROVIDED_SERVICES.putIfAbsent(serviceName, providerModel) != null) {
    
    
            LOGGER.warn("Already register the same:" + serviceName);
        }
    }
    ...
}

这个时候仅仅放了一个Provider模型，还没有具体的东西。

java.util.concurrent.ConcurrentMap#putIfAbsent

/**
 * If the specified key is not already associated
 * with a value, associate it with the given value.
 * This is equivalent to
 * 等价于下面
 *  <pre> {@code
 * if (!map.containsKey(key))
 *   return map.put(key, value);
 * else
 *   return map.get(key);
 * }</pre>
 * 不包含这个key，就将key/value放入map，并返回null
 * 包含的话直接返回已经存在的value
 * ...
 */
 V putIfAbsent(K key, V value);

3.3 根据Service、注册中心、暴露协议等各种信息 形成注册的URL

//org.apache.dubbo.config.ServiceConfig#doExportUrls
private void doExportUrls() {
    
    
    // 加载多注册中心（形成标准化的注册中心URL）
    List<URL> registryURLs = loadRegistries(true);
    // 遍历当前service的所有服务暴露协议
    for (ProtocolConfig protocolConfig : protocols) {
    
    
        String pathKey = URL.buildKey(getContextPath(protocolConfig).map(p -> p + "/" + path).orElse(path), group, version);
        ProviderModel providerModel = new ProviderModel(pathKey, ref, interfaceClass);
        ApplicationModel.initProviderModel(pathKey, providerModel);
        // 使用一个协议将service暴露到所有注册中心
        doExportUrlsFor1Protocol(protocolConfig, registryURLs);
    }
}

接下来看最重要的doExportUrlsFor1Protocol方法，先看上半部分组装URL的逻辑：

//org.apache.dubbo.config.ServiceConfig#doExportUrlsFor1Protocol
private void doExportUrlsFor1Protocol(ProtocolConfig protocolConfig, List<URL> registryURLs) {
    
    
    // 获取服务暴露协议名称
    String name = protocolConfig.getName();
    if (StringUtils.isEmpty(name)) {
    
    
	    //空的话默认Dubbo
        name = DUBBO;
    }

    // 创建并初始化用于存放元数据信息的map
    Map<String, String> map = new HashMap<String, String>();
    // side=provider代表提供者
    map.put(SIDE_KEY, PROVIDER_SIDE);
	//添加运行时数据
    appendRuntimeParameters(map);
    //添加各种标签对应的元数据
    appendParameters(map, metrics);
    appendParameters(map, application);
    appendParameters(map, module);
    // remove 'default.' prefix for configs from ProviderConfig
    // appendParameters(map, provider, Constants.DEFAULT_KEY);
    appendParameters(map, provider);
    appendParameters(map, protocolConfig);
    appendParameters(map, this);
    // 方法级别的标签处理
    if (CollectionUtils.isNotEmpty(methods)) {
    
    
        for (MethodConfig method : methods) {
    
    
	        //也是添加各种元数据
			...
        } // end of methods for
    }
	//判断是否是泛化服务，对接口的方法的处理
    if (ProtocolUtils.isGeneric(generic)) {
    
    
        map.put(GENERIC_KEY, generic);
        map.put(METHODS_KEY, ANY_VALUE);
    } else {
    
    
        String revision = Version.getVersion(interfaceClass, version);
        if (revision != null && revision.length() > 0) {
    
    
            map.put(REVISION_KEY, revision);
        }

        String[] methods = Wrapper.getWrapper(interfaceClass).getMethodNames();
        if (methods.length == 0) {
    
    
            logger.warn("No method found in service interface " + interfaceClass.getName());
            map.put(METHODS_KEY, ANY_VALUE);
        } else {
    
    
            map.put(METHODS_KEY, StringUtils.join(new HashSet<String>(Arrays.asList(methods)), ","));
        }
    }
    if (!ConfigUtils.isEmpty(token)) {
    
    
        if (ConfigUtils.isDefault(token)) {
    
    
            map.put(TOKEN_KEY, UUID.randomUUID().toString());
        } else {
    
    
            map.put(TOKEN_KEY, token);
        }
    }  // map的初始化-end
	// 上面所有代码都是在做元数据map的初始化
	
    // export service
    //为服务提供者注册和绑定IP地址，可以单独配置。(配置优先级:环境变量-> java系统属性->配置文件中的主机属性->/etc/hosts ->默认网络地址->第一个可用网络地址)
    String host = this.findConfigedHosts(protocolConfig, registryURLs, map);
    //为服务提供者注册和绑定端口，可以单独配置(配置优先级:环境变量-> java系统属性-协议配置文件中的>端口属性->协议默认端口)
    Integer port = this.findConfigedPorts(protocolConfig, name, map);
    // 使用暴露协议名称、host、port、path(服务接口名)及元数据(map)组装为一个URL
    URL url = new URL(name, host, port, getContextPath(protocolConfig).map(p -> p + "/" + path).orElse(path), map);

    // ConfiguratorFactory用于对现有暴露协议进行再配置的SPI扩展
    if (ExtensionLoader.getExtensionLoader(ConfiguratorFactory.class)
            .hasExtension(url.getProtocol())) {
    
      // 判断是否存在指定协议的再配置扩展类
        url = ExtensionLoader.getExtensionLoader(ConfiguratorFactory.class)
                // 对指定协议进行再配置
                .getExtension(url.getProtocol()).getConfigurator(url).configure(url);
    }
	...
}

关于ConfiguratorFactory对现有暴露协议进行再配置：

// ConfiguratorFactory用于对现有暴露协议进行再配置的SPI扩展
if (ExtensionLoader.getExtensionLoader(ConfiguratorFactory.class)
        .hasExtension(url.getProtocol())) {
     
       // 判断是否存在指定协议的再配置扩展类
    url = ExtensionLoader.getExtensionLoader(ConfiguratorFactory.class)
            // 对指定协议进行再配置
            .getExtension(url.getProtocol()).getConfigurator(url).configure(url);
}

看下hasExtension方法：

//org.apache.dubbo.common.extension.ExtensionLoader#hasExtension
public boolean hasExtension(String name) {
     
     
    if (StringUtils.isEmpty(name)) {
     
     
        throw new IllegalArgumentException("Extension name == null");
    }
    Class<?> c = this.getExtensionClass(name);
    return c != null;
}
//org.apache.dubbo.common.extension.ExtensionLoader#getExtensionClass
private Class<?> getExtensionClass(String name) {
     
     
    if (type == null) {
     
     
        throw new IllegalArgumentException("Extension type == null");
    }
    if (name == null) {
     
     
        throw new IllegalArgumentException("Extension name == null");
    }
    // 从 所有支持的扩展类(不包含adaptive与wrapper) 中查找是否有指定名称的类
    return getExtensionClasses().get(name);
}

DEBUG：
在这里插入图片描述

dubbo源码中只有两个ConfiguratorFactory，没有dubbo的：
在这里插入图片描述
所以这里也不用太关注

3.4 对URL进行服务暴露，其中服务暴露分本地暴露和远程暴露

//org.apache.dubbo.config.ServiceConfig#doExportUrlsFor1Protocol
private void doExportUrlsFor1Protocol(ProtocolConfig protocolConfig, List<URL> registryURLs) {
    
    
	...
	//上面代码已经把注册URL构建完成了
	
    // 获取<dubbo:service/>的scope属性
    String scope = url.getParameter(SCOPE_KEY);
    // don't export when none is configured
    // 如果scope属性为"none"，则什么也不做
    if (!SCOPE_NONE.equalsIgnoreCase(scope)) {
    
    

        // export to local if the config is not remote (export to remote only when config is remote)
        // 若scope的值不为"remote"，则进行本地服务暴露
        if (!SCOPE_REMOTE.equalsIgnoreCase(scope)) {
    
    
            // 本地暴露
            exportLocal(url);
        }
        // export to remote if the config is not local (export to local only when config is local)
        // 若scope的值不为local，则进行远程服务暴露
        if (!SCOPE_LOCAL.equalsIgnoreCase(scope)) {
    
    
            ...
        }
    }
    this.urls.add(url);
}

可以看到根据scope的值

  • none：不暴露
  • local：只本地暴露
  • remote：只远程暴露
  • 不配置：既本地暴露、也远程暴露

3.4.1 本地暴露

先看本地服务暴露exportLocal方法：

//org.apache.dubbo.config.ServiceConfig#exportLocal
private void exportLocal(URL url) {
    
    
	// 此时传进来的是注册URL dubbo://hostL:port/service?xxx&xxx...
    // 构建URL
    URL local = URLBuilder.from(url)
		    //LOCAL_PROTOCOL值为injvm
            .setProtocol(LOCAL_PROTOCOL)  // 指定当前url的协议为injvm
            //LOCALHOST_VALUE值为127.0.0.1
            .setHost(LOCALHOST_VALUE)  // 指定host为本机
            .setPort(0)   // 指定没有端口
            .build();
    // 将注册URL的协议强行改成injvm
    // protocol是自适应类，这样可以通过自适应机制让InjvmProtocol进行暴露
    // 可以看到是先用PROXY_FACTORY转成Invoker，在用protocol发布的
    // 发布的时候会将Invoker封装成Exporter
    Exporter<?> exporter = protocol.export(
            PROXY_FACTORY.getInvoker(ref, (Class) interfaceClass, local));
    exporters.add(exporter);
    logger.info("Export dubbo service " + interfaceClass.getName() + " to local registry url : " + local);
}

先看一下构建Invoker：

PROXY_FACTORY.getInvoker(ref, (Class) interfaceClass, local)方法中，PROXY_FACTORY是ProxyFactory接口的自适应类，代理有两种实现，JDK和Javassist，默认是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 '$'
        // Wrapper.getWrapper方法会为每种服务接口生成一个包装类实例，有兴趣自己看吧
        // 反正最终执行的方法是proxy.methodName
        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);
            }
        };
    }

}

该类中有两个方法，一个是给消费者端用的，一个是给提供者端用的。

再看一下injvm协议暴露：

DEBUG：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
为了方便看源码，断点调试，可以把这个动态生成的自适应类Protocol$Adaptive拷贝出来生成java文件放入工程中（为什么拷贝出来能够运行之前讲Dubbo动态编译的时候解释过）
在这里插入图片描述

上面显示的是ProtocalFilterWrapper，因为被Wrapper增强了，不是重点，直接看InjvmProtocol：

public class InjvmProtocol extends AbstractProtocol implements Protocol {
    
    
	...
	//这个exporterMap是在父类抽象类AbstractProtocol中的
	//每个暴露协议都有一个这样的Map，用来存当前协议中所有暴露的服务
	//消费者端请求的时候，需要从这个map中找服务
	protected final Map<String, Exporter<?>> exporterMap = new ConcurrentHashMap<String, Exporter<?>>();
	
    @Override
    public <T> Exporter<T> export(Invoker<T> invoker) throws RpcException {
    
    
        return new InjvmExporter<T>(invoker, invoker.getUrl().getServiceKey(), exporterMap);
    }
    ...
}

我们看下InjvmExporter：

class InjvmInvoker<T> extends AbstractInvoker<T> {
    
    

    private final String key;

    private final Map<String, Exporter<?>> exporterMap;

    InjvmInvoker(Class<T> type, URL url, String key, Map<String, Exporter<?>> exporterMap) {
    
    
        super(type, url);
        this.key = key;
        //当消费者端消费的时候，调用信息到达提供者端时，就要从这个map中找暴露的服务
        //这个exporterMap是AbstractProtocol中传过来的，可以看出来一种暴露协议专门维护
        //一个这样的map
        this.exporterMap = exporterMap;
    }
	...
}

本地暴露injvm协议很简单，就是构建一个Exporter放入exporterMap即可。

本地服务暴露的意义：
消费者消费服务的时候，如果这个服务本地有，就直接调用本地的服务了
因为服务器既是服务提供者又是服务消费者，是有可能消费到自己的服务，直接本地调用。

3.4.2 远程暴露

重新返回 doExportUrlsFor1Protocol()方法，接下来看远程服务暴露：

private void doExportUrlsFor1Protocol(ProtocolConfig protocolConfig, List<URL> registryURLs) {
    
    
	...
	//上面代码已经把注册URL构建完成了
	
    // 获取<dubbo:service/>的scope属性
    String scope = url.getParameter(SCOPE_KEY);
	// don't export when none is configured
    if (!SCOPE_NONE.equalsIgnoreCase(scope)) {
    
    
		...// 若scope的值不为remote，则进行本地服务暴露

        // 若scope的值不为local，则进行远程服务暴露
        if (!SCOPE_LOCAL.equalsIgnoreCase(scope)) {
    
    
            if (!isOnlyInJvm() && logger.isInfoEnabled()) {
    
    
                logger.info("Export dubbo service " + interfaceClass.getName() + " to url " + url);
            }
            if (CollectionUtils.isNotEmpty(registryURLs)) {
    
      // 若存在注册中心
                // 遍历所有注册中心
                for (URL registryURL : registryURLs) {
    
    
                    //if protocol is only injvm ,not register
                    // 若当前协议为injvm，则说明当前仅做本地暴露，这里的远程暴露直接结束
                    if (LOCAL_PROTOCOL.equalsIgnoreCase(url.getProtocol())) {
    
    
                        continue;
                    }
                    url = url.addParameterIfAbsent(DYNAMIC_KEY, registryURL.getParameter(DYNAMIC_KEY));
                    URL monitorUrl = loadMonitor(registryURL);
                    if (monitorUrl != null) {
    
    
                        url = url.addParameterAndEncoded(MONITOR_KEY, monitorUrl.toFullString());
                    }
                    if (logger.isInfoEnabled()) {
    
    
                        logger.info("Register dubbo service " + interfaceClass.getName() + " url " + url + " to registry " + registryURL);
                    }

                    // For providers, this is used to enable custom proxy to generate invoker
                    String proxy = url.getParameter(PROXY_KEY);
                    if (StringUtils.isNotEmpty(proxy)) {
    
    
                        registryURL = registryURL.addParameter(PROXY_KEY, proxy);
                    }
                    // 使用URL构建出invoker
                    Invoker<?> invoker = PROXY_FACTORY.getInvoker(ref, (Class) interfaceClass, registryURL.addParameterAndEncoded(EXPORT_KEY, url.toFullString()));
                    // 使用当前<dubbo:service/>的配置，对invoker进行一次封装，形成真正用于暴露的invoker
                    DelegateProviderMetaDataInvoker wrapperInvoker = new DelegateProviderMetaDataInvoker(invoker, this);
                    // 远程服务暴露(会注册到注册中心)
                    Exporter<?> exporter = protocol.export(wrapperInvoker);
                    exporters.add(exporter);
                }
            } else {
    
      // 处理没有注册中心的情况
                Invoker<?> invoker = PROXY_FACTORY.getInvoker(ref, (Class) interfaceClass, url);
                DelegateProviderMetaDataInvoker wrapperInvoker = new DelegateProviderMetaDataInvoker(invoker, this);
                // 服务暴露(不注册到注册中心)
                Exporter<?> exporter = protocol.export(wrapperInvoker);
                exporters.add(exporter);
            }
            /**
             * @since 2.7.0
             * ServiceData Store
             */
            MetadataReportService metadataReportService = null;
            if ((metadataReportService = getMetadataReportService()) != null) {
    
    
                metadataReportService.publishProvider(url);
            }
        }
    }
    this.urls.add(url);
}

这里分两个情况：

  • 有注册中心的情况
  • 没有注册中心的情况

先看没有注册中心的情况：

private void doExportUrlsFor1Protocol(ProtocolConfig protocolConfig, List<URL> registryURLs) {
    
    
	...
	// 获取<dubbo:service/>的scope属性
	String scope = url.getParameter(SCOPE_KEY);
	// don't export when none is configured
	if (!SCOPE_NONE.equalsIgnoreCase(scope)) {
    
    
		...
		// 若scope的值不为local，则进行远程服务暴露
		if (!SCOPE_LOCAL.equalsIgnoreCase(scope)) {
    
    
			...
			if (CollectionUtils.isNotEmpty(registryURLs)) {
    
      // 若存在注册中心
				...
			} else {
    
      // 处理没有注册中心的情况
				// 构建Invoker，之前分析过了
				// 注意这里的url是 dubbo://ip:port/xxxx?xxx&xxx
				Invoker<?> invoker = PROXY_FACTORY.getInvoker(ref, (Class) interfaceClass, url);
				// 委托类，将invoker和元数据ServiceConfig封装在了一起，没什么特别的
				DelegateProviderMetaDataInvoker wrapperInvoker = new DelegateProviderMetaDataInvoker(invoker, this);
				// 服务暴露(不注册到注册中心)
				// 注意，此时这里的url是dubbo://ip:port/xxxx?xxx&xxx
				// 所以protocol自适应会直接用DubboProtocol进行暴露
				// 这是与有注册中心情况的最重要的区别！
				Exporter<?> exporter = protocol.export(wrapperInvoker);
				exporters.add(exporter);
			}
			/**
			 * @since 2.7.0
			 * ServiceData Store
			 */
			MetadataReportService metadataReportService = null;
			if ((metadataReportService = getMetadataReportService()) != null) {
    
    
				metadataReportService.publishProvider(url);
			}
		}
	}
	this.urls.add(url);
}

这里需要提醒的是Exporter<?> exporter = protocol.export(wrapperInvoker)这个方法，通过自适应进制，会直接调用org.apache.dubbo.rpc.protocol.dubbo.DubboProtocol#export方法，因为invoker中的URL参数路径是dubbo://ip:port/xxxx?xxx&xxx，这是与有注册中心情况的最重要的区别！

DubboProtocol协议进行服务暴露将在3.6中讲解。

有注册中心的情况：

private void doExportUrlsFor1Protocol(ProtocolConfig protocolConfig, List<URL> registryURLs) {
    
    
	...
	// 获取<dubbo:service/>的scope属性
	String scope = url.getParameter(SCOPE_KEY);
	// don't export when none is configured
	if (!SCOPE_NONE.equalsIgnoreCase(scope)) {
    
    
		...
		// 若scope的值不为local，则进行远程服务暴露
		if (!SCOPE_LOCAL.equalsIgnoreCase(scope)) {
    
    
			...
			if (CollectionUtils.isNotEmpty(registryURLs)) {
    
      // 若存在注册中心
				// 遍历所有注册中心
				for (URL registryURL : registryURLs) {
    
    
					//if protocol is only injvm ,not register
					// 若当前协议为injvm，则说明当前仅做本地暴露，这里的远程暴露直接结束
					if (LOCAL_PROTOCOL.equalsIgnoreCase(url.getProtocol())) {
    
    
						continue;
					}
					//DYNAMIC_KEY=dynamic，指定是否动态
					url = url.addParameterIfAbsent(DYNAMIC_KEY, registryURL.getParameter(DYNAMIC_KEY));
					// 加载监控中心的元数据信息
					URL monitorUrl = loadMonitor(registryURL);
					if (monitorUrl != null) {
    
    
						//如果存在将监控中心信息加入到"注册URL"
						url = url.addParameterAndEncoded(MONITOR_KEY, monitorUrl.toFullString());
					}
					if (logger.isInfoEnabled()) {
    
    
						logger.info("Register dubbo service " + interfaceClass.getName() + " url " + url + " to registry " + registryURL);
					}

					// For providers, this is used to enable custom proxy to generate invoker
					// 指定生成动态代理的方式，默认是javassist
					String proxy = url.getParameter(PROXY_KEY);
					if (StringUtils.isNotEmpty(proxy)) {
    
    
						registryURL = registryURL.addParameter(PROXY_KEY, proxy);
					}
					// 使用URL构建出invoker，注意这里构建invoker用的不是"注册URL"了
					// 而是用 注册中心URL，并在注册中心URL上加上参数"export"，值就是"注册URL"
					Invoker<?> invoker = PROXY_FACTORY.getInvoker(ref, (Class) interfaceClass, registryURL.addParameterAndEncoded(EXPORT_KEY, url.toFullString()));
					// 使用当前<dubbo:service/>的配置，对invoker进行一次封装，形成真正用于暴露的invoker
					// 委托类，将invoker和元数据封装在了一起
					DelegateProviderMetaDataInvoker wrapperInvoker = new DelegateProviderMetaDataInvoker(invoker, this);
					// 远程服务暴露(会注册到注册中心)
					// 注意这里和没有注册中心的情况有很大区别
					// 此时invoker 的URL格式是 
					// registry://zkOS:2181?....&xxx&registry=zookeeper&export="注册URL"
					// 所以protocol.export会走RegistryProtocol进行服务暴露
					Exporter<?> exporter = protocol.export(wrapperInvoker);
					exporters.add(exporter);
				}
			} else {
    
      // 处理没有注册中心的情况
				...
			}
			/**
			 * @since 2.7.0
			 * ServiceData Store
			 */
			MetadataReportService metadataReportService = null;
			if ((metadataReportService = getMetadataReportService()) != null) {
    
    
				metadataReportService.publishProvider(url);
			}
		}
	}
	this.urls.add(url);
}

注意：这里和没有注册中心的情况有很大区别，此时invoker 的URL格式是registry://zkOS:2181?....&xxx&registry=zookeeper&export="注册URL"， 用的是注册中心URL，所以protocol.export会走RegistryProtocol进行服务暴露

3.5 有注册中心情况的服务暴露 - 完成服务注册

DEBUG：
还是Protocol$Adaptive，此时extName为registry：
在这里插入图片描述
可以看下增强类：
在这里插入图片描述

接下来直接看org.apache.dubbo.registry.integration.RegistryProtocol#export，该方法主要完成了三件事：

  • 注册ServiceConfigurationListener监听器，实时监控配置中心的配置信息变化
  • 使用配置的协议（这里就是Dubbo协议）进行服务暴露
  • 注册到注册中心

即相比于没有注册中心的情况，多做了一步注册到注册中心的动作，这里主要分析注册到注册中心的逻辑，真正的服务暴露dubbo协议暴露，在3.6中讲解。

public class RegistryProtocol implements Protocol {
    
    
	...
    @Override
    public <T> Exporter<T> export(final Invoker<T> originInvoker) throws RpcException {
    
    
        // 从invoker中获取到注册中心URL
        URL registryUrl = getRegistryUrl(originInvoker);
        // url to export locally
        // 从invoker中获取到提供者URL（刚才说过"注册URL"作为注册中心URL的参数,key是export）
        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);
		// 将动态配置中心的配置元数据信息覆盖当前提供者元数据信息
		// 并注册一个ServiceConfigurationListener监听器，监听动态配置中心的信息变化
        providerUrl = overrideUrlWithConfig(providerUrl, overrideSubscribeListener);
        //export invoker
        // 远程暴露，使用配置的协议进行真正的暴露
        final ExporterChangeableWrapper<T> exporter = doLocalExport(originInvoker, providerUrl);

        // url to registry
        // 获取注册中心
        final Registry registry = getRegistry(originInvoker);
        // 获取注册的URL，并过滤掉url参数
        final URL registeredProviderUrl = getRegisteredProviderUrl(providerUrl, registryUrl);
        ProviderInvokerWrapper<T> providerInvokerWrapper = ProviderConsumerRegTable.registerProvider(originInvoker,
                registryUrl, registeredProviderUrl);
        //to judge if we need to delay publish
        //获取是否要注册到注册中心，没有配置默认就是true
        boolean register = registeredProviderUrl.getParameter("register", true);
        if (register) {
    
    
            // 将提供者注册到注册中心
            register(registryUrl, registeredProviderUrl);
            providerInvokerWrapper.setReg(true);
        }

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

        exporter.setRegisterUrl(registeredProviderUrl);
        exporter.setSubscribeUrl(overrideSubscribeUrl);
        //Ensure that a new exporter instance is returned every time export
        // 确保每次导出时都返回一个新的export实例
        return new DestroyableExporter<>(exporter);
    }
    ...
}

整个方法整体流程看过了，现在我们看一些细节：

(1) 从invoker中获取到注册中心URL

看getRegistryUrl方法：

//org.apache.dubbo.registry.integration.RegistryProtocol#getRegistryUrl
private URL getRegistryUrl(Invoker<?> originInvoker) {
    
    
    URL registryUrl = originInvoker.getUrl();
    if (REGISTRY_PROTOCOL.equals(registryUrl.getProtocol())) {
    
    
        // 获取到URL中的registry属性，当前为zookeeper
        String protocol = registryUrl.getParameter(REGISTRY_KEY, DEFAULT_REGISTRY);
        // 将URL的协议替换为zookeeper，将去掉URL中的registry属性
        registryUrl = registryUrl.setProtocol(protocol).removeParameter(REGISTRY_KEY);
    }
    return registryUrl;
}

DEBUG：
在这里插入图片描述

从registry://换成了zookeeper://
在这里插入图片描述

(2) 从invoker中获取到提供者URL

看getProviderUrl方法：

//org.apache.dubbo.registry.integration.RegistryProtocol#getProviderUrl
private URL getProviderUrl(final Invoker<?> originInvoker) {
    
    
    // 获取到URL中的export属性，并解码为String
    // registry://zkOS:2181/org.apache.dubbo.registry.RegistryService?application=demo-provider
    // &dubbo=2.0.2&export=dubbo%3A%2F%2F192.168.0.109%3A20880%2Forg.apache.dubbo.demo.DemoService
    // %3Fanyhost%3Dtrue%26application%3Ddemo-provider%26bean.name%3Dorg.apache.dubbo.demo.DemoService
    // %26bind.ip%3D192.168.0.109%26bind.port%3D20880%26deprecated%3Dfalse%26dubbo%3D2.0.2
    // %26dynamic%3Dtrue%26generic%3Dfalse%26interface%3Dorg.apache.dubbo.demo.DemoService%26methods%3DsayHello%26pid%3D18440%26
    // qos.port%3D22222%26register%3Dtrue%26release%3D%26side%3Dprovider%26
    // timestamp%3D1589549171978&pid=18440&qos.port=22222&registry=zookeeper&timestamp=1589549171971
    String export = originInvoker.getUrl().getParameterAndDecoded(EXPORT_KEY);
    if (export == null || export.length() == 0) {
    
    
        throw new IllegalArgumentException("The registry export url is null! registry: " + originInvoker.getUrl());
    }
    return URL.valueOf(export);
}

DEBUG：
在这里插入图片描述
解码后就没有乱码

(3) 真正的服务暴露，使用配置的协议进行服务暴露入口

看doLocalExport 方法：

//org.apache.dubbo.registry.integration.RegistryProtocol#doLocalExport
private <T> ExporterChangeableWrapper<T> doLocalExport(final Invoker<T> originInvoker, URL providerUrl) {
    
    
    String key = getCacheKey(originInvoker);
	
    return (ExporterChangeableWrapper<T>) bounds.computeIfAbsent(key, s -> {
    
    
	    //创建Invoker委托对象，将Invoker和提供者URL元数据信息绑定在一起
        Invoker<?> invokerDelegate = new InvokerDelegate<>(originInvoker, providerUrl);
        //核心方法其实是protocol.export(invokerDelegate)
        //这里originInvoker的URL已经是 "注册URL"了，dubbo://xxx...
        //所以之后肯定会走DubboProtocol进行服务暴露，将在3.6详细讲解
        return new ExporterChangeableWrapper<>((Exporter<T>) protocol.export(invokerDelegate), originInvoker);
    });
}

java.util.concurrent.ConcurrentMap#computeIfAbsent方法：

/**
 * {@inheritDoc}
 *
 * @implSpec
 * The default implementation is equivalent to the following steps for this
 * {@code map}, then returning the current value or {@code null} if now
 * absent:
 * 等价于：
 * <pre> {@code
 * if (map.get(key) == null) {
 *     V newValue = mappingFunction.apply(key);
 *     if (newValue != null)
 *         return map.putIfAbsent(key, newValue);
 * }
 * }</pre>
 * ...
 */
@Override
default V computeIfAbsent(K key,
        Function<? super K, ? extends V> mappingFunction) {
     
     
	...
}

(4) 获取注册中心

看getRegistry(originInvoker) 方法：

//org.apache.dubbo.registry.integration.RegistryProtocol#getRegistry
private Registry getRegistry(final Invoker<?> originInvoker) {
    
    
	//刚才跟过getRegistryUrl，URL的协议替换为zookeeper
    URL registryUrl = getRegistryUrl(originInvoker);
    return registryFactory.getRegistry(registryUrl);
}

DEBUG，registryFactory是一个自适应类：
在这里插入图片描述
在这里插入图片描述

看ZookeeperRegistryFactory的getRegistry方法，其实现是父类的抽象类AbstractRegistryFactory的getRegistry方法：

//org.apache.dubbo.registry.support.AbstractRegistryFactory#getRegistry
public Registry getRegistry(URL url) {
    
    
	//再次构建URL
    url = URLBuilder.from(url)
            .setPath(RegistryService.class.getName())
            .addParameter(INTERFACE_KEY, RegistryService.class.getName())//INTERFACE_KEY=interface
            .removeParameters(EXPORT_KEY, REFER_KEY)//移除export和refer属性
            .build();
    // 从url中获取注册中心的key (需要将注册中心的key放入map中下次获取就不需要重复创建注册中心)
    String key = url.toServiceStringWithoutResolving();
    // 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();
    }
}

继续看createRegistry方法创建注册中心：

public class ZookeeperRegistryFactory extends AbstractRegistryFactory {
    
    

    private ZookeeperTransporter zookeeperTransporter;

    /**
     * Invisible injection of zookeeper client via IOC/SPI
     * @param zookeeperTransporter
     */
    public void setZookeeperTransporter(ZookeeperTransporter zookeeperTransporter) {
    
    
        this.zookeeperTransporter = zookeeperTransporter;
    }

    @Override
    public Registry createRegistry(URL url) {
    
    
        return new ZookeeperRegistry(url, zookeeperTransporter);
    }

}

看一下ZookeeperRegistry构造：

public class ZookeeperRegistry extends FailbackRegistry {
    
    
   	...
	private final static int DEFAULT_ZOOKEEPER_PORT = 2181;
	//这个zkClient是Dubbo封装的
    private final ZookeeperClient zkClient;

    public ZookeeperRegistry(URL url, ZookeeperTransporter zookeeperTransporter) {
    
    
        super(url);
        if (url.isAnyHost()) {
    
    
            throw new IllegalStateException("registry address == null");
        }
        String group = url.getParameter(GROUP_KEY, DEFAULT_ROOT);
        if (!group.startsWith(PATH_SEPARATOR)) {
    
    
            group = PATH_SEPARATOR + group;
        }
        this.root = group;
        // zookeeperTransporter封装的是ZK的客户端，默认是curator
        // 使用curator客户端连接上注册中心，并返回一个zkClient(Dubbo的API，封装的也是curator)
        zkClient = zookeeperTransporter.connect(url);
        // 为zkClient添加一个连接状态监听，若连接失败，则会重新连接
        zkClient.addStateListener(state -> {
    
    
            if (state == StateListener.RECONNECTED) {
    
    
                try {
    
    
                    recover();  // 重连
                    //为什么需要重连，可以看到ZookeeperRegistry继承FailbackRegistry
                    //所以具有容错的功能
                } catch (Exception e) {
    
    
                    logger.error(e.getMessage(), e);
                }
            }
        });
    }
    ...
}

(5) 将提供者注册到注册中心

注册中心获取完了，最后看register方法

//org.apache.dubbo.registry.integration.RegistryProtocol#register
public void register(URL registryUrl, URL registeredProviderUrl) {
    
    
    // 获取注册中心，之前已经创建成功，这个时候是从缓存获取的
    Registry registry = registryFactory.getRegistry(registryUrl);
    // 完成注册(调用父类抽象类的register())
    registry.register(registeredProviderUrl);
}

DUBUG，看到registry是ZookeeperRegistry：
在这里插入图片描述

我们看ZookeeperRegistry的父类FailbackRegistry的register方法：

//org.apache.dubbo.registry.support.FailbackRegistry#register
public void register(URL url) {
    
    
    super.register(url);
    removeFailedRegistered(url);
    removeFailedUnregistered(url);
    try {
    
    
        // Sending a registration request to the server side
        // 调用子类的doRegister()
        doRegister(url);
    } catch (Exception e) {
    
    
        Throwable t = e;

        // If the startup detection is opened, the Exception is thrown directly.
        boolean check = getUrl().getParameter(Constants.CHECK_KEY, true)
                && url.getParameter(Constants.CHECK_KEY, true)
                && !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);
        }

        // Record a failed registration request to a failed list, retry regularly
        addFailedRegistered(url);
    }
}

继续看doRegister

//org.apache.dubbo.registry.zookeeper.ZookeeperRegistry#doRegister
public void doRegister(URL url) {
    
    
    try {
    
    
        // 创建节点
        // 第二个参数若为false，则创建持久节点，true，则创建临时节点
        // DYNAMIC_KEY = dynamic
        // 这里可以看出dynamic属性用来控制 提供者在注册中心的信息是否是实时的
        zkClient.create(toUrlPath(url), url.getParameter(DYNAMIC_KEY, true));
    } catch (Throwable e) {
    
    
        throw new RpcException("Failed to register " + url + " to zookeeper " + getUrl() + ", cause: " + e.getMessage(), e);
    }
}

DEBUG，看下效果：
在这里插入图片描述

一执行完毕
在这里插入图片描述

3.6 真正的服务暴露 - Dubbo协议的服务暴露

无论是否有注册中心，最终都会通过配置的协议进行服务暴露，默认是Dubbo暴露协议，接下来我们分析Dubbo服务暴露协议，看protocol.export(invokerDelegate)方法：

在这里插入图片描述

增强的方法不用关注，直接看org.apache.dubbo.rpc.protocol.dubbo.DubboProtocol#export

public <T> Exporter<T> export(Invoker<T> invoker) throws RpcException {
    
    
    URL url = invoker.getUrl();
	// 此时的url是 dubbo://xxxx..
    // export service.
    String key = serviceKey(url);
    // 生成exporter
    DubboExporter<T> exporter = new DubboExporter<T>(invoker, key, exporterMap);
    // 将exporter存放到exporterMap中，将来消费者的调用请求到来后，会首先从这里查找
    // 其所需要的exporter
    exporterMap.put(key, exporter);

    //export an stub service for dispatching event
    Boolean isStubSupportEvent = url.getParameter(STUB_EVENT_KEY, DEFAULT_STUB_EVENT);
    Boolean isCallbackservice = url.getParameter(IS_CALLBACK_SERVICE, false);
    if (isStubSupportEvent && !isCallbackservice) {
    
    
        String stubServiceMethods = url.getParameter(STUB_EVENT_METHODS_KEY);
        if (stubServiceMethods == null || stubServiceMethods.length() == 0) {
    
    
            if (logger.isWarnEnabled()) {
    
    
                logger.warn(new IllegalStateException("consumer [" + url.getParameter(INTERFACE_KEY) +
                        "], has set stubproxy support event ,but no stub methods founded."));
            }

        } else {
    
    
            stubServiceMethodsMap.put(url.getServiceKey(), stubServiceMethods);
        }
    }
    // 启动NettyServer
    openServer(url);
    // 优化序列化
    optimizeSerialization(url);

    return exporter;
}

从代码中可以看出，Dubbo协议暴露做了下面几件事：

  • 生成exporter并放入了exporterMap
  • 导出用于分派事件的存根服务
  • 启动交换服务的服务端(Dubbo暴露协议底层实现是NettyServer)
  • 优化序列化

这里我们只关注第三步。

DEBUG，看下exporterMap的ServiceKey是啥：
在这里插入图片描述

3.6.1 启动交换服务的服务端(Dubbo暴露协议底层实现是NettyServer)

dubbo中的交换服务，也叫作消息交换模式，通俗说就是 请求响应模型，更高一层的抽象

  • 对于提供者端来说是ExchangeServer，负责接受请求，处理请求，响应请求
  • 对于消费者端来说是ExchangeClient，负责发起请求，接受提供者端的响应，处理响应
@SPI(HeaderExchanger.NAME)
public interface Exchanger {
     
     

    /**
     * bind.
     * 绑定一个地址和端口、消息处理器，启动Server端
     * @param url
     * @param handler
     * @return message server
     */
    @Adaptive({
     
     Constants.EXCHANGER_KEY})
    ExchangeServer bind(URL url, ExchangeHandler handler) throws RemotingException;

    /**
     * connect.
     * 连接Server端，启动客户端端，也绑定了一个消息处理器
     * @param url
     * @param handler
     * @return message channel
     */
    @Adaptive({
     
     Constants.EXCHANGER_KEY})
    ExchangeClient connect(URL url, ExchangeHandler handler) throws RemotingException;

}

看openServer方法：

//org.apache.dubbo.rpc.protocol.dubbo.DubboProtocol#openServer
private void openServer(URL url) {
    
    
    // find server.
    // 获取key：  ip:port
    String key = url.getAddress();
    //client can export a service which's only for server to invoke
    // 从url中获取isServer属性值，isServer为true，表示当前为provider
    boolean isServer = url.getParameter(IS_SERVER_KEY, true);
    if (isServer) {
    
    
        // dubbo-check
        // serverMap是成员变量，每种暴露协议都会维护一个这个map
        // 而map的key放的是ip:port
		// 由此我们可以推断：
		// 相同IP、端口的情况，每种暴露协议都会创建一个ExchangeServer
		// 相同协议情况，每个ip、端口都会创建一个ExchangeServer
        ExchangeServer server = serverMap.get(key);
        if (server == null) {
    
    
            synchronized (this) {
    
    
                server = serverMap.get(key);
                if (server == null) {
    
    
                    // 对于Dubbo协议来说createServer(url)中最终会创建一个NettyServer
                    serverMap.put(key, createServer(url));
                }
            }
        } else {
    
    
            // server supports reset, use together with override
            // 不同的是服务不一样,url不一样
            // 所以如果IP、端口一样的不同服务会走else方法  
            // 只需要更新server里的url即可。在原来的URL基础上加上新的服务的URL
            server.reset(url);
        }
    }
}

从这段代码中可以看出 服务和 ExchangeServer、协议、IP端口 之间的关系：

首先每个协议之间是隔离的，在相同协议的情况下，每一个IP端口会对应一个Server
对于ExchangeServer来说，每一个ExchangeServer专门处理 一个固定协议、固定地址端口 的所有服务

看createServer方法：

//org.apache.dubbo.rpc.protocol.dubbo.DubboProtocol#createServer
private ExchangeServer createServer(URL url) {
    
    
    url = URLBuilder.from(url)
            // send readonly event when server closes, it's enabled by default
            .addParameterIfAbsent(CHANNEL_READONLYEVENT_SENT_KEY, Boolean.TRUE.toString())
            // enable heartbeat by default
            .addParameterIfAbsent(HEARTBEAT_KEY, String.valueOf(DEFAULT_HEARTBEAT))
            .addParameter(CODEC_KEY, DubboCodec.NAME)
            .build();
    //DEFAULT_REMOTING_SERVER = netty
    //默认用netty实现Transporter
    //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 {
    
    
	    //绑定地址端口，和请求处理器，启动ExchangeServer 
	    //此时url是dubbo://ip:port/xxxService?xxx&xxx...
        server = Exchangers.bind(url, requestHandler);
    } catch (RemotingException e) {
    
    
        throw new RpcException("Fail to start server(url: " + url + ") " + e.getMessage(), e);
    }

    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);
        }
    }

    return server;
}

继续看server = Exchangers.bind(url, requestHandler)方法：

//org.apache.dubbo.remoting.exchange.Exchangers#bind(org.apache.dubbo.common.URL, org.apache.dubbo.remoting.exchange.ExchangeHandler)
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");
    return getExchanger(url).bind(url, handler);
}

public static Exchanger getExchanger(URL url) {
    
    
	//EXCHANGER_KEY = "exchanger"
	//DEFAULT_EXCHANGER = "header"
	//即默认用头交换模式
    String type = url.getParameter(Constants.EXCHANGER_KEY, Constants.DEFAULT_EXCHANGER);
    return getExchanger(type);
}

public static Exchanger getExchanger(String type) {
    
    
    return ExtensionLoader.getExtensionLoader(Exchanger.class).getExtension(type);
}

上面代码可以看出，会调用HeaderExchanger的bind方法：

public class HeaderExchanger implements Exchanger {
    
    

    public static final String NAME = "header";

    @Override
    public ExchangeClient connect(URL url, ExchangeHandler handler) throws RemotingException {
    
    
        return new HeaderExchangeClient(Transporters.connect(url, new DecodeHandler(new HeaderExchangeHandler(handler))), true);
    }

    @Override
    public ExchangeServer bind(URL url, ExchangeHandler handler) throws RemotingException {
    
    
    	//看到这里创建了一个头交换Server实例
    	//并对handler进行了两次包装，最终封装成了ChannelHandler
        return new HeaderExchangeServer(Transporters.bind(url, new DecodeHandler(new HeaderExchangeHandler(handler))));
    }

}

这里我们主要关注看Transporters.bind()方法，Transporters字面翻译是传输者，可以理解为七层网络模型中的传输层，是真正负责数据传输的，而一般默认会用netty实现，我们继续看：

//org.apache.dubbo.remoting.Transporters#bind(org.apache.dubbo.common.URL, org.apache.dubbo.remoting.ChannelHandler...)
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 {
    
    
    	//如果多个处理器，用ChannelHandlerDispatcher包装一下，底层实现就是循环遍历
        handler = new ChannelHandlerDispatcher(handlers);
    }
    return getTransporter().bind(url, handler);
}

public static Transporter getTransporter() {
    
    
    return ExtensionLoader.getExtensionLoader(Transporter.class).getAdaptiveExtension();
}

注意此时getTransporter返回的是Transporter的动态自适应类

我们在把这个类拷贝出来，方便断点：
在这里插入图片描述

看NettyTransporter ：

public class NettyTransporter implements Transporter {
    
    

    public static final String NAME = "netty";

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

    @Override
    public Client connect(URL url, ChannelHandler listener) throws RemotingException {
    
    
        return new NettyClient(url, listener);
    }

}

继续跟org.apache.dubbo.remoting.transport.netty4.NettyServer构造：

public class NettyServer extends AbstractServer implements Server {
    
    

    private static final Logger logger = LoggerFactory.getLogger(NettyServer.class);
    /**
     * the cache for alive worker channel.
     * <ip:port, dubbo channel>
     */
    private Map<String, Channel> channels;
    /**
     * netty server bootstrap.
     */
    private ServerBootstrap bootstrap;
    /**
     * the boss channel that receive connections and dispatch these to worker channel.
     */
	private io.netty.channel.Channel channel;

    private EventLoopGroup bossGroup;
    private EventLoopGroup workerGroup;

    public NettyServer(URL url, ChannelHandler handler) throws RemotingException {
    
    
        // you can customize name and type of client thread pool by THREAD_NAME_KEY and THREADPOOL_KEY in CommonConstants.
        // the handler will be warped: MultiMessageHandler->HeartbeatHandler->handler
        super(url, ChannelHandlers.wrap(handler, ExecutorUtil.setThreadName(url, SERVER_THREAD_POOL_NAME)));
    }
    ...
}

跟super构造：

public abstract class AbstractServer extends AbstractEndpoint implements Server {
    
    

    protected static final String SERVER_THREAD_POOL_NAME = "DubboServerHandler";
    private static final Logger logger = LoggerFactory.getLogger(AbstractServer.class);
    ExecutorService executor;
    private InetSocketAddress localAddress;
    private InetSocketAddress bindAddress;
    private int accepts;
    private int idleTimeout;

    public AbstractServer(URL url, ChannelHandler handler) throws RemotingException {
    
    
        super(url, handler);
        localAddress = getUrl().toInetSocketAddress();

        String bindIp = getUrl().getParameter(Constants.BIND_IP_KEY, getUrl().getHost());
        int bindPort = getUrl().getParameter(Constants.BIND_PORT_KEY, getUrl().getPort());
        if (url.getParameter(ANYHOST_KEY, false) || NetUtils.isInvalidLocalHost(bindIp)) {
    
    
            bindIp = ANYHOST_VALUE;
        }
        bindAddress = new InetSocketAddress(bindIp, bindPort);
        this.accepts = url.getParameter(ACCEPTS_KEY, DEFAULT_ACCEPTS);
        this.idleTimeout = url.getParameter(IDLE_TIMEOUT_KEY, DEFAULT_IDLE_TIMEOUT);
        try {
    
    
	        //跟doOpen
            doOpen();
            if (logger.isInfoEnabled()) {
    
    
                logger.info("Start " + getClass().getSimpleName() + " bind " + getBindAddress() + ", export " + getLocalAddress());
            }
        } catch (Throwable t) {
    
    
            throw new RemotingException(url.toInetSocketAddress(), null, "Failed to bind " + getClass().getSimpleName()
                    + " on " + getLocalAddress() + ", cause: " + t.getMessage(), t);
        }
        ...
    }
    ...
}

主要看doOpen，实现在其子类：

//org.apache.dubbo.remoting.transport.netty4.NettyServer#doOpen
protected void doOpen() throws Throwable {
    
    
    bootstrap = new ServerBootstrap();

    bossGroup = new NioEventLoopGroup(1, new DefaultThreadFactory("NettyServerBoss", true));
    workerGroup = new NioEventLoopGroup(getUrl().getPositiveParameter(IO_THREADS_KEY, Constants.DEFAULT_IO_THREADS),
            new DefaultThreadFactory("NettyServerWorker", true));
	
	//自定义handler，真正处理业务的
    final NettyServerHandler nettyServerHandler = new NettyServerHandler(getUrl(), this);
    channels = nettyServerHandler.getChannels();

    bootstrap.group(bossGroup, workerGroup)
            .channel(NioServerSocketChannel.class)
            .childOption(ChannelOption.TCP_NODELAY, Boolean.TRUE)
            .childOption(ChannelOption.SO_REUSEADDR, Boolean.TRUE)
            .childOption(ChannelOption.ALLOCATOR, PooledByteBufAllocator.DEFAULT)
            .childHandler(new ChannelInitializer<NioSocketChannel>() {
    
    
                @Override
                protected void initChannel(NioSocketChannel ch) throws Exception {
    
    
                    // FIXME: should we use getTimeout()?
                    int idleTimeout = UrlUtils.getIdleTimeout(getUrl());
                    NettyCodecAdapter adapter = new NettyCodecAdapter(getCodec(), getUrl(), NettyServer.this);
                    ch.pipeline()//.addLast("logging",new LoggingHandler(LogLevel.INFO))//for debug
                            .addLast("decoder", adapter.getDecoder())
                            .addLast("encoder", adapter.getEncoder())
                            .addLast("server-idle-handler", new IdleStateHandler(0, 0, idleTimeout, MILLISECONDS))
                            .addLast("handler", nettyServerHandler);
                }
            });
    // bind
    ChannelFuture channelFuture = bootstrap.bind(getBindAddress());
    channelFuture.syncUninterruptibly();
    channel = channelFuture.channel();

}

这里可以看出提供者接收消费者请求消息的入口就是NettyServerHandler。

猜你喜欢

转载自blog.csdn.net/weixin_41947378/article/details/108472702
今日推荐
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
GCC 14.1 发布
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
Java自定义时间格式
同步整形电路
在开发中最最最常用的字符串的属性大集合
Linux 查看端口占用并杀掉
Java基础四：ArrayList
多线程之死锁就是这么简单
mysql 基础命令集
awk 命令详解
Centos6.3编译安装nginx+php步骤
OCR （Optical Character Recognition，光学字符识别）
每日归档
更多
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022