Java spi 扩展 java spi接口

转载

mob64ca140c75c7 2023-11-26 11:26:11

文章标签 Java spi 扩展 SPI 实例源码原理 文章分类 Java 后端开发

前言

偶然间发现一个问题，工程中同时有H2*.jar，sqlite*.jar，但代码中只使用到了h2数据库，可是发现org.sqlite.JDBC类被加载了，并且org.sqlite.JDBC的静态代码块执行了！这是怎么做到的呢？还好之前了解过spi，发现这是通过SPI机制实现的。

1 SPI是什么? 和API有啥区别呢？

API（Application Programming Interface，应用程序接口），SPI（Service Provider Interface，服务提供接口）

API是应用程序内部接口，而SPI是给外部（第三方）服务暴露的接口。

SPI本质上提供了一种服务发现机制，通过某个接口来查找外部实现了该接口的服务，配合ServiceLoader等库，可以实现服务的自动装载，类似于Spring的IOC，本质上都是解耦，面向接口编程。

看着迷糊？来个例子看看。

2 举个栗子

场景：我们需要一个告警服务，但服务的实现者并不存在于本工程内。我们在外部提供syslog和kafka两种方式实现告警服务。

定义一个通用告警接口：

/**
 * 告警APi
 * @author chaozai
 * @date 2019年4月17日
 *
 */
public interface WarningAPI {
    /**
     * 发送告警消息
     */
    void sendWarningMsg(String msg);
    
}

两个外部告警实现：

public class SyslogWarningAPI implements WarningAPI{

    @Override
    public void sendWarningMsg(String msg) {
	System.out.println("use syslog send warning msg : "+msg);
    }

}

public class KafkaWarningAPI implements WarningAPI{

    @Override
    public void sendWarningMsg(String msg) {
	System.out.println("use kafka send warning msg : "+msg);
    }

}

SPI配置（关键）：

src(java工程)或者src\main\resources下创建META-INF/services文件夹，在该文件夹下创建spi.WarningAPI（接口的全限定名：包+类名）文件，文件内容为服务的全限定名：

spi.SyslogWarningAPI
spi.KafkaWarningAPI

测试程序：

/**
 * SPI测试
 * @author chaozai
 * @date 2019年4月17日
 *
 */
public class SPITest {
    
    public static void main(String[] args) {
	ServiceLoader<WarningAPI> loadedAPIs = ServiceLoader.load(WarningAPI.class);
        Iterator<WarningAPI> apiIterator = loadedAPIs.iterator();
        try{
            while(apiIterator.hasNext()) {
        	WarningAPI warningAPI = apiIterator.next();
        	warningAPI.sendWarningMsg("spi test");
            }
        } catch(Throwable t) {
            t.printStackTrace();
        }
    }
}

测试结果：

use syslog send warning msg : spi test
use kafka send warning msg : spi test

使用总结：

1、当服务提供者提供了接口的一种具体实现后，在jar包的META-INF/services目录下创建一个以“接口全限定名”为命名的文件，内容为实现类的全限定名；
2、接口实现类所在的jar包放在主程序的classpath中；
3、主程序通过java.util.ServiceLoder动态装载实现模块，它通过扫描所有META-INF/services目录下的配置文件找到实现类的全限定名，把类加载到JVM；
4、SPI的实现类必须有一个无参的构造方法；

ServiceLoader提供了服务发现，加载，遍历，初始化等功能，下面简略的看看源码吧。

3 ServiceLoader源码

成员变量：被加载的服务接口类；类加载器；权限控制器；缓存服务实例；懒加载器（使用时才去遍历文件哦）；

public final class ServiceLoader<S>
    implements Iterable<S>
{
    //查找前缀，在遍历过程中使用
    private static final String PREFIX = "META-INF/services/";

    // The class or interface representing the service being loaded
    private final Class<S> service;

    // The class loader used to locate, load, and instantiate providers
    private final ClassLoader loader;

    // The access control context taken when the ServiceLoader is created
    private final AccessControlContext acc;

    // Cached providers, in instantiation order
    private LinkedHashMap<String,S> providers = new LinkedHashMap<>();

    // The current lazy-lookup iterator
    private LazyIterator lookupIterator;

第一步：加载

public static <S> ServiceLoader<S> load(Class<S> service) {
    //上下文的类加载器，一般为SystemClassloader
	ClassLoader cl = Thread.currentThread().getContextClassLoader();
	return ServiceLoader.load(service, cl);
}
public static <S> ServiceLoader<S> load(Class<S> service,
				    ClassLoader loader)
{
    //创建ServiceLoader对象
	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);
}

发现：仅仅是初始化了各个成员变量

第二步：得到遍历器

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

	};
}

第三步：查找服务

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

第四步：获取服务对象

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
}