【dubbo】dubbo SPI机制（ExtensionLoader）

阅读量：5771 次

发布时间：2019-06-18

本文共 11338 字，大约阅读时间需要 37 分钟。

Dubbo强大的扩展能力，主要依赖于它自己实现的一套SPI机制，开发人员可以根据dubbo的规范进行扩展现有的功能或者替换现有的实现，dubbo内部的功能的实现也都是通过的SPI来实现的，这是dubbo的功能高度可插拔的原因。但是dubbo并没有使用Java的SPI，之所以没有使用Java自带的SPI在官方文档上有如下阐述。

JDK标准的SPI会一次性实例化扩展点所有实现，如果有扩展实现初始化很耗时，但如果没用上也加载，会很浪费资源。

如果扩展点加载失败，连扩展点的名称都拿不到了。比如：JDK标准的ScriptEngine，通过 getName()获取脚本类型的名称，但如果RubyScriptEngine因为所依赖的jruby.jar不存在，导致RubyScriptEngine类加载失败，这个失败原因被吃掉了，和ruby对应不起来，当用户执行ruby脚本时，会报不支持ruby，而不是真正失败的原因。

增加了对扩展点IoC和AOP的支持，一个扩展点可以直接setter注入其它扩展点。

如果想要使用Java自带的SPI，可以参考

使用约定

在扩展类的jar包内，放置扩展点配置文件：META-INF/dubbo/接口全限定名，内容为：配置名=扩展实现类全限定名，多个实现类用换行符分隔。

注意：这里的配置文件是放在你自己的jar包内，不是dubbo本身的jar包内，Dubbo会全ClassPath扫描所有jar包内同名的这个文件，然后进行合并

dubbo SPI的主要是通过ExtensionLoader这个类来实现的，所有关键代码也都在这个类中，使用方式有两种，一种可以手工指定，另外一种是自动生成。

基本用法和示例

有一个DuSPI的接口，接口中有一个sayHi的方法，然后通过dubbo的SPI机制进行调用其相关实现。

接口类

必须要有@SPI注解，SPI注解可以有一个value参数，代表默认的实现。

//接口类，定义了一个SayHello的方法，需要被实现@SPIpublic interface DuSPI {    public String SayHello(String hi);}//实现类，没什么好说的。public class LocalDuSPI implements DuSPI {    @Override    public String SayHello(String hi) {        return "FROM LocalDuSPI : "+hi;    }}

扩展点配置

调用方式

public class DuSPIMain {    private static final DuSPI duSPI = ExtensionLoader.getExtensionLoader(DuSPI.class).getExtension("local");    public static void main(String[] args) {        String hi = duSPI.SayHello("扩展SPI");        System.out.println(hi);    }}

输出结果为

上述就是非常简单的手工指定实现类用例。getExtension("local");接收一个key值，这个key就是spi文件中的key，得到的实现就是key对应的实现类。

ExtensionLoader还有一种自动寻找扩展的方法，getAdaptiveExtension，不需要手工指定实现，而是在方法具体调用的时候自动发现其具体的实现类。例如Protocol扩展，它的export方法就是通过invoke的URL中的Protocol，自动的发现实现

private static final ProxyFactory proxyFactory = ExtensionLoader.getExtensionLoader(ProxyFactory.class).getAdaptiveExtension();Invoker
     invoker = proxyFactory.getInvoker(ref, (Class) interfaceClass, registryURL.addParameterAndEncoded(Constants.EXPORT_KEY, url.toFullString()));Exporter
     exporter = protocol.export(invoker);

Duboo SPI源码解析ExtensionLoader类

通过对类注释，可以看到这个类主要实现以下几个功能

自动注入关联扩展点

自动Wrap上扩展点的Wrap类

缺省获得的扩展点的一个内部类Adaptive

这个类的实例需简要有一个getExtensionLoader的静态工厂方法，接收一个Class类型的对象，来获取其实例。

@SuppressWarnings("unchecked")public static 
    
      ExtensionLoader
     
       getExtensionLoader(Class
      
        type) {    if (type == null)        throw new IllegalArgumentException("Extension type == null");    if(!type.isInterface()) {        throw new IllegalArgumentException("Extension type(" + type + ") is not interface!");    }    if(!withExtensionAnnotation(type)) {        throw new IllegalArgumentException("Extension type(" + type +                ") is not extension, because WITHOUT @" + SPI.class.getSimpleName() + " Annotation!");    }    ExtensionLoader
       
         loader = (ExtensionLoader
        
         ) EXTENSION_LOADERS.get(type);    if (loader == null) {        EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader
         
          (type)); loader = (ExtensionLoader
          
           ) EXTENSION_LOADERS.get(type); } return loader;}

通过以上代码可以看出，传入的对象必须是一个接口，并且必须是带有@SPI注解，获取完了以后，针对相应的接口类型会缓存到map中去。

根据key返回相应的实现类方法

getExtensionClass(String name)

首先会去在缓存里面查找，看是否已经加载过这个类，如果加载过的话就直接返回，如果没有，则配置文件中查找，然后进行加载。这样就达到了它说的jdk的spi要全部加载所有扩展，而不是按需加载，如果有相应的扩展找不到就会报错的或者一个类的加载很耗的问题。

