/**
 * 注册中心配置数组
 */
protected List<ProtocolConfig> protocols;

  1: /**
  2:  * 暴露 Dubbo URL
  3:  */
  4: @SuppressWarnings({"unchecked", "rawtypes"})
  5: private void doExportUrls() {
  6:     // 加载注册中心 URL 数组
  7:     List<URL> registryURLs = loadRegistries(true);
  8:     // 循环 `protocols` ，向逐个注册中心分组暴露服务。
  9:     for (ProtocolConfig protocolConfig : protocols) {
 10:         doExportUrlsFor1Protocol(protocolConfig, registryURLs);
 11:     }
 12: }

 1: /**
 2:  * 加载注册中心 URL 数组
 3:  *
 4:  * @param provider 是否是服务提供者
 5:  * @return URL 数组
 6:  */
 7: protected List<URL> loadRegistries(boolean provider) {
 8:     // 校验 RegistryConfig 配置数组。
 9:     checkRegistry();
10:     // 创建 注册中心 URL 数组
11:     List<URL> registryList = new ArrayList<URL>();
12:     if (registries != null && !registries.isEmpty()) {
13:         for (RegistryConfig config : registries) {
14:             // 获得注册中心的地址
15:             String address = config.getAddress();
16:             if (address == null || address.length() == 0) {
17:                 address = Constants.ANYHOST_VALUE;
18:             }
19:             String sysaddress = System.getProperty("dubbo.registry.address"); // 从启动参数读取
20:             if (sysaddress != null && sysaddress.length() > 0) {
21:                 address = sysaddress;
22:             }
23:             // 有效的地址
24:             if (address.length() > 0
25:                     && !RegistryConfig.NO_AVAILABLE.equalsIgnoreCase(address)) {
26:                 Map<String, String> map = new HashMap<String, String>();
27:                 // 将各种配置对象，添加到 `map` 集合中。
28:                 appendParameters(map, application);
29:                 appendParameters(map, config);
30:                 // 添加 `path` `dubbo` `timestamp` `pid` 到 `map` 集合中。
31:                 map.put("path", RegistryService.class.getName());
32:                 map.put("dubbo", Version.getVersion());
33:                 map.put(Constants.TIMESTAMP_KEY, String.valueOf(System.currentTimeMillis()));
34:                 if (ConfigUtils.getPid() > 0) {
35:                     map.put(Constants.PID_KEY, String.valueOf(ConfigUtils.getPid()));
36:                 }
37:                 // 若不存在 `protocol` 参数，默认 "dubbo" 添加到 `map` 集合中。
38:                 if (!map.containsKey("protocol")) {
39:                     if (ExtensionLoader.getExtensionLoader(RegistryFactory.class).hasExtension("remote")) { // "remote"
40:                         map.put("protocol", "remote");
41:                     } else {
42:                         map.put("protocol", "dubbo");
43:                     }
44:                 }
45:                 // 解析地址，创建 Dubbo URL 数组。（数组大小可以为一）
46:                 List<URL> urls = UrlUtils.parseURLs(address, map);
47:                 // 循环 `url` ，设置 "registry" 和 "protocol" 属性。
48:                 for (URL url : urls) {
49:                     // 设置 `registry=${protocol}` 和 `protocol=registry` 到 URL
50:                     url = url.addParameter(Constants.REGISTRY_KEY, url.getProtocol());
51:                     url = url.setProtocol(Constants.REGISTRY_PROTOCOL);
52:                     // 添加到结果
53:                     if ((provider && url.getParameter(Constants.REGISTER_KEY, true)) // 服务提供者 && 注册
54:                             || (!provider && url.getParameter(Constants.SUBSCRIBE_KEY, true))) { // 服务消费者 && 订阅
55:                         registryList.add(url);
56:                     }
57:                 }
58:             }
59:         }
60:     }
61:     return registryList;
62: }

 1: /**
 2:  * 基于单个协议，暴露服务
 3:  *
 4:  * @param protocolConfig 协议配置对象
 5:  * @param registryURLs 注册中心链接对象数组
 6:  */
 7: private void doExportUrlsFor1Protocol(ProtocolConfig protocolConfig, List<URL> registryURLs) {
 8:     // ... 【省略】 创建服务 URL 对象
 9: 
10:     String scope = url.getParameter(Constants.SCOPE_KEY);
11:     // don't export when none is configured
12:     if (!Constants.SCOPE_NONE.toString().equalsIgnoreCase(scope)) {
13: 
14:         // export to local if the config is not remote (export to remote only when config is remote)
15:         if (!Constants.SCOPE_REMOTE.toString().equalsIgnoreCase(scope)) {
16:             exportLocal(url);
17:         }
18:         // export to remote if the config is not local (export to local only when config is local)
19:         if (!Constants.SCOPE_LOCAL.toString().equalsIgnoreCase(scope)) {
20:             // ... 【省略】远程暴露 
21:         }
22:     }
23:     this.urls.add(url);
24: }

