SPI(Service Provider Interface)详解-蒲公英云

介绍

SPI 全称为 (Service Provider Interface) ，是JVM内置的一种服务提供发现机制。Java在语言层面为我们提供了一种方便地创建可扩展应用的途径。我们只需要按照SPI的要求，在jar包中进行适当的配置，jvm就会在运行时通过懒加载，帮我们找到所需的服务并加载。如果我们一直不使用某个服务，那么它不会被加载，一定程度上避免了资源的浪费。

1、应用

熟悉JDBC的同学都知道，在jdbc4.0之前，在使用DriverManager获取DB连接之前，我们总是需要通过Class.forName显示的加载驱动（为了执行驱动类的static代码，注册驱动实例对象到DriverManager中），例如：

Connection comm = null;
Statement stmt = null;
try {
    //注册mysql的jdbc驱动
    Class.forName("com.mysql.jdbc.Driver");
    //创建连接
    conn = DriverManagger.getConnection(url,user,pwd);
}

在JDBC4.0开始，这个显式的初始化不再是必选项了，它存在的意义只是为了向上兼容。那么JDBC4.0之后，我们的应用是如何找到对应的驱动呢？答案就是SPI。

2、使用

一个服务(Service)通常指的是已知的接口或者抽象类（SPI并没有强制要求服务必须是interface或abstract class，完全可以将class注册为SPI注册服务）
服务提供方就是对这个接口或者抽象类的实现，按照SPI 标准，在资源路径META-INF/services目录下创建一个文件（文件的命名为该服务接口的全限定名）；内容为实现类的全限定名，每行一个，可以使用#作为注释
将服务的提供代码打包成jar，放到classpath下；

完成以上后，在程序运行时可使用ServiceLoader.load(Class class) api获取到接口服务的所有实现类。SPI底层原理：使用懒加载的方式，在运行时将该服务接口的实现类通过Class.forName的方式加载到JVM中，并做实例初始化。

示例

1）接口服务：

package spi;
public interface Animal {
    void eat();
    void sleep();
}

2）服务实现：

package spi;
public class Dog implements Animal{
    @Override
    public void eat() {
        System.out.println("dog eat...");
    }
    @Override
    public void sleep() {
        System.out.println("dog sleep...");
    }
}

3）SPI配置文件：

在resource下创建META-INf/services目录，然后创建文件spi.Animal，内容：spi.Dog

4）测试代码：

package spi;
import java.util.Iterator;
import java.util.ServiceLoader;
public class SPITest {
    public static void main(String[] args) {
        ServiceLoader<Animal> animals = ServiceLoader.load(Animal.class);
        for (Animal animal : animals) {//增强型for循环等价于下面的iterator迭代
            animal.eat();
            animal.sleep();
        }
        Iterator<Animal> iterator = animals.iterator();
        while(iterator.hasNext()) {
            Animal animal = iterator.next();
            animal.eat();
            animal.sleep();
        }
    }
}

说明：本示例是在一个工程下演示的，可以将Animal接口打包成animal.jar，Dog实现工程中实现引入animal.jar，并且配置META-INF文件，在打包成dog.jar。最后创建一个test工程，引入dog.jar即可进行测试。

源码解读

1、创建ServiceLoader实例：

public final class ServiceLoader<S> implements Iterable<S> {
    //...
    //重新load指定serivice的实现。通过LazyIterator实现懒加载。
    public void reload() {
        providers.clear();//是个LinkedHashMap 类型
        lookupIterator = new LazyIterator(service, loader);
    }
    //私有ServiceLoader构造函数，须通过ServiceLoader.load(Class<?>)静态方法创建ServiceLoader实例
    private ServiceLoader(Class<S> svc, ClassLoader cl) {
        service = Objects.requireNonNull(svc, "Service interface cannot be null");
        loader = (cl == null) ? ClassLoader.getSystemClassLoader() : cl;
        acc = (System.getSecurityManager() != null) ? AccessController.getContext() : null;
        reload();
    }
    //构建ServiceLoader实例
    public static <S> ServiceLoader<S> load(Class<S> service,
            ClassLoader loader)
    {
        return new ServiceLoader<>(service, loader);
    }
    //通过service的class创建ServiceLoader实例，默认使用上下文classloader
    public static <S> ServiceLoader<S> load(Class<S> service) {
        ClassLoader cl = Thread.currentThread().getContextClassLoader();
        return ServiceLoader.load(service, cl);
    }
}

说明：

通过load静态方法创建ServiceLoader实例，构造完ServiceLoader后，并不会立刻扫描当前进程中的服务实现，而是创建一个LazyIterator懒加载迭代器，在实际使用时采取扫描服务实现类并加载；
默认使用当前线程的上下文classLoader，后面会用该classLoader加载服务实现类；

2、ServiceLoader的遍历：

ServiceLoader实现Iterable<?>接口，调用load方法（创建ServiceLoader实例）返回了一个服务类型的迭代器，接下来使用iterator（或者增强型for循环）遍历ServiceLoader实例时，才会真正的扫描、加载对应的服务实现类。

public final class ServiceLoader<S> implements Iterable<S> {
    //...
    //缓存的service provider，按照初始化顺序排列。
    private LinkedHashMap<String,S> providers = new LinkedHashMap<>();
    //当前的LazyIterator迭代器指针，服务懒加载迭代器
    private LazyIterator lookupIterator;
    //增强型for循环或者直接iterator()方法遍历ServiceLoader
    public Iterator<S> iterator() {
        return new Iterator<S>() {
            //创建Iterator迭代器时的ServiceLoader.providers快照，
            //因此在首次迭代时，iterator总是会通过LazyIterator进行懒加载
            Iterator<Map.Entry<String,S>> knownProviders
                = providers.entrySet().iterator();
            public boolean hasNext() {
                // 如果已经扫描过，则对providers进行迭代；
                if (knownProviders.hasNext())
                    return true;
                // 如果没有扫描过，则通过lookupIterator进行扫描和懒加载
                return lookupIterator.hasNext();
            }
            public S next() {
                // 如果已经扫描过，则对providers进行迭代；
                if (knownProviders.hasNext())
                    return knownProviders.next().getValue();
                // 如果没有扫描过，则通过lookupIterator进行扫描和懒加载
                return lookupIterator.next();
            }
            public void remove() {
                throw new UnsupportedOperationException();
            }
        };
    }
}

说明：

首次迭代时，因为ServiceLoader.providers中没有任何缓存，总是会通过LazyIterator进行懒加载，并将service实现的全限定名与加载的service实例作为key-value缓存到ServiceLoader.providers中。
之后再进行迭代时，总是在ServiceLoader.providers中进行。

3、懒加载迭代器LazyIterator：

public final class ServiceLoader<S> implements Iterable<S> {
    private static final String PREFIX = "META-INF/services/";
    //...
    private class LazyIterator implements Iterator<S> {//内部类
        Class<S> service;
        ClassLoader loader;
        Enumeration<URL> configs = null;
        Iterator<String> pending = null;//配置文件中的服务实现类的迭代器(每行一个)
        String nextName = null;
        private LazyIterator(Class<S> service, ClassLoader loader) {
            this.service = service; this.loader = loader;
        }
        private boolean hasNextService() {
            if (nextName != null) {
                return true;
            }
            if (configs == null) {//首次迭代时
                try {
                    String fullName = PREFIX + service.getName();
                    if (loader == null)//通过ClassLoader.getResources()获得资源URL集合
                        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;
        }
        private S nextService() {
            if (!hasNextService()) throw new NoSuchElementException();
            String cn = nextName;
            try {
                Class<?> c = Class.forName(cn, false, loader);
                S p = service.cast(c.newInstance());
                providers.put(cn, p);
                return p;
            } catch (ClassNotFoundException x) {
                fail(service,"Provider " + cn + " not found");
            }
            throw new Error();          // This cannot happen
        }
        public boolean hasNext() {
            if (acc == null) {
                return hasNextService();
            } else {
                PrivilegedAction<Boolean> action = new PrivilegedAction<Boolean>() {
                    public Boolean run() { return hasNextService(); }
                };
                return AccessController.doPrivileged(action, acc);
            }
        }
        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);
            }
        }
        public void remove() {
            throw new UnsupportedOperationException();
        }
    }
}

说明：

hasNextService方法实现了资源的查找，通过classLoader的getResources方法实现；
nextService方法实现了服务实现类的实例化，通过Class.forName实现；
LazyIterator中除了hasNextService、nextService方法外还有Iterator的hasNext、next方法，其内部调用了hasNextService和nextService。