一篇文章带你理解Java的SPI机制(图文并茂)

2024-10-29 09:43:41 作者：家乡的落日

本文详细介绍了Java的SPI机制,包括其定义、用途和实现方式,SPI(ServiceProviderInterface)是一种服务发现机制,用于实现框架或库的扩展点,文中通过代码介绍的非常详细,需要的朋友可以参考下

一、Java的SPI机制

1、什么是Java的SPI ？

SPI全称 Service Provider Interface ，字面意思：“服务提供者的接口”，是一种服务发现机制。

用于实现框架或库的扩展点，允许在运行时动态地插入或更换组件实现。它提供了一个框架来发现和加载服务实现，使得软件模块能够灵活地选择和使用不同的服务提供商。SPI鼓励松耦合的设计，因为服务的消费者不需要直接依赖于具体的服务实现。有没有想到面向对象的某个设计原则，SOLID中的 O 开闭原则，对扩展开放对修改关闭。Java允许服务提供者，按照SPI给定的规则实现自己的服务，而Java应用使用通过SPI规则提供的服务时无需进行额外的配置，并且可以随时替换服务，也无需修改业务代码。

SPI可以和我们常用的API对比着理解。

API全称、Application Programming Interface，字面意思：“应用程序编程接口” 。API是一组规则和定义，允许一个软件应用与另一个软件应用、库或操作系统进行交互。它定义了如何进行数据传输、请求服务或执行特定功能的协议和工具。API为开发人员提供了一种标准化的方式来访问和使用预先构建的功能，而无需了解这些功能内部的复杂实现细节。

总结：

名称	目的	使用者	举例
SPI	支持可插拔的架构，便于组件和服务的替换与扩展。	主要由服务提供者（如库、框架开发者）实现，但也需要应用开发者配置以启用特定的服务实现。(这里说的配置一般就是引入jar或者maven、gradle的坐标即可)	Java中，JDBC驱动的加载就是一个典型的SPI应用。
API	简化开发过程，提高效率，促进不同系统间的互操作性。	通常由应用开发者使用，以集成外部服务或内部模块。	语音识别 API、文件上传 API等

个人感觉SPI就是种"设计模式"，只是不在常见的23种设计模式之中，Java利用"SPI这种设计模式" 实现灵活的选择服务供应商实现,来达到解耦的目的，以此提高程序的可修改性和灵活性。
SPI和外观设计模式也有相通之处、外观模式(Facade) 定义了一个高层接口，为子系统中的一组接口提供一个一致的界面，从而简化子系统的使用。

简单的图示对比：拿NASA的重返月球计划举例。

NASA准备把重返月球计划的着陆器设计部分分包给商业航天公司来完成。

如果还按照API的方式来实现，那么可能就是下图中的结果。NASA想替换某个方案就必须修改系统去适配其他公司的API接口。
这样代码的耦合性就大大提高了。并且导致NASA失去了主动性。NASA这个甲方才不愿意这么干。所以NASA决定采用SPI规则来约束供应商。

NASA给出了关键性的技术指标。

假设目前有SpaceX 和 Blue Origin两家公司中标去完成着陆器的设计。这两家公司需要遵循NASA给定的SPI规则进行设计。
两家公司月球着陆器产品设计完成后，NASA只需要按照SPI规则去加载对应的产品即可。

下图可以看出，虽然两家公司的火箭设计不一样，但是他们的接口都符合NASA指定的接口规则。这样NASA就可以很轻松的集成两家公司的方案，如果觉得SpaceX的方案不好，直接拿Blue Origin的方案无缝替代即可。

2、JavaSPI 代码示例 (使用Maven项目演示)

①、NASA先定义SPI接口并发布到本地仓库供SpaceX和BlueOrigin实现项目结构：

pom文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.nasa</groupId>
    <artifactId>SPI-interface</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>
</project>

maven打包安装到本地仓库

打包好的jar名称

SPI接口：

package com.nasa;
/**
 * NASA提供的SPI接口
 * */
public interface LandingOnTheMoon {
    /**
     * 着陆方法
     */
    void land();
}

SPI加载实现(稍后会详细介绍)：

package com.nasa;

import java.util.ArrayList;
import java.util.List;
import java.util.ServiceLoader;

/**
 * 加载具体的服务实现
 * */
public class LandingOnTheMoonLoader {

    private static volatile LandingOnTheMoonLoader LOADER;

    private final LandingOnTheMoon landingOnTheMoon;

