一、java SPI

1.1 什么是SPI

SPI (Service Provider Interface)，是一种将服务接口与服务实现实现分离的机制，以达到解耦的目的，大大提高了项目的可拓展性。

例如在数据库的产品中，有各式各样的数据库产品，而如果每一个产品都有一个各自的配置类，那么在使用中无疑是非常麻烦的，例如我要使用mysql需要调用mysql的相关配置类，而在调用oracle数据时则需要调用oracle相关类。如果本来使用mysql，而现在需要换成oracle，如果采用这种方式的话则需要修改代码，耦合性很高。

所以java就关于数据库连接驱动有一个固定接口，各大数据库厂商只需要在提供jar包时实现其接口，对用户来说就可以只通过修改配置来完成更换的操作。

1.2 如何使用SPI

那么java SPI是如何使用的呢？

约定在 Classpath 下的 META-INF/services/ 目录里创建一个以服务接口命名的文件，然后文件里面记录的是此 jar 包提供的具体实现类的全限定名。

可以看一下Mysql的jar包

其中的内容为：

该文件的意思是，该mysql的jar包提供了一个关于接口“java.sql.Driver”的实现“com.mysql.cj.jdbc.Driver”。

那么java在运行过程中就会收集到这个信息，后续哪里需要调用的时候，就根据需求找到该实现类。

1.3 SPI实践

例如我们现在有一个接口，两个实现类。

1. public interface StuService {
2. void getName();
3. }
5. public class Stu1 implements StuService{
6. @Override
7. public void getName() {
8. System.out.println("Alice");
9. }
10. }
12. public class Stu2 implements StuService{
13. @Override
14. public void getName() {
15. System.out.println("Bob");
16. }
17. }
19. public class SpiDemo {
20. public static void main(String[] args) {
21. ServiceLoader<StuService> stus = ServiceLoader.load(StuService.class);
22. Iterator<StuService> iterator = stus.iterator();
23. while (iterator.hasNext()) {
24. StuService stu = iterator.next();
25. stu.getName();
26. }
27. }
28. }

我们在项目的/Resource/META-INF/services/com.example.demo.dubbo.StuService中根据命名规则定义：

1. com.example.demo.dubbo.Stu1
2. com.example.demo.dubbo.Stu2

运行结果如下：

1. Alice
2. Bob

可以看到，我们首先获取了接口的ServiceLoader，然后获取了他的迭代器，然后获取每个实现类，并执行了其中的接口方法。

1.4 SPI实现源码

从获取迭代器的源码开始分析：ServiceLoader.load(StuService.class);

1. public static <S> ServiceLoader<S> load(Class<S> service) {
2. ClassLoader cl = Thread.currentThread().getContextClassLoader();
3. return ServiceLoader.load(service, cl);
4. }
6. public static <S> ServiceLoader<S> load(Class<S> service,
7. ClassLoader loader)
8. {
9. return new ServiceLoader<>(service, loader);
10. }
12. private ServiceLoader(Class<S> svc, ClassLoader cl) {
13. service = Objects.requireNonNull(svc, "Service interface cannot be null");
14. loader = (cl == null) ? ClassLoader.getSystemClassLoader() : cl;
15. acc = (System.getSecurityManager() != null) ? AccessController.getContext() : null;
16. reload();
17. }
19. public void reload() {
20. providers.clear();
21. lookupIterator = new LazyIterator(service, loader);
22. }

可以看到就是创建了一个迭代器并返回了。需要注重看一下迭代器对应重写的hasNext()与next()方法。

1. public boolean hasNext() {
2. if (acc == null) {
3. return hasNextService();
4. } else {
5. PrivilegedAction<Boolean> action = new PrivilegedAction<Boolean>() {
6. public Boolean run() { return hasNextService(); }
7. };
8. return AccessController.doPrivileged(action, acc);
9. }
10. }

可以看到最终调用的是这个方法hasNextService()

1. private boolean hasNextService() {
2. if (nextName != null) {
3. return true;
4. }
5. if (configs == null) {
6. try {
7. //其中PREFIX就是"META-INF/services/"，也就是我们约定的地方获取类名
8. String fullName = PREFIX + service.getName();
9. if (loader == null)
10. configs = ClassLoader.getSystemResources(fullName);
11. else
12. configs = loader.getResources(fullName);
13. } catch (IOException x) {
14. fail(service, "Error locating configuration files", x);
15. }
16. }
17. while ((pending == null) || !pending.hasNext()) {
18. if (!configs.hasMoreElements()) {
19. return false;
20. }
21. //解析文件，对应我们的代码应该有两项
22. pending = parse(service, configs.nextElement());
23. }
24. //当第一次执行该方法时，因为有两个实现类，所以此时该值不为空
25. nextName = pending.next();
26. return true;
27. }

代码还是非常简单的，总结来说就是首先去我们约定好的地方获取我们要加载的类，对应我们的demo也就是去获取"/Resource/META-INF/services/com.example.demo.dubbo.StuService"这个文件，然后读取文件流加载文本中的内容，并对有多项的实现类进行缓存。

然后就是next():

1. public S next() {
2. if (acc == null) {
3. return nextService();
4. } else {
5. PrivilegedAction<S> action = new PrivilegedAction<S>() {
6. public S run() { return nextService(); }
7. };
8. return AccessController.doPrivileged(action, acc);
9. }
10. }

可以看到跟上面很类似的也是调用nextService():

1. private S nextService() {
2. if (!hasNextService())
3. throw new NoSuchElementException();
4. String cn = nextName;
5. nextName = null;
6. Class<?> c = null;
7. try {
8. //获取要加载的class
9. c = Class.forName(cn, false, loader);
10. } catch (ClassNotFoundException x) {
11. fail(service,
12. "Provider " + cn + " not found");
13. }
14. if (!service.isAssignableFrom(c)) {
15. fail(service,
16. "Provider " + cn + " not a subtype");
17. }
18. try {
19. //通过反射创建class对应实例
20. S p = service.cast(c.newInstance());
21. providers.put(cn, p);
22. return p;
23. } catch (Throwable x) {
24. fail(service,
25. "Provider " + cn + " could not be instantiated",
26. x);
27. }
28. throw new Error(); // This cannot happen
29. }

以上就是java SPI的源码了，总结来说就是会分为两步，首先会去约定的位置获取文件信息，然后获取文本中的实现类，并通过反射的方式获取实例。

二、Dubbo SPI

2.1 Dubbo SPI与java SPI区别

那么为什么java已经有了SPI机制，Dubbo还要进行重写呢。

其实在上面的使用过程中我们就会发现，假如说我们一个接口有多个实现类，而我们只想要其中一个类时。

因为加载器只会返回一个迭代器，我们只能通过遍历迭代器来加载我们的实现类，因此会实例化很多无用的类，而当这些类加载又比较耗时时，就会造成无用的资源浪费。

2.2 Dubbo SPI配置

同样的，Dubbo SPI也有约定的存放文件配置的位置：

• META-INF/services/ 目录：该目录下的 SPI 配置文件是为了用来兼容 java SPI 。

• META-INF/dubbo/ 目录：该目录存放用户自定义的 SPI 配置文件。

• META-INF/dubbo/internal/ 目录：该目录存放 Dubbo 内部使用的 SPI 配置文件。

在java中，SPI的配置文件是以换行为区分有多个实现类的，而Dubbo中则是以键值对的形式来存储配置。

例如：

2.3 SPI实例

还是基于我们刚刚的实例：

1. @SPI
2. public interface StuService {
3. void getName();
4. }

注意此处加上了@SPI注解

我们在"/Resource/META-INF/dubbo/com.example.demo.dubbo.StuService"新建文件，内容如下：

1. stu1 = com.example.demo.dubbo.Stu1
2. stu2 = com.example.demo.dubbo.Stu2

main方法添加dubbo获取spi

1. public static void main(String[] args) {
2. ServiceLoader<StuService> stus = ServiceLoader.load(StuService.class);
3. Iterator<StuService> iterator = stus.iterator();
4. while (iterator.hasNext()) {
5. StuService stu = iterator.next();
6. stu.getName();
7. }
9. ExtensionLoader<StuService> extensionLoader = ExtensionLoader.getExtensionLoader(StuService.class);
10. StuService stu1 = extensionLoader.getExtension("stu1");
11. stu1.getName();
12. StuService stu2 = extensionLoader.getExtension("stu2");
13. stu2.getName();
14. }

输出结果：

1. Alice
2. Bob
3. 21:58:45.480 [main] INFO com.alibaba.dubbo.common.logger.LoggerFactory - using logger: com.alibaba.dubbo.common.logger.slf4j.Slf4jLoggerAdapter
4. Alice
5. Bob

可以看到，我们的Dubbo SPI也能够正常获取实现类。

2.4 Dubbo SPI源码

同样我们从获取的地方入手：

1. //获取ExtensionLoader
2. ExtensionLoader<StuService> extensionLoader = ExtensionLoader.getExtensionLoader(StuService.class);
3. //获取加载对象
4. StuService stu1 = extensionLoader.getExtension("stu1");

首先看extensionLoader.getExtension("stu1");

1. public T getExtension(String name) {
2. Holder<Object> holder = cachedInstances.get(name);
3. if (holder == null) {
4. cachedInstances.putIfAbsent(name, new Holder<Object>());
5. holder = cachedInstances.get(name);
6. }
7. Object instance = holder.get();
8. if (instance == null) {
9. synchronized (holder) {
10. instance = holder.get();
11. if (instance == null) {
12. //创建对象
13. instance = createExtension(name);
14. holder.set(instance);
15. }
16. }
17. }
18. return (T) instance;
19. }

createExtension(name)

1. private T createExtension(String name) {
2. //1.获取class
3. Class<?> clazz = getExtensionClasses().get(name);
4. if (clazz == null) {
5. throw findException(name);
6. }
7. try {
8. T instance = (T) EXTENSION_INSTANCES.get(clazz);
9. if (instance == null) {
10. //2.通过反射实例化对象
11. EXTENSION_INSTANCES.putIfAbsent(clazz, clazz.newInstance());
12. instance = (T) EXTENSION_INSTANCES.get(clazz);
13. }
14. injectExtension(instance);
15. Set<Class<?>> wrapperClasses = cachedWrapperClasses;
16. if (wrapperClasses != null && !wrapperClasses.isEmpty()) {
17. for (Class<?> wrapperClass : wrapperClasses) {
18. instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance));
19. }
20. }
21. return instance;
22. } catch (Throwable t) {
23. throw new IllegalStateException("Extension instance(name: " + name + ", class: " +
24. type + ") could not be instantiated: " + t.getMessage(), t);
25. }
26. }

可以看到主要有两步：

1. 获取class

可以看到入参是我们传入的stu1，而class已经变成我们配置文件中对应的class文件了。

那么dubbo是如何进行转换的呢？

getExtensionClasses()方法中主要是先调用缓存，如果缓存中没有的话会加载类，也就是loadExtensionClasses()

1. private Map<String, Class<?>> loadExtensionClasses() {
2. final SPI defaultAnnotation = type.getAnnotation(SPI.class);
3. if (defaultAnnotation != null) {
4. String value = defaultAnnotation.value();
5. if ((value = value.trim()).length() > 0) {
6. String[] names = NAME_SEPARATOR.split(value);
7. if (names.length > 1) {
8. throw new IllegalStateException("more than 1 default extension name on extension " + type.getName()
9. + ": " + Arrays.toString(names));
10. }
11. if (names.length == 1) cachedDefaultName = names[0];
12. }
13. }
15. //初始化返回结果
16. Map<String, Class<?>> extensionClasses = new HashMap<String, Class<?>>();
17. //从"META-INF/dubbo/internal/"路径中加载class文件
18. loadDirectory(extensionClasses, DUBBO_INTERNAL_DIRECTORY);
19. //从"META-INF/dubbo"路径中加载class文件
20. loadDirectory(extensionClasses, DUBBO_DIRECTORY);
21. //从"META-INF/services"路径中加载class文件
22. loadDirectory(extensionClasses, SERVICES_DIRECTORY);
23. return extensionClasses;
24. }

可以看到会从以下三个约定好的路径下加载配置文件

loadDirectory()会加载loadResource()

1. private void loadResource(Map<String, Class<?>> extensionClasses, ClassLoader classLoader, java.net.URL resourceURL) {
2. try {
3. //读取文件流
4. BufferedReader reader = new BufferedReader(new InputStreamReader(resourceURL.openStream(), "utf-8"));
5. try {
6. String line;
7. while ((line = reader.readLine()) != null) {
8. final int ci = line.indexOf('#');
9. if (ci >= 0) line = line.substring(0, ci);
10. line = line.trim();
11. if (line.length() > 0) {
12. try {
13. String name = null;
14. //解析 “=” 号
15. int i = line.indexOf('=');
16. if (i > 0) {
17. //获取前面的key值
18. name = line.substring(0, i).trim();
19. //获取后面的class
20. line = line.substring(i + 1).trim();
21. }
22. if (line.length() > 0) {
23. //将key与class加载到返回结果中
24. loadClass(extensionClasses, resourceURL, Class.forName(line, true, classLoader), name);
25. }
26. }
27. }
28. }
29. }
30. }
31. }

总结来说，会以文本的方式去解析文件中的内容，分别获取其key值与class值，并将其加载到结果中。在获取到class后，最后以反射的方式进行实例化对象。

2.5 从源码角度上来看Dubbo为何要重写SPI

java SPI在获取到接口名称后，会返回一个迭代器，如果我们想要加载某一个实现类则需要通过循环迭代的方式实例化对象，会加载很多不需要的资源，比较浪费。

而Dubbo SPI则通过键值对的形式，让我们在获取实现类时可以直接通过key值获取到要加载的对象，而不需要再遍历生产所有的实现类，效率相对来说比较高。

作者：韩国凯