图文并茂带你理解Java的SPI机制

目录

一、Java的SPI机制1、什么是Java的SPI ？2、JavaSPI 代码示例 (使用Maven项目演示)3、 JavaSPI 机制的核心-ServiceLoader4、实现自己的ServiceLoader5、Java中还有哪些SPI实现？

一、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.SpaceXLandSpaceX 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来加载传输协议和其他服务提供者。

…