Java SPI案例

本文目录导读：

1. 什么是Java SPI
2. 基础案例
3. 进阶案例：数据库连接池SPI
4. 带优先级的SPI实现
5. 案例：日志插件系统
6. Spring Boot中的SPI使用
7. 完整示例：支付系统
8. 注意事项

我来为你详细介绍Java SPI（Service Provider Interface）的案例。

什么是Java SPI

SPI（Service Provider Interface）是Java提供的一种服务发现机制,允许服务提供者在运行时动态地发现和加载实现类。

基础案例

定义SPI接口

// LogService.java
public interface LogService {
    void log(String message);
    String getType();
}

创建具体实现

// FileLogServiceImpl.java
public class FileLogServiceImpl implements LogService {
    @Override
    public void log(String message) {
        System.out.println("[文件日志] " + message);
    }
    @Override
    public String getType() {
        return "file";
    }
}
// DatabaseLogServiceImpl.java
public class DatabaseLogServiceImpl implements LogService {
    @Override
    public void log(String message) {
        System.out.println("[数据库日志] " + message);
    }
    @Override
    public String getType() {
        return "database";
    }
}

创建配置文件

在 src/main/resources/META-INF/services/ 目录下创建文件 com.example.LogService（文件名必须是接口的完全限定名）

com.example.spi.FileLogServiceImpl
com.example.spi.DatabaseLogServiceImpl

使用SPI加载服务

// SPIDemo.java
import java.util.ServiceLoader;
public class SPIDemo {
    public static void main(String[] args) {
        ServiceLoader<LogService> serviceLoader = ServiceLoader.load(LogService.class);
        // 遍历所有实现
        for (LogService logService : serviceLoader) {
            System.out.println("发现服务: " + logService.getType());
            logService.log("测试日志");
            System.out.println("--------------");
        }
    }
}

进阶案例：数据库连接池SPI

实际项目中常用SPI实现数据库驱动加载：

// DatabaseProvider.java - SPI接口
public interface DatabaseProvider {
    Connection getConnection();
    String getDriverName();
    String getUrl();
}
// MySQLProvider.java - MySQL实现
public class MySQLProvider implements DatabaseProvider {
    @Override
    public Connection getConnection() {
        System.out.println("连接到MySQL数据库...");
        return null;
    }
    @Override
    public String getDriverName() {
        return "MySQL Driver";
    }
    @Override
    public String getUrl() {
        return "jdbc:mysql://localhost:3306/test";
    }
}
// PostgreSQLProvider.java - PostgreSQL实现
public class PostgreSQLProvider implements DatabaseProvider {
    @Override
    public Connection getConnection() {
        System.out.println("连接到PostgreSQL数据库...");
        return null;
    }
    @Override
    public String getDriverName() {
        return "PostgreSQL Driver";
    }
    @Override
    public String getUrl() {
        return "jdbc:postgresql://localhost:5432/test";
    }
}
// 使用SPI加载数据库提供者
public class DatabaseManager {
    public static DatabaseProvider getProvider(String driverName) {
        ServiceLoader<DatabaseProvider> loader = ServiceLoader.load(DatabaseProvider.class);
        for (DatabaseProvider provider : loader) {
            if (provider.getDriverName().equals(driverName)) {
                return provider;
            }
        }
        return null;
    }
}

带优先级的SPI实现

// PriorityService.java
public interface PriorityService {
    int getPriority();
    void execute();
}
// 支持优先级排序的SPI加载器
public class PriorityServiceLoader {
    public static List<PriorityService> loadSorted() {
        List<PriorityService> services = new ArrayList<>();
        ServiceLoader<PriorityService> loader = ServiceLoader.load(PriorityService.class);
        for (PriorityService service : loader) {
            services.add(service);
        }
        // 按优先级排序
        services.sort((s1, s2) -> Integer.compare(s2.getPriority(), s1.getPriority()));
        return services;
    }
}

案例：日志插件系统

