DUBBO扩展ExtensionLoader 之接口Wrapper实现剖析

起因，在服务接口的发布过程中，其中invoker会经过协议的导出后生成一个Exporter，如下图：

上图代码中的 Exporter<?> exporter = protocol.export(invoker);这句代码里面会涉及到protocol的Wrapper 。其中的protocol是通过dubbo 的SPI机制动态生成的适配类产生的对象。其定义在ServiceConfig类中，定义如下：

 private static final Protocol protocol = ExtensionLoader.getExtensionLoader(Protocol.class).getAdaptiveExtension();

其中产生的动态类如下：

package com.alibaba.dubbo.rpc;
import com.alibaba.dubbo.common.extension.ExtensionLoader;

public class Protocol$Adpative implements com.alibaba.dubbo.rpc.Protocol {
    public com.alibaba.dubbo.rpc.Invoker refer(java.lang.Class arg0, com.alibaba.dubbo.common.URL arg1) throws java.lang.Class {
        if (arg1 == null) 
            throw new IllegalArgumentException("url == null");

        com.alibaba.dubbo.common.URL url = arg1;
        String extName = ( url.getProtocol() == null ? "dubbo" : url.getProtocol() );
        if(extName == null) 
            throw new IllegalStateException("Fail to get extension(com.alibaba.dubbo.rpc.Protocol) name from url(" + url.toString() + ") use keys([protocol])");

        com.alibaba.dubbo.rpc.Protocol extension = (com.alibaba.dubbo.rpc.Protocol)ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.rpc.Protocol.class).getExtension(extName);

        return extension.refer(arg0, arg1);
    }

    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("com.alibaba.dubbo.rpc.Invoker argument == null");

        if (arg0.getUrl() == null) 
            throw new IllegalArgumentException("com.alibaba.dubbo.rpc.Invoker argument getUrl() == null");com.alibaba.dubbo.common.URL url = arg0.getUrl();
        //根据URL配置信息获取Protocol协议，默认是dubbo
        String extName = ( url.getProtocol() == null ? "dubbo" : url.getProtocol() );
        if(extName == null) 
            throw new IllegalStateException("Fail to get extension(com.alibaba.dubbo.rpc.Protocol) name from url(" + url.toString() + ") use keys([protocol])");
            //根据协议名，获取Protocol的实现
            //获得Protocol的实现过程中，会对Protocol先进行依赖注入，然后进行Wrapper包装，最后返回被修改过的Protocol
            //包装经过了ProtocolFilterWrapper，ProtocolListenerWrapper，RegistryProtocol
        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);
    }

    public void destroy() {
        throw new UnsupportedOperationException("method public abstract void com.alibaba.dubbo.rpc.Protocol.destroy() of interface com.alibaba.dubbo.rpc.Protocol is not adaptive method!");
    }

    public int getDefaultPort() {
        throw new UnsupportedOperationException("method public abstract int com.alibaba.dubbo.rpc.Protocol.getDefaultPort() of interface com.alibaba.dubbo.rpc.Protocol is not adaptive method!");
    }
}

根据URL配置信息获取Protocol协议，默认是dubbo，String extName = ( url.getProtocol() == null ? “dubbo” : url.getProtocol() );
好了，看下这句 com.alibaba.dubbo.rpc.Protocol extension = (com.alibaba.dubbo.rpc.Protocol)ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.rpc.Protocol.class).getExtension(extName); 根据协议名，获取Protocol的实现，获得Protocol的实现过程中，会对Protocol先进行依赖注入，然后进行Wrapper包装，最后返回被修改过的Protocol，包装经过了ProtocolFilterWrapper，ProtocolListenerWrapper，RegistryProtocol

光从生成的代码里面我们看不到如何对其进行了包装，这下就得看private static final Protocol protocol = ExtensionLoader.getExtensionLoader(Protocol.class).getAdaptiveExtension();了。
其中getAdaptiveExtension（）里面会加载该接口的所有实现，dubbo会扫描META-INF/dubbo/，META-INF/services/，META-INF/dubbo/internal/ 三个目录下的文件。具体的加载机制这里先不描述。

