溫習 SPI 機制（Java SPI 、Spring SPI、Dubbo SPI）

作者：勇哥 2024-10-29 08:34:55

SPI 的本質是將接口實現類的全限定名配置在文件中，并由服務加載器讀取配置文件，加載實現類。這樣可以在運行時，動態為接口替換實現類。正因此特性，我們可以很容易的通過 SPI 機制為我們的程序提供拓展功能。

SPI 全稱為 Service Provider Interface，是一種服務發現機制。

圖片

1 Java SPI 示例

本節通過一個示例演示 Java SPI 的使用方法。首先，我們定義一個接口，名稱為 Robot。

public interface Robot {
    void sayHello();
}

接下來定義兩個實現類，分別為 OptimusPrime 和 Bumblebee。

public class OptimusPrime implements Robot {
    
    @Override
    public void sayHello() {
        System.out.println("Hello, I am Optimus Prime.");
    }
  
}

public class Bumblebee implements Robot {

    @Override
    public void sayHello() {
        System.out.println("Hello, I am Bumblebee.");
    }
  
}

接下來 META-INF/services 文件夾下創建一個文件，名稱為 Robot 的全限定名 org.apache.spi.Robot。文件內容為實現類的全限定的類名，如下：

org.apache.spi.OptimusPrime
org.apache.spi.Bumblebee

做好所需的準備工作，接下來編寫代碼進行測試。

public class JavaSPITest {
    @Test
    public void sayHello() throws Exception {
        ServiceLoader<Robot> serviceLoader = ServiceLoader.load(Robot.class);
        System.out.println("Java SPI");
        // 1. forEach 模式
        serviceLoader.forEach(Robot::sayHello);
        // 2. 迭代器模式
        Iterator<Robot> iterator = serviceLoader.iterator();
        while (iterator.hasNext()) {
            Robot robot = iterator.next();
          //System.out.println(robot);
          //robot.sayHello();
        }
    }
}

最后來看一下測試結果，如下：

圖片

2 經典 Java SPI 應用 : JDBC DriverManager

在JDBC4.0 之前，我們開發有連接數據庫的時候，通常先加載數據庫相關的驅動，然后再進行獲取連接等的操作。

// STEP 1: Register JDBC driver
Class.forName("com.mysql.jdbc.Driver");
// STEP 2: Open a connection
String url = "jdbc:xxxx://xxxx:xxxx/xxxx";
Connection conn = DriverManager.getConnection(url,username,password);

JDBC4.0之后使用了 Java 的 SPI 擴展機制，不再需要用 Class.forName("com.mysql.jdbc.Driver") 來加載驅動，直接就可以獲取 JDBC 連接。

接下來，我們來看看應用如何加載 MySQL JDBC 8.0.22 驅動：

圖片

首先 DriverManager類是驅動管理器，也是驅動加載的入口。

/**
 * Load the initial JDBC drivers by checking the System property
 * jdbc.properties and then use the {@code ServiceLoader} mechanism
 */
static {
     loadInitialDrivers();
     println("JDBC DriverManager initialized");
}

在 Java 中，static 塊用于靜態初始化，它在類被加載到 Java 虛擬機中時執行。

靜態塊會加載實例化驅動，接下來我們看看loadInitialDrivers 方法。

圖片

加載驅動代碼包含四個步驟：

系統變量中獲取有關驅動的定義。
使用 SPI 來獲取驅動的實現類（字符串的形式）。
遍歷使用 SPI 獲取到的具體實現，實例化各個實現類。
根據第一步獲取到的驅動列表來實例化具體實現類。

我們重點關注 SPI 的用法，首先看第二步，使用 SPI 來獲取驅動的實現類 , 對應的代碼是：

ServiceLoader<Driver> loadedDrivers = ServiceLoader.load(Driver.class);

這里沒有去 META-INF/services目錄下查找配置文件，也沒有加載具體實現類，做的事情就是封裝了我們的接口類型和類加載器，并初始化了一個迭代器。

接著看第三步，遍歷使用SPI獲取到的具體實現，實例化各個實現類，對應的代碼如下：

Iterator<Driver> driversIterator = loadedDrivers.iterator();
//遍歷所有的驅動實現
while(driversIterator.hasNext()) {
    driversIterator.next();
}

在遍歷的時候，首先調用driversIterator.hasNext()方法，這里會搜索 classpath 下以及 jar 包中所有的META-INF/services目錄下的java.sql.Driver文件，并找到文件中的實現類的名字，此時并沒有實例化具體的實現類。

然后是調用driversIterator.next()方法，此時就會根據驅動名字具體實例化各個實現類了，現在驅動就被找到并實例化了。

3 Java SPI 機制源碼解析

我們根據第一節 JDK SPI 示例，學習 ServiceLoader 類的實現。

ServiceLoader類

進入 ServiceLoader 類的load方法：

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

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

上面的代碼，load 方法會通過傳遞的服務類型和類加載器classLoader 創建一個 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();
}

// 緩存已經被實例化的服務提供者，按照實例化的順序存儲
private LinkedHashMap<String,S> providers = new LinkedHashMap<>();

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

私有構造器會創建懶迭代器 LazyIterator 對象，所謂懶迭代器，就是對象初始化時，僅僅是初始化，只有在真正調用迭代方法時，才執行加載邏輯。

示例代碼中創建完 serviceLoader 之后，接著調用iterator()方法：

