3、Dubbo的Directory目录与Router路由服务
当我们聊到Dubbo的Directory服务目录&Router路由服务时，我们应该考虑什么？
- 服务目录主要用来管理服务提供者列表，它实现了哪些管理功能？
- 消费端如何使用服务目录中的服务列表？进行服务调用？
在服务消费端应用中，每个需要消费的服务都被包装为ReferenceConfig，在应用启动时会调用每个服务对应的ReferenceConfig的get()方法，然后为每个服务创建一个自己的RegistryDirectory对象，每个RegistryDirectory管理该服务提供者的Invoker的地址列表、路由规则、动态配置等信息，当服务提供者的信息发生变化时，RegistryDirectory会动态的得到变化通知并自动更新；
Dubbo的Directory目录
Directory的实现有RegistryDirectory和StaticDirectory两种，前者管理的invoker列表是根据服务注册中心的推送变化而变化的，而后者是当消费端使用端注册中心的时候，会把所有服务注册中心的invoker列表汇集到一个invoker列表中；
我们主要看RegistryDirectory:
- 消费端何时创建RegistryDirectory
- RegistryDirectory管理的invoker列表如何动态变化
- 路由信息如何保存&变化
1、RegistryDirectory创建
(1)、ReferenceConfig开始
RegistryDirectory是在服务消费端启动的时候创建的。ReferenceConfig代表了一个要消费的服务的配置对象，首先会调用ReferenceConfig的get()方法，意味着要创建一个对服务提供方远程调用的代理。
public synchronized T get() {
// 已销毁，不可获得
if (destroyed) {
throw new IllegalStateException("Already destroyed!");
}
// 初始化
if (ref == null) {
init();
}
return ref;
}init()中会创建服务提供端调用的代理对象；
private void init() {
....
// 创建 Service 代理对象
ref = createProxy(map);
....
}创建代理的时候，首先会调用RegistryProtocol类的refer方法，这里Protocol是一个SPI扩展点RegistryProtocol是它的一个自适应的扩展实现，真正发起调用是用其适配器类Protocol$Adaptive进行间接调用的。另外ProtocolListenerWrapper、QosProtocolWrapper和ProtocolFilterWrapper是对RegistryProtocol类的功能的增强；
/**
* 创建 Service 代理对象
*
* @param map 集合
* @return 代理对象
*/
@SuppressWarnings({"unchecked", "rawtypes", "deprecation"})
private T createProxy(Map map) {
....
invoker = refprotocol.refer(interfaceClass, urls.get(0));
....
// 创建 Service 代理对象
return (T) proxyFactory.getProxy(invoker);
}
(1)、RegistryProtocol进入refer
public Invoker refer(Class type, URL url) throws RpcException {
...
// 获得注册中心
Registry registry = registryFactory.getRegistry(url);
....
// 执行服务引用
return doRefer(cluster, registry, type, url);
} private Invoker doRefer(Cluster cluster, Registry registry, Class type, URL url) {
// 创建 RegistryDirectory 对象，并设置注册中心
RegistryDirectory directory = new RegistryDirectory(type, url);
directory.setRegistry(registry);
directory.setProtocol(protocol);
// 创建订阅 URL
// all attributes of REFER_KEY
Map parameters = new HashMap(directory.getUrl().getParameters()); // 服务引用配置集合
URL subscribeUrl = new URL(Constants.CONSUMER_PROTOCOL, parameters.remove(Constants.REGISTER_IP_KEY), 0, type.getName(), parameters);
// 向注册中心注册自己（服务消费者）
if (!Constants.ANY_VALUE.equals(url.getServiceInterface())
&& url.getParameter(Constants.REGISTER_KEY, true)) {
registry.register(subscribeUrl.addParameters(Constants.CATEGORY_KEY, Constants.CONSUMERS_CATEGORY,
Constants.CHECK_KEY, String.valueOf(false))); // 不检查的原因是，不需要检查。
}
// 向注册中心订阅服务提供者 + 路由规则 + 配置规则
directory.subscribe(subscribeUrl.addParameter(Constants.CATEGORY_KEY,
Constants.PROVIDERS_CATEGORY
+ "," + Constants.CONFIGURATORS_CATEGORY
+ "," + Constants.ROUTERS_CATEGORY));
// 创建 Invoker 对象
Invoker invoker = cluster.join(directory);
// 向本地注册表，注册消费者
ProviderConsumerRegTable.registerConsumer(invoker, url, subscribeUrl, directory);
return invoker;
} 我们可看到在RegistryProtocol的refer()方法的dorefer()中创建了RegistryDirectory目录；
1、RegistryDirectory中invoker列表的更新
（1）、ZookeeperRegistry的doSubscribe
创建完RegistryDirectory后，调用了器subscribe()方法，这里假设使用的注册中心是zookeeper,这样就会去ZookeeperRegistry去订阅需要调用的服务提供者的地址列表；订阅方法中会添加一个监听器，当zookeeper发现服务提供者地址列表发生变化时，zkClient会回调这个监听器的notify（）方法；
@Override
protected void doSubscribe(final URL url, final NotifyListener listener) {
try {
// 处理所有 Service 层的发起订阅，例如监控中心的订阅
if (Constants.ANY_VALUE.equals(url.getServiceInterface())) {
String root = toRootPath();
// 获得 url 对应的监听器集合
ConcurrentMap listeners = zkListeners.get(url);
if (listeners == null) { // 不存在，进行创建
zkListeners.putIfAbsent(url, new ConcurrentHashMap());
listeners = zkListeners.get(url);
}
// 获得 ChildListener 对象
ChildListener zkListener = listeners.get(listener);
if (zkListener == null) { // 不存在 ChildListener 对象，进行创建 ChildListener 对象
listeners.putIfAbsent(listener, new ChildListener() {
public void childChanged(String parentPath, List currentChilds) {
for (String child : currentChilds) {
child = URL.decode(child);
// 新增 Service 接口全名时（即新增服务），发起该 Service 层的订阅
if (!anyServices.contains(child)) {
anyServices.add(child);
subscribe(url.setPath(child).addParameters(Constants.INTERFACE_KEY, child,
Constants.CHECK_KEY, String.valueOf(false)), listener);
}
}
}
});
zkListener = listeners.get(listener);
}
// 创建 Service 节点。该节点为持久节点。
zkClient.create(root, false);
// 向 Zookeeper ，Service 节点，发起订阅
List services = zkClient.addChildListener(root, zkListener);
// 首次全量数据获取完成时，循环 Service 接口全名数组，发起该 Service 层的订阅
if (services != null && !services.isEmpty()) {
for (String service : services) {
service = URL.decode(service);
anyServices.add(service);
subscribe(url.setPath(service).addParameters(Constants.INTERFACE_KEY, service,
Constants.CHECK_KEY, String.valueOf(false)), listener);
}
}
// 处理指定 Service 层的发起订阅，例如服务消费者的订阅
} else {
// 子节点数据数组
List urls = new ArrayList();
// 循环分类数组
for (String path : toCategoriesPath(url)) {
// 获得 url 对应的监听器集合
ConcurrentMap listeners = zkListeners.get(url);
if (listeners == null) { // 不存在，进行创建
zkListeners.putIfAbsent(url, new ConcurrentHashMap());
listeners = zkListeners.get(url);
}
// 获得 ChildListener 对象
ChildListener zkListener = listeners.get(listener);
if (zkListener == null) { // 不存在 ChildListener 对象，进行创建 ChildListener 对象
listeners.putIfAbsent(listener, new ChildListener() {
public void childChanged(String parentPath, List currentChilds) {
// 变更时，调用 `#notify(...)` 方法，回调 NotifyListener
ZookeeperRegistry.this.notify(url, listener, toUrlsWithEmpty(url, parentPath, currentChilds));
}
});
zkListener = listeners.get(listener);
}
// 创建 Type 节点。该节点为持久节点。
zkClient.create(path, false);
// 向 Zookeeper ，PATH 节点，发起订阅
List children = zkClient.addChildListener(path, zkListener);
// 添加到 `urls` 中
if (children != null) {
urls.addAll(toUrlsWithEmpty(url, path, children));
}
}
// 首次全量数据获取完成时，调用 `#notify(...)` 方法，回调 NotifyListener
notify(url, listener, urls);
}
} catch (Throwable e) {
throw new RpcException("Failed to subscribe " + url + " to zookeeper " + getUrl() + ", cause: " + e.getMessage(), e);
}
} (2)、RegistryDerictory的notify()通知
订阅zk并设置监听器后，同步返回了订阅的服务地址列表、路由规则、配置信息等，然后同步调用了RegistryDerictory的notify()方法返回，返回的服务提供者信息被分为三组(地址列表、路由规则、服务降级等配置信息)，并通过refreshInvoker()写入到RoutChain里，当服务消费方的集群容错策略要获取可用服务提供者对应的invoker列表时，会调用RouterChain的route()方法，其内部根据路由规则信息和invoker列表提供服务
@Override
public synchronized void notify(List urls) {
// 根据 URL 的分类或协议，分组成三个集合 。
List invokerUrls = new ArrayList(); // 服务提供者 URL 集合
List routerUrls = new ArrayList();
List configuratorUrls = new ArrayList();
for (URL url : urls) {
String protocol = url.getProtocol();
String category = url.getParameter(Constants.CATEGORY_KEY, Constants.DEFAULT_CATEGORY);
if (Constants.ROUTERS_CATEGORY.equals(category) || Constants.ROUTE_PROTOCOL.equals(protocol)) {
routerUrls.add(url);
} else if (Constants.CONFIGURATORS_CATEGORY.equals(category) || Constants.OVERRIDE_PROTOCOL.equals(protocol)) {
configuratorUrls.add(url);
} else if (Constants.PROVIDERS_CATEGORY.equals(category)) {
invokerUrls.add(url);
} else {
logger.warn("Unsupported category " + category + " in notified url: " + url + " from registry " + getUrl().getAddress() + " to consumer " + NetUtils.getLocalHost());
}
}
// 处理配置规则 URL 集合
// configurators
if (!configuratorUrls.isEmpty()) {
this.configurators = toConfigurators(configuratorUrls);
}
// 处理路由规则 URL 集合
// routers
if (!routerUrls.isEmpty()) {
List routers = toRouters(routerUrls);
if (routers != null) { // null - do nothing
setRouters(routers);
}
}
// 合并配置规则，到 `directoryUrl` 中，形成 `overrideDirectoryUrl` 变量。
List localConfigurators = this.configurators; // local reference
// merge override parameters
this.overrideDirectoryUrl = directoryUrl;
if (localConfigurators != null && !localConfigurators.isEmpty()) {
for (Configurator configurator : localConfigurators) {
this.overrideDirectoryUrl = configurator.configure(overrideDirectoryUrl);
}
}
// 处理服务提供者 URL 集合
// providers
refreshInvoker(invokerUrls);
} 这里省略refreshInvoker内容了；