dubbo filter原理

Provider构建调用链过程

ProtocolFilterWrapper是一个protocol的包装类（dubbo的spi机制，一个类的构造函数的参数是其接口，则此类为包装类）

            //服务提供者暴露一个服务 
public <T> Exporter<T> export(Invoker<T> invoker) throws RpcException {
            //如果是注册协议直接调用protocol的export(dubbo服务发布包含1将服务信息注册到注册中心2在本地暴露服务监听服务端口(多个服务公用一个端口))
        if (Constants.REGISTRY_PROTOCOL.equals(invoker.getUrl().getProtocol())) {
            return protocol.export(invoker);
        }
        //调用protocol的export之前构建invoker的filter调用链
        return protocol.export(buildInvokerChain(invoker, Constants.SERVICE_FILTER_KEY, Constants.PROVIDER));
    }


 private static <T> Invoker<T> buildInvokerChain(final Invoker<T> invoker, String key, String group) {
        Invoker<T> last = invoker;
        //通过spi机制拿到符合条件的filter
        List<Filter> filters = ExtensionLoader.getExtensionLoader(Filter.class).getActivateExtension(invoker.getUrl(), key, group);
        if (!filters.isEmpty()) {
            //循环filter构建调用链
            for (int i = filters.size() - 1; i >= 0; i--) {
                final Filter filter = filters.get(i);
                final Invoker<T> next = last;
                last = new Invoker<T>() {

                    @Override
                    public Class<T> getInterface() {
                        return invoker.getInterface();
                    }

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

                    @Override
                    public boolean isAvailable() {
                        return invoker.isAvailable();
                    }

                    @Override
                    public Result invoke(Invocation invocation) throws RpcException {
                        return filter.invoke(next, invocation);
                    }

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

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

ExtensionLoader dubbo 的spi容器

//处理Activate的注解信息(对filter进行过滤排序操作)  
 public List<T> getActivateExtension(URL url, String key, String group) {
        String value = url.getParameter(key);
        return getActivateExtension(url, value == null || value.length() == 0 ? null : Constants.COMMA_SPLIT_PATTERN.split(value), group);
    }


  //处理Activate的注解信息(对filter进行过滤排序操作)  
 public List<T> getActivateExtension(URL url, String[] values, String group) {
        List<T> exts = new ArrayList<T>();
        List<String> names = values == null ? new ArrayList<String>(0) : Arrays.asList(values);
        if (!names.contains(Constants.REMOVE_VALUE_PREFIX + Constants.DEFAULT_KEY)) {
            getExtensionClasses();
            //cachedActivates 缓存了所有Activate注解的实例
            for (Map.Entry<String, Activate> entry : cachedActivates.entrySet()) {
                String name = entry.getKey();
                Activate activate = entry.getValue();
                //对filter组进行过滤(provider与consumer)
                if (isMatchGroup(group, activate.group())) {
                    //从容器中拿到filter实例
                    T ext = getExtension(name);
                    if (!names.contains(name)
                            && !names.contains(Constants.REMOVE_VALUE_PREFIX + name)
                            根据url的参数过滤filter
                            && isActive(activate, url)) {
                        exts.add(ext);
                    }
                }
            }
         
            Collections.sort(exts, ActivateComparator.COMPARATOR);
        }
        //处理配置中filter的顺序与-配置
        List<T> usrs = new ArrayList<T>();
        for (int i = 0; i < names.size(); i++) {
            String name = names.get(i);
            //添加配置中显示配置的
            if (!name.startsWith(Constants.REMOVE_VALUE_PREFIX)
                    && !names.contains(Constants.REMOVE_VALUE_PREFIX + name)) {
                if (Constants.DEFAULT_KEY.equals(name)) {
                    if (!usrs.isEmpty()) {
                        exts.addAll(0, usrs);
                        usrs.clear();
                    }
                } else {
                    T ext = getExtension(name);
                    usrs.add(ext);
                }
            }
        }
        if (!usrs.isEmpty()) {
            exts.addAll(usrs);
        }
        return exts;
    }

Consumer构建调用链过程 

  //消费者引用服务   
 public <T> Invoker<T> refer(Class<T> type, URL url) throws RpcException {
        //同理注册协议直接调用
        if (Constants.REGISTRY_PROTOCOL.equals(url.getProtocol())) {
            return protocol.refer(type, url);
        }
        //构建消费者调用链
        return buildInvokerChain(protocol.refer(type, url), Constants.REFERENCE_FILTER_KEY, Constants.CONSUMER);
    }

//后面的逻辑与provider相同