介绍：

        Java的SPI（Service Provider Interface）机制是一种服务发现机制，它允许第三方为一个接口或抽象类提供实现，并使得应用程序可以在运行时发现和使用这些实现。SPI机制的核心思想是将接口实现类的全类名配置在一个文本文件中，应用程序通过读取这个文件来获取接口实现类的全类名，然后使用反射机制创建实例并调用方法。演示代码Github

SPI与API的区别：

从广义上来说它们都属于接口，而且很容易混淆。下面先用一张图说明一下：

SPI（Service Provider Interface）和API（Application Programming Interface）虽然都是接口，但它们在使用目的、使用阶段以及实现方式上存在区别。

1. 使用目的：API是提供给外部开发者的一套预定义的方法或规则，用于规定软件组件之间如何交互。而SPI是为了使服务实现可插拔和可扩展，它允许在运行时动态地发现和加载服务实现。
2. 使用阶段：API通常在开发阶段由调用方直接使用，定义了调用接口。SPI则主要被框架扩展人员使用，用于在应用程序中提供可插拔的实现，调用方可选择使用内置实现或自己实现。
3. 实现方式：API的实现由提供方完成，并对外提供一组规则和约定供调用方使用。SPI的实现则是通过配置文件来指定具体实现类，这些实现类在程序运行时被动态加载。

总的来说，API主要用于定义组件间的交互标准，而SPI则是一种服务扩展机制，用于实现模块化开发中的动态加载和服务替换。

代码演示：

1、service-provider-interface 

创建java 项目service-provider-interface ，创建接口Logger和类LoggerSerice，代码如下：

/**  * @author 思维穿梭  */ public interface Logger {     /**      *  info 级别打印日志      * @param message      */     void info(String message);      /**      *  debug 级别打印日志      * @param message      */     void debug(String message);  }  

 import java.util.ArrayList; import java.util.List; import java.util.ServiceLoader;  /**  * @author 思维穿梭  *   */ public class LoggerService {     private static final LoggerService SERVICE = new LoggerService();      private final Logger logger;      private final List loggerList;       private LoggerService() {         ServiceLoader loader = ServiceLoader.load(Logger.class);         List list = new ArrayList<>();         for (Logger log :loader){             list.add(log);         }         loggerList = list;         if (!list.isEmpty()){             logger = list.get(0);         } else{             logger = null;         }      }      public static  LoggerService getService(){         return SERVICE;     }        public void info(String msg) {         if (logger == null) {             System.out.println("info 中没有发现 Logger 服务提供者");         } else {             logger.info(msg);         }     }      public void debug(String msg) {         if (loggerList.isEmpty()) {             System.out.println("debug 中没有发现 Logger 服务提供者");         }         loggerList.forEach(log -> log.debug(msg));     }   }

2、service-provider

创建java项目service-provider，将service-provider-interface项目jar包引入，创建Logger的实现类LogBack.

import com.dream.spi.log.Logger;  /**  *  @author 思维穿梭  */ public class LogBack implements Logger {     @Override     public void info(String message) {         System.out.println("LogBack info 打印日志： " + message);     }      @Override     public void debug(String message) {         System.out.println("LogBack debug 打印日志： " + message);     } } 

创建META-INF\services目录，在目录下常见Logger接口全名为为文件名的文件，文件中写入其实现类LogBack的全名称。如图：

3、spi-test

创建java项目spi-test。项目引入上面两个项目的jar包。创建测试类SpiTest，代码如下：

 import com.dream.spi.log.LoggerService;    /**  * @author 思维穿梭  */ public class SpiTest {     public static void main(String[] args)     {         // 这里可以调用SPI的实现类的方法         LoggerService loggerService = LoggerService.getService();         loggerService.info("你好");         loggerService.debug("测试Java SPI 机制");              } } 

运行结果：

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

ServiceLoader

ServiceLoader部分代码

public final class ServiceLoader     implements Iterable {      private static final String PREFIX = "META-INF/services/";        public static  ServiceLoader load(Class service) {         ClassLoader cl = Thread.currentThread().getContextClassLoader();         return ServiceLoader.load(service, cl);     }      public static  ServiceLoader load(Class service,                                             ClassLoader loader) {         return new ServiceLoader<>(service, loader);     }      private ServiceLoader(Class 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();     }      public void reload() {         providers.clear();         lookupIterator = new LazyIterator(service, loader);     }         public Iterator iterator() {         return new Iterator() {              Iterator> 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();             }          };     }      private class LazyIterator         implements Iterator     {          Class service;         ClassLoader loader;         Enumeration configs = null;         Iterator pending = null;         String nextName = null;          private LazyIterator(Class service, ClassLoader loader) {             this.service = service;             this.loader = loader;         }          private boolean hasNextService() {             if (nextName != null) {                 return true;             }             if (configs == null) {                 try {                     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();             String cn = nextName;             nextName = null;             Class c = null;             try {                 c = Class.forName(cn, false, loader);             } catch (ClassNotFoundException x) {                 fail(service,                      "Provider " + cn + " not found");             }             if (!service.isAssignableFrom(c)) {                 fail(service,                      "Provider " + cn  + " not a subtype");             }             try {                 S p = service.cast(c.newInstance());                 providers.put(cn, p);                 return p;             } catch (Throwable x) {                 fail(service,                      "Provider " + cn + " could not be instantiated",                      x);             }             throw new Error();          // This cannot happen         }       }        

LoggerService类中的代码作为入口。 

public class LoggerService {     private static final LoggerService SERVICE = new LoggerService();     private final Logger logger;     private final List loggerList;      private LoggerService() {         ServiceLoader loader = ServiceLoader.load(Logger.class);

 private LoggerService() {         ServiceLoader loader = ServiceLoader.load(Logger.class);         List list = new ArrayList();         Iterator var3 = loader.iterator();          while(var3.hasNext()) {             Logger log = (Logger)var3.next();             list.add(log);         } 

    public Iterator iterator() {         return new Iterator() {              Iterator> 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();             }          };     }

lookupIterator = new LazyIterator(service, loader);