Java SPI技术

背景

面试官： 项目中用到过SLF4J吗？

了不起： 用过，会在相关类上加上@Slf4j注解

面试官： 他底层是如何打日志的呢？

了不起： 运用到了Java的SPI技术

SPI工作原理

实现SPI主要有下面几步：

在类路径下创建一个名为META-INF/services的目录。
在该目录下创建一个以接口全限定名命名的文件，例如com.example.MyInterface。
在这个文件中，列出所有实现该接口的类的全限定名，每个类名占一行。

当Java程序需要使用SPI时，它会通过java.util.ServiceLoader类来加载所有可用的实现。ServiceLoader会扫描类路径下的META-INF/services目录，找到对应的接口文件，并实例化其中列出的实现类。

参考SLF4J，我们自己实现一个日志门面假设我们有一个日志接口Logger：

public interface Logger {
    void info(String message);
    void debug(String message);
}

现在，我们想要为这个接口提供一个实现，例如LogbackLogger：

public class LogbackLogger implements Logger {
    @Override
    public void info(String message) {
        // Logback info logging implementation
    }

    @Override
    public void debug(String message) {
        // Logback debug logging implementation
    }
}

为了使用SPI，我们需要在META-INF/services目录下创建一个名为com.example.Logger的文件，并在其中添加LogbackLogger的全限定名

com.example.LogbackLogger

最后，我们可以通过ServiceLoader来加载所有可用的Logger实现：

ServiceLoader<Logger> serviceLoader = ServiceLoader.load(Logger.class);
for (Logger logger : serviceLoader) {
    logger.info("你好");
    logger.debug("测试Java SPI 机制");
}

运行结果如下

Logback info 打印日志：你好
Logback debug 打印日志：测试 Java SPI 机制

加载策略

当存在多个日志框架实现时，Java SPI会加载所有可用的实现。但是，通常情况下，我们需要根据某种策略来选择一个特定的实现。为了实现这一目标，我们可以采用以下方法：

优先级排序

为每个实现分配一个优先级，并在加载实现时根据优先级进行排序。这可以通过在META-INF/services中的接口文件中为每个实现分配一个权重值来实现。然后，在使用ServiceLoader加载实现时，可以根据权重值对实现进行排序，选择权重最高的实现。例如：

public class LoggerPriorityComparator implements Comparator<Logger> {
    @Override
    public int compare(Logger logger1, Logger logger2) {
        return Integer.compare(logger2.getPriority(), logger1.getPriority());
    }
}

ServiceLoader<Logger> serviceLoader = ServiceLoader.load(Logger.class);
List<Logger> loggers = new ArrayList<>();
for (Logger logger : serviceLoader) {
    loggers.add(logger);
}
loggers.sort(new LoggerPriorityComparator());
Logger selectedLogger = loggers.get(0);

配置文件

在应用的配置文件中指定要使用的日志框架实现。在加载实现时，可以根据配置文件中的设置来选择特定的实现。例如，可以在application.properties文件中添加以下配置：

logger.implementation=com.example.LogbackLogger

然后，在代码中使用以下方法加载指定的实现：

String loggerImplementation = // 从配置文件中读取实现类名
ServiceLoader<Logger> serviceLoader = ServiceLoader.load(Logger.class);
Logger selectedLogger = null;
for (Logger logger : serviceLoader) {
    if (logger.getClass().getName().equals(loggerImplementation)) {
        selectedLogger = logger;
        break;
    }
}

环境变量或系统属性

可以使用环境变量或系统属性来指定要使用的日志框架实现。这种方法类似于使用配置文件，但是更适用于在部署时动态指定实现的场景。例如，可以在启动应用时设置系统属性：

java -Dlogger.implementation=com.example.LogbackLogger -jar myapp.jar

然后，在代码中使用以下方法加载指定的实现

String loggerImplementation = System.getProperty("logger.implementation");
ServiceLoader<Logger> serviceLoader = ServiceLoader.load(Logger.class);
Logger selectedLogger = null;
for (Logger logger : serviceLoader) {
    if (logger.getClass().getName().equals(loggerImplementation)) {
        selectedLogger = logger;
        break;
    }
}

通过以上方法，可以在存在多个日志框架实现时，根据不同的策略来选择使用哪个实现。

SPI技术的优缺点

SPI技术有下面几个优点

