SPI你认识吗

人生有涯，学海无涯

一、SPI是什么

SPI是相对API而言的。

API指的是应用对服务调用方提供的接口，用于提供某种服务、功能，面向的是服务调用方。

SPI指的是应用对服务实现方提供的接口，用于实现某种服务、功能，面向的是服务实现方

二、SPI的使用

2.1、创建服务接口

package com.jw.spi;

public interface Fruit {
    String getName();
}

2.2、创建多个服务实现

package com.jw.spi;

public class Apple implements Fruit {
    @Override
    public String getName() {
        return "apple";
    }
}

package com.jw.spi;

public class Banana implements Fruit {
    @Override
    public String getName() {
        return "Banana";
    }
}

这里的两个服务实现类，针对的是两个服务实现方，一方实现了Apple，另一方实现了Banana。

2.3、创建配置文件

在resource下创建/META-INF/services目录，在services目录下创建以服务接口全限定名为名称的文件：com.jw.spi.Fruit

文件内容为，当前服务实现的服务实现者类的全限定名

com.jw.spi.Apple

2.4、创建测试类

public class Test {

    public static void main(String[] args) {
        ServiceLoader<Fruit> s = ServiceLoader.load(Fruit.class);
        Iterator<Fruit> it = s.iterator();
        while(it.hasNext()){
            System.out.println(it.next().getName());
        }
    }
}

执行结果为：

 apple

三、SPI的实现原理

SPI的实现主要依靠的就是ServiceLoader类。使用该类加载接口类型（例如：Fruit.class）

ServiceLoader<Fruit> s = ServiceLoader.load(Fruit.class);

虽然是一个load方法，但是并没有加载到指定的服务实现类，这里仅仅是对加载服务实现类做一些准备工作：

下面分析一下ServiceLoader类的源码：

public final class ServiceLoader<S>
    implements Iterable<S>
{
    // 扫描目录前缀
    private static final String PREFIX = "META-INF/services/";

    // 被加载的类或接口
    private final Class<S> service;

    // 用于定位、加载和实例化实现方实现的类的类加载器
    private final ClassLoader loader;

    // 上下文对象
    private final AccessControlContext acc;

    // 按照实例化的顺序缓存已经实例化的类
    private LinkedHashMap<String,S> providers = new LinkedHashMap<>();

    // 懒查找迭代器
    private LazyIterator lookupIterator;
    
    
    // 创建ServiceLoader    
    public static <S> ServiceLoader<S> load(Class<S> service) {
        ClassLoader cl = Thread.currentThread().getContextClassLoader();
        return ServiceLoader.load(service, cl);
    }

    public static <S> ServiceLoader<S> load(Class<S> service,
                                            ClassLoader loader)
    {
        return new ServiceLoader<>(service, loader);
    }

   private ServiceLoader(Class<S> svc, ClassLoader cl) {
        // 为service赋值
        service = Objects.requireNonNull(svc, "Service interface cannot be null");
           // 为loader赋值
        loader = (cl == null) ? ClassLoader.getSystemClassLoader() : cl;
           // 为acc赋值
        acc = (System.getSecurityManager() != null) ? AccessController.getContext() : null;
        reload();
    }

    public void reload() {
        // 清空providers缓存
        providers.clear();
        // 为lookupIterator赋值，其实就是创建一个LazyIterator延迟迭代器。
        lookupIterator = new LazyIterator(service, loader);
    }

    // 私有内部类，提供对所有的service的类的加载与实例化
    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;
        }
        
      ....
        
}

然后创建迭代器：Iterator<Fruit> it = s.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;
            return lookupIterator.hasNext();
        }

        public S next() {
            if (knownProviders.hasNext())
                return knownProviders.next().getValue();
            return lookupIterator.next();
        }

        public void remove() {
            throw new UnsupportedOperationException();
        }

    };
}

iterator方法中采用了匿名内部类的方式定义了一个新的迭代器，这个迭代器中每一个方法都是通过调用之前创建好的延迟迭代器lookupIterator来完成的

最后就是进行迭代加载了。

while(it.hasNext()){
    System.out.println(it.next().getName());
}

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);
    }
}

private boolean hasNextService() {
    if (nextName != null) {
        return true;
    }
    if (configs == null) {
        try {
            // 获取目录下所有的类
            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;
}

hasNext方法调用了延迟迭代器的hasNext方法，内部调用了hasNextService方法，在这个方法中就会设法去找到指定名称（META-INF/services/+接口全限定名）的资源文件。并完成读取文件内容的操作。

然后执行it.next()操作，这个又会调用延迟迭代器的对应方法hasNext，内部调用了nextService方法，这个方法主要功能就是加载上面从文件中读取到的全限定名称表示的类。并生成实例，将实例保存到providers中。

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);
    }
}

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中
        providers.put(cn, p);
        return p;
    } catch (Throwable x) {
        fail(service,
             "Provider " + cn + " could not be instantiated",
             x);
    }
    throw new Error();          // This cannot happen
}

四、总结

关于spi的详解到此就结束了，总结下spi能带来的好处：

• 不需要改动源码就可以实现扩展，解耦。
• 实现扩展对原来的代码几乎没有侵入性。
• 只需要添加配置就可以实现扩展，符合开闭原则。