@SPI
public interface ConfiguratorFactory {

    /**
     * get the configurator instance.
     *
     * @param url - configurator url.
     * @return configurator instance.
     */
    @Adaptive("protocol")
    Configurator getConfigurator(URL url);

}

public class OverrideConfiguratorFactory implements ConfiguratorFactory {

    @Override
    public Configurator getConfigurator(URL url) {
        return new OverrideConfigurator(url);
    }

}

public class AbsentConfiguratorFactory implements ConfiguratorFactory {

    @Override
    public Configurator getConfigurator(URL url) {
        return new AbsentConfigurator(url);
    }

}

public interface Configurator extends Comparable<Configurator> {

    /**
     * get the configurator url.
     *
     * 配置规则
     *
     * @return configurator url.
     */
    URL getUrl();

    /**
     * Configure the provider url.
     *
     * 配置到 URL 中
     *
     * @param url - old rovider url.
     * @return new provider url.
     */
    URL configure(URL url);

}

/**
 * 配置规则 URL
 */
private final URL configuratorUrl;

public AbstractConfigurator(URL url) {
    if (url == null) {
        throw new IllegalArgumentException("configurator url == null");
    }
    this.configuratorUrl = url;
}

@Override
public URL getUrl() {
    return configuratorUrl;
}

 1: @Override
 2: public URL configure(URL url) {
 3:     if (configuratorUrl.getHost() == null || url == null || url.getHost() == null) {
 4:         return url;
 5:     }
 6:     // If override url has port, means it is a provider address. We want to control a specific provider with this override url, it may take effect on the specific provider instance or on consumers holding this provider instance.
 7:     // 配置规则，URL 带有端口( port )，意图是控制提供者机器。可以在提供端生效 也可以在消费端生效
 8:     if (configuratorUrl.getPort() != 0) {
 9:         if (url.getPort() == configuratorUrl.getPort()) {
10:             return configureIfMatch(url.getHost(), url);
11:         }
12:     // override url don't have a port, means the ip override url specify is a consumer address or 0.0.0.0
13:     // 配置规则，URL 没有端口，override 输入消费端地址 或者 0.0.0.0
14:     } else {
15:         // 1.If it is a consumer ip address, the intention is to control a specific consumer instance, it must takes effect at the consumer side, any provider received this override url should ignore;
16:         // 2.If the ip is 0.0.0.0, this override url can be used on consumer, and also can be used on provider
17:         // 1. 如果是消费端地址，则意图是控制消费者机器，必定在消费端生效，提供端忽略；
18:         // 2. 如果是0.0.0.0可能是控制提供端，也可能是控制提供端
19:         if (url.getParameter(Constants.SIDE_KEY, Constants.PROVIDER).equals(Constants.CONSUMER)) {
20:             // NetUtils.getLocalHost是消费端注册到zk的消费者地址
21:             return configureIfMatch(NetUtils.getLocalHost(), url);// NetUtils.getLocalHost is the ip address consumer registered to registry.
22:         } else if (url.getParameter(Constants.SIDE_KEY, Constants.CONSUMER).equals(Constants.PROVIDER)) {
23:             // 控制所有提供端，地址必定是0.0.0.0，否则就要配端口从而执行上面的if分支了
24:             return configureIfMatch(Constants.ANYHOST_VALUE, url);// take effect on all providers, so address must be 0.0.0.0, otherwise it won't flow to this if branch
25:         }
26:     }
27:     return url;
28: }

 1: private URL configureIfMatch(String host, URL url) {
 2:     // 匹配 Host
 3:     if (Constants.ANYHOST_VALUE.equals(configuratorUrl.getHost()) || host.equals(configuratorUrl.getHost())) {
 4:         // 匹配 "application"
 5:         String configApplication = configuratorUrl.getParameter(Constants.APPLICATION_KEY, configuratorUrl.getUsername()); // TODO 芋艿，为啥 username
 6:         String currentApplication = url.getParameter(Constants.APPLICATION_KEY, url.getUsername());
 7:         if (configApplication == null || Constants.ANY_VALUE.equals(configApplication)
 8:                 || configApplication.equals(currentApplication)) {
 9:             // 配置 URL 中的条件 KEYS 集合。其中下面四个 KEY ，不算是条件，而是内置属性。考虑到下面要移除，所以添加到该集合中。
10:             Set<String> conditionKeys = new HashSet<String>();
11:             conditionKeys.add(Constants.CATEGORY_KEY);
12:             conditionKeys.add(Constants.CHECK_KEY);
13:             conditionKeys.add(Constants.DYNAMIC_KEY);
14:             conditionKeys.add(Constants.ENABLED_KEY);
15:             // 判断传入的 url 是否匹配配置规则 URL 的条件。除了 "application" 和 "side" 之外，带有 `"~"` 开头的 KEY ，也是条件。
16:             for (Map.Entry<String, String> entry : configuratorUrl.getParameters().entrySet()) {
17:                 String key = entry.getKey();
18:                 String value = entry.getValue();
19:                 if (key.startsWith("~") || Constants.APPLICATION_KEY.equals(key) || Constants.SIDE_KEY.equals(key)) {
20:                     conditionKeys.add(key);
21:                     // 若不相等，则不匹配配置规则，直接返回
22:                     if (value != null && !Constants.ANY_VALUE.equals(value)
23:                             && !value.equals(url.getParameter(key.startsWith("~") ? key.substring(1) : key))) {
24:                         return url;
25:                     }
26:                 }
27:             }
28:             // 移除条件 KEYS 集合，并配置到 URL 中
29:             return doConfigure(url, configuratorUrl.removeParameters(conditionKeys));
30:         }
31:     }
32:     return url;
33: }

