在开发的时候，可能多个项目会修改同一个服务，那么不能直接暴露出来，否则会被其他人给调用到，导致数据不正常，那么这种情况下可以使用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，服务正常调用，如果不匹配，那么和上面一样的结果。
总结一下：
- 提供者不同服务会再zk上创建不同的节点
- 提供者保存exporter的时候会根据version的不同去构造不同的key放到map中
- 消费者会获取providers下的节点，并比对版本是否一样，如果不一样则返回一个empty协议的url
- 如果协议为empty，那么会将forbidden设置为true，调用会报错
- 当有节点发生变化又会执行比对的过程