解耦：SPI机制将接口和实现分离，使得它们可以独立地进行开发和部署。这样，当需要替换或升级实现时，不需要修改接口或其他依赖于接口的代码。这有助于降低系统的维护成本和复杂性。
扩展性：SPI允许第三方为现有的Java库提供实现，这意味着库的功能可以轻松地进行扩展。开发者可以根据自己的需求为库提供定制的实现，而无需修改库本身。这使得库更具灵活性和可扩展性。
插件化：SPI机制支持动态加载实现，这意味着可以在运行时根据需要加载不同的实现。这为开发插件式应用提供了便利，使得应用可以在运行时根据用户的需求或配置加载不同的功能模块。

任何技术都有缺点，SPI也不例外。

性能开销：SPI机制需要扫描类路径下的META-INF/services目录以查找和加载实现。这可能导致一定程度的性能开销，特别是在类路径较长或实现较多的情况下。为了解决这个问题，可以考虑使用缓存机制来存储已加载的实现，以减少重复扫描和加载的开销。
实例化策略：SPI默认使用无参构造函数来实例化实现类。这意味着所有实现类都必须提供一个无参构造函数。这可能限制了实现类的灵活性，特别是在需要依赖注入或其他初始化逻辑的情况下。为了解决这个问题，可以考虑使用自定义的实例化策略，例如通过工厂方法或依赖注入框架来创建实现类的实例。
版本控制：当存在多个版本的实现时，SPI无法直接区分它们。这可能导致版本冲突或不兼容的问题。为了解决这个问题，可以在实现类中添加版本信息，并在加载实现时根据版本信息进行筛选。另外，可以考虑使用模块化技术（如Java模块系统或OSGi）来管理不同版本的实现。

实例化策略

工厂方法示例

首先，定义一个工厂接口

public interface LoggerFactory {
    Logger createLogger();
}

然后，在实现类中提供一个工厂方法

public class LogbackLogger implements Logger {
    // Logger implementation

    public static class LogbackLoggerFactory implements LoggerFactory {
        @Override
        public Logger createLogger() {
            // 在这里可以执行任何初始化逻辑
            return new LogbackLogger();
        }
    }
}

在META-INF/services中的接口文件中，指定工厂类而不是实现类

com.example.LoggerFactory=com.example.LogbackLogger$LogbackLoggerFactory

最后，在代码中使用ServiceLoader加载工厂类，并通过工厂方法创建实现类的实例：

ServiceLoader<LoggerFactory> serviceLoader = ServiceLoader.load(LoggerFactory.class);
LoggerFactory factory = serviceLoader.iterator().next();
Logger logger = factory.createLogger();

依赖注入示例

在这个示例中，我们将使用Spring框架作为依赖注入容器。首先，定义一个接口和实现类：

public interface Logger {
    void log(String message);
}

@Component
public class LogbackLogger implements Logger {
    // Logger implementation
}

然后，在Spring配置类中，配置ServiceLoader来加载Logger实现：

@Configuration
public class AppConfig {
    @Bean
    public Logger logger() {
        ServiceLoader<Logger> serviceLoader = ServiceLoader.load(Logger.class);
        return serviceLoader.iterator().next();
    }
}

在这个示例中，我们使用了Spring的@Component注解来标记实现类，以便让Spring容器自动扫描和管理它。然后，在配置类中，我们使用ServiceLoader来加载Logger实现，并将其注册为Spring容器中的一个Bean。这样，我们就可以在其他地方使用依赖注入来获取Logger实例，例如：

@Service
public class MyService {
    private final Logger logger;

    public MyService(Logger logger) {
        this.logger = logger;
    }

    public void doSomething() {
        logger.log("Doing something...");
    }
}

版本控制

为了在实现类中添加版本信息，我们可以定义一个接口方法来获取版本信息，然后在实现类中提供具体的版本信息。以下是一个示例：

首先，定义一个带有getVersion方法的接口：

public interface Logger {
    void log(String message);
    String getVersion();
}

然后，在实现类中提供具体的版本信息

public class LogbackLogger implements Logger {
    private static final String VERSION = "1.0.0";

    @Override
    public void log(String message) {
        // Logback logging implementation
    }

    @Override
    public String getVersion() {
        return VERSION;
    }
}

在加载实现时，可以根据版本信息进行筛选。例如，可以选择最新版本的实现：

ServiceLoader<Logger> serviceLoader = ServiceLoader.load(Logger.class);
Logger selectedLogger = null;
String latestVersion = null;
for (Logger logger : serviceLoader) {
    String version = logger.getVersion();
    if (latestVersion == null || version.compareTo(latestVersion) > 0) {
        latestVersion = version;
        selectedLogger = logger;
    }
}

背景

相关概念