聊聊Java SPI机制

SPI简介

SPI（Service Provider Interface）直译过来的意思就是服务提供接口，它并非是一种新技术，而是面向接口编程的重要理念。OOP世界中，老生常谈的是面向接口编程，它可以实现接口的定义与实现解耦合，提高代码的灵活性，实现可拔插式编程。

常用的开源框架SLFJ、数据库驱动等的实现中都有SPI机制，深入理解SPI机制对于理解三方框架的基本原理会有帮助，基于SPI机制，我们也可以自己设计扩展点，更加灵活的支撑多变的业务场景。

• 接口与实现分离 SPI机制的重要作用就是解耦合，提高灵活性和扩展性，服务调用方对于接口实现无感知，接口实现类可以基于配置文件实现对调用方无感知的平滑转换，如上图所示（图片来源于网络），调用方调用接口时，实现类可以是A或B，根据配置动态选择，接口定义和实现类分离，可以有效解耦合，若是A、B服务不满足需求，可以重新定义实现类C,对于调用方无需修改，直接新增实现类即可，满足向修改关闭，向扩展开放的OOP原则。
• SPI与API区别
  • API 概念上更接近于实现方、大多数情况下与实现方处于同一包中，API常见于日常开发中，比如提供给各种端调用的服务端API、API是接口定义，实现逻辑存在于接口实现类中。
  • SPI 概念上更依赖调用方，实现类常存在于独立的包中，例如SLFJ的各种日志实现框架，SLFJ定义了日志标准，可以根据配置加载不同的日志实现类。

举个例子

假设产品提出一个文本搜索需求，业务初期搜索基于数据库即可，随着业务发展，需要支持ES的搜索，日后甚至需要支持MongoDB等非关系型数据库的搜索，如何设计实现？ 需求其实很简单，需要满足基本的文本搜索需求，未来业务发展能灵活支持不同数据源的诉求，实现对调用方无感知的可拔插替换，利用SPI机制很容易满足此产品需求。

• 定义接口

  首先定义搜索的接口，为简单起见，入参为关键词key，返回值为匹配的搜索结果，具体定义如下：

//省略依赖包导入，下同
public interface Search {
    public List<String> search(String keyword);   
}

• 具体实现类

//基于数据库的搜索
@Slf4j
public class DatabaseSearchImpl implements Search {
    @Override
    public List<String> search(String keyword) {
        log.info("数据库搜索，关键词:{}", keyword);
        return new ArrayList<>();
    }
}

//基于ElasticSearch搜索
@Slf4j
public class ESSearchImpl implements Search {
    @Override
    public List<String> search(String keyword) {
        log.info("ElasticSearch搜索，关键词:{}", keyword);
        return new ArrayList<>();
    }
}

• 配置文件

• 使用方式

@Slf4j
public class SPITest {
    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.search("hello world");
        }
    }
}

通过定义实现类及配置文件，可以实现实现类的动态扩展，其中需要在classpath:/META-INF/文件目录下创建文件并声明实现类。

应用场景

• JDBC加载数据库驱动 DriverManager是数据库驱动管理类,基于SPI机制可以记载不同的数据库驱动，实现可拔插，通过分析部分源码，帮助进一步理解SPI机制。我们可以看到DriverManager内部通过ServiceLoader加载数据库驱动。

//静态代码块加载数据库驱动
static {
    loadInitialDrivers();
    println("JDBC DriverManager initialized");
}
//加载数据库驱动
private static void loadInitialDrivers() {
    String drivers;
    try {
        drivers = AccessController.doPrivileged(new PrivilegedAction<String>() {
            public String run() {
                return System.getProperty("jdbc.drivers");
            }
        });
    } catch (Exception ex) {
        drivers = null;
    }

    AccessController.doPrivileged(new PrivilegedAction<Void>() {
        public Void run() {
            //ServiceLoader记载驱动库驱动
            ServiceLoader<Driver> loadedDrivers = ServiceLoader.load(Driver.class);
            //迭代获取加载的驱动
            Iterator<Driver> driversIterator = loadedDrivers.iterator();      
            try{
                while(driversIterator.hasNext()) {
                    driversIterator.next();
                }
            } catch(Throwable t) {
            }
            return null;
        }
    });

    println("DriverManager.initialize: jdbc.drivers = " + drivers);

    if (drivers == null || drivers.equals("")) {
        return;
    }
    String[] driversList = drivers.split(":");
    println("number of Drivers:" + driversList.length);
    for (String aDriver : driversList) {
        try {
            println("DriverManager.Initialize: loading " + aDriver);
            Class.forName(aDriver, true,
                    ClassLoader.getSystemClassLoader());
        } catch (Exception ex) {
            println("DriverManager.Initialize: load failed: " + ex);
        }
    }
}

• 配置文件 由此可见，基于SPI机制，DriverManager可以可拔插式的切换不同的数据库驱动类，实现灵活的扩展，当然除了加载数据库驱动以外，日志框架、Dubbo等设计中也常常见到SPI机制等身影，限于篇幅，不展开论述。
• SLFJ日志实现
• Dubbo服务扩展点
• 需要扩展的业务场景
• ...

实现原理

以上我们根据一个简单的示例及加载JDBC数据库驱动的应用中了解到SPI机制，发现它都用到了ServiceLoader类，它是SPI机制实现的核心，我们可以通过分析部分源码，揭开的神秘面纱，深入理解SPI机制的实现原理。

public final class ServiceLoader<S>
    implements Iterable<S>
{

    //查找配置文件的目录
    private static final String PREFIX = "META-INF/services/";

    //表示要被加载的服务的类或接口
    private final Class<S> service;

    //这个ClassLoader用来定位，加载，实例化服务提供者
    private final ClassLoader loader;

    // 访问控制上下文
    private final AccessControlContext acc;

    // 缓存已经被实例化的服务提供者，按照实例化的顺序存储
    private LinkedHashMap<String,S> providers = new LinkedHashMap<>();

    // 迭代器
    private LazyIterator lookupIterator;
    
    //重新加载，就相当于重新创建ServiceLoader了，用于新的服务提供者安装到正在运行的Java虚拟机中的情况。
    public void reload() {
        //清空缓存中所有已实例化的服务提供者
        providers.clear();
        //新建一个迭代器，该迭代器会从头查找和实例化服务提供者
        lookupIterator = new LazyIterator(service, loader);
    }

    //私有构造器
    //使用指定的类加载器和服务创建服务加载器
    //如果没有指定类加载器，使用系统类加载器，就是应用类加载器。
    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();
    }

 ....
    //解析配置文件，解析指定的url配置文件
    //使用parseLine方法进行解析，未被实例化的服务提供者会被保存到缓存中去
    private Iterator<String> parse(Class<?> service, URL u)
        throws ServiceConfigurationError
    {
        InputStream in = null;
        BufferedReader r = null;
        ArrayList<String> names = new ArrayList<>();
        try {
            in = u.openStream();
            r = new BufferedReader(new InputStreamReader(in, "utf-8"));
            int lc = 1;
            while ((lc = parseLine(service, u, r, lc, names)) >= 0);
        }
        return names.iterator();
    }

    //服务提供者查找的迭代器
    private class LazyIterator
        implements Iterator<S>
    {

        Class<S> service;//服务提供者接口
        ClassLoader loader;//类加载器
        Enumeration<URL> configs = null;//保存实现类的url
        Iterator<String> pending = null;//保存实现类的全名
        String nextName = null;//迭代器中下一个实现类的全名

        private LazyIterator(Class<S> service, ClassLoader loader) {
            this.service = service;
            this.loader = loader;
        }
        ...
        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 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();
            }

        };
    }

    //为指定的服务使用指定的类加载器来创建一个ServiceLoader
    public static <S> ServiceLoader<S> load(Class<S> service,
                                            ClassLoader loader)
    {
        return new ServiceLoader<>(service, loader);
    }

    //使用线程上下文的类加载器来创建ServiceLoader
    public static <S> ServiceLoader<S> load(Class<S> service) {
        ClassLoader cl = Thread.currentThread().getContextClassLoader();
        return ServiceLoader.load(service, cl);
    }

    //使用扩展类加载器为指定的服务创建ServiceLoader
    //只能找到并加载已经安装到当前Java虚拟机中的服务提供者，应用程序类路径中的服务提供者将被忽略
    public static <S> ServiceLoader<S> loadInstalled(Class<S> service) {
        ClassLoader cl = ClassLoader.getSystemClassLoader();
        ClassLoader prev = null;
        while (cl != null) {
            prev = cl;
            cl = cl.getParent();
        }
        return ServiceLoader.load(service, prev);
    }

    public String toString() {
        return "java.util.ServiceLoader[" + service.getName() + "]";
    }

}

首先，ServiceLoader实现了Iterable接口，所以它有迭代器的属性，主要是实现了迭代器的hasNext和next方法。调用lookupIterator的相应hasNext和next方法，lookupIterator是懒加载迭代器。

其次，LazyIterator中的hasNext方法，静态变量PREFIX就是”META-INF/services/”目录，这也就是为什么需要在classpath下的META-INF/services/目录里创建一个以服务接口命名的文件。

最后，通过反射方法Class.forName()加载类对象，并用newInstance方法将类实例化，并把实例化后的类缓存到providers对象中，(LinkedHashMap<String,S>）然后返回实例对象。

所以我们可以看到ServiceLoader不是实例化以后，就去读取配置文件中的具体实现并进行实例化。而是等到使用迭代器去遍历的时候，才会加载对应的配置文件去解析，调用hasNext方法的时候会去加载配置文件进行解析，调用next方法的时候进行实例化并缓存。 所有的配置文件只会加载一次，服务提供者也只会被实例化一次，重新加载配置文件可使用reload方法。

使用方式

SPI机制是基于接口的编程，也是基于约定的编程，通过创建目录，定义实现类，并利用ServiceLoader.load完成加载，具体如下图：

总结

• 优势

  灵活高扩展，可拔插，满足OOP原则

• 缺点

  • ServiceLoader非线程安全
  • 不能按需加载，需要遍历所有实现类并实例化，效率地下
  • 只能根据迭代遍历配置文件获取实现类，不支持根据参数获取实现类，相对不够灵活

参考鸣谢

无声明的拿来主义，本质上属于剽窃。 本文仅作个人学习积累的产物，期间参考了2篇博客，为尊重原创，贴出原文链接，并在此感谢作者。

博客原文如下：

Java常用机制 - SPI机制详解

Java SPI思想梳理