    private final List<LandingOnTheMoon> landingOnTheMoons;

    /**
     * 加载服务
     * */
    private LandingOnTheMoonLoader() {
        ServiceLoader<LandingOnTheMoon> loader = ServiceLoader.load(LandingOnTheMoon.class);
        List<LandingOnTheMoon> list = new ArrayList<>();
        for (LandingOnTheMoon landingOnTheMoon : loader) {
            list.add(landingOnTheMoon);
        }
        landingOnTheMoons = list;
        if (!list.isEmpty()) {
            // 取第一个
            landingOnTheMoon = list.get(0);
        } else {
            landingOnTheMoon = null;
        }
    }


    /**
     * LandingOnTheMoonLoader 单例加载
     * */
    public static LandingOnTheMoonLoader getLOADER() {
        if (LOADER == null) {
            synchronized (LandingOnTheMoonLoader.class) {
                if (LOADER == null) {
                    LOADER = new LandingOnTheMoonLoader();
                }
            }
        }
        return LOADER;
    }


    public void land(){
        if(landingOnTheMoons.isEmpty()){
            System.out.println("LandingOnTheMoon服务未加载！");
        }else {
            LandingOnTheMoon landingOnTheMoon = landingOnTheMoons.get(0);
            landingOnTheMoon.land();
        }
    }
}

②、SpaceX实现自己的登陆月球方案

先引入NASA 指定的SPI接口

pom文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.spacex</groupId>
    <artifactId>SpaceX</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>

        <dependency>
            <groupId>com.nasa</groupId>
            <artifactId>SPI-interface</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>

    </dependencies>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

</project>

SpaceX的登陆月球实现：

package com.spacex;

import com.nasa.LandingOnTheMoon;

/**
 * SpaceX实现的月球着陆方案
 * */
public class SpaceXLand implements LandingOnTheMoon {
    @Override
    public void land() {
        System.out.println("SpaceX landing on the moon with StarShip~");
    }
}

SpaceX的登陆月球实现配置信息：

注意： Maven项目中 META-INF/services/SPI接口全限定名需要放在resources目录下

内容为SpaceX实现类的全限定名：

③、BlueOrigin实现自己的登陆月球方案

先引入NASA 指定的SPI接口

pom文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.blue</groupId>
    <artifactId>BlueOrigin</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>

        <dependency>
            <groupId>com.nasa</groupId>
            <artifactId>SPI-interface</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>

    </dependencies>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

</project>

BlueOrigin的登陆月球实现：

package com.blue;

import com.nasa.LandingOnTheMoon;

/**
 * 蓝色起源实现的月球着陆方案
 * */
public class BlueOriginLand implements LandingOnTheMoon {
    @Override
    public void land() {
        System.out.println("BlueOrigin landing on the moon with  NewGlenn~");
    }
}

BlueOrigin的登陆月球实现配置信息：Maven项目中 META-INF/services/SPI接口全限定名需要放在resources目录下

内容为BlueOrigin实现类的全限定名：

编写测试代码：

新建一个Maven项目

pom文件中引入SpaceX的实现坐标

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.nasa</groupId>
    <artifactId>NASA-LANDING</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
    
        <!--使用蓝色起源的着陆实现-->
  <!--      <dependency>
            <groupId>com.blue</groupId>
            <artifactId>BlueOrigin</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>-->

        <!--使用SpaceX的着陆实现-->
        <dependency>
            <groupId>com.spacex</groupId>
            <artifactId>SpaceX</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>

    </dependencies>

</project>

package com.nasa;

public class LandingShow {

    public static void main(String[] args) {
        LandingOnTheMoonLoader service = LandingOnTheMoonLoader.getLOADER();
        service.land();
    }
}

执行结果：

SpaceX landing on the moon with StarShip~

此时如果NASA觉得SpaceX的方案不行，需要更换BlueOrigin的方案，操作起来非常简单，只需要注释掉SpaceX的坐标，添加BlueOrigin的坐标，业务代码完全不用改。

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.nasa</groupId>
    <artifactId>NASA-LANDING</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <!--使用蓝色起源的着陆实现-->
        <dependency>
            <groupId>com.blue</groupId>
            <artifactId>BlueOrigin</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>

        <!--使用SpaceX的着陆实现-->
<!--        <dependency>-->
<!--            <groupId>com.spacex</groupId>-->
<!--            <artifactId>SpaceX</artifactId>-->
<!--            <version>1.0-SNAPSHOT</version>-->
<!--        </dependency>-->

    </dependencies>