创建扩展是使用的createExtension方法，类实例化以后，会查看有没有对其他扩展点的应用，如果有的话就调用injectExtension方法，去注入其他的扩展类，这样就达到了它所说的AOP的功能。

加载扩展类的方法是loadExtensionClasses

private Map
    
     > loadExtensionClasses() {    final SPI defaultAnnotation = type.getAnnotation(SPI.class);    if(defaultAnnotation != null) {        String value = defaultAnnotation.value();        if(value != null && (value = value.trim()).length() > 0) {            String[] names = NAME_SEPARATOR.split(value);            if(names.length > 1) {                throw new IllegalStateException("more than 1 default extension name on extension " + type.getName()                        + ": " + Arrays.toString(names));            }            if(names.length == 1) cachedDefaultName = names[0];        }    }        Map
     
      > extensionClasses = new HashMap
      
       >();    loadFile(extensionClasses, DUBBO_INTERNAL_DIRECTORY);    loadFile(extensionClasses, DUBBO_DIRECTORY);    loadFile(extensionClasses, SERVICES_DIRECTORY);    return extensionClasses;}

通过以上可以得出以下结论

加载SPI注解，注解的value只能有一个，也就是默认扩展实现类。

Dubbo会依次扫描META-INF/dubbo/internal/、META-INF/dubbo/、

META-INF/services/ 这三个文件夹，优先级正好相反，看有没有相应的SPI文件、通过loadFile方法进行扫描和加载。

private void loadFile(Map
    
     > extensionClasses, String dir) {        String fileName = dir + type.getName();        try {            ...            if (urls != null) {                while (urls.hasMoreElements()) {                    java.net.URL url = urls.nextElement();                    try {                        BufferedReader reader = new BufferedReader(new InputStreamReader(url.openStream(), "utf-8"));                        try {                            String line = null;                            while ((line = reader.readLine()) != null) {                                final int ci = line.indexOf('#');                                if (ci >= 0) line = line.substring(0, ci);                                line = line.trim();                                ...                                        int i = line.indexOf('=');                                        if (i > 0) {                                            name = line.substring(0, i).trim();                                            line = line.substring(i + 1).trim();                                        }                                ...                                            Class
      clazz = Class.forName(line, true, classLoader);                                            if (! type.isAssignableFrom(clazz)) {                                                throw new IllegalStateException("Error when load extension class(interface: " +                                                        type + ", class line: " + clazz.getName() + "), class "                                                        + clazz.getName() + "is not subtype of interface.");                                            }                                                                            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);                                 ...                                                    String[] names = NAME_SEPARATOR.split(name);                                                    if (names != null && names.length > 0) {                                                        Activate activate = clazz.getAnnotation(Activate.class);                                                        if (activate != null) {                                                            cachedActivates.put(names[0], activate);                                                        }                                ...                                                    }                                                }                                            }                                        }                                      }}

通过加载类的文件可以看出

逐行读取配置文件

忽略#号后内容作为注释

分割字符串，等号前面的作为key，等号后面的作为value

通过Class.forName(value)获取具体的实现类对象

做一些类的类型校验

缓存得到的类

自适应Extention(Protocol示例)

在生成对象引用的时候，并不直接生成实现对象，而是先生成一个代理对象，直到调用的时候，在根据传递的参数决定调用的是哪个具体的实现类。Dubbo的SPI实现了自动发现机制。通过调用getAdaptiveExtension方法生成代理对象。在Protocol接口的使用中就用到了这个方法。

ServiceConfig类用需要有引用对象Protocol，这是标明dubbo的服务注册所使用的协议。Protocol的实现类很多

但是在声明的时候并不指名要调用哪种协议的实现。

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

代码上调用了getAdaptiveExtension()方法，生成代理对象，由于是代码生成的代理对象，在dubbo中并没有定义，所以只能把类文件拼装的代码的代码打印出来，生成类文件的代码是ExtensionLoader的createAdaptiveExtensionClassCode方法。生成的代理对象的类的定义如下：

package com.alibaba.dubbo.rpc;import com.alibaba.dubbo.common.extension.ExtensionLoader;public class Protocol$Adpative implements com.alibaba.dubbo.rpc.Protocol {    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!");    }    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();        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.export(arg0);    }}

这是一个通过javassit自动生成的一个类，实现了Protocol接口，对于服务端内容导出发布，实现了export方法，export 方法中，首先获取Invoker的url，URL中获取Protocol的protocol属性的值，看是否进行了设置，默认为dubbo，然后再调用dubboSPI（ExtensionLoader）机制中的getExtension方法，把Key传入进去，以达到自动获取Protocol的目的，然后找到真正的实现类，再调用其export方法。如果采用zk作为注册中心，通过配置<dubbo:registry address="zookeeper://localhost:2181" />

这样取得的key是就是registry，真正的实现类则是

com.alibaba.dubbo.registry.integration.RegistryProtocol

当然，上述只是讲述了dubbo spi设计的一个大概的思路，还有很多的其他的细节问题在本文中并未提到，不过这对于了解dubbo自定义实现SPI的设计已经足够。

转载于:https://my.oschina.net/u/2457218/blog/1517866

你可能感兴趣的文章

一起谈.NET技术，你应该知道的15个Silverlight诀窍