// LoggerPlugin.java - 日志插件接口
public interface LoggerPlugin {
    void debug(String message);
    void info(String message);
    void error(String message);
    boolean isEnabled();
}
// ConsoleLoggerPlugin.java - 控制台日志插件
public class ConsoleLoggerPlugin implements LoggerPlugin {
    @Override
    public void debug(String message) {
        if (isEnabled()) {
            System.out.println("DEBUG: " + message);
        }
    }
    @Override
    public void info(String message) {
        if (isEnabled()) {
            System.out.println("INFO: " + message);
        }
    }
    @Override
    public void error(String message) {
        if (isEnabled()) {
            System.err.println("ERROR: " + message);
        }
    }
    @Override
    public boolean isEnabled() {
        return true;
    }
}
// FileLoggerPlugin.java - 文件日志插件
public class FileLoggerPlugin implements LoggerPlugin {
    private boolean enabled = true;
    @Override
    public void debug(String message) {
        // 写入文件
        writeToFile("DEBUG: " + message);
    }
    @Override
    public void info(String message) {
        writeToFile("INFO: " + message);
    }
    @Override
    public void error(String message) {
        writeToFile("ERROR: " + message);
    }
    @Override
    public boolean isEnabled() {
        return enabled;
    }
    private void writeToFile(String content) {
        System.out.println("[写入文件] " + content);
    }
}

Spring Boot中的SPI使用

// 自定义Spring Boot自动配置
@Configuration
public class CustomAutoConfiguration {
    @Bean
    @ConditionalOnMissingBean
    public MyService myService() {
        return new DefaultMyService();
    }
}
// 通过META-INF/spring.factories声明自动配置
// spring.factories文件内容：
// org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
// com.example.autoconfig.CustomAutoConfiguration
// 工厂加载机制
public class SpringFactoriesLoader {
    public static <T> List<T> loadFactories(Class<T> type, ClassLoader classLoader) {
        // 从 META-INF/spring.factories 加载实现类
    }
}

完整示例：支付系统

// PaymentService.java - SPI接口
public interface PaymentService {
    void pay(BigDecimal amount);
    String getPaymentType();
}
// 支付宝实现
public class AlipayService implements PaymentService {
    @Override
    public void pay(BigDecimal amount) {
        System.out.println("使用支付宝支付: " + amount + " 元");
    }
    @Override
    public String getPaymentType() {
        return "支付宝";
    }
}
// 微信支付实现
public class WechatPayService implements PaymentService {
    @Override
    public void pay(BigDecimal amount) {
        System.out.println("使用微信支付: " + amount + " 元");
    }
    @Override
    public String getPaymentType() {
        return "微信支付";
    }
}
// 支付管理器
public class PaymentManager {
    private Map<String, PaymentService> paymentServices = new HashMap<>();
    public PaymentManager() {
        loadServices();
    }
    private void loadServices() {
        ServiceLoader<PaymentService> loader = ServiceLoader.load(PaymentService.class);
        for (PaymentService service : loader) {
            paymentServices.put(service.getPaymentType(), service);
        }
    }
    public PaymentService getPaymentService(String type) {
        return paymentServices.get(type);
    }
}
// 使用示例
public class PaymentDemo {
    public static void main(String[] args) {
        PaymentManager manager = new PaymentManager();
        // 动态选择支付方式
        PaymentService payment = manager.getPaymentService("支付宝");
        if (payment != null) {
            payment.pay(new BigDecimal("100.00"));
        }
        payment = manager.getPaymentService("微信支付");
        if (payment != null) {
            payment.pay(new BigDecimal("200.00"));
        }
    }
}

注意事项

优缺点

优点：

• 解耦：服务接口与实现分离
• 可扩展性强：添加新实现只需增加配置文件
• 自动发现：无需修改客户端代码

缺点：

• 无法延迟加载
• 加载过程复杂可能导致性能问题
• 错误处理较困难

最佳实践

// 安全的SPI使用方式
public class SafeSpiUsage {
    public static List<MyService> getServices() {
        List<MyService> services = new ArrayList<>();
        ServiceLoader<MyService> loader = ServiceLoader.load(MyService.class);
        Iterator<MyService> iterator = loader.iterator();
        while (iterator.hasNext()) {
            try {
                MyService service = iterator.next();
                if (service.isAvailable()) {
                    services.add(service);
                }
            } catch (ServiceConfigurationError e) {
                // 处理加载错误
                System.err.println("加载服务失败: " + e.getMessage());
            }
        }
        return services;
    }
}

Java SPI机制是一种强大的服务发现机制，广泛应用于各种框架中（如JDBC、Spring Boot、Dubbo等），通过SPI可以轻松实现插拔式架构,提高系统的可扩展性和可维护性。