。。。。。省略
 if (clazz.isAnnotationPresent(Adaptive.class)) {
    if(cachedAdaptiveClass == null) {
          cachedAdaptiveClass = clazz;
      } else if (! cachedAdaptiveClass.equals(clazz)) {
          throw new IllegalStateException("More than 1 adaptive class found: "
                  + cachedAdaptiveClass.getClass().getName()
                  + ", " + clazz.getClass().getName());
      }
  } else {
      try {
          clazz.getConstructor(type);
          Set<Class<?>> wrappers = cachedWrapperClasses;
          if (wrappers == null) {
              cachedWrapperClasses = new ConcurrentHashSet<Class<?>>();
              wrappers = cachedWrapperClasses;
          }
          wrappers.add(clazz);
          。。。。。。省略

扫描到实现类后，会进行判断实现类中是否有Adaptive注解，有的话滤过，直接返回当前实现类作为适配类，这里就不会生成动态适配类。
如果没有适配注解的话， 会进入这个代码块

 clazz.getConstructor(type);
 Set<Class<?>> wrappers = cachedWrapperClasses;
 if (wrappers == null) {
     cachedWrapperClasses = new ConcurrentHashSet<Class<?>>();
     wrappers = cachedWrapperClasses;
 }
 wrappers.add(clazz);

其实就是把含有以该接口为唯一参数的构造函数的实现类当做包装类，放入cachedWrapperClasses中。
好了，下面我们看看Protocol 接口的实现类有如下这么多，

registry=com.alibaba.dubbo.registry.integration.RegistryProtocol
filter=com.alibaba.dubbo.rpc.protocol.ProtocolFilterWrapper       包装类
listener=com.alibaba.dubbo.rpc.protocol.ProtocolListenerWrapper  包装类
mock=com.alibaba.dubbo.rpc.support.MockProtocol
injvm=com.alibaba.dubbo.rpc.protocol.injvm.InjvmProtocol
dubbo=com.alibaba.dubbo.rpc.protocol.dubbo.DubboProtocol
rmi=com.alibaba.dubbo.rpc.protocol.rmi.RmiProtocol
hessian=com.alibaba.dubbo.rpc.protocol.hessian.HessianProtocol
com.alibaba.dubbo.rpc.protocol.http.HttpProtocol
com.alibaba.dubbo.rpc.protocol.webservice.WebServiceProtocol
thrift=com.alibaba.dubbo.rpc.protocol.thrift.ThriftProtocol
memcached=memcom.alibaba.dubbo.rpc.protocol.memcached.MemcachedProtocol
redis=com.alibaba.dubbo.rpc.protocol.redis.RedisProtocol

可以看到com.alibaba.dubbo.rpc.protocol.ProtocolFilterWrapper 和 com.alibaba.dubbo.rpc.protocol.ProtocolListenerWrapper 这两个实现类是包装类，均含有以该接口为唯一参数的构造函数。所以会放入cachedWrapperClasses中。

下来回头看下生成的动态适配类，最后执行这句代码： com.alibaba.dubbo.rpc.Protocol extension = (com.alibaba.dubbo.rpc.Protocol)ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.rpc.Protocol.class).getExtension(extName);
getExtension(extName);方法第一次执行时候会创建适配类的实例，//extName此时是dubbo，照理会生成DubboProtocol的实例对象，但是看下方法实现，

	public T getExtension(String name) {
		if (name == null || name.length() == 0)
		    throw new IllegalArgumentException("Extension name == null");
		if ("true".equals(name)) {
		    return getDefaultExtension();
		}
		Holder<Object> holder = cachedInstances.get(name);
		if (holder == null) {
		    cachedInstances.putIfAbsent(name, new Holder<Object>());
		    holder = cachedInstances.get(name);
		}
		Object instance = holder.get();
		if (instance == null) {
		    synchronized (holder) {
	            instance = holder.get();
	            if (instance == null) {
	                instance = createExtension(name); //第一次执行时候会创建适配类的实例
	                holder.set(instance);
	            }
	        }
		}
		return (T) instance;
	}

第一次执行时候会创建适配类的实例,调用方法createExtension（“dubbo”）；再进去看下

   private T createExtension(String name) {
        Class<?> clazz = getExtensionClasses().get(name);
        if (clazz == null) {
            throw findException(name);
        }
        try {
            T instance = (T) EXTENSION_INSTANCES.get(clazz);
            if (instance == null) {
                EXTENSION_INSTANCES.putIfAbsent(clazz, (T) clazz.newInstance());
                instance = (T) EXTENSION_INSTANCES.get(clazz);
            }
            injectExtension(instance);
            Set<Class<?>> wrapperClasses = cachedWrapperClasses;
            if (wrapperClasses != null && wrapperClasses.size() > 0) {
                for (Class<?> wrapperClass : wrapperClasses) {
                    instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance));
                }
            }
            return instance;
        } catch (Throwable t) {
            throw new IllegalStateException("Extension instance(name: " + name + ", class: " +
                    type + ")  could not be instantiated: " + t.getMessage(), t);
        }
    }

Set<Class<?>> wrapperClasses = cachedWrapperClasses;
if (wrapperClasses != null && wrapperClasses.size() > 0) {
      for (Class<?> wrapperClass : wrapperClasses) {
           instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance));
       }
}

发现：
这里面用到了cachedWrapperClasses，此时里面包含ProtocolFilterWrapper，ProtocolListenerWrapper两个实现类。
由于定义的顺序关系，所以先执行ProtocolFilterWrapper，得到包装后的对象，再执行ProtocolListenerWrapper，所以最终返回的对象是ProtocolListenerWrapper的实例对象。

所以这块Exporter<?> exporter = protocol.export(invoker);实际上是先执行ProtocolListenerWrapper，里面的export方法，再执行ProtocolFilterWrapper里面的export方法。和装配里面的相反，即后装配的先执行。

ProtocolFilterWrapper类负责初始化invoker所有的Filter。这个类非常重要，dubbo机制里面日志记录、超时等等功能都是在这一部分实现的。后续再完善这部分内容。。。。