Iterator<Robot> iterator = serviceLoader.iterator();

// 迭代方法實現
public Iterator<S> iterator() {
     return new Iterator<S>() {
          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();
          }
     };
}

迭代方法的實現本質是調用懶迭代器 lookupIterator 的 hasNext() 和 next() 方法。

1）hasNext() 方法

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

懶迭代器的hasNextService方法首先會通過加載器通過文件全名獲取配置對象 Enumeration<URL> configs ，然后調用解析parse方法解析classpath下的META-INF/services/目錄里以服務接口命名的文件。

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

當 hasNextService 方法返回 true ，我們可以調用迭代器的 next 方法，本質是調用懶加載器 lookupIterator 的 next() 方法：

2）next() 方法

Robot robot = iterator.next();

// 調用懶加載器 lookupIterator 的  `next()` 方法
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
  }

通過反射方法 Class.forName() 加載類對象，并用newInstance方法將類實例化，并把實例化后的類緩存到providers對象中，(LinkedHashMap<String,S>類型，然后返回實例對象。

4 Java SPI 機制的缺陷

通過上面的解析，可以發現，我們使用 JDK SPI 機制的缺陷：

不能按需加載，需要遍歷所有的實現，并實例化，然后在循環中才能找到我們需要的實現。如果不想用某些實現類，或者某些類實例化很耗時，它也被載入并實例化了，這就造成了浪費。
獲取某個實現類的方式不夠靈活，只能通過 Iterator 形式獲取，不能根據某個參數來獲取對應的實現類。
多個并發多線程使用 ServiceLoader 類的實例是不安全的。

5 Spring SPI 機制

Spring SPI 沿用了 Java SPI 的設計思想，Spring 采用的是 spring.factories 方式實現 SPI 機制，可以在不修改 Spring 源碼的前提下，提供 Spring 框架的擴展性。

圖片

1）創建 MyTestService 接口

public interface MyTestService {
    void printMylife();
}

2）創建 MyTestService 接口實現類

WorkTestService :

public class WorkTestService implements MyTestService {
    public WorkTestService(){
        System.out.println("WorkTestService");
    }
    public void printMylife() {
        System.out.println("我的工作");
    }
}

FamilyTestService :

public class FamilyTestService implements MyTestService {
    public FamilyTestService(){
        System.out.println("FamilyTestService");
    }
    public void printMylife() {
        System.out.println("我的家庭");
    }
}

3）在資源文件目錄，創建一個固定的文件 META-INF/spring.factories。

#key是接口的全限定名，value是接口的實現類
com.courage.platform.sms.demo.service.MyTestService = com.courage.platform.sms.demo.service.impl.FamilyTestService,com.courage.platform.sms.demo.service.impl.WorkTestService

4）運行代碼

// 調用 SpringFactoriesLoader.loadFactories 方法加載 MyTestService 接口所有實現類的實例
List<MyTestService> myTestServices = SpringFactoriesLoader.loadFactories(
            MyTestService.class,
            Thread.currentThread().getContextClassLoader()
);

for (MyTestService testService : myTestServices) {
     testService.printMylife();
}

運行結果：

FamilyTestService
WorkTestService
我的家庭
我的工作

Spring SPI 機制非常類似，但還是有一些差異：

Java SPI 是一個服務提供接口對應一個配置文件，配置文件中存放當前接口的所有實現類，多個服務提供接口對應多個配置文件，所有配置都在 services 目錄下。
Spring SPI 是一個 spring.factories 配置文件存放多個接口及對應的實現類，以接口全限定名作為key，實現類作為value來配置，多個實現類用逗號隔開，僅 spring.factories 一個配置文件。

和 Java SPI 一樣，Spring SPI 也無法獲取某個固定的實現，只能按順序獲取所有實現。

6 Dubbo SPI 機制

基于 Java SPI 的缺陷無法支持按需加載接口實現類，Dubbo 并未使用 Java SPI，而是重新實現了一套功能更強的 SPI 機制。

Dubbo SPI 的相關邏輯被封裝在了 ExtensionLoader 類中，通過 ExtensionLoader，我們可以加載指定的實現類。

Dubbo SPI 所需的配置文件需放置在 META-INF/dubbo 路徑下，配置內容如下：

optimusPrime = org.apache.spi.OptimusPrime
bumblebee = org.apache.spi.Bumblebee

與 Java SPI 實現類配置不同，Dubbo SPI 是通過鍵值對的方式進行配置，這樣我們可以按需加載指定的實現類。

另外，在測試 Dubbo SPI 時，需要在 Robot 接口上標注 @SPI 注解。

下面來演示 Dubbo SPI 的用法：

public class DubboSPITest {

    @Test
    public void sayHello() throws Exception {
        ExtensionLoader<Robot> extensionLoader = 
            ExtensionLoader.getExtensionLoader(Robot.class);
        Robot optimusPrime = extensionLoader.getExtension("optimusPrime");
        optimusPrime.sayHello();
        Robot bumblebee = extensionLoader.getExtension("bumblebee");
        bumblebee.sayHello();
    }
}

測試結果如下：

圖片

另外，Dubbo SPI 除了支持按需加載接口實現類，還增加了 IOC 和 AOP 等特性。

責任編輯：武曉燕來源：勇哥Java實戰

SPI 機制接口

溫習 SPI 機制 （Java SPI 、Spring SPI、Dubbo SPI）