详解 Java 实践 SPI 机制及浅析源码

什么是 SPI 机制

SPI（Service Provider Interface）即服务提供者接口，是一种动态替换服务实现的机制。在 SPI 机制中，服务接口的实现必须和接口分离，并通过配置文件声明其实现类。

如何使用 SPI 机制

Java SPI 机制基于 Java 的类加载机制实现。以 java.util.ServiceLoader 为例，Java SPI 主要涉及以下三个组件：

Service Interface（服务接口）：一个或多个接口，其具体实现类通过 SPI 机制被动态加载；
Service Provider Interface（服务提供者接口）：标准接口，揭示具体服务实现的方法；
Service Provider（服务提供者）：服务提供者实现，必须实现服务提供者接口。

使用 Java SPI 机制大致的流程如下：

定义服务接口；
编写服务实现类，并实现服务提供者接口；
将服务实现类注册到 META-INF/services/{serviceInterface} 的配置文件中；
使用 java.util.ServiceLoader 加载本地注册的服务实现。

具体示例代码如下：

定义服务接口

public interface HelloService {
    void sayHello(String name);
}

定义服务实现类

public class HelloServiceImpl implements HelloService {
    @Override
    public void sayHello(String name) {
        System.out.println("Hello " + name);
    }
}

定义服务提供者接口

public interface HelloServiceProvider {
    HelloService getHelloService();
}

实现服务提供者接口

public class DefaultHelloServiceProvider implements HelloServiceProvider {
    @Override
    public HelloService getHelloService() {
        return new HelloServiceImpl();
    }
}

注册服务实现类

在项目的 src/main/resources/META-INF/services/ 目录下创建 com.example.spi.HelloServiceProvider 文件，内容如下：

com.example.spi.DefaultHelloServiceProvider

加载服务实现类

public class App {
    public static void main(String[] args) {
        ServiceLoader<HelloServiceProvider> loaders = ServiceLoader.load(HelloServiceProvider.class);
        for (HelloServiceProvider loader : loaders) {
            HelloService service = loader.getHelloService();
            service.sayHello("world");
        }
    }
}

Java SPI 源码浅析

Java SPI 机制是基于服务接口的类加载机制实现的。在 Java 中，一个类的加载过程主要分为三个阶段：加载，链接和初始化。

在加载阶段，类加载器通过获取目标字节码并生成 Class 对象。链接阶段主要包括如下三个步骤：

校验：确保 Class 文件的字节流符合 Java 虚拟机规范；
准备：为静态成员变量分配内存并设置默认值；
解析：将符号引用替换为直接引用。

初始化阶段即为执行静态代码块，并初始化静态成员变量。Java SPI 在加载服务实现类时，主要使用到类加载机制的链接机制，具体来说，就是在 SPI 机制中，java.util.ServiceLoader 加载到具体的服务实现类时，通过 Class.forName() 方法加载类，并执行类加载器的链接操作。

同样以 java.util.ServiceLoader 为例，其源码如下：

public final class ServiceLoader<S> implements Iterable<S> {
    private final Class<S> service;

    ...

    private ServiceLoader(Class<S> svc) {
        service = Objects.requireNonNull(svc, "Service interface cannot be null");
        ClassLoader cl = Thread.currentThread().getContextClassLoader();
        if (cl == null) {
            cl = ClassLoader.getSystemClassLoader();
        }
        acc = SecurityManager? acc = SecurityManager.getStackAccessControlContext(): null;
        this.loader = new LazyIterator(service, cl);
    }

    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, Objects.requireNonNull(loader, "ClassLoader cannot be null"));
    }

}

其中，Class.forName() 方法的具体实现代码如下：

public static Class<?> forName(String className, boolean initialize,
                               ClassLoader loader)
        throws ClassNotFoundException {
    Class<?> clazz;
    if (!checkName(className))
        throw new ClassNotFoundException(className);
    try {
        if (loader == null) {
            clazz = Class.forName(className, initialize, ClassLoader.getSystemClassLoader());
        } else {
            clazz = loader.loadClass(className);
        }
    } catch (ClassNotFoundException e) {
        //如果指定的类还没加载，并且有父类加载器，再去父类加载器中查找
        Class<?> c = null;
        if (parent != null) {
            c = parent.loadClass(name, false);
        } else {
            c = findBootstrapClassOrNull(name);
        }
        if (c != null) {
            //如果在父类加载器中找到此类，就使用父类加载器的定义
            clazz = c;
        } else {
            //否则，抛出找不到类的异常
            throw new ClassNotFoundException(name);
        }
    }
    return clazz;
}

从源码可以看出，Java SPI 的实现主要依靠 Java 的类加载机制和反射机制。其中，java.util.ServiceLoader 类的 LazyIterator 内部类通过迭代器模式动态加载服务实现类，其中涉及到类加载、反射等技术。