/**
 * 自适应 Protocol 实现对象
 */
private static final Protocol protocol = ExtensionLoader.getExtensionLoader(Protocol.class).getAdaptiveExtension();
/**
 * 自适应 ProxyFactory 实现对象
 */
private static final ProxyFactory proxyFactory = ExtensionLoader.getExtensionLoader(ProxyFactory.class).getAdaptiveExtension();

/**
 * {@link #interfaceName} 对应的接口类
 *
 * 非配置
 */
private Class<?> interfaceClass;
/**
 * Service 对象
 */
// reference to interface impl
private T ref;
/**
 * 服务配置暴露的 Exporter 。
 * URL ：Exporter 不一定是 1：1 的关系。
 * 例如 {@link #scope} 未设置时，会暴露 Local + Remote 两个，也就是 URL ：Exporter = 1：2
 *      {@link #scope} 设置为空时，不会暴露，也就是 URL ：Exporter = 1：0
 *      {@link #scope} 设置为 Local 或 Remote 任一时，会暴露 Local 或 Remote 一个，也就是 URL ：Exporter = 1：1
 *
 * 非配置。
 */
private final List<Exporter<?>> exporters = new ArrayList<Exporter<?>>();

  1: /**
  2:  * 本地暴露服务
  3:  *
  4:  * @param url 注册中心 URL
  5:  */
  6: @SuppressWarnings({"unchecked", "rawtypes"})
  7: private void exportLocal(URL url) {
  8:     if (!Constants.LOCAL_PROTOCOL.equalsIgnoreCase(url.getProtocol())) {
  9:         // 创建本地 Dubbo URL
 10:         URL local = URL.valueOf(url.toFullString())
 11:                 .setProtocol(Constants.LOCAL_PROTOCOL) // injvm
 12:                 .setHost(LOCALHOST) // 本地
 13:                 .setPort(0); // 端口=0
 14:         // 添加服务的真实类名，例如 DemoServiceImpl ，仅用于 RestProtocol 中。
 15:         ServiceClassHolder.getInstance().pushServiceClass(getServiceClass(ref));
 16:         // 使用 ProxyFactory 创建 Invoker 对象
 17:         // 使用 Protocol 暴露 Invoker 对象
 18:         Exporter<?> exporter = protocol.export(proxyFactory.getInvoker(ref, (Class) interfaceClass, local));
 19:         // 添加到 `exporters`
 20:         exporters.add(exporter);
 21:         logger.info("Export dubbo service " + interfaceClass.getName() + " to local registry");
 22:     }
 23: }

1: public <T> Exporter<T> export(Invoker<T> invoker) throws RpcException {
2:     // 注册中心
3:     if (Constants.REGISTRY_PROTOCOL.equals(invoker.getUrl().getProtocol())) {
4:         return protocol.export(invoker);
5:     }
6:     // 建立带有 Filter 过滤链的 Invoker ，再暴露服务。
7:     return protocol.export(buildInvokerChain(invoker, Constants.SERVICE_FILTER_KEY, Constants.PROVIDER));
8: }

 1: /**
 2:  * 创建带 Filter 链的 Invoker 对象
 3:  *
 4:  * @param invoker Invoker 对象
 5:  * @param key 获取 URL 参数名
 6:  * @param group 分组
 7:  * @param <T> 泛型
 8:  * @return Invoker 对象
 9:  */
10: private static <T> Invoker<T> buildInvokerChain(final Invoker<T> invoker, String key, String group) {
11:     Invoker<T> last = invoker;
12:     // 获得过滤器数组
13:     List<Filter> filters = ExtensionLoader.getExtensionLoader(Filter.class).getActivateExtension(invoker.getUrl(), key, group);
14:     // 倒序循环 Filter ，创建带 Filter 链的 Invoker 对象
15:     if (!filters.isEmpty()) {
16:         for (int i = filters.size() - 1; i >= 0; i--) {
17:             final Filter filter = filters.get(i);
18:             final Invoker<T> next = last;
19:             last = new Invoker<T>() {
20: 
21:                 public Class<T> getInterface() {
22:                     return invoker.getInterface();
23:                 }
24: 
25:                 public URL getUrl() {
26:                     return invoker.getUrl();
27:                 }
28: 
29:                 public boolean isAvailable() {
30:                     return invoker.isAvailable();
31:                 }
32: 
33:                 public Result invoke(Invocation invocation) throws RpcException {
34:                     return filter.invoke(next, invocation);
35:                 }
36: 
37:                 public void destroy() {
38:                     invoker.destroy();
39:                 }
40: 
41:                 @Override
42:                 public String toString() {
43:                     return invoker.toString();
44:                 }
45:             };
46:         }
47:     }
48:     return last;
49: }

 1: public <T> Exporter<T> export(Invoker<T> invoker) throws RpcException {
 2:     // 注册中心
 3:     if (Constants.REGISTRY_PROTOCOL.equals(invoker.getUrl().getProtocol())) {
 4:         return protocol.export(invoker);
 5:     }
 6:     // 暴露服务，创建 Exporter 对象
 7:     Exporter<T> exporter = protocol.export(invoker);
 8:     // 获得 ExporterListener 数组
 9:     List<ExporterListener> listeners = Collections.unmodifiableList(ExtensionLoader.getExtensionLoader(ExporterListener.class).getActivateExtension(invoker.getUrl(), Constants.EXPORTER_LISTENER_KEY));
10:     // 创建带 ExporterListener 的 Exporter 对象
11:     return new ListenerExporterWrapper<T>(exporter, listeners);
12: }

public abstract class AbstractProtocol implements Protocol {

    /**
     * Exporter 集合
     *
     * key: 服务键 {@link #serviceKey(URL)} 或 {@link URL#getServiceKey()} 。
     *      不同协议会不同
     */
    protected final Map<String, Exporter<?>> exporterMap = new ConcurrentHashMap<String, Exporter<?>>();
    
    // ... 省略和本文无关的方法与属性
    
}

/**
 * 协议名
 */
public static final String NAME = Constants.LOCAL_PROTOCOL;
/**
 * 默认端口
 */
public static final int DEFAULT_PORT = 0;
/**
 * 单例。在 Dubbo SPI 中，被初始化，有且仅有一次。
 */
private static InjvmProtocol INSTANCE;

public InjvmProtocol() {
    INSTANCE = this;
}

public static InjvmProtocol getInjvmProtocol() {
    if (INSTANCE == null) {
        ExtensionLoader.getExtensionLoader(Protocol.class).getExtension(InjvmProtocol.NAME); // load
    }
    return INSTANCE;
}

public <T> Exporter<T> export(Invoker<T> invoker) throws RpcException {
    return new InjvmExporter<T>(invoker, invoker.getUrl().getServiceKey(), exporterMap);
}

public abstract class AbstractExporter<T> implements Exporter<T> {

    protected final Logger logger = LoggerFactory.getLogger(getClass());

    /**
     * Invoker 对象
     */
    private final Invoker<T> invoker;
    /**
     * 是否取消暴露服务
     */
    private volatile boolean unexported = false;

    public AbstractExporter(Invoker<T> invoker) {
        if (invoker == null)
            throw new IllegalStateException("service invoker == null");
        if (invoker.getInterface() == null)
            throw new IllegalStateException("service type == null");
        if (invoker.getUrl() == null)
            throw new IllegalStateException("service url == null");
        this.invoker = invoker;
    }

    @Override
    public Invoker<T> getInvoker() {
        return invoker;
    }
    
    @Override
    public void unexport() {
        if (unexported) {
            return;
        }
        unexported = true;
        getInvoker().destroy();
    }

    public String toString() {
        return getInvoker().toString();
    }

}

class InjvmExporter<T> extends AbstractExporter<T> {

    /**
     * 服务键
     */
    private final String key;
    /**
     * Exporter 集合
     *
     * key: 服务键
     *
     * 该值实际就是 {@link com.alibaba.dubbo.rpc.protocol.AbstractProtocol#exporterMap}
     */
    private final Map<String, Exporter<?>> exporterMap;

    InjvmExporter(Invoker<T> invoker, String key, Map<String, Exporter<?>> exporterMap) {
        super(invoker);
        this.key = key;
        this.exporterMap = exporterMap;
        // 添加到 Exporter 集合
        exporterMap.put(key, this);
    }

    @Override
    public void unexport() {
        super.unexport();
        // 移除出 Exporter 集合
        exporterMap.remove(key);
    }

}

public class ListenerExporterWrapper<T> implements Exporter<T> {

    private static final Logger logger = LoggerFactory.getLogger(ListenerExporterWrapper.class);

    /**
     * 真实的 Exporter 对象
     */
    private final Exporter<T> exporter;
    /**
     * Exporter 监听器数组
     */
    private final List<ExporterListener> listeners;

    public ListenerExporterWrapper(Exporter<T> exporter, List<ExporterListener> listeners) {
        if (exporter == null) {
            throw new IllegalArgumentException("exporter == null");
        }
        this.exporter = exporter;
        this.listeners = listeners;
        // 执行监听器
        if (listeners != null && !listeners.isEmpty()) {
            RuntimeException exception = null;
            for (ExporterListener listener : listeners) {
                if (listener != null) {
                    try {
                        listener.exported(this);
                    } catch (RuntimeException t) {
                        logger.error(t.getMessage(), t);
                        exception = t;
                    }
                }
            }
            if (exception != null) {
                throw exception;
            }
        }
    }

    public Invoker<T> getInvoker() {
        return exporter.getInvoker();
    }

    public void unexport() {
        try {
            exporter.unexport();
        } finally {
            // 执行监听器
            if (listeners != null && !listeners.isEmpty()) {
                RuntimeException exception = null;
                for (ExporterListener listener : listeners) {
                    if (listener != null) {
                        try {
                            listener.unexported(this);
                        } catch (RuntimeException t) {
                            logger.error(t.getMessage(), t);
                            exception = t;
                        }
                    }
                }
                if (exception != null) {
                    throw exception;
                }
            }
        }
    }

}

@SPI
public interface ExporterListener {

    /**
     * The exporter exported.
     *
     * 当服务暴露完成
     *
     * @param exporter
     * @throws RpcException
     * @see com.alibaba.dubbo.rpc.Protocol#export(Invoker)
     */
    void exported(Exporter<?> exporter) throws RpcException;

    /**
     * The exporter unexported.
     *
     * 当服务取消暴露完成
     *
     * @param exporter
     * @throws RpcException
     * @see com.alibaba.dubbo.rpc.Exporter#unexport()
     */
    void unexported(Exporter<?> exporter);

}

public abstract class ExporterListenerAdapter implements ExporterListener {

    public void exported(Exporter<?> exporter) throws RpcException { }

    public void unexported(Exporter<?> exporter) throws RpcException { }

}