</project>

执行结果：

BlueOrigin landing on the moon with NewGlenn~

3、 JavaSPI 机制的核心-ServiceLoader

上面代码中我们使用ServiceLoader 去加载具体的服务实现。

ServiceLoader 是从JDK1.6 开始提供的一个类，用于加载服务提供者。

我们看下源码：

其中 String PREFIX = “META-INF/services/”;

这个就是JDK的SPI功能规定的具体服务实现的配置信息文件所在的目录 META-INF/services/

JDK的SPI规定服务实现者需要在 META-INF/services/ 目录下新建文件名为 SPI接口全限定类名的文件

文件内容为服务实现者需要被加载的具体类的全限定类名

我们上面代码在加载服务的时候调用了ServiceLoader.load(LandingOnTheMoon.class);方法

ServiceLoader<LandingOnTheMoon> loader = ServiceLoader.load(LandingOnTheMoon.class);

看下这个方法的源码：

public static <S> ServiceLoader<S> load(Class<S> service) {
        ClassLoader cl = Thread.currentThread().getContextClassLoader();
        return ServiceLoader.load(service, cl);
    }

可以看到这个方法只是获取了当前线程的上下文类加载器然后又调用了一个load的重载方法

public static <S> ServiceLoader<S> load(Class<S> service,
                                            ClassLoader loader)
    {
        return new ServiceLoader<>(service, loader);
    }

在重载的load方法中又调用了ServiceLoader的私有构造器

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

然后调用 reload();方法

  public void reload() {
        providers.clear();
        lookupIterator = new LazyIterator(service, loader);
    }

reload();方法里面调用了 new LazyIterator(service, loader);

具体的类加载行为就是在LazyIterator内部类中完成的。

这里的 lookupIterator = new LazyIterator(service, loader); 创建LazyIterator 懒加载迭代器对象，并没有马上去加载SPI的具体服务。

当我们调用 for (LandingOnTheMoon landingOnTheMoon : loader) {…} 循环时，会触发迭代器，在ServiceLoader中，迭代器是由Iterable接口的iterator()方法提供的。当第一次调用iterator()时，如果之前没有创建过迭代器，它会创建一个新的LazyIterator实例。

对应下面的源码：

//  lookupIterator 在 调用reload 方法时 创建过了
private LazyIterator lookupIterator;
// 存储已经加载过的服务提供者实例  在 调用reload 方法时   调用了providers.clear(); 清空了这个集合
private LinkedHashMap<String,S> providers = new LinkedHashMap<>();
    
public Iterator<S> iterator() {
     return new Iterator<S>() {
     	 // 第一次调用时 providers 是空集合 会调用  lookupIterator 也就是 LazyIterator 的实例
         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();
         }

     };
 }

下面看 LazyIterator 的实现具体的类加载就在这里：

LazyIterator 的 hasNext 和 next方法中判断了 acc 是否是null

其中 acc = (System.getSecurityManager() != null) ? AccessController.getContext() : null; 这段代码是在 ServiceLoader初始化的时候执行的
主要用于判断当前Java运行环境中是否存在安全管理器（SecurityManager），默认情况下不会配置，如果配置了SecurityManager，某些敏感操作（比如文件访问、网络连接等）可能会受到安全策略的限制或需要相应的权限检查。

这个不重要，我们还是看具体的方法 hasNextService 和 nextService方法。

 public boolean hasNext() {
            if (acc == null) {
                return hasNextService();
            } else {
                PrivilegedAction<Boolean> action = new PrivilegedAction<Boolean>() {
                    public Boolean run() { return hasNextService(); }
                };
                return AccessController.doPrivileged(action, acc);
            }
        }

        public S next() {
            if (acc == null) {
                return nextService();
            } else {
                PrivilegedAction<S> action = new PrivilegedAction<S>() {
                    public S run() { return nextService(); }
                };
                return AccessController.doPrivileged(action, acc);
            }
        }

LazyIterator 的 hasNextService 和 nextService方法终于到了加载具体服务的地方了。

// 迭代器
Iterator<String> pending = null;
  