protected abstract URL doConfigure(URL currentUrl, URL configUrl);

@Override
public int compareTo(Configurator o) {
    if (o == null) {
        return -1;
    }
    // host 升序
    int ipCompare = getUrl().getHost().compareTo(o.getUrl().getHost());
    // 若 host 相同，按照 priority 降序
    if (ipCompare == 0) {//host is the same, sort by priority
        int i = getUrl().getParameter(Constants.PRIORITY_KEY, 0);
        int j = o.getUrl().getParameter(Constants.PRIORITY_KEY, 0);
        if (i < j) {
            return -1;
        } else if (i > j) {
            return 1;
        } else {
            return 0;
        }
    } else {
        return ipCompare;
    }
}

public class OverrideConfigurator extends AbstractConfigurator {

    public OverrideConfigurator(URL url) {
        super(url);
    }

    @Override
    public URL doConfigure(URL currentUrl, URL configUrl) {
        return currentUrl.addParameters(configUrl.getParameters()); // 覆盖添加
    }

}

public class AbsentConfigurator extends AbstractConfigurator {

    public AbsentConfigurator(URL url) {
        super(url);
    }

    @Override
    public URL doConfigure(URL currentUrl, URL configUrl) {
        return currentUrl.addParametersIfAbsent(configUrl.getParameters()); // 不存在时添加
    }

}

/**
 * 将overrideURL 转换为 map，供重新 refer 时使用.
 * 每次下发全部规则，全部重新组装计算
 *
 * @param urls 契约：
 *             </br>1.override://0.0.0.0/...(或override://ip:port...?anyhost=true)&para1=value1...表示全局规则(对所有的提供者全部生效)
 *             </br>2.override://ip:port...?anyhost=false 特例规则（只针对某个提供者生效）
 *             </br>3.不支持override://规则... 需要注册中心自行计算.
 *             </br>4.不带参数的override://0.0.0.0/ 表示清除override
 *
 * @return Configurator 集合
 */
 public static List<Configurator> toConfigurators(List<URL> urls) {
    // ...省略代码
 }

 1: public static List<Configurator> toConfigurators(List<URL> urls) {
 2:     // 忽略，若配置规则 URL 集合为空
 3:     if (urls == null || urls.isEmpty()) {
 4:         return Collections.emptyList();
 5:     }
 6: 
 7:     // 创建 Configurator 集合
 8:     List<Configurator> configurators = new ArrayList<Configurator>(urls.size());
 9:     for (URL url : urls) {
10:         // 若协议为 `empty://` ，意味着清空所有配置规则，因此返回空 Configurator 集合
11:         if (Constants.EMPTY_PROTOCOL.equals(url.getProtocol())) {
12:             configurators.clear();
13:             break;
14:         }
15:         // 对应第 4 条契约，不带参数的 override://0.0.0.0/ 表示清除 override
16:         Map<String, String> override = new HashMap<String, String>(url.getParameters());
17:         // The anyhost parameter of override may be added automatically, it can't change the judgement of changing url
18:         // override 上的 anyhost 可能是自动添加的，不能影响改变url判断
19:         override.remove(Constants.ANYHOST_KEY);
20:         if (override.size() == 0) {
21:             configurators.clear();
22:             continue;
23:         }
24:         // 获得 Configurator 对象，并添加到 `configurators` 中
25:         configurators.add(configuratorFactory.getConfigurator(url));
26:     }
27:     // 排序
28:     Collections.sort(configurators);
29:     return configurators;
30: }

 1: private URL mergeUrl(URL providerUrl) {
 2:     // 合并消费端参数
 3:     providerUrl = ClusterUtils.mergeUrl(providerUrl, queryMap); // Merge the consumer side parameters
 4: 
 5:     // 合并配置规则
 6:     List<Configurator> localConfigurators = this.configurators; // local reference
 7:     if (localConfigurators != null && !localConfigurators.isEmpty()) {
 8:         for (Configurator configurator : localConfigurators) {
 9:             providerUrl = configurator.configure(providerUrl);
10:         }
11:     }
12: 
13:     // 不检查连接是否成功，总是创建 Invoker ！
14:     providerUrl = providerUrl.addParameter(Constants.CHECK_KEY, String.valueOf(false)); // Do not check whether the connection is successful or not, always create Invoker!
15: 
16:     // The combination of directoryUrl and override is at the end of notify, which can't be handled here
17:     // 仅合并提供者参数，因为 directoryUrl 与 override 合并是在 notify 的最后，这里不能够处理
18:     this.overrideDirectoryUrl = this.overrideDirectoryUrl.addParametersIfAbsent(providerUrl.getParameters()); // Merge the provider side parameters
19: 
20:     // 【忽略】因为是对 1.0 版本的兼容
21:     if ((providerUrl.getPath() == null || providerUrl.getPath().length() == 0)
22:             && "dubbo".equals(providerUrl.getProtocol())) { // Compatible version 1.0
23:         //fix by tony.chenl DUBBO-44
24:         String path = directoryUrl.getParameter(Constants.INTERFACE_KEY);
25:         if (path != null) {
26:             int i = path.indexOf('/');
27:             if (i >= 0) {
28:                 path = path.substring(i + 1);
29:             }
30:             i = path.lastIndexOf(':');
31:             if (i >= 0) {
32:                 path = path.substring(0, i);
33:             }
34:             providerUrl = providerUrl.setPath(path);
35:         }
36:     }
37: 
38:     // 返回服务提供者 URL
39:     return providerUrl;
40: }

 1: @Override
 2: public <T> Exporter<T> export(final Invoker<T> originInvoker) throws RpcException {
 3:     // 暴露服务
 4:     // export invoker
 5:     final ExporterChangeableWrapper<T> exporter = doLocalExport(originInvoker);
 6: 
 7:     // 获得注册中心 URL
 8:     URL registryUrl = getRegistryUrl(originInvoker);
 9: 
10:     // 获得注册中心对象
11:     // registry provider
12:     final Registry registry = getRegistry(originInvoker);
13: 
14:     // 获得服务提供者 URL
15:     final URL registedProviderUrl = getRegistedProviderUrl(originInvoker);
16: 
17:     //to judge to delay publish whether or not
18:     boolean register = registedProviderUrl.getParameter("register", true);
19: 
20:     // 向注册中心订阅服务消费者
21:     ProviderConsumerRegTable.registerProvider(originInvoker, registryUrl, registedProviderUrl);
22: 
23:     // 向注册中心注册服务提供者（自己）
24:     if (register) {
25:         register(registryUrl, registedProviderUrl);
26:         ProviderConsumerRegTable.getProviderWrapper(originInvoker).setReg(true); // // 标记向本地注册表的注册服务提供者，已经注册
27:     }
28: 
29:     // 使用 OverrideListener 对象，订阅配置规则
30:     // Subscribe the override data
31:     // 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.
32:     // 创建订阅配置规则的 URL
33:     final URL overrideSubscribeUrl = getSubscribedOverrideUrl(registedProviderUrl);
34:     // 创建 OverrideListener 对象，并添加到 `overrideListeners` 中
35:     final OverrideListener overrideSubscribeListener = new OverrideListener(overrideSubscribeUrl, originInvoker);
36:     overrideListeners.put(overrideSubscribeUrl, overrideSubscribeListener);
37:     // 向注册中心，发起订阅
38:     registry.subscribe(overrideSubscribeUrl, overrideSubscribeListener);
39:     //Ensure that a new exporter instance is returned every time export
40:     return new DestroyableExporter<T>(exporter, originInvoker, overrideSubscribeUrl, registedProviderUrl);
41: }

/**
 * 重新 export ：protocol 中的 exporter destroy 问题
 *
 * 1. 要求 registry protocol 返回的 exporter 可以正常 destroy
 * 2. notify 后不需要重新向注册中心注册
 * 3. export 方法传入的 invoker 最好能一直作为 exporter 的 invoker.
 */

/**
 * 订阅 URL 对象
 */
private final URL subscribeUrl;
/**
 * 原始 Invoker 对象
 */
private final Invoker originInvoker;

public OverrideListener(URL subscribeUrl, Invoker originalInvoker) {
    this.subscribeUrl = subscribeUrl;
    this.originInvoker = originalInvoker;
}

 1: @Override
 2: public synchronized void notify(List<URL> urls) {
 3:     // 获得匹配的规则配置 URL 集合
 4:     logger.debug("original override urls: " + urls);
 5:     List<URL> matchedUrls = getMatchedUrls(urls, subscribeUrl);
 6:     logger.debug("subscribe url: " + subscribeUrl + ", override urls: " + matchedUrls);
 7:     // No matching results
 8:     if (matchedUrls.isEmpty()) {
 9:         return;
10:     }
11:     // 将配置规则 URL 集合，**转换**成对应的 Configurator 集合
12:     List<Configurator> configurators = RegistryDirectory.toConfigurators(matchedUrls);
13: 
14:     // 获得真实的 Invoker 对象
15:     final Invoker<?> invoker;
16:     if (originInvoker instanceof InvokerDelegete) {
17:         invoker = ((InvokerDelegete<?>) originInvoker).getInvoker();
18:     } else {
19:         invoker = originInvoker;
20:     }
21:     // The origin invoker
22:     // 获得真实的 Invoker 的 URL 对象
23:     URL originUrl = RegistryProtocol.this.getProviderUrl(invoker);
24: 
25:     // 忽略，若对应的 Exporter 对象不存在
26:     String key = getCacheKey(originInvoker);
27:     ExporterChangeableWrapper<?> exporter = bounds.get(key);
28:     if (exporter == null) {
29:         logger.warn(new IllegalStateException("error state, exporter should not be null"));
30:         return;
31:     }
32: 
33:     // The current, may have been merged many times
34:     // 获得 Invoker 当前的 URL 对象，可能已经被之前的配置规则合并过
35:     URL currentUrl = exporter.getInvoker().getUrl();
36:     // Merged with this configuration
37:     // 基于 originUrl 对象，合并配置规则，生成新的 newUrl 对象
38:     URL newUrl = getConfigedInvokerUrl(configurators, originUrl);
39:     // 判断新老 Url 不匹配，重新暴露 Invoker
40:     if (!currentUrl.equals(newUrl)) {
41:         RegistryProtocol.this.doChangeLocalExport(originInvoker, newUrl);
42:         logger.info("exported provider url changed, origin url: " + originUrl + ", old export url: " + currentUrl + ", new export url: " + newUrl);
43:     }
44: }

 1: private <T> void doChangeLocalExport(final Invoker<T> originInvoker, URL newInvokerUrl) {
 2:     // 校验对应的 Exporter 是否存在。若不存在，打印告警日志。
 3:     String key = getCacheKey(originInvoker);
 4:     final ExporterChangeableWrapper<T> exporter = (ExporterChangeableWrapper<T>) bounds.get(key);
 5:     if (exporter == null) {
 6:         logger.warn(new IllegalStateException("error state, exporter should not be null"));
 7:     } else {
 8:         // 创建 InvokerDelegete 对象
 9:         final Invoker<T> invokerDelegete = new InvokerDelegete<T>(originInvoker, newInvokerUrl);
10:         // 重新暴露 Invoker
11:         // 设置到 ExporterChangeableWrapper 中
12:         exporter.setExporter(protocol.export(invokerDelegete));
13:     }
14: }