一篇文章看懂 Java SPI 机制及原理

JAVA SPI

什么是JavaSPI

它是 Service provider interface 的简写，即服务提供发现接口。是一种动态替换发现机制。

​ 比如有个接口（他可以有很多实现类），想运行时动态的给它添加实现，你只需要添加一个实现。我们经常遇到的就是java.sql.Driver接口，其他不同厂商可以针对同一接口做出不同的实现，mysql和postgresql都有不同的实现提供给用户，而Java的SPI机制可以为某个接口寻找服务实现。

​ Java中SPI机制主要思想是将装配的控制权移到程序之外，在模块化设计中这个机制尤其重要，其核心思想就是 解耦。

SPI简单示例

我们现在需要使用一个内容搜索接口，搜索的实现可能是基于文件系统的搜索，也可能是基于数据库的搜索。

• 先定义好接口

public interface Search {
    public List<String> searchDoc(String keyword);   
} 

• 文件搜索实现

public class FileSearch implements Search{
    @Override
    public List<String> searchDoc(String keyword) {
        System.out.println("文件搜索 "+keyword);
        return null;
    }
}

• 数据库搜索实现

public class DatabaseSearch implements Search{
    @Override
    public List<String> searchDoc(String keyword) {
        System.out.println("数据搜索 "+keyword);
        return null;
    }
}

• resources 接下来可以在resources下新建META-INF/services/目录，然后新建接口全限定名的文件：com.cainiao.ys.spi.learn.Search，里面加上我们需要用到的实现类

com.cainiao.ys.spi.learn.FileSearch

• 测试方法

public class TestCase {
    public static void main(String[] args) {
        ServiceLoader<Search> s = ServiceLoader.load(Search.class);
        Iterator<Search> iterator = s.iterator();
        while (iterator.hasNext()) {
           Search search =  iterator.next();
           search.searchDoc("hello world");
        }
    }
}

可以看到输出结果：文件搜索 hello world

如果在com.cainiao.ys.spi.learn.Search文件里写上两个实现类，那最后的输出结果就是两行了。

这就是因为ServiceLoader.load(Search.class)在加载某接口时，会去META-INF/services下找接口的全限定名文件，再根据里面的内容加载相应的实现类。

这就是spi的思想，接口的实现由provider实现，provider只用在提交的jar包里的META-INF/services下根据平台定义的接口新建文件，并添加进相应的实现类内容就

SPI使用及分析

​ 在JDBC4.0之前，我们开发有连接数据库的时候，通常会用Class.forName(“com.mysql.jdbc.Driver”)这句先加载数据库相关的驱动，然后再进行获取连接等的操作。

​ 而JDBC4.0之后不需要用Class.forName(“com.mysql.jdbc.Driver”)来加载驱动，直接获取连接就可以了，现在这种方式就是使用了Java的SPI扩展机制来实现。

JDBC接口定义

​ 首先在java中定义了接口java.sql.Driver，并没有具体的实现，具体的实现都是由不同厂商来提供的。

mysql实现

​ 在mysql的jar包mysql-connector-java-6.0.6.jar中，可以找到META-INF/services目录，该目录下会有一个名字为java.sql.Driver的文件，文件内容是com.mysql.cj.jdbc.Driver，这里面的内容就是针对Java中定义的接口的实现。

源码实现

​ 之所以可以直接获取连接，是因为DriverManager在初始化的时候，就已经根据java SPI把我们需要的连接对象注册进registeredDrivers中。下面让我们看看源代码。

public class DriverManager {
    // List of registered JDBC drivers
    private final static CopyOnWriteArrayList<DriverInfo> registeredDrivers = new CopyOnWriteArrayList<>();
    /* Prevent the DriverManager class from being instantiated. */
    private DriverManager(){}
    /**
     * Load the initial JDBC drivers by checking the System property
     * jdbc.properties and then use the {@code ServiceLoader} mechanism
     */
    static {
        loadInitialDrivers();
        println("JDBC DriverManager initialized");
    }
}

​ 可以看到静态代码块中有一个loadInitialDrivers代码，它的作用注释也写得很清楚，通过检查 System 属性加载初始 JDBC 驱动程序jdbc.properties 然后使用 {@code ServiceLoader} 机制。这里其实就是使用SPI，我们接着往下看。看他的loadInitialDrivers()方法。

private static void loadInitialDrivers() {
    String drivers;
	.....
    //  这里主要讲和SPI相关的部分代码
    AccessController.doPrivileged(new PrivilegedAction<Void>() {
        public Void run() {
			//使用SPI的ServiceLoader来加载接口的实现
            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;
        }
    });
}

这里可以看到他是使用迭代器进行遍历的，这里主要看他的 driversIterator.next(); 这一步，这一步我们进他的实现类，也就是ServiceLoader这个类里面的next方法

        public S next() {
            if (acc == null) {
                return nextService();
            } else {
                PrivilegedAction<S> action = new PrivilegedAction<S>() {
                    public S run() { 
                        return nextService(); 
                    }
                };
                return AccessController.doPrivileged(action, acc);
            }
        }

然后我们到看有一步 return nextService(); 继续进入nextService()方法

        private S nextService() {
            if (!hasNextService())
                throw new NoSuchElementException();
            String cn = nextName;
            nextName = null;
            Class<?> c = null;
            try {
                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
        }

这里我们就可以看到他有一步

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

我们debug可以看到这里的cn 其实就是 com.mysql.jdbc.Driver 就是我们之前的必须写的那段代码

Class.forName(“com.mysql.jdbc.Driver”) 然后驱动就会被注册，我们就可以直接使用了。

这也就是为什么不用写这段代码的原因了。

SPI机制通常怎么使用

看完上面的几个例子解析，应该都能知道大概的流程了：

• 有关组织或者公司定义标准。就是定义接口。比如接口java.sql.Driver。

• 具体厂商或者框架开发者实现。比如java.sql.Driver文件。

• 程序猿使用。

  ServiceLoader<Driver> loadedDrivers = ServiceLoader.load(Driver.class);
  //获取迭代器
  Iterator<Driver> driversIterator = loadedDrivers.iterator();
  //遍历
  while(driversIterator.hasNext()) {
      driversIterator.next();
      //可以做具体的业务逻辑
  }
  

SPI和API的区别

• SPI - “接口”位于“调用方”所在的“包”中
  • 概念上更依赖调用方
  • 组织上位于调用方所在的包中。
  • 实现位于独立的包中
  • 常见的例子是：插件模式的插件
• API - “接口”位于“实现方”所在的“包”中
  • 概念上更接近实现方
  • 组织上位于实现方所在的包中
  • 实现和接口在一个包中

SPI缺点

• 不能按需加载，需要遍历所有的实现，并实例化，然后在循环中才能找到我们需要的实现。如果不想用某些实现类，或者某些类实例化很耗时，他也会被载入并实例化了，这就会造成了浪费。
• 获取某个实现类的方式不够灵活，只能通过Iterator形式获取，不能根据某个参数来获取对应的实现类。
• 多个并发多线程使用ServiceLoader类的实例是不安全的。