Dubbo的SPI实现以及与JDK实现的区别-51CTO.COM

在 Java 里，为了规范开发，制定了大量的「规范」与「标准」，这些上层的内容，大多是以接口的形式提供出来。那这些接口最终实现是谁呢，在哪里呢?

规范并不关心这个。

所谓规范，是指定了一系列内容，来指导我们的开发实现。比如 Servlet规范对于 Servlet 的行为做了说明，具体实现时，可以是 Tomcat，可以是Jetty 等等。

再比如 Java 的 JDBC 规范，规定了 Driver 提供者需要实现的内容，但具体是 Oracle，或者MySQL 都可以支持。关于JDBC 可以看之前一篇文章(没想到你是这样的 JDBC)。在之前我们可以通过 Class.forName来进行Driver 具体实现类的加载。从JDK1.6开始，官方提供了一个名为「SPI」的机制，来更方便快捷的进行对应实现类的加载，不需要我们关心。我们所需要做的，只需要将包含实现类的 JAR 文件放到 classpath中即可。

正好最近读了一些Dubbo的源码，其中有 Dubbo 的不同于JDK的另一种 SPI实现。所以这篇我们来看 Dubbo 的「SPI」实现以及与 JDK 实现的区别。

首先，什么是 SPI 呢?

SPI(Service Provider Interfaces)，可以理解成一个交给第三方实现的API。JDK文档这样描述

A service is a well-known set of interfaces and (usually abstract) classes. A service provider is a specific implementation of a service.

在Java 中使用到SPI的这些地方：

JDBC
JNDI
Java XML Processing API
Locael
NIO Channel Provider
……

通过这种SPI 的实现形式，我们的应用仿佛有了可插拔的能力。

我们之前的文章Tomcat 中的可插拔以及 SCI 的实现原理里，也分析了容器中是如何做到可插拔的。

JDK中的SPI 是怎样实现的呢?

在JDK中包含一个SPI最核心的类：ServiceLoader，在需要加载Provider类的时候，我们所要做的是：

ServiceLoader.load(Provider.class);

在JDK中规范了 Service Provider的路径，所有 Provider必须在JAR文件的META-INF/services目录下包含一个文件，文件名就是我们要实现的Service的名称全路径。比如我们熟悉的JDBC 的MySQL实现，在mysql-connector中，就有这样一个文件

META-INF/services/java.sql.Driver

这些provider是什么时候加载的呢?

由于Provider 的加载和初始化是Lazy的实现，所以需要的时候，可以遍历Provider 的 Iterator，按需要加载，已经加载的会存放到缓存中。

但有些实现不想Lazy，就直接在 ServiceLoader 的load执行之后直接把所有的实现都加载和初始化了，比如这次说的JDBC，所以这里在Tomcat里有个处理内存泄漏的，可以查看之前的文章(Tomcat与内存泄露处理)

继续说回具体的加载时机。我们一般在Spring 的配置中会增加一个datasource，这个数据源一般会在启动时做为一个Bean被初始化，此时数据源中配置的driver会被设置。

这些内容传入Bean中，会调用DriverManager的初始化

static { 
   loadInitialDrivers(); 
    println("JDBC DriverManager initialized"); 
} 
 
loadInitialDrivers 执行的的时候，除了ServiceLoader.load外，还进行了初始化 
 
ServiceLoader<Driver> loadedDrivers = ServiceLoader.load(Driver.class); 
Iterator<Driver> driversIterator = loadedDrivers.iterator(); 
try{ 
    while(driversIterator.hasNext()) { 
        driversIterator.next(); 
    } 
} catch(Throwable t) { 
// Do nothing 
} 
return null;

我们再来看 Dubbo 的SPI实现方式。如果你能看下 Dubbo 的源码就会发现，实现时并没有使用 JDK 的SPI，而是自已设计了一种。

我们以Main class启动来看看具体的实现。

我们从使用的入口处来看，***步传入一个接口，然后再传入期待的实现的名称

SpringContainer container = (SpringContainer) ExtensionLoader.getExtensionLoader(Container.class).getExtension("spring");

