Java SPI 机制详解

什么是SPI

概念

SPI（Service Provider Interface）是一种服务提供接口，它是 Java 提供的一种扩展机制，可以让第三方服务提供商来扩展框架或应用程序的功能。

字面意思就是：“服务提供者的接口”，我的理解是：专门提供给服务提供者或者扩展框架功能的开发者去使用的一个接口。

SPI 将服务接口和具体的服务实现分离开来，将服务调用方和服务实现者解耦，能够提升程序的扩展性、可维护性。修改或者替换服务实现并不需要修改调用方。

作用

SPI 机制是 Java 中非常重要的一种扩展机制，它可以让应用程序更加灵活和易于扩展，可以让开发者只关注接口定义，而不需要关注具体实现，从而实现松耦合和高内聚的设计。

SPI 机制在很多 Java 框架和应用程序中都得到了广泛的应用，例如 JDBC、JAX-WS、Servlet API 等。

应用场景：

用于在运行时动态地发现和加载服务实现类，通常通过在 META-INF/services 目录下创建对应的配置文件来实现。

在这种方式下，服务提供者需要实现对应的接口或者继承对应的抽象类，并将实现类的全限定名写入到配置文件中，Java 运行时环境会自动加载和调用相应的实现类。

SPI 和 API 有什么区别？

API 和 SPI 都是用于实现模块化和扩展性的机制，但它们的实现方式不同。

• API 是通过接口和类的方式实现的，通常在编译时就已经确定，
• 而 SPI 是通过配置文件和类加载器的方式实现的，通常在运行时动态加载。

SPI（Service Provider Interface）指的是服务提供者接口，是一种用于动态加载和扩展服务的机制，通过定义服务接口、服务提供者接口和加载配置文件的方式，实现了在运行时动态加载服务提供者实现的功能。SPI 主要用于插件化和扩展性方面的应用，例如，Java 中的日志框架、序列化框架和数据库连接池等都使用了 SPI 机制。

API（Application Programming Interface）指的是应用程序接口，是一种规范或约定，用于定义软件模块之间的交互方式。API 定义了一个软件模块提供的功能、输入参数、输出结果和调用方式等信息，其他模块可以通过调用 API 提供的方法来使用这些功能。例如，Java 中的 JDBC API 定义了一系列接口和类，用于连接和操作各种不同类型的数据库。

当实现方提供了接口和实现，我们可以通过调用实现方的接口从而拥有实现方给我们提供的能力，这就是 API ，这种接口和实现都是放在实现方的。（需要使用接口的人直接调用厂家提供的接口）

当接口存在于调用方这边时，就是 SPI ，由接口调用方确定接口规则，然后由不同的厂商去根据这个规则对这个接口进行实现，从而提供服务。(需要使用接口的人定义一个标准让厂家制造)

SPI 示例

假设我们有一个服务接口 HelloService 和一个服务提供者接口 HelloServiceProvider，代码如下所示：

public interface HelloService {
    void sayHello();
}

public interface HelloServiceProvider {
    HelloService getHelloService();
}

我们还有两个服务提供者实现类 HelloServiceAProvider 和 HelloServiceBProvider，代码如下所示：

public class HelloServiceAProvider implements HelloServiceProvider {
    @Override
    public HelloService getHelloService() {
        return new HelloServiceA();
    }
}

public class HelloServiceBProvider implements HelloServiceProvider {
    @Override
    public HelloService getHelloService() {
        return new HelloServiceB();
    }
}

其中，HelloServiceA 和 HelloServiceB 分别是 HelloService 接口的实现类。

我们需要在 META-INF/services 目录下创建一个名为 com.example.HelloServiceProvider 的文件，文件内容为服务提供者实现类的全限定类名，如下所示：

com.example.HelloServiceAProvider
com.example.HelloServiceBProvider

然后，在程序中通过 SPI 机制加载服务提供者实现，代码如下所示：

import java.util.ServiceLoader;

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

在运行程序时，会依次加载 HelloServiceAProvider 和 HelloServiceBProvider，并分别调用它们的 getHelloService() 方法来获取 HelloService 的实现类，然后调用 sayHello() 方法输出相应的信息。

此外，还可以在服务提供者实现类中加入一些输出语句，来加强对 SPI 机制的理解，例如：

public class HelloServiceAProvider implements HelloServiceProvider {
    @Override
    public HelloService getHelloService() {
        System.out.println("Loading HelloServiceAProvider...");
        return new HelloServiceA();
    }
}

这样，在运行程序时，会输出服务提供者实现类的加载信息，帮助理解 SPI 机制的运行原理。

API 示例

以下是一个简单的接口示例，用于实现计算器的加法运算：

public interface Calculator {
    int add(int a, int b);
}

这个接口定义了一个 add() 方法，用于对两个整数进行加法运算并返回结果。

接下来，我们可以编写两个实现类，分别实现加法运算的不同方式：

public class SimpleCalculator implements Calculator {
    @Override
    public int add(int a, int b) {
        return a + b;
    }
}

public class AdvancedCalculator implements Calculator {
    @Override
    public int add(int a, int b) {
        return Math.addExact(a, b);
    }
}

其中，SimpleCalculator 实现了简单的加法运算，而 AdvancedCalculator 则使用了 JDK 提供的 Math.addExact() 方法，能够更加精确地进行加法运算。

最后，我们可以在程序中使用这些实现类，来执行加法运算：

public class Main {
    public static void main(String[] args) {
        Calculator calculator = new SimpleCalculator();
        int result = calculator.add(2, 3);
        System.out.println("SimpleCalculator result: " + result);

        calculator = new AdvancedCalculator();
        result = calculator.add(2, 3);
        System.out.println("AdvancedCalculator result: " + result);
    }
}

在上述代码中，我们首先实例化了一个 SimpleCalculator 对象，并调用其 add() 方法对 2 和 3 进行加法运算，得到结果为 5。接着，我们实例化了一个 AdvancedCalculator 对象，并调用其 add() 方法进行相同的运算，得到结果同样为 5。

与 SPI 机制不同的是，这里的接口实现是在编译时已经确定的，而不是在运行时动态加载的。这种方式适用于比较简单的应用场景，当需要扩展功能时，需要手动编写新的实现类并重新编译程序。