dubbo源码分析3 -- protocol 协议

协议

协议是基于SPI,它的类分布图如下：

Exporter<?> exporter = protocol.export(
               proxyFactory.getInvoker(ref, (Class) interfaceClass, local));

协议有
DubboProtocol,InjvmProtocol,MemcachedProtocol,MockProtocol,RedisProtocol.ThriftProtocol….

那么他是到底选择哪一个协议呢
上面前两节说到这里会根据字节码生成一个Protocol$Adpative类。
那么这时Invoker 中根据url.getProtocol()来确定走哪一个类，如果没有指定，那么就走dubbo协议

public class Protocol$Adpative implements com.alibaba.dubbo.rpc.Protocol {
   //....
    public com.alibaba.dubbo.rpc.Exporter export(com.alibaba.dubbo.rpc.Invoker arg0) 
      throws com.alibaba.dubbo.rpc.Invoker {
        if (arg0 == null) 
            throw new IllegalArgumentException("..");
        if (arg0.getUrl() == null) 
            throw new IllegalArgumentException("..");
            com.alibaba.dubbo.common.URL url = arg0.getUrl();
            String extName = ( url.getProtocol() == null ?
             "dubbo" : url.getProtocol() );
        if(extName == null) 
            throw new IllegalStateException("..");
        com.alibaba.dubbo.rpc.Protocol extension = (com.alibaba.dubbo.rpc.Protocol)
            ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.rpc.Protocol.class)
            .getExtension(extName);
        return extension.export(arg0);
    }
}

---

ProtocolListenerWrapper—> ProtocolFilterWrapper协议装饰者

而协议外面有个装饰者ProtocolListenerWrapper
除了是RegisterProtocol，是直接调用，其余的都要走ListenerExporterWrapper

public class ProtocolListenerWrapper implements Protocol {

    private final Protocol protocol;

    //....

    public <T> Exporter<T> export(Invoker<T> invoker) throws RpcException {
        //如果是RegisterProtocol，那么直接调用
        if (Constants.REGISTRY_PROTOCOL.equals(invoker.getUrl().getProtocol())) {
            return protocol.export(invoker);
        }

        return new ListenerExporterWrapper<T>(protocol.export(invoker), 
                Collections.unmodifiableList(ExtensionLoader.getExtensionLoader(
                ExporterListener.class).getActivateExtension(invoker.getUrl(), 
                Constants.EXPORTER_LISTENER_KEY)));
    }

    public <T> Invoker<T> refer(Class<T> type, URL url) throws RpcException {
        //如果是RegisterProtocol，那么直接调用
        if (Constants.REGISTRY_PROTOCOL.equals(url.getProtocol())) {
            return protocol.refer(type, url);
        }
        return new ListenerInvokerWrapper<T>(protocol.refer(type, url), 
                Collections.unmodifiableList(
                        ExtensionLoader.getExtensionLoader(InvokerListener.class)
                        .getActivateExtension(url, Constants.INVOKER_LISTENER_KEY)));
    }

    public void destroy() {
        protocol.destroy();
    }

}

ListenerInvokerWrapper

public ListenerExporterWrapper(Exporter<T> exporter, List<ExporterListener>
 listeners{ 
    //.. 传进来的Listeners监听
    if (listeners != null && listeners.size() > 0) {
        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;
        }
    }
 }

有哪些listeners

Collections.unmodifiableList(ExtensionLoader.getExtensionLoader
(ExporterListener.class).getActivateExtension(
invoker.getUrl(), Constants.EXPORTER_LISTENER_KEY))

ProtocolFilterWrapper ：
根据Filter组织一个单性链表，前面都是Filter, 链的尾巴是真正的代理工厂Wrapper，

public class ProtocolFilterWrapper implements Protocol {

    private final Protocol protocol;//原生态的dubbo,registry....

    public <T> Exporter<T> export(Invoker<T> invoker) throws RpcException {
        //registry走原生的
        if (Constants.REGISTRY_PROTOCOL.equals(invoker.getUrl().getProtocol())) {
            return protocol.export(invoker);
        }
        return protocol.export(buildInvokerChain(invoker, Constants.SERVICE_FILTER_KEY, Constants.PROVIDER));
    }

    public <T> Invoker<T> refer(Class<T> type, URL url) throws RpcException {
        //registry走原生的
        if (Constants.REGISTRY_PROTOCOL.equals(url.getProtocol())) {
            return protocol.refer(type, url);
        }
        return buildInvokerChain(protocol.refer(type, url), Constants.REFERENCE_FILTER_KEY, Constants.CONSUMER);
    }

    public void destroy() {
        protocol.destroy();
    }

    //重点Invoker他是一个单性链表next
    private static <T> Invoker<T> buildInvokerChain(final Invoker<T> invoker, String key, String group) {
        Invoker<T> last = invoker;
        //获取到所有的Filter（TimeoutFilter、ExcetionFilter,MonitorFilter,
        //DubboDataTranferFilter...）
        List<Filter> filters = ExtensionLoader.getExtensionLoader(Filter.class).
                getActivateExtension(invoker.getUrl(), key, group);
        if (filters.size() > 0) {
            for (int i = filters.size() - 1; i >= 0; i --) {
                final Filter filter = filters.get(i);
                final Invoker<T> next = last;
                last = new Invoker<T>() {
                    public Class<T> getInterface() {
                        return invoker.getInterface();
                    }

                    public URL getUrl() {
                        return invoker.getUrl();
                    }

                    public boolean isAvailable() {
                        return invoker.isAvailable();
                    }
                    //调用
                    public Result invoke(Invocation invocation) throws RpcException {
                        return filter.invoke(next, invocation);
                    }

                    public void destroy() {
                        invoker.destroy();
                    }

                    @Override
                    public String toString() {
                        return invoker.toString();
                    }
                };
            }
        }
        return last;
    }

}