private boolean hasNextService() {
      if (nextName != null) {
          return true;
      }
      if (configs == null) {
          try {
          	  // 这里获取 SPI配置文件的文件名  包含 META-INF/services/
              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();
    // nextName 在hasNextService中已经被赋值了
    String cn = nextName;
    nextName = null;
    Class<?> c = null;
    try {
        //  关键点终于来了  最终还是利用Java的反射机制 完成类的加载
        c = Class.forName(cn, false, loader);
    } catch (ClassNotFoundException x) {
        fail(service,
             "Provider " + cn + " not found");
    }
    // 判断下 加载的 Class 的类型 是否实现了 给定的 SPI接口   拿上面NASA登月的例子看，这里的 service 就是  LandingOnTheMoon.class
    if (!service.isAssignableFrom(c)) {
        fail(service,
             "Provider " + cn  + " not a subtype");
    }
    try {
    	// 通过反射实例化 SPI的实现类 并且转换成 SPI接口类型
        S p = service.cast(c.newInstance());
        // 保存到  LinkedHashMap<String,S> providers 缓存中
        providers.put(cn, p);
        return p;
    } catch (Throwable x) {
        fail(service,
             "Provider " + cn + " could not be instantiated",
             x);
    }
    throw new Error();          // This cannot happen
}

看具体的parse 方法(解析服务实现者提供的配置文件)

private Iterator<String> parse(Class<?> service, URL u)
        throws ServiceConfigurationError
    {
        InputStream in = null;
        BufferedReader r = null;
        // 保存解析配置文件内的 全限定类名
        ArrayList<String> names = new ArrayList<>();
        try {
            in = u.openStream();
            r = new BufferedReader(new InputStreamReader(in, "utf-8"));
            int lc = 1;
            // 一行一行的读取配置信息 并将每行解析出的全限定类名 保存到 names 
            // parseLine 方法不用看了 就是解析字符串的
            while ((lc = parseLine(service, u, r, lc, names)) >= 0);
        } catch (IOException x) {
            fail(service, "Error reading configuration file", x);
        } finally {
            try {
                if (r != null) r.close();
                if (in != null) in.close();
            } catch (IOException y) {
                fail(service, "Error closing configuration file", y);
            }
        }
        // 返回 拥有所有实现SPI接口的服务提供者全限定类名集合的迭代器
        return names.iterator();
    }

绕了半天通过源码发现最终类的加载还是通过 Java反射机制实现的。

那了解了ServiceLoader的具体实现之后，我们也可以实现一个自己的服务加载器。

ServiceLoader只不过在实现了核心的SPI服务加载功能的基础上增加了一些额外的功能，比如通过LazyIterator 实现延迟加载，

可以调用reload() 在应用运行时实现服务的动态加载(不用重启应用就能加载服务)，访问控制(比如判断当前Java运行环境中是否存在安全管理器)，还有按照加载顺序保存已加载的服务等等。不过ServiceLoader也是线程不安全的这点需要注意。

4、实现自己的ServiceLoader

我们实现一个最简单的ServiceLoader只考虑加载服务的功能，其他的安全、性能之类的都不考虑。

我们也仿照ServiceLoader类的结构，和SPI配置类规定的路径来实现。

package com.nasa;

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URL;
import java.util.*;

public class MySimpleServiceLoader<T> {

    // 直接copy ServiceLoader的规则
    private static final String PREFIX = "META-INF/services/";


    // 定义的SPI接口
    private final Class<T> service;

    // 类加载器
    private final ClassLoader loader;

    // 保存已加载的服务实例
    private final LinkedHashMap<String, T> providers = new LinkedHashMap<>();

    // 构造方法T
    private MySimpleServiceLoader(Class<T> svc, ClassLoader cl) {
        service = Objects.requireNonNull(svc, "Service interface cannot be null");
        loader = (cl == null) ? ClassLoader.getSystemClassLoader() : cl;
        // 加载服务
        realLoad();
    }

    public static <T> MySimpleServiceLoader<T> load(Class<T> service) {
        ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
        return new MySimpleServiceLoader<>(service, contextClassLoader);
    }


    private void realLoad() {
        String fullName = PREFIX + service.getName();
        try {
            // 获取配置文件
            Enumeration<URL> resources = loader.getResources(fullName);
            // 读取配置文件
            while (resources.hasMoreElements()) {
                URL url = resources.nextElement();
                InputStream inputStream = url.openStream();
                BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream, "utf-8"));
                // 我们就不做解析错误之类的逻辑了  默认给的配置文件都是对的
                String name = reader.readLine();
                // 通过反射创建对象
                Class<?> aClass = Class.forName(name, false, loader);
                // 判断 服务实现类是否实现了 给定的SPI接口
                if (service.isAssignableFrom(aClass)) {
                    T cast = service.cast(aClass.newInstance());
                    providers.put(name, cast);
                }
            }
        } catch (Exception e) {
            System.out.println("出现异常！");
            e.printStackTrace();
        }
    }

    // 返回加载好的 服务实现
    public LinkedHashMap<String, T> getProviders() {
        return providers;
    }
}

