JDK原始碼系列(一) ------ 深入理解SPI機制
阿新 • • 發佈：2019-12-29
什麼是SPI機制
最近我建了另一個文章分類，用於擴充套件JDK中一些重要但不常用的功能。
SPI，全名Service Provider Interface，是一種服務發現機制。它可以看成是一種針對介面實現類的解耦方案。我們只需要採用配置檔案方式配置好介面的實現類，就可以利用SPI機制去載入到它們了，當我們需要修改實現類時，改改配置檔案就可以了，而不需要去改程式碼。
當然，有的同學可能會問，spring也可以做介面實現類的解耦，是不是SPI就沒用了呢？雖然兩者都可以達到相同的目的，但是不一定所有應用都可以引入spring框架，例如JDBC自動發現驅動並註冊，它就是採用SPI機制，它就不大可能引入spring
druid、dubbo等都採用了SPI機制。
怎麼使用SPI
需求
利用SPI機制載入使用者服務介面的實現類並測試。
工程環境
JDK：1.8.0_201
maven：3.6.1
IDE：eclipse 4.12
主要步驟
- 編寫使用者服務類介面和實現類；
- 在
classpath路徑下的META-INF/services資料夾下配置好介面的實現類； - 利用
SPI機制載入介面實現類並測試。
建立專案
專案型別Maven Project，打包方式jar
引入依賴
<dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.12</version> <scope>test</scope> </dependency>
編寫使用者服務類介面
路徑：cn.zzs.spi
public interface UserService {
void save();
}編寫介面實現類
路徑：cn.zzs.spi。這裡就簡單實現就好了。
public class UserServiceImpl1 implements UserService { @Override public void save() { System.err.println("執行服務1的save方法"); } } // ------------------------ public class UserServiceImpl2 implements UserService { @Override public void save() { System.err.println("執行服務2的save方法"); } }
配置介面檔案
在resources路徑下建立META-INF/services資料夾，並以UserService的全限定類名為檔名，建立一個檔案。如圖所示。
檔案中寫入介面實現類的全限定類名，多個用換行符隔開。
cn.zzs.spi.UserServiceImpl1
cn.zzs.spi.UserServiceImpl2編寫測試方法
路徑：test下的cn.zzs.spi。如果實際專案中配置了比較多的介面檔案，可以考慮抽取工具類。
public class UserServiceTest {
@Test
public void test() {
// 1. 建立一個ServiceLoader物件
ServiceLoader<UserService> userServiceLoader = ServiceLoader.load(UserService.class);
// 2. 建立一個迭代器
Iterator<UserService> userServiceIterator = userServiceLoader.iterator();
// 3. 載入配置檔案並例項化介面實現類
while(userServiceIterator.hasNext()) {
UserService userService = userServiceIterator.next();
userService.save();
System.out.println("==================");
}
}
}測試結果
執行服務1的save方法
==================
執行服務2的save方法
==================SPI在JDBC中的應用
本文以mysql 8.0.15版本的驅動來說明。首先，當我們呼叫Class.forName("com.mysql.cj.jdbc.Driver")時，會去執行這個類的靜態程式碼塊，在靜態程式碼塊中就會完成驅動註冊。
static {
try {
//靜態程式碼塊中註冊當前驅動
java.sql.DriverManager.registerDriver(new Driver());
} catch (SQLException E) {
throw new RuntimeException("Can't register driver!");
}
}JDK6後不再需要Class.forName(driver)也能註冊驅動。因為從JDK6開始，DriverManager增加了以下靜態程式碼塊，當類被載入時會執行static程式碼塊的loadInitialDrivers方法。
而這個方法會通過查詢系統引數（jdbc.drivers）和SPI機制兩種方式去載入資料庫驅動。
注意：考慮篇幅，以下程式碼經過修改，僅保留所需部分。
static {
loadInitialDrivers();
}
//這個方法通過兩個渠道載入所有資料庫驅動：
//1. 查詢系統引數jdbc.drivers獲得資料驅動類名
//2. SPI機制
private static void loadInitialDrivers() {
//通過系統引數jdbc.drivers讀取資料庫驅動的全路徑名。該引數可以通過啟動引數來設定，其實引入SPI機制後這一步好像沒什麼意義了。
String drivers;
try {
drivers = AccessController.doPrivileged(new PrivilegedAction<String>() {
public String run() {
return System.getProperty("jdbc.drivers");
}
});
} catch (Exception ex) {
drivers = null;
}
//使用SPI機制載入驅動
AccessController.doPrivileged(new PrivilegedAction<Void>() {
public Void run() {
//讀取META-INF/services/java.sql.Driver檔案的類全路徑名。
ServiceLoader<Driver> loadedDrivers = ServiceLoader.load(Driver.class);
Iterator<Driver> driversIterator = loadedDrivers.iterator();
//載入並初始化類
try{
while(driversIterator.hasNext()) {
// 這裡才會去例項化驅動
driversIterator.next();
}
} catch(Throwable t) {
// Do nothing
}
return null;
}
});
if (drivers == null || drivers.equals("")) {
return;
}
//載入jdbc.drivers引數配置的實現類
String[] driversList = drivers.split(":");
for (String aDriver : driversList) {
try {
Class.forName(aDriver, true,
ClassLoader.getSystemClassLoader());
} catch (Exception ex) {
println("DriverManager.Initialize: load failed: " + ex);
}
}
}在mysql的驅動包中，我們可以看到SPI的配置檔案。
原始碼分析
本文將根據測試例子中方法的呼叫順序來分析。
@Test
public void test() {
// 1. 建立一個ServiceLoader物件
ServiceLoader<UserService> userServiceLoader = ServiceLoader.load(UserService.class);
// 2. 建立一個迭代器
Iterator<UserService> userServiceIterator = userServiceLoader.iterator();
// 3. 載入配置檔案並例項化介面實現類
while(userServiceIterator.hasNext()) {
UserService userService = userServiceIterator.next();
userService.save();
System.out.println("==================");
}
}注意：考慮篇幅，以下程式碼經過修改，僅保留所需部分。
建立一個ServiceLoader
我們從load(Class service)方法開始分析，可以看到，呼叫這個方法時還不會去載入配置檔案和初始化介面實現類。因為SPI採用延遲載入的方式，只有去呼叫hasNext()才會去載入配置檔案，呼叫next()才會去例項化物件。
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)
{
// 建立一個ServiceLoader物件
return new ServiceLoader<>(service, loader);
}
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<>();
// 迭代器，有載入和例項化介面實現類的方法
private LazyIterator lookupIterator;
public void reload() {
// 清空存放的介面實現類物件
providers.clear();
// 建立一個LazyIterator
lookupIterator = new LazyIterator(service, loader);
}
// LazyIterator是ServiceLoader的內部類
private class LazyIterator implements Iterator<S> {
private LazyIterator(Class<S> service, ClassLoader loader) {
this.service = service;
this.loader = loader;
}
}建立一個迭代器
因為SPI機制採用了延遲載入的方式，所以在沒有呼叫next()之前，providers會是一個空的Map，也就是說以下的knownProviders也會是一個空的迭代器，所以，這個時候都必須去呼叫lookupIterator的方法，本文討論的正是這種情況。
public Iterator<S> iterator() {
return new Iterator<S>() {
// providers的迭代器，一般為空
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();
}
};
}載入配置檔案
前面已經提到，當呼叫hasNext()時才會去載入配置檔案。那麼，我們直接看LazyIterator的hasNext()方法
// 介面型別
Class<S> service;
// 類載入器
ClassLoader loader;
// 配置檔案列表，一般只有一個
Enumeration<URL> configs = null;
// 所有實現類全限定類名的迭代器
Iterator<String> pending = null;
// 下一個實現類全限定類名
String nextName = null;
public boolean hasNext() {
return hasNextService();
}
private boolean hasNextService() {
// 判斷是否有下一個實現類全限定類名，有的話直接返回true
// 第一次呼叫這個方法nextName肯定是null的
if(nextName != null) {
return true;
}
// 下面就是載入配置檔案了
if(configs == null) {
// 本文例子中：fullName = META-INF/services/cn.zzs.spi.UserService
String fullName = PREFIX + service.getName();
if(loader == null)
configs = ClassLoader.getSystemResources(fullName);
else
configs = loader.getResources(fullName);
}
// pending是所有實現類全限定類名的迭代器，此時是空
while((pending == null) || !pending.hasNext()) {
// 如果檔案中沒有配置實現類，直接返回false
if(!configs.hasMoreElements()) {
return false;
}
// 解析配置檔案，並初始化pending迭代器
pending = parse(service, configs.nextElement());
}
// 將第一個實現類的全限定類名賦值給nextName
nextName = pending.next();
return true;
}解析的過程就是簡單的IO操作，這裡就不再擴充套件了。
例項化介面實現類
前面已經提到，當呼叫next()時才會去例項化介面實現類。那麼，我們直接看LazyIterator的next()方法。
public S next() {
return nextService();
}
private S nextService() {
// 判斷是否有下一個介面實現類。因為前面已經有nextName，所以直接返回true
if (!hasNextService())
throw new NoSuchElementException();
// 獲得下一個介面實現類的全限定類名
String cn = nextName;
// 將nextName置空，這樣下次呼叫hasNext()就會重新賦值nextName
nextName = null;
Class<?> c = null;
// 載入介面實現類
c = Class.forName(cn, false, loader);
// 判斷是否是指定介面的實現類
if (!service.isAssignableFrom(c)) {
fail(service,"Provider " + cn + " not a subtype");
}
// 轉化為指定型別
S p = service.cast(c.newInstance());
// 放入providers的Map中
// 前面提到過，只有呼叫了next()方法，這個Map才會放入元素
providers.put(cn, p);
return p;
}
以上，SPI的原始碼基本分析完。
參考資料
本文為原創文章，轉載請附上原文出處連結：https://github.com/ZhangZiSheng001/01-spi-demo