这里传入的是Container.class, 期待的实现是spring。

 // synchronized in getExtensionClasses 
     private Map<String, Class<?>> loadExtensionClasses() { 
         final SPI defaultAnnotation = type.getAnnotation(SPI.class); 
         if (defaultAnnotation != null) { 
             String value = defaultAnnotation.value(); 
             if ((valuevalue = 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<String, Class<?>> extensionClasses = new HashMap<String, Class<?>>(); 
        loadDirectory(extensionClasses, DUBBO_INTERNAL_DIRECTORY); 
        loadDirectory(extensionClasses, DUBBO_DIRECTORY); 
        loadDirectory(extensionClasses, SERVICES_DIRECTORY); 
        return extensionClasses; 
    }

共从三个地方加载扩展的class

DUBBO_INTERNAL_DIRECTORY META-INF/dubbo/internal/
DUBBO_DIRECTORY META-INF/dubbo/
SERVICES_DIRECTORY META-INF/services/

 private void loadDirectory(Map<String, Class<?>> extensionClasses, String dir) { 
         String fileName = dir + type.getName(); 
         try { 
             Enumeration<java.net.URL> urls; 
             ClassLoader classLoader = findClassLoader(); 
             if (classLoader != null) { 
                 urls = classLoader.getResources(fileName); 
             } else { 
                 urls = ClassLoader.getSystemResources(fileName); 
            } 
            if (urls != null) { 
                while (urls.hasMoreElements()) { 
                    java.net.URL resourceURL = urls.nextElement();   
                    loadResource(extensionClasses, classLoader, resourceURL); 
                } 
            } 
        } catch (Throwable t) { 
            logger.error("Exception when load extension class(interface: " + 
                    type + ", description file: " + fileName + ").", t); 
        } 
    }

这里通过classLoader，寻找符合传入的特定名称的文件，java.net.URL resourceURL = urls.nextElement();

此时会得到一个包含该文件的URLPath，再通过loadResource，将资源加载

此时得到的文件内容是

spring=com.alibaba.dubbo.container.spring.SpringContainer

再进一步，将等号后面的class加载，即可完成。

loadClass时，并不是直接通过类似Class.forName等形式加载，而是下面这个样子：

private void loadClass(Map<String, Class<?>> extensionClasses, java.net.URL resourceURL, Class<?> clazz, String name) throws NoSuchMethodException { 
         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 if (isWrapperClass(clazz)) { 
            Set<Class<?>> wrappers = cachedWrapperClasses; 
            if (wrappers == null) { 
                cachedWrapperClasses = new ConcurrentHashSet<Class<?>>(); 
                wrappers = cachedWrapperClasses; 
            } 
            wrappers.add(clazz); 
        } else { 
            clazz.getConstructor(); 
            if (name == null || name.length() == 0) { 
                name = findAnnotationName(clazz); 
                if (name.length() == 0) { 
                    throw new IllegalStateException("No such extension name for the class " + clazz.getName() + " in the config " + resourceURL); 
                } 
            } 
            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); 
                } 
                for (String n : names) { 
                    if (!cachedNames.containsKey(clazz)) { 
                        cachedNames.put(clazz, n); 
                    } 
                    Class<?> c = extensionClasses.get(n); 
                    if (c == null) { 
                        extensionClasses.put(n, clazz); 
                    } else if (c != clazz) { 
                        throw new IllegalStateException("Duplicate extension " + type.getName() + " name " + n + " on " + c.getName() + " and " + clazz.getName()); 
                    } 
                } 
            } 
        } 
    }

加载之后，需要对class进行初始化，此时直接newInstance一个，再通过反射注入的方式将对应的属性设置进去。

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, clazz.newInstance()); 
                instance = (T) EXTENSION_INSTANCES.get(clazz); 
            } 
            injectExtension(instance); 
            Set<Class<?>> wrapperClasses = cachedWrapperClasses; 
            if (wrapperClasses != null && !wrapperClasses.isEmpty()) { 
                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); 
        } 
    }

private T injectExtension(T instance) { 
        try { 
            if (objectFactory != null) { 
                for (Method method : instance.getClass().getMethods()) { 
                    if (method.getName().startsWith("set") 
                            && method.getParameterTypes().length == 1 
                            && Modifier.isPublic(method.getModifiers())) { 
                        Class<?> pt = method.getParameterTypes()[0]; 
                        try { 
                           String property = method.getName().length() > 3 ? method.getName().substring(3, 4).toLowerCase() + method.getName().substring(4) : ""; 
                           Object object = objectFactory.getExtension(pt, property); 
                           if (object != null) { 
                               method.invoke(instance, object); 
                           } 
                       } catch (Exception e) { 
                           logger.error("fail to inject via method " + method.getName() 
                                   + " of interface " + type.getName() + ": " + e.getMessage(), e); 
                       } 
                   } 
               } 
           } 
       } catch (Exception e) { 
           logger.error(e.getMessage(), e); 
       } 
       return instance; 
   }

通过上面的描述我们看到，JDK 与 Dubbo的 SPI 实现上，虽然都是从JAR中加载对应的扩展，但还是有些明显的区别，比如：Dubbo 支持更多的加载路径，同时，并不是通过Iterator的形式，而是直接通过名称来定位具体的Provider，按需要加载，效率更高，同时支持Provider以类似IOC的形式提供等等。

【本文为51CTO专栏作者“侯树成”的原创稿件，转载请通过作者微信公众号『Tomcat那些事儿』获取授权】

戳这里，看该作者更多好文