使用自定义的服务加载器 MySimpleServiceLoader

package com.nasa;

import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;

/**
 * 加载具体的服务实现
 * */
public class LandingOnTheMoonLoader {

    private static volatile LandingOnTheMoonLoader LOADER;

    private final LandingOnTheMoon landingOnTheMoon;

    private final List<LandingOnTheMoon> landingOnTheMoons = new ArrayList<>();

    /**
     * 加载服务
     * */
    private LandingOnTheMoonLoader() {
        // 通过自定义的服务加载器 去加载服务实现
        MySimpleServiceLoader<LandingOnTheMoon> mySimpleServiceLoader = MySimpleServiceLoader.load(LandingOnTheMoon.class);
        LinkedHashMap<String, LandingOnTheMoon> providers = mySimpleServiceLoader.getProviders();

        providers.forEach((k,v)->{
            System.out.println(k);
            landingOnTheMoons.add(v);
        });
        if (!landingOnTheMoons.isEmpty()) {
            // 取第一个
            landingOnTheMoon = landingOnTheMoons.get(0);
        } else {
            landingOnTheMoon = null;
        }

    }


    /**
     * LandingOnTheMoonLoader 单例加载
     * */
    public static LandingOnTheMoonLoader getLOADER() {
        if (LOADER == null) {
            synchronized (LandingOnTheMoonLoader.class) {
                if (LOADER == null) {
                    LOADER = new LandingOnTheMoonLoader();
                }
            }
        }
        return LOADER;
    }


    public void land(){
        if(landingOnTheMoons.isEmpty()){
            System.out.println("LandingOnTheMoon服务未加载！");
        }else {
            LandingOnTheMoon landingOnTheMoon = landingOnTheMoons.get(0);
            landingOnTheMoon.land();
        }
    }
}

测试：

public static void main(String[] args) {
        LandingOnTheMoonLoader service = LandingOnTheMoonLoader.getLOADER();
        service.land();
    }

使用SpaceX的实现，结果如下：

com.spacex.SpaceXLand
SpaceX landing on the moon with StarShip~

5、Java中还有哪些SPI实现？

1、JDBC (Java Database Connectivity): JDBC驱动的加载就是SPI的一个经典应用。各个数据库厂商提供自己的JDBC驱动实现，应用程序无需直接引用具体驱动的实现类，只需将驱动JAR包放入类路径，Java SPI机制会自动发现并加载合适的驱动。
2、日志框架: 如SLF4J (Simple Logging Facade for Java) 和Logback、Log4j等，它们利用SPI机制来发现和加载具体的日志实现。用户可以根据需要选择或更换日志实现，而无需修改应用程序代码。
3、Spring框架: 虽然Spring框架本身更倾向于使用其自身的bean工厂和依赖注入机制来管理组件和服务，但Spring也支持SPI机制，特别是在某些扩展点和与第三方库集成时。
4、Dubbo: Apache Dubbo是一个高性能的RPC框架，它大量使用SPI机制来实现其插件体系，允许用户轻松替换或扩展序列化、负载均衡、集群容错等核心组件。
5、JNDI (Java Naming and Directory Interface): JNDI服务提供者也是通过SPI机制注册和发现的，允许应用程序访问不同的命名和目录服务。
6、JAX-WS (Java API for XML Web Services) 和 JAX-RS (Java API for RESTful Web Services): 这些Java Web服务技术框架使用SPI来发现和加载实现特定功能的服务提供者，比如SOAP绑定和HTTP连接器。
7、JavaBeans Activation Framework (JAF): 用于处理MIME类型的邮件附件等，通过SPI来发现数据处理器。
8、JavaMail: 用于发送和接收电子邮件的API，利用SPI来加载传输协议和其他服务提供者。

…

总结

到此这篇关于Java的SPI机制的文章就介绍到这了,更多相关Java的SPI机制内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

一篇文章带你理解Java的SPI机制(图文并茂)

一、Java的SPI机制

1、什么是Java的SPI ？

2、JavaSPI 代码示例 (使用Maven项目演示)

3、 JavaSPI 机制的核心-ServiceLoader

4、实现自己的ServiceLoader

5、Java中还有哪些SPI实现？

总结

您可能感兴趣的文章: