转载

深入理解ServiceLoader类与SPI机制

最近我们自己在重构项目，系统为了符合82原则（希望是80%的业务能通过穷举的方式固定下来，只有20%的允许特殊的定义），那么在固定一些标准流程以后，比如我们放大了原子服务的能力，当放大原子服务能力的时候，你就会发现，虽然抽象上看做的事情是一个意思，但是到实际去实现的时候发现还是各不相同。

在这里为了解决一个实现不同，但流程相同的问题，以及团队协作上的问题。我们引入的SPI (Service Provider Interface) 。

使用案例

通常情况下，使用ServiceLoader来实现SPI机制。 SPI 全称为 (Service Provider Interface) ，是JDK内置的一种服务提供发现机制。SPI是一种动态替换发现的机制，比如有个接口，想运行时动态的给它添加实现，你只需要添加一个实现。

SPI机制可以归纳为如下的图：

深入理解ServiceLoader类与SPI机制

如果大家看过源代码或者说看过一些博客文章大概都清楚，在一些开源项目中大量的使用了SPI的方式，比如： mysql-connector-java ， dubbo 等。

我们大概看眼MySQL的一个SPI实现

深入理解ServiceLoader类与SPI机制

JDBC中的接口即为： java.sql.Driver

SPI机制的实现核心类为： java.util.ServiceLoader

Provider则为： com.mysql.jdbc.Driver

com.mysql.jdbc.Driver  
com.mysql.fabric.jdbc.FabricMySQLDriver

简单写个SPI

代码部分，接口与实现类定义：

package com.vernon.test.spi;

/**
 * Created with vernon-test
 *
 * @description:
 * @author: chenyuan
 * @date: 2020/4/2
 * @time: 11:08 上午
 */
public interface IRepository {  
    void save(String data);
}

package com.vernon.test.spi.impl;

import com.vernon.test.spi.IRepository;

/**
 * Created with vernon-test
 *
 * @description:
 * @author: chenyuan
 * @date: 2020/4/2
 * @time: 11:09 上午
 */
public class MongoRepository implements IRepository {  
    @Override
    public void save(String data) {
        System.out.println("Save " + data + " to Mongo");
    }
}

package com.vernon.test.spi.impl;

import com.vernon.test.spi.IRepository;

/**
 * Created with vernon-test
 *
 * @description:
 * @author: chenyuan
 * @date: 2020/4/2
 * @time: 11:08 上午
 */
public class MysqlRepository implements IRepository {

    @Override
    public void save(String data) {
        System.out.println("Save " + data + " to Mysql");
    }

}

调用函数定义：

package com.vernon.test.spi;

import java.util.Iterator;  
import java.util.ServiceLoader;

/**
 * Created with vernon-test
 *
 * @description:
 * @author: chenyuan
 * @date: 2020/4/2
 * @time: 11:12 上午
 */
public class SPIMain {

    public static void main(String[] args) {
        ServiceLoader<IRepository> serviceLoader = ServiceLoader.load(IRepository.class);
        Iterator<IRepository> it = serviceLoader.iterator();
        while (it != null && it.hasNext()) {
            IRepository demoService = it.next();
            System.out.println("class:" + demoService.getClass().getName());
            demoService.save("tom");
        }
    }

}

执行结果：

Connected to the target VM, address: '127.0.0.1:58517', transport: 'socket'  
class:com.vernon.test.spi.impl.MongoRepository  
Save tom to Mongo  
class:com.vernon.test.spi.impl.MysqlRepository  
Save tom to Mysql  
Disconnected from the target VM, address: '127.0.0.1:58517', transport: 'socket'

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 = Objects.requireNonNull(svc, "Service interface cannot be null");
    loader = (cl == null) ? ClassLoader.getSystemClassLoader() : cl;
    acc = (System.getSecurityManager() != null) ? AccessController.getContext() : null;
    reload();
}

public void reload() {  
    providers.clear();
    lookupIterator = new LazyIterator(service, loader);
}

SercviceLoader的初始化跑完如上代码就结束了。但是实际上联系待实现接口和实现接口的类之间的关系并不只是在构造ServiceLoader类的过程中完成的，而是在迭代器的方法 hasNext() 中实现的。

动态调用的实现

在使用案例中写的forEach语句内部逻辑就是迭代器，迭代器的重要方法就是 hasNext() ：

ServiceLoader是一个实现了接口Iterable接口的类。

hasNext() 方法的源代码：

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

抛出复杂的确保安全的操作，可以将上述代码看作就是调用了方法： hasNextService .

hasNextService() 方法的源代码：

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

上述代码中比较重要的代码块是：

String fullName = PREFIX + service.getName();  
            if (loader == null)
                configs = ClassLoader.getSystemResources(fullName);

此处PREFIX（前缀）是一个常量字符串(用于规定配置文件放置的目录，使用相对路径，说明其上层目录为以项目名为名的文件夹)：

private static final String PREFIX = "META-INF/services/";

那么fullName会被赋值为： META-INF/services/com.vernon.test.spi.IRepository

然后调用方法 getSystemResources 或 getResources 将fullName参数视作为URL，返回配置文件的URL集合。

pending = parse(service, configs.nextElement());

parse 方法是凭借参数1：接口的Class对象和参数2：配置文件的URL来解析配置文件，返回值是含有配置文件里面的内容，也就是实现类的全名（包名+类名）字符串的迭代器；

最后调用下面的代码，得到下面要加载的类的完成类路径字符串，相对路径。在使用案例中，此值就可以为：

com.vernon.test.spi.impl.MongoRepository  
com.vernon.test.spi.impl.MysqlRepository

这仅仅是迭代器判断是否还有下一个迭代元素的方法，而获取每轮迭代元素的方法为： nextService() 方法。

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