public interface Directory<T> extends Node {

    // Service interface type
    Class<T> getInterface();

    // The list() method filters the Invoker collection maintained by itself based on the Invocation request provided, and returns the Invoker collection that meets the conditions.
    List<Invoker<T>> list(Invocation invocation) throws RpcException;

    // The getAllInvokers() method returns all Invoker objects maintained by the current Directory object.
    List<Invoker<T>> getAllInvokers();

    // Consumer-side URL
    URL getConsumerUrl();

}

public void subscribe(URL url) {

setConsumerUrl(url);

// Add the current RegistryDirectory object as a ConfigurationListener to the CONSUMER_CONFIGURATION_LISTENER

CONSUMER_CONFIGURATION_LISTENER.addNotifyListener(this);

serviceConfigurationListener = new ReferenceConfigurationListener(this, url);

// Complete the subscription operation. The operations on the registry have been introduced in the previous lesson, so I won't repeat them here.

registry.subscribe(url, this);

}

public synchronized void notify(List<URL> urls) {

// Classify according to category into configurators, routers, and providers

Map<String, List<URL>> categoryUrls = urls.stream()

        .filter(Objects::nonNull)

        .filter(this::isValidCategory)

        .filter(this::isNotCompatibleFor26x)

        .collect(Collectors.groupingBy(this::judgeCategory));

// Get URLs of the configurators type and convert them into Configurator objects

List<URL> configuratorURLs = categoryUrls.getOrDefault(CONFIGURATORS_CATEGORY, Collections.emptyList());

this.configurators = Configurator.toConfigurators(configuratorURLs).orElse(this.configurators);

// Get URLs of the routers type and convert them into Router objects, then add them to the RouterChain

List<URL> routerURLs = categoryUrls.getOrDefault(ROUTERS_CATEGORY, Collections.emptyList());

toRouters(routerURLs).ifPresent(this::addRouters);

// Get URLs of the providers type and process them by calling the refreshOverrideAndInvoker() method

List<URL> providerURLs = categoryUrls.getOrDefault(PROVIDERS_CATEGORY, Collections.emptyList());

... // In Dubbo 3.0, the AddressListener listener will be triggered, but the AddressListener interface has not been implemented yet, so this code is omitted

refreshOverrideAndInvoker(providerURLs);

}

