源码解析 之 服务发布

1. 查找服务发布的入口

Dubbo 请求中的元数据 dubbo context_dubbo源码解析

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

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的转换

Dubbo 请求中的元数据 dubbo context_dubbo源码解析_02

往下走:

Dubbo 请求中的元数据 dubbo context_dubbo源码解析_03


Dubbo 请求中的元数据 dubbo context_dubbo源码解析_04

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属性:

Dubbo 请求中的元数据 dubbo context_dubbo源码解析_05


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 请求中的元数据 dubbo context_dubbo源码解析_06

dubbo源码中只有两个ConfiguratorFactory,没有dubbo的:

Dubbo 请求中的元数据 dubbo context_dubbo源码解析_07


所以这里也不用太关注

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:

Dubbo 请求中的元数据 dubbo context_dubbo源码解析_08


Dubbo 请求中的元数据 dubbo context_dubbo源码解析_09


Dubbo 请求中的元数据 dubbo context_dubbo源码解析_10


为了方便看源码,断点调试,可以把这个动态生成的自适应类Protocol$Adaptive拷贝出来生成java文件放入工程中(为什么拷贝出来能够运行之前讲Dubbo动态编译的时候解释过)


Dubbo 请求中的元数据 dubbo context_dubbo源码解析_11

上面显示的是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®istry=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:

Dubbo 请求中的元数据 dubbo context_dubbo源码解析_12


可以看下增强类:


Dubbo 请求中的元数据 dubbo context_dubbo源码解析_13

接下来直接看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:

Dubbo 请求中的元数据 dubbo context_dubbo源码解析_14

从registry://换成了zookeeper://

Dubbo 请求中的元数据 dubbo context_dubbo源码解析_15

(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®istry=zookeeper×tamp=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:

Dubbo 请求中的元数据 dubbo context_dubbo源码解析_16


解码后就没有乱码

(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是一个自适应类:

Dubbo 请求中的元数据 dubbo context_dubbo源码解析_17


Dubbo 请求中的元数据 dubbo context_dubbo源码解析_18

看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:

Dubbo 请求中的元数据 dubbo context_dubbo源码解析_19

我们看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,看下效果:

Dubbo 请求中的元数据 dubbo context_dubbo源码解析_20

一执行完毕

Dubbo 请求中的元数据 dubbo context_dubbo源码解析_21

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是啥:

Dubbo 请求中的元数据 dubbo context_dubbo源码解析_22

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的动态自适应类

我们在把这个类拷贝出来,方便断点:

Dubbo 请求中的元数据 dubbo context_dubbo源码解析_23

看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。