AbstractProtocol源码解析

public abstract class AbstractProtocol implements Protocol {

protected final Logger logger = LoggerFactory.getLogger(getClass());
//key是 监听 address （ip：port）。
protected final Map<String, Exporter<?>> exporterMap = new ConcurrentHashMap<String, Exporter<?>>();

/**
 * <host:port, ProtocolServer>
 */
protected final Map<String, ProtocolServer> serverMap = new ConcurrentHashMap<>();

//TODO SoftReference
protected final Set<Invoker<?>> invokers = new ConcurrentHashSet<Invoker<?>>();
//根据端口+接口+版本+分组=一个字符串返回
protected static String serviceKey(URL url) {
    int port = url.getParameter(Constants.BIND_PORT_KEY, url.getPort());
    return serviceKey(port, url.getPath(), url.getParameter(VERSION_KEY), url.getParameter(GROUP_KEY));
}
//根据端口+接口+版本+分组=一个字符串返回
protected static String serviceKey(int port, String serviceName, String serviceVersion, String serviceGroup) {
    return ProtocolUtils.serviceKey(port, serviceName, serviceVersion, serviceGroup);
}
//返回协议list
public List<ProtocolServer> getServers() {
    return Collections.unmodifiableList(new ArrayList<>(serverMap.values()));
}
//需要统计的对象就放全局变量里，有统计的对象，就有卸载这些对象内存的方法。
@Override
public void destroy() {
    for (Invoker<?> invoker : invokers) {
        if (invoker != null) {
            invokers.remove(invoker);
            try {
                if (logger.isInfoEnabled()) {
                    logger.info("Destroy reference: " + invoker.getUrl());
                }
                invoker.destroy();
            } catch (Throwable t) {
                logger.warn(t.getMessage(), t);
            }
        }
    }
    for (String key : new ArrayList<String>(exporterMap.keySet())) {
        Exporter<?> exporter = exporterMap.remove(key);
        if (exporter != null) {
            try {
                if (logger.isInfoEnabled()) {
                    logger.info("Unexport service: " + exporter.getInvoker().getUrl());
                }
                exporter.unexport();
            } catch (Throwable t) {
                logger.warn(t.getMessage(), t);
            }
        }
    }
}

@Override
public <T> Invoker<T> refer(Class<T> type, URL url) throws RpcException {
    return new AsyncToSyncInvoker<>(protocolBindingRefer(type, url));
}

protected abstract <T> Invoker<T> protocolBindingRefer(Class<T> type, URL url) throws RpcException;
//返回一个map
public Map<String, Exporter<?>> getExporterMap() {
    return exporterMap;
}
//返回一个集合
public Collection<Exporter<?>> getExporters() {
    return Collections.unmodifiableCollection(exporterMap.values());
}

}