private void refreshInvoker(List<URL> invokerUrls) {

// If the invokerUrls collection is not empty, its length is 1, and the protocol is empty, it means that all providers of this service have gone offline. The Invoker corresponding to the current provider will be destroyed.

if (invokerUrls.size() == 1 && invokerUrls.get(0) != null

        && EMPTY_PROTOCOL.equals(invokerUrls.get(0).getProtocol())) {

    this.forbidden = true; // Set the forbidden flag to true, subsequent requests will throw exceptions directly

    this.invokers = Collections.emptyList();

    routerChain.setInvokers(this.invokers); // Clear the Invoker collection in the RouterChain

    destroyAllInvokers(); // Close all Invoker objects

} else {

    this.forbidden = false; // Set the forbidden flag to false, RegistryDirectory can handle subsequent requests normally

    Map<String, Invoker<T>> oldUrlInvokerMap = this.urlInvokerMap; // Save a local reference

    if (invokerUrls == Collections.<URL>emptyList()) {

        invokerUrls = new ArrayList<>();

    }

    if (invokerUrls.isEmpty() && this.cachedInvokerUrls != null) {

        // If the invokerUrls collection is empty and cachedInvokerUrls is not empty, use the data cached in cachedInvokerUrls,

        // indicating that the providers directory in the registry has not changed, and the invokerUrls is empty, indicating that the cachedInvokerUrls collection caches the latest values

        invokerUrls.addAll(this.cachedInvokerUrls);

    } else {

        // If the invokerUrls collection is not empty, update the cachedInvokerUrls collection with the invokerUrls collection

        // indicating that the providers have changed, and the invokerUrls collection contains all the service providers in the registry at this time

        this.cachedInvokerUrls = new HashSet<>();

        this.invokers = multiGroup ? toMergeInvokerList(newInvokers) : newInvokers;

        this.urlInvokerMap = newUrlInvokerMap;

        // 比较新旧两组Invoker集合，销毁掉已经下线的Invoker

        destroyUnusedInvokers(oldUrlInvokerMap, newUrlInvokerMap);

    }

}

private Map<String, Invoker<T>> toInvokers(List<URL> urls) {

... // Return an empty Map directly when the urls collection is empty

Set<String> keys = new HashSet<>();

String queryProtocols = this.queryMap.get(PROTOCOL_KEY); // Get the protocols supported by the consumer, that is, the protocol specified by the protocol parameter

for (URL providerUrl : urls) {

    if (queryProtocols != null && queryProtocols.length() > 0) {

        boolean accept = false;

        String[] acceptProtocols = queryProtocols.split(",");

        for (String acceptProtocol : acceptProtocols) { // Traverse all the protocols supported by the consumer

            if (providerUrl.getProtocol().equals(acceptProtocol)) {

                accept = true;

                break;

            }

        }

        if (!accept) {

            continue; // If the current URL does not support the protocol of the consumer, the subsequent conversion to Invoker logic cannot be executed

        }

    }

    if (EMPTY_PROTOCOL.equals(providerUrl.getProtocol())) {

        continue; // Skip URLs with empty protocol

    }

    // If the consumer does not support the protocol of the URL (check whether there is a corresponding Protocol extension implementation through the SPI), the URL will also be skipped

    if (!ExtensionLoader.getExtensionLoader(Protocol.class).hasExtension(providerUrl.getProtocol())) {

        logger.error("...");

        continue;

    }

    // Merge URL parameters, this merge process will be introduced later in this lesson

    URL url = mergeUrl(providerUrl);

    // Get the string representation of the complete URL, which is the key in the urlInvokerMap collection

    String key = url.toFullString();

    if (keys.contains(key)) { // Skip duplicate URLs

        continue;

    }

    keys.add(key); // Record the key

    // Match the Invoker object in the urlInvokerMap cache. If the cache is hit, simply add the Invoker to the newUrlInvokerMap collection;
    // If the cache is not hit, create a new Invoker object and add it to the newUrlInvokerMap collection

    Map<String, Invoker<T>> localUrlInvokerMap = this.urlInvokerMap;

    Invoker<T> invoker = localUrlInvokerMap == null ? null : localUrlInvokerMap.get(key);

    if (invoker == null) {

        try {

            boolean enabled = true;

            if (url.hasParameter(DISABLED_KEY)) { // Check the disable and enable parameters in the URL to determine whether an Invoker object can be created

                enabled = !url.getParameter(DISABLED_KEY, false);

            } else {

                enabled = url.getParameter(ENABLED_KEY, true);

            }

            if (enabled) { // Create the corresponding Invoker object through the Protocol.refer() method here

                invoker = new InvokerDelegate<>(protocol.refer(serviceType, url), url, providerUrl);

            }

        } catch (Throwable t) {

            logger.error("Failed to refer invoker for interface:" + serviceType + ",url:(" + url + ")" + t.getMessage(), t);

        }

        if (invoker != null) { // Record the mapping relationship between the key and the Invoker object in newUrlInvokerMap

newUrlInvokerMap.put(key, invoker);

}

} else {// Cache hit, directly transfer Invoker in urlInvokerMap to newUrlInvokerMap

newUrlInvokerMap.put(key, invoker);

}

}

keys.clear();

return newUrlInvokerMap;

}


**The code of the toInvokers() method is a bit long, but the core logic is to call the Protocol.refer() method to create the Invoker object, and the other logic is to determine whether to call the method.**

Inside the toInvokers() method, we can see that the mergeUrl() method is called to merge the URL parameters. In the mergeUrl() method, the configurators URL in the configurators directory of the registry center (override protocol), as well as the configurations dynamically added by the service governance console, are merged with the Provider URL, which overrides some of the original information of the Provider URL. The specific implementation is as follows:

```java
private URL mergeUrl(URL providerUrl) {

// First, remove the attributes in the Provider URL that only take effect on the Provider side, such as threadname, threadpool, corethreads, threads, queues, and so on.

// Then, override the corresponding configurations of the Provider URL with the configurations on the Consumer side. Among them, the version, group, methods, timestamp and other parameters have the priority of the Provider side's configurations.

// Finally, merge the Filter and Listener configurations from both the Provider and Consumer sides.

providerUrl = ClusterUtils.mergeUrl(providerUrl, queryMap);

// Merge configurators type URLs. configurators type URLs can be divided into three types:

// The first type is the URLs added under the configurators directory of the registry center (override protocol).

// The second type is the dynamic configurations obtained through the ConsumerConfigurationListener listener (listens to application-level configurations).

// The third type is the dynamic configurations obtained through the ReferenceConfigurationListener listener (listens to service-level configurations).

// Here, you only need to understand that in addition to the configurators in the configurators directory of the registry center, there are also configurations that can be dynamically added through the service governance console,

// The ConsumerConfigurationListener and ReferenceConfigurationListener listeners are used to listen to dynamic configurations from the service governance console.

// As for the specific use of the service governance console, it will be detailed later.

providerUrl = overrideWithConfigurator(providerUrl);

// Add check=false, which means that the Provider's availability is only checked when it is called.

providerUrl = providerUrl.addParameter(Constants.CHECK_KEY, String.valueOf(false));

// Reassign the overrideDirectoryUrl with the providerUrl after the first step of parameter merge (including the properties overridden by the override protocol)。

this.overrideDirectoryUrl = this.overrideDirectoryUrl.addParametersIfAbsent(providerUrl.getParameters());

... // Omit the compatibility logic for Dubbo's lower versions

return providerUrl;

}

private List<Invoker<T>> toMergeInvokerList(List<Invoker<T>> invokers) {

List<Invoker<T>> mergedInvokers = new ArrayList<>();

Map<String, List<Invoker<T>>> groupMap = new HashMap<>();

for (Invoker<T> invoker : invokers) { // Group the Invokers by group

String group = invoker.getUrl().getParameter(GROUP_KEY, "");

groupMap.computeIfAbsent(group, k -> new ArrayList<>());

groupMap.get(group).add(invoker);

}

if (groupMap.size() == 1) { // If there is only one group, directly use the Invoker collection corresponding to that group as mergedInvokers

mergedInvokers.addAll(groupMap.values().iterator().next());

} else if (groupMap.size() > 1) { // Merge the Invoker collections corresponding to each group into one Invoker

for (List<Invoker<T>> groupList : groupMap.values()) {

// This uses StaticDirectory and Cluster to merge the Invokers in each group

StaticDirectory<T> staticDirectory = new StaticDirectory<>(groupList);

staticDirectory.buildRouterChain();

mergedInvokers.add(CLUSTER.join(staticDirectory));

}

} else {

mergedInvokers = invokers;

}

return mergedInvokers;

}

public List<Invoker<T>> doList(Invocation invocation) {

if (forbidden) { // Check for the forbidden field. When this field is set to true in the refreshInvoker() process, it means that there is no available Provider, so an exception is thrown

throw new RpcException("...");

}

if (multiGroup) {

// Special handling when multiGroup is true. In the refreshInvoker() method, filtering has been done using the Router for the multiGroup scenario, so the interface is returned directly here

return this.invokers == null ? Collections.emptyList() : this.invokers;

}

List<Invoker<T>> invokers = null;

// Use the RouterChain.route() method to filter the Invoker collection and finally obtain the Invoker collection that meets the routing conditions

invokers = routerChain.route(getConsumerUrl(), invocation);

return invokers == null ? Collections.emptyList() : invokers;

}