【Dubbo】带着问题看源码：什么是SPI机制？Dubbo是如何实现的？

什么是SPI？

在Java中，SPI全称为 Service Provider Interface，是一种典型的面向接口编程机制。定义通用接口，然后具体实现可以动态替换，和 IoC 有异曲同工之妙。

Java SPI 实现DEMO

定义一个接口

public interface Human {

    String sayHello();

}

定义两个实现类

public class American implements Human {

    @Override

    public String sayHello() {

        return "Hello,I'm American";

    }

}

public class Chinese implements Human {

    @Override

    public String sayHello() {

        return "你好，我是中国人";

    }

}

新建接口全名文件，例如本例： com.xx.spi.Human,放到META-INF/services路径下，文件内容为实现类的全名，不同实现类之前换行。
```
com.xx.spi.American

com.xx.spi.Chinese
```

编码测试

public class SpiApplication {

    public static void main(String[] args) {

        ServiceLoader<Human> humans = ServiceLoader.load(Human.class);

        for (Human human : humans) {

            System.out.println(human.sayHello());

        }

    }

}

Java SPI 源码解析

ServiceLoader 提供了静态方法 load(Class<S> service),本质上还是要new一个新的实例，调用私有构造方法 ServiceLoader(Class<S> svc, ClassLoader cl).

 private ServiceLoader(Class<S> svc, ClassLoader cl) {

        service = Objects.requireNonNull(svc, "Service interface cannot be null");

     	// 此时的 cl 为 Thread.currentThread().getContextClassLoader();

        loader = (cl == null) ? ClassLoader.getSystemClassLoader() : cl;

        acc = (System.getSecurityManager() != null) ? AccessController.getContext() : null;

        reload();

    }

初始化内部 LazyIterator

 public void reload() {

        // Cached providers, in instantiation order

        //private LinkedHashMap<String,S> providers = new LinkedHashMap<>();

        //先清空缓存

        providers.clear();

        //重新初始化 lazyIterator ，此时对象还没有被创建

        lookupIterator = new LazyIterator(service, loader);

    }

ServiceLoader 本身实现了 Iterable 接口。遍历时会获取 iterator.

public Iterator<S> iterator() {

        return new Iterator<S>() {

            //已经缓存的列表

            Iterator<Map.Entry<String,S>> knownProviders

                = providers.entrySet().iterator();

            public boolean hasNext() {

                //先从缓存中找

                if (knownProviders.hasNext())

                    return true;

                //缓存 MISS ，调用内部 LazyIterator.hasNext()

                return lookupIterator.hasNext();

            }

            public S next() {

                //缓存中存在，直接返回

                if (knownProviders.hasNext())

                    return knownProviders.next().getValue();

                //缓存 MISS，调用内部 LazyIterator.next()

                return lookupIterator.next();

            }

            public void remove() {

                throw new UnsupportedOperationException();

            }

        };

    }

LazyIterator#next()

 public S next() {

            if (acc == null) {

                //查找下一个 Service

                return nextService();

            } else {

                PrivilegedAction<S> action = new PrivilegedAction<S>() {

                    public S run() { return nextService(); }

                };

                return AccessController.doPrivileged(action, acc);

            }

        }

LazyIterator#hasNextService()

 private boolean hasNextService() {

            if (nextName != null) {

                return true;

            }

            if (configs == null) {

                try {

                    //查找文件  META-INF/services/com.xx.spi.Human

                    String fullName = PREFIX + service.getName();

                    if (loader == null)

                        configs = ClassLoader.getSystemResources(fullName);

                    else

                        configs = loader.getResources(fullName);

                } catch (IOException x) {

                    fail(service, "Error locating configuration files", x);

                }

            }

            while ((pending == null) || !pending.hasNext()) {

                //没有更多元素，遍历结束

                if (!configs.hasMoreElements()) {

                    return false;

                }

                pending = parse(service, configs.nextElement());

            }

     		//给下一个名称赋值

            nextName = pending.next();

            return true;

        }

LazyIterator#nextService()

 private S nextService() {

            if (!hasNextService())

                throw new NoSuchElementException();

            //调用完  hasNextService 方法之后，nextName 更新

            String cn = nextName;

            nextName = null;

            Class<?> c = null;

            try {

                //获取 Class

                c = Class.forName(cn, false, loader);

            } catch (ClassNotFoundException x) {

                fail(service,

                     "Provider " + cn + " not found");

            }

     		//判断类是否继承指定接口

            if (!service.isAssignableFrom(c)) {

                fail(service,

                     "Provider " + cn  + " not a subtype");

            }

            try {

            	//反射创建对象

                S p = service.cast(c.newInstance());

                //加入缓存，下次访问直接访问缓存

                providers.put(cn, p);

                return p;

            } catch (Throwable x) {

                fail(service,

                     "Provider " + cn + " could not be instantiated",

                     x);

            }

            throw new Error();          // This cannot happen

        }

小结

可以看出在Java SPI的实现中，核心代码就是反射创建对象实例。经典的实际应用中可以参考 JDBC的Driver实现。这里不在赘述。

在 Dubbo相关官方博客介绍了它的缺点：

需要遍历所有的实现，并实例化，然后我们在循环中才能找到我们需要的实现。
配置文件中只是简单的列出了所有的扩展实现，而没有给他们命名。导致在程序中很难去准确的引用它们。
扩展如果依赖其他的扩展，做不到自动注入和装配
不提供类似于Spring的IOC和AOP功能
扩展很难和其他的框架集成，比如扩展里面依赖了一个Spring bean，原生的Java SPI不支持

Dubbo SPI 实现DEMO

定义一个接口,添加 @SPI 注解

@SPI("human")

public interface Human {

    @Adaptive

    String sayHello(URL url);

}

定义两个实现类

public class American implements Human {

    @Override

    public String sayHello(URL url) {

        return "Hello,I'm American";

    }

}

public class Chinese implements Human {

    @Override

    public String sayHello(URL url) {

        return "你好，我是中国人";

    }

}

新建接口全名文件，例如本例： com.xx.spi.Human,放到META-INF/dubbo/internal路径下，文件内容为key=value 形式。
```
//默认实现

human=com.xx.spi.Chinese

//中国

cn=com.xx.spi.Chinese

//美国

en=com.xx.spi.American
```

编码测试

public class DubboSpiApplication {

    public static void main(String[] args) {

		//根据 human 参数动态获取实现类

        URL url = URL.valueOf("test://localhost/test?human=en");

        Human humanDefault = ExtensionLoader.getExtensionLoader(Human.class).getDefaultExtension();

        Human humanAdaptive = ExtensionLoader.getExtensionLoader(Human.class).getAdaptiveExtension();

        //default

        System.out.println(humanDefault.sayHello(url));

        //adaptive

        System.out.println(humanAdaptive.sayHello(url));

    }

}

Dubbo SPI 源码解析

ExtensionLoader

ExtensionLoader内置了各种不同的缓存，以提高性能,所以在后续的代码中会将缓存判断的地方去掉，只保留核心代码

//缓存 ExtensionLoader 实例，每个 Class<?> 对应一个，静态方法 getExtensionLoader 即从该缓存中获取

private static final ConcurrentMap<Class<?>, ExtensionLoader<?>> EXTENSION_LOADERS = new ConcurrentHashMap<>(); 

private final ConcurrentMap<Class<?>, String> cachedNames = new ConcurrentHashMap<>();

    //缓存 配置文件中的 key value 对象.

    private final Holder<Map<String, Class<?>>> cachedClasses = new Holder<>();

    private final Map<String, Object> cachedActivates = new ConcurrentHashMap<>();

    private final ConcurrentMap<String, Holder<Object>> cachedInstances = new ConcurrentHashMap<>();

    private final Holder<Object> cachedAdaptiveInstance = new Holder<>();

    private volatile Class<?> cachedAdaptiveClass = null;

ExtensionLoader# getDefaultExtension()

 public T getDefaultExtension() {

        //做准备工作，扫描配置文件，提取类信息等

        getExtensionClasses();

        //获取类实例

        return getExtension(cachedDefaultName);

    }

ExtensionLoader# getExtensionClasses()

 private Map<String, Class<?>> getExtensionClasses() {

        //省略其他缓存判断和加锁代码，其实就是调用此方法，然后放入 cachedClasses 中

        return loadExtensionClasses();

    }

ExtensionLoader#loadExtensionClasses()

 private Map<String, Class<?>> loadExtensionClasses() {

        //解析默认名称 例如 @SPI("human") 中的human

        cacheDefaultExtensionName();

        Map<String, Class<?>> extensionClasses = new HashMap<>();

        //从 META-INF/dubbo/internal/ 目录下加载

        loadDirectory(extensionClasses, DUBBO_INTERNAL_DIRECTORY, type.getName());

        //从 META-INF/dubbo/internal/ 目录下加载 内置的类，例如ExtensionFactory

        loadDirectory(extensionClasses, DUBBO_INTERNAL_DIRECTORY, type.getName().replace("org.apache", "com.alibaba"));

        //从 META-INF/dubbo/ 目录下加载

        loadDirectory(extensionClasses, DUBBO_DIRECTORY, type.getName());

        loadDirectory(extensionClasses, DUBBO_DIRECTORY, type.getName().replace("org.apache", "com.alibaba"));

        //从 META-INF/services/ 目录下加载,兼容Java SPI 方式

        loadDirectory(extensionClasses, SERVICES_DIRECTORY, type.getName());

        loadDirectory(extensionClasses, SERVICES_DIRECTORY, type.getName().replace("org.apache", "com.alibaba"));

        return extensionClasses;

    }

ExtensionLoader#loadResource()

 private void loadResource(Map<String, Class<?>> extensionClasses, ClassLoader classLoader, java.net.URL resourceURL) {

        try {

            //读取文件

            try (BufferedReader reader = new BufferedReader(new InputStreamReader(resourceURL.openStream(), StandardCharsets.UTF_8))) {

                String line;

                while ((line = reader.readLine()) != null) {

                    final int ci = line.indexOf('#');

                    if (ci >= 0) {

                        line = line.substring(0, ci);

                    }

                    line = line.trim();

                    if (line.length() > 0) {

                        try {

                            String name = null;

                            int i = line.indexOf('=');

                            if (i > 0) {

                                //解析出  key  value ，key为别名 value 为类的全名

                                name = line.substring(0, i).trim();

                                line = line.substring(i + 1).trim();

                            }

                            if (line.length() > 0) {

                                loadClass(extensionClasses, resourceURL, Class.forName(line, true, classLoader), name);

                            }

                        }

                        //...其他代码

    }

此时，cachedClasses 已经存放若干类信息。

ExtensionLoader#getExtension()

 public T getExtension(String name) {

	   //忽略缓存部分代码，核心就是调用此方法进行类的实例化

       return (T)createExtension(name);

    }

ExtensionLoader#createExtension()

 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) {

                //缓存MISS，调用 newInstance() 方法实例化，存入缓存

                EXTENSION_INSTANCES.putIfAbsent(clazz, clazz.newInstance());

                instance = (T) EXTENSION_INSTANCES.get(clazz);

            }

            //做后续的注入工作（下文解析）

            injectExtension(instance);

            //包装类构造函数注入（下文解析）

            Set<Class<?>> wrapperClasses = cachedWrapperClasses;

            if (CollectionUtils.isNotEmpty(wrapperClasses)) {

                for (Class<?> wrapperClass : wrapperClasses) {

                    instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance));

                }

            }

            return instance;

        } catch (Throwable t) {

        }

    }

所以到了这一步，就很明了了，其实核心代码还是通过反射的方式newInstance创建对象实例，然后存入缓存。但是后续又做了一些注入工作。功能性要比 JAVA SPI丰富一些。

ExtensionLoader#injectExtension()

 private T injectExtension(T instance) {

        try {

            if (objectFactory != null) {

                //遍历所有的方法

                for (Method method : instance.getClass().getMethods()) {

                    //如果是set方法

                    if (isSetter(method)) {

                        //方法存在 DisableInject 注解，不注入

                        if (method.getAnnotation(DisableInject.class) != null) {

                            continue;

                        }

                        //获取参数类型

                        Class<?> pt = method.getParameterTypes()[0];

                        //如果是基本类型的参数，跳过

                        if (ReflectUtils.isPrimitives(pt)) {

                            continue;

                        }

                        try {

                            //获取属性名称

                            String property = getSetterProperty(method);

                            //通过 Factory 获取 扩展实例。

                            Object object = objectFactory.getExtension(pt, property);

                            //获取到了就执行 set 方法

                            if (object != null) {

                                method.invoke(instance, object);

                            }

                        } catch (Exception e) {

                            logger.error("Failed to inject via method " + method.getName()

                                    + " of interface " + type.getName() + ": " + e.getMessage(), e);

                        }

                    }

                }

            }

        } catch (Exception e) {

            logger.error(e.getMessage(), e);

        }

        return instance;

    }

ExtensionLoader#getAdaptiveExtension()

 public T getAdaptiveExtension() {

    //除去其他判断代码，核心方法

    return （T）createAdaptiveExtension();

 }

ExtensionLoader#createAdaptiveExtension()

 private T createAdaptiveExtension() {

     //忽略 injectExtension方法，主要是看AdaptiveExtensionClass如何获取

     return injectExtension((T) getAdaptiveExtensionClass().newInstance());

 }

ExtensionLoader#getAdaptiveExtensionClass()

 private Class<?> getAdaptiveExtensionClass() {

        //同样，先加载类信息

        getExtensionClasses();

        //读取缓存

        if (cachedAdaptiveClass != null) {

            return cachedAdaptiveClass;

        }

        // 创建

        return cachedAdaptiveClass = createAdaptiveExtensionClass();

    }

ExtensionLoader#createAdaptiveExtensionClass()

这个方法比较有意思，会动态创建一个新的类，类名 Class$Adaptive.

private Class<?> createAdaptiveExtensionClass() {

        //生成类的字符串代码

        String code = new AdaptiveClassCodeGenerator(type, cachedDefaultName).generate();

        ClassLoader classLoader = findClassLoader();

        //获取内置的 Compiler，它也是通过 ExtensionLoader 生成的实例，可以通过修改配置 <dubbo:application compiler="jdk"/> 选择使用哪一种。Dubbo支持 JDK，Javassist,AdaptiveCompiler

        org.apache.dubbo.common.compiler.Compiler compiler = ExtensionLoader.getExtensionLoader(org.apache.dubbo.common.compiler.Compiler.class).getAdaptiveExtension();

        //编译生成类

        return compiler.compile(code, classLoader);

    }

默认使用 javassist

@SPI("javassist")

public interface Compiler {

    /**

     * Compile java source code.

     *

     * @param code        Java source code

     * @param classLoader classloader

     * @return Compiled class

     */

    Class<?> compile(String code, ClassLoader classLoader);

}

类结构图如下：

JavassistCompiler 和 JdkCompiler 是真正做事的，而AdaptiveCompiler则是为了实现动态选择编译器而生的。

 @Override

    public Class<?> compile(String code, ClassLoader classLoader) {

        Compiler compiler;

        ExtensionLoader<Compiler> loader = ExtensionLoader.getExtensionLoader(Compiler.class);

        String name = DEFAULT_COMPILER; // copy reference

        if (name != null && name.length() > 0) {

            //根据 name 获取编译器

            compiler = loader.getExtension(name);

        } else {

            //获取默认编译器，即 @SPI 注解标明的编译器，默认是 javassist

            compiler = loader.getDefaultExtension();

        }

        return compiler.compile(code, classLoader);

    }

那么，编译器编译的代码是什么呢？我将代码格式稍微整理了一下

//包名

package com.xx.spi;

//导入

import org.apache.dubbo.common.extension.ExtensionLoader;

//生成的类名 ClassName+ $ + Adaptive

public class Human$Adaptive implements com.fanpan26.jls.spi.Human {

    public java.lang.String sayHello(org.apache.dubbo.common.URL arg0) {

        //参数校验

        if (arg0 == null) throw new IllegalArgumentException("url == null");

        org.apache.dubbo.common.URL url = arg0;

        //获取参数

        String extName = url.getParameter("human", "human");

        //如果没有获取到，说明配置文件里没有，抛出异常

        if (extName == null) {

            throw new IllegalStateException("Failed to get extension (com.fanpan26.jls.spi.Human) name from url (" + url.toString() + ") use keys([human])");

        }

        //最终还是调用了  getExtension(String name); 方法获取实例

        com.fanpan26.jls.spi.Human extension = ExtensionLoader.getExtensionLoader(com.fanpan26.jls.spi.Human.class).getExtension(extName);

        //最后调用该实例的方法

        return extension.sayHello(arg0);

    }

}

所以，到此为止， getExtension(String name) 是个核心方法，很多地方都会用到他。即便是 Adaptive类，最终生成的类方法中也是调用了该方法。

ExtensionLoader#getActivateExtension()

此方法也是大同小异，不在赘述。

总结

简单的做了一下 JAVA SPI 和Dubbo SPI 的代码解析，也有很多细节没有分析。相比于JAVA SPI，Dubbo SPI提供了更加丰富的功能和更高的灵活性。Dubbo SPI 在Dubbo框架中的应用到处可见，所以它的重要性不言而喻。通过代码的编写与调试，让我收获良多。分析不正确的地方还请多多谅解和批评指正。

巴特西