dubbo 5 Listener和Filter

前面的服务提供者和消费者暴漏和引用过程中首先都是用的Protocol，
而且使用ExtensionLoader加载的adaptive的Protocol，最终得到的是
ProtocolListenerWrapper->ProtocolFilterWrapper->{RegistryProtocol,DubboProtocol}


1、ProtocolListenerWrapper如何使用Listener的
也就是export,refer方法
使用了ExtensionLoader得到了当前配置激活的ExporterListener，或者InvokerListener，
然后new出ListenerExporterWrapper或者ListenerInvokerWrapper
ListenerExporterWrapper构造方法中遍历了listeners执行了listener.exported方法，同样unexport

方法也是遍历执行，再看看ListenerInvokerWrapper也是类似

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.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;
            }
        }
    }

2、ProtocolFilterWrapper的export

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

关键就在于buildInvokerChain，它把最后的invoker和激活的filter整合到了一起

private static <T> Invoker<T> buildInvokerChain(final Invoker<T> invoker, String key, String group) {
        Invoker<T> last = invoker;
        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;
    }

可以这样表示一下

   filterN  ...   filter2     filter1      invoker0(就是具体接口实现类)	
                       new出对应的
   invokerN       invoker2     invoker1
   
   //invokerN的invoke方法为
   public Result invoke(Invocation invocation) throws RpcException {
       return filterN.invoke(invoker(N-1), invocation);
    }

这样就形成了一个过滤链，所以使用filter时候一般是

@Activate(group = Constants.PROVIDER)
public class XxxFilter implements Filter {	
      public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException {
	      //调用前拦截处理
		  Result result = invoker.invoke(invocation);
		  //对结果拦截处理
		  return result;
		  
	  }
}