Dubbo源码分析----多版本

在开发的时候，可能多个项目会修改同一个服务，那么不能直接暴露出来，否则会被其他人给调用到，导致数据不正常，那么这种情况下可以使用dubbo的多版本来解决这个问题，配置如下：

// 稳定环境下的provider和consumer
<dubbo:service interface="com.foo.BarService" version="1.0.0" />
<dubbo:reference id="barService" interface="com.foo.BarService" version="1.0.0" />

// 项目环境下的provider和consumer，我司用的是1.0.0加上项目后缀，这个只要能区分就OK
<dubbo:service interface="com.foo.BarService" version="1.0.0xxx" />
<dubbo:reference id="barService" interface="com.foo.BarService" version="1.0.0xxx" />

那么稳定环境下的项目之间会调用稳定的服务，而项目环境中由于还在开发，接口可能不稳定，所以改了版本号，其他人调用不到(除非他们指定了你的非稳定版本，这种情况嘛….活该(〃’▽’〃))，那么dubbo是如何区分这几个服务的呢？接下来从consumer和provider源码开始分析

提供者

对于提供者来说，需要暴露两个版本的服务，从zk上说的就是创建了两个不一样的节点。回顾一下当提供者接收到请求的时候，首先会先找到exporter，然后再找到invoker，那么
- 如果是一个机器上暴露了两个版本的服务，这块如何做区分呢？

这个问题要看下DubboProtocol类的export方法，因为这是讲exporter保存起来的地方

    public <T> Exporter<T> export(Invoker<T> invoker) throws RpcException {
        URL url = invoker.getUrl();

        // export service.
        String key = serviceKey(url);
        DubboExporter<T> exporter = new DubboExporter<T>(invoker, key, exporterMap);
        exporterMap.put(key, exporter);

        //....
        return exporter;
    }

可以看到，如果要支持多版本，这个key肯定要不一样，所以大概能猜出来，这个key的组成一定有version，那么看下serviceKey方法

    protected static String serviceKey(URL url) {
        return ProtocolUtils.serviceKey(url);
    }
    //ProtocolUtils
    public static String serviceKey(URL url) {
        return serviceKey(url.getPort(), url.getPath(), url.getParameter(Constants.VERSION_KEY),
                          url.getParameter(Constants.GROUP_KEY));
    }
    public static String serviceKey(int port, String serviceName, String serviceVersion, String serviceGroup) {
        StringBuilder buf = new StringBuilder();
        if (serviceGroup != null && serviceGroup.length() > 0) {
            buf.append(serviceGroup);
            buf.append("/");
        }
        buf.append(serviceName);
        if (serviceVersion != null && serviceVersion.length() > 0 && !"0.0.0".equals(serviceVersion)) {
            buf.append(":");
            buf.append(serviceVersion);
        }
        buf.append(":");
        buf.append(port);
        return buf.toString();
    }

参数传了version，key的组成和version有关，另外还和group有关，这个属性和分组有关，到这里可以知道提供者这边不同版本的服务有不同的exporter，进而也可以说明，消费者会把version这个属性发送过来，接下来看下消费者的处理

消费者

消费者这边就比较复杂了，从ZookeeperRegistry的doSubscribe方法开始看起，因为这里是处理zk相关节点的地方，而多版本在zk上是节点的不同，所以看下这里是否有对节点做特殊处理

    protected void doSubscribe(final URL url, final NotifyListener listener) {
                //....
                List<URL> urls = new ArrayList<URL>();
                for (String path : toCategoriesPath(url)) {
                    ConcurrentMap<NotifyListener, ChildListener> listeners = zkListeners.get(url);
                    if (listeners == null) {
                        zkListeners.putIfAbsent(url, new ConcurrentHashMap<NotifyListener, ChildListener>());
                        listeners = zkListeners.get(url);
                    }
                    ChildListener zkListener = listeners.get(listener);
                    if (zkListener == null) {
                        listeners.putIfAbsent(listener, new ChildListener() {
                            public void childChanged(String parentPath, List<String> currentChilds) {
                                ZookeeperRegistry.this.notify(url, listener, toUrlsWithEmpty(url, parentPath, currentChilds));
                            }
                        });
                        zkListener = listeners.get(listener);
                    }
                    zkClient.create(path, false);
                    List<String> children = zkClient.addChildListener(path, zkListener);
                    if (children != null) {
                        urls.addAll(toUrlsWithEmpty(url, path, children));
                    }
                }
                notify(url, listener, urls);
//....
    }

主要看providers的类目，在addChildListener方法调用后，会返回儿子节点，即服务提供者节点，这时候，调用toUrlsWithEmpty方法

    private List<URL> toUrlsWithEmpty(URL consumer, String path, List<String> providers) {
        List<URL> urls = toUrlsWithoutEmpty(consumer, providers);
        if (urls == null || urls.isEmpty()) {
            int i = path.lastIndexOf('/');
            String category = i < 0 ? path : path.substring(i + 1);
            URL empty = consumer.setProtocol(Constants.EMPTY_PROTOCOL).addParameter(Constants.CATEGORY_KEY, category);
            urls.add(empty);
        }
        return urls;
    }

进来后，会再调用toUrlsWithoutEmpty进行处理，并返回一个List，当List为空，会构建一个empty协议的url，这个后面讲到，如果不为空，则直接返回，那么看下toUrlsWithoutEmpty方法

    private List<URL> toUrlsWithoutEmpty(URL consumer, List<String> providers) {
        List<URL> urls = new ArrayList<URL>();
        if (providers != null && providers.size() > 0) {
            for (String provider : providers) {
                provider = URL.decode(provider);
                if (provider.contains("://")) {
                    URL url = URL.valueOf(provider);
                    if (UrlUtils.isMatch(consumer, url)) {
                        urls.add(url);
                    }
                }
            }
        }
        return urls;
    }

可以看到，会遍历提供者节点，和消费者进行比对，如果符合，那么才会返回，到这里就可以知道了UrlUtils.isMatch会有version的判断

    public static boolean isMatch(URL consumerUrl, URL providerUrl) {
        String consumerInterface = consumerUrl.getServiceInterface();
        String providerInterface = providerUrl.getServiceInterface();
        if( ! (Constants.ANY_VALUE.equals(consumerInterface) || StringUtils.isEquals(consumerInterface, providerInterface)) ) return false;

        if (! isMatchCategory(providerUrl.getParameter(Constants.CATEGORY_KEY, Constants.DEFAULT_CATEGORY), 
                consumerUrl.getParameter(Constants.CATEGORY_KEY, Constants.DEFAULT_CATEGORY))) {
            return false;
        }
        if (! providerUrl.getParameter(Constants.ENABLED_KEY, true) 
                && ! Constants.ANY_VALUE.equals(consumerUrl.getParameter(Constants.ENABLED_KEY))) {
            return false;
        }

        String consumerGroup = consumerUrl.getParameter(Constants.GROUP_KEY);
        String consumerVersion = consumerUrl.getParameter(Constants.VERSION_KEY);
        String consumerClassifier = consumerUrl.getParameter(Constants.CLASSIFIER_KEY, Constants.ANY_VALUE);

        String providerGroup = providerUrl.getParameter(Constants.GROUP_KEY);
        String providerVersion = providerUrl.getParameter(Constants.VERSION_KEY);
        String providerClassifier = providerUrl.getParameter(Constants.CLASSIFIER_KEY, Constants.ANY_VALUE);
        return (Constants.ANY_VALUE.equals(consumerGroup) || StringUtils.isEquals(consumerGroup, providerGroup) || StringUtils.isContains(consumerGroup, providerGroup))
               && (Constants.ANY_VALUE.equals(consumerVersion) || StringUtils.isEquals(consumerVersion, providerVersion))
               && (consumerClassifier == null || Constants.ANY_VALUE.equals(consumerClassifier) || StringUtils.isEquals(consumerClassifier, providerClassifier));
    }

方法里比较了很多参数，这里我们只关心version，version不一样的时候，会返回false，即toUrlsWithEmpty方法会返回一个empty协议的url。

回到doSubscribe方法，获取到urls之后，会调用notify方法，该方法一路调用到com.alibaba.dubbo.registry.integration.RegistryDirectory#refreshInvoker方法

    private void refreshInvoker(List<URL> invokerUrls){
        if (invokerUrls != null && invokerUrls.size() == 1 && invokerUrls.get(0) != null
                && Constants.EMPTY_PROTOCOL.equals(invokerUrls.get(0).getProtocol())) {
            this.forbidden = true; // 禁止访问
            this.methodInvokerMap = null; // 置空列表
            destroyAllInvokers(); // 关闭所有Invoker
        } else {
            this.forbidden = false; // 允许访问
            //....
        }
    }

这里判断Url如果是empty协议的，那么forbidden会设置为true，即禁止访问，那么会有什么后果呢？

在com.alibaba.dubbo.registry.integration.RegistryDirectory#doList方法中会首先判断该属性

    public List<Invoker<T>> doList(Invocation invocation) {
        if (forbidden) {
            throw new RpcException(RpcException.FORBIDDEN_EXCEPTION, "Forbid consumer " +  NetUtils.getLocalHost() 
+ " access service " + getInterface().getName() + " from registry " + getUrl().getAddress() + " use dubbo version " 
+ Version.getVersion() + ", Please check registry access list (whitelist/blacklist).");
        }
        //....
    }

即调用的时候会报错

那么又有一个问题

• 当前调用的时候没有该版本的服务，那么当该版本的服务启动之后，会如何处理？

对服务暴露和提供熟悉的应该会知道，消费者对providers节点设置了监听器，当节点变化，然后调用一下notify方法，如果新增的节点是匹配版本的那么refreshInvoker中forbidden不为true，服务正常调用，如果不匹配，那么和上面一样的结果。

总结一下：
1. 提供者不同服务会再zk上创建不同的节点
2. 提供者保存exporter的时候会根据version的不同去构造不同的key放到map中
3. 消费者会获取providers下的节点，并比对版本是否一样，如果不一样则返回一个empty协议的url
4. 如果协议为empty，那么会将forbidden设置为true，调用会报错
5. 当有节点发生变化又会执行比对的过程