JDK版本為1.8
SPI全稱Service Provider Interface，是Java提供的一套用來被第三方實現或者擴充套件的API，它可以用來啟用框架擴充套件和替換元件。
Java SPI 實際上是“基於介面的程式設計＋策略模式＋配置檔案”組合實現的動態載入機制。
系統設計的各個抽象，往往有很多不同的實現方案，在面向的物件的設計裡，一般推薦模組之間基於介面程式設計，模組之間不對實現類進行硬編碼。一旦程式碼裡涉及具體的實現類，就違反了可拔插的原則，如果需要替換一種實現，就需要修改程式碼。為了實現在模組裝配的時候能不在程式裡動態指明，這就需要一種服務發現機制。
Java SPI就是提供這樣的一個機制：為某個介面尋找服務實現的機制。有點類似IOC的思想，就是將裝配的控制權移到程式之外，在模組化設計中這個機制尤其重要。所以SPI的核心思想就是解耦。
要使用Java SPI，需要遵循如下約定：
1、當服務提供者提供了介面的一種具體實現後，在jar包的META-INF/services目錄下建立一個以“介面全限定名”為命名的檔案，內容為實現類的全限定名；
2、介面實現類所在的jar包放在主程式的classpath中；
3、主程式透過java.util.ServiceLoder動態裝載實現模組，它透過掃描META-INF/services目錄下的配置檔案找到實現類的全限定名，把類載入到JVM；
4、SPI的實現類必須攜帶一個不帶引數的構造方法；
專案結構如下：
src/main
--------java
lzc.spidemo
api
Car.java
impl
BCCar.java
BMCar.java
Test.java
--------resource
META-INF.services
lzc.spidemo.api.CarCar.java
public interface Car {
public String getCarName();
}BCCar.java
public class BCCar implements Car {
@Override
public String getCarName() {
return "賓士車";
}
}BMCar.java
public class BMCar implements Car {
@Override
public String getCarName() {
return "寶馬車";
}
}META-INF/services/lzc.spidemo.api.Car
在META-INF/services/下新建一個檔案，名字為lzc.spidemo.api.Car
lzc.spidemo.impl.BCCar
lzc.spidemo.impl.BMCarTest.java
public class Test {
public static void main(String[] args) {
// ServiceLoader.load(Car.class)
ServiceLoader<Car> carList = ServiceLoader.load(Car.class);
// ServiceLoader.iterator()
Iterator<Car> carIterator = carList.iterator();
while (carIterator.hasNext()) { // LazyIterator.hasNext()
Car car = carIterator.next(); // LazyIterator.next()
System.out.println(car.getCarName());
}
}
}根據執行結果可以發現，ServiceLoader.load(Car.class)可以幫我們找到Car的實現類BCCar和BMCar，接下來透過原來來分析一下它是如何找到Car的實現類的。
Java的SPI機制實現跟ServiceLoader這個類有關
public final class ServiceLoader<S> implements Iterable<S> {
// 讀取配置檔案的字首路徑 META-INF/services/
private static final String PREFIX = "META-INF/services/";
// 需要被載入的服務介面或者服務類
private final Class<S> service;
// 類載入器
private final ClassLoader loader;
// 建立ServiceLoader時採用的訪問控制上下文，預設情況下為 null
private final AccessControlContext acc;
// 快取SPI的實現，key是完整類名
private LinkedHashMap<String,S> providers = new LinkedHashMap<>();
// 當前的迭代器，預設初始化為: new LazyIterator(service, loader)
// 這裡是懶載入的，只有使用的時候才去迭代,載入
// LazyIterator 是 ServiceLoader 的內部類
private LazyIterator lookupIterator;
}可以看到，ServiceLoader實現了Iterable介面，覆寫其iterator方法能產生一個迭代器；同時ServiceLoader有一個內部類LazyIterator，而LazyIterator又實現了Iterator介面，說明LazyIterator是一個迭代器。
ServiceLoader.load(Car.class)
從ServiceLoader.load(Car.class)開始分析
// java.util.ServiceLoader
public static <S> ServiceLoader<S> load(Class<S> service) {
// 獲取當前執行緒上下文類載入器 AppClassLoader
ClassLoader cl = Thread.currentThread().getContextClassLoader();
// 把剛才取出的執行緒上下文類載入器作為引數傳入，用於後面去載入classpath中的外部廠商提供的驅動類
// 將service介面類和執行緒上下文類載入器作為引數傳入，繼續呼叫load方法
return ServiceLoader.load(service, cl);
}檢視ServiceLoader.load(service, cl)
// java.util.ServiceLoader
public static <S> ServiceLoader<S> load(Class<S> service, ClassLoader loader) {
// 將service介面類和執行緒上下文類載入器作為構造引數，建立一個ServiceLoader物件
return new ServiceLoader<>(service, loader);
}檢視new ServiceLoader<>(service, loader)
// java.util.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()方法
檢視reload()方法
// java.util.ServiceLoader
public void reload() {
// 清除快取
providers.clear();
// 新建 LazyIterator
lookupIterator = new LazyIterator(service, loader);
}在reload方法中又新建了一個LazyIterator物件，然後賦值給lookupIterator。
// java.util.ServiceLoader
// LazyIterator 是 ServiceLoader的內部類
private class LazyIterator implements Iterator<S> {
Class<S> service;
ClassLoader loader;
Enumeration<URL> configs = null;
Iterator<String> pending = null;
String nextName = null;
private LazyIterator(Class<S> service, ClassLoader loader) {
this.service = service;
this.loader = loader;
}
}在構建LazyIterator物件時，只是給其service和loader屬性賦值，並沒有去載入介面的實現類。
ServiceLoader.iterator()
檢視ServiceLoader.iterator()
// java.util.ServiceLoader
public Iterator<S> iterator() {
// 這裡返回的是一個匿名的迭代器物件
return new Iterator<S>() {
// 將 providers 快取的資料轉換成迭代器 Iterator 並賦值給 knownProviders
Iterator<Map.Entry<String,S>> knownProviders
= providers.entrySet().iterator();
public boolean hasNext() {
// 如果快取中有資料就直接返回true
if (knownProviders.hasNext())
return true;
// 快取中沒有資料，呼叫 LazyIterator.hasNext()
return lookupIterator.hasNext();
}
public S next() {
// 如果快取中有資料就直接從快取中返回
if (knownProviders.hasNext())
return knownProviders.next().getValue();
// 快取中沒有資料，呼叫 LazyIterator.next()
return lookupIterator.next();
}
public void remove() {
throw new UnsupportedOperationException();
}
};
}LazyIterator.hasNext()
檢視LazyIterator.hasNext()
// java.util.ServiceLoader.LazyIterator
// LazyIterator 是 ServiceLoader 的內部類
public boolean hasNext() {
// 預設情況下 acc = null
if (acc == null) {
return hasNextService();
} else {
PrivilegedAction<Boolean> action = new PrivilegedAction<Boolean>() {
public Boolean run() { return hasNextService(); }
};
return AccessController.doPrivileged(action, acc);
}
}檢視hasNextService()方法
// java.util.ServiceLoader.LazyIterator
// LazyIterator 是 ServiceLoader 的內部類
// 這裡會涉及到一個名詞 "全限定名"
// 這裡說的 "全限定名" = "包路徑"."類名名稱或者是介面名名稱"
private boolean hasNextService() {
// 如果 nextName 不為空，則直接返回 true
if (nextName != null) {
return true;
}
if (configs == null) {
try {
// PREFIX = "META-INF/services/"
// service.getName() 獲取介面的全限定名
// 在構建LazyIterator物件時已經給其成員屬性service賦值
String fullName = PREFIX + service.getName();
// 在構建LazyIterator物件時已經給其成員屬性loader賦值
// 載入 "META-INF/services/介面的全限定名" 檔案
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;
}
// 解析 "META-INF/services/介面的全限定名" 檔案內容
// 返回 "META-INF/services/介面的全限定名" 檔案內容中的服務提供者的全限定名並賦值給pending屬性
pending = parse(service, configs.nextElement());
}
// 然後取出一個服務提供者全限定名賦值給LazyIterator的成員變數nextName
nextName = pending.next();
return true;
}這裡用到了懶載入的思想，當需要時才去載入配置檔案。
該方法的主要功能是：去META-INF/services/目錄下載入介面檔案的內容，解析檔案內容賦值給LazyIterator的成員變數pending，pending是一個Iterator，然後取出第一個值賦值給LazyIterator的成員變數nextName。
比如META-INF/services/lzc.spidemo.api.Car的檔案內容為。
lzc.spidemo.impl.BCCar
lzc.spidemo.impl.BMCar那麼LazyIterator的pending屬性就儲存了lzc.spidemo.impl.BCCar和lzc.spidemo.impl.BMCar這兩個值，然後取出lzc.spidemo.impl.BCCar賦值給LazyIterator的成員變數nextName。
執行完LazyIterator的hasNext方法後，會繼續執行LazyIterator的next方法
LazyIterator.next()
檢視LazyIterator.next()方法
// java.util.ServiceLoader.LazyIterator
// LazyIterator 是 ServiceLoader 的內部類
public S next() {
// 預設情況下 acc = null
if (acc == null) {
return nextService();
} else {
PrivilegedAction<S> action = new PrivilegedAction<S>() {
public S run() { return nextService(); }
};
return AccessController.doPrivileged(action, acc);
}
}檢視LazyIterator.nextService()方法
// java.util.ServiceLoader.LazyIterator
// LazyIterator 是 ServiceLoader 的內部類
private S nextService() {
if (!hasNextService())
throw new NoSuchElementException();
// hasNextService()方法中為 nextNam e賦值過服務提供者實現類的全限定名
String cn = nextName;
// 將 nextName 設定為空
// 下次呼叫 hasNextService() 時會從 pending 獲取值並賦值給 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集合進行快取
providers.put(cn, p);
// 返回例項
return p;
} catch (Throwable x) {
fail(service,
"Provider " + cn + " could not be instantiated",
x);
}
throw new Error(); // This cannot happen
}LazyIterator.nextService()利用Class.forName(String name, boolean initialize,ClassLoader loader)載入服務提供者實現類，然後利用c.newInstance()例項化，把例項化的類儲存到providers中快取起來。
JDBC驅動載入是利用了Java的SPI機制。JDBC提供了一組介面規範，不同的資料庫廠商只要編寫符合這套JDBC介面規範的驅動程式碼，那麼就可以用Java語言來連線資料庫。
以MySQL為例分析JDBC驅動載入原始碼。
首先需要引入mysql-connector-java依賴包，版本為8.0.20。mysql-connector-java.jar包目錄下的META-INF/services/下有一個java.sql.Driver檔案，檔案內容如下所示：
com.mysql.cj.jdbc.Driver載入MySQL驅動類
public class DBUtils {
private static String dirverClassName = "com.mysql.cj.jdbc.Driver";
private static String url = "jdbc:mysql://127.0.0.1:3306/lzc?characterEncoding=utf8";
private static String user = "root";
private static String password = "root";
public static Connection getDBConnection() {
Connection conn = null;
// try {
// // 在JDBC 4.0 規範中可以省略這一步了
// // Class.forName 用來載入類資訊並執行類的靜態塊
// Class.forName(dirverClassName);
// } catch (ClassNotFoundException e) {
// e.printStackTrace();
// }
try {
// 透過 DriverManager 獲取 Connection
conn = DriverManager.getConnection(url, user, password);
} catch (SQLException e) {
e.printStackTrace();
}
return conn;
}
}從上面的程式碼可以發現，透過DriverManager.getConnection(String url,String user, String password)可以獲取Connection連線資訊，此時肯定會執行DriverManager的靜態塊程式碼。
檢視java.sql.DriverManager靜態程式碼：
// java.sql.DriverManager
public class DriverManager {
// 用來儲存JDBC驅動列表
// 就是實現了 java.sql.Driver 介面的類在類載入時會主動註冊到 registeredDrivers
private final static CopyOnWriteArrayList<DriverInfo> registeredDrivers = new CopyOnWriteArrayList<>();
static {
loadInitialDrivers();
println("JDBC DriverManager initialized");
}
}檢視loadInitialDrivers()方法
// java.sql.DriverManager
private static void loadInitialDrivers() {
String drivers;
try {
drivers = AccessController.doPrivileged(new PrivilegedAction<String>() {
public String run() {
return System.getProperty("jdbc.drivers");
}
});
} catch (Exception ex) {
drivers = null;
}
// 重點看這裡
AccessController.doPrivileged(new PrivilegedAction<Void>() {
public Void run() {
// 前面已經分析過這裡的原理了
ServiceLoader<Driver> loadedDrivers = ServiceLoader.load(Driver.class);
// 呼叫 ServiceLoader 的 iterator 方法
Iterator<Driver> driversIterator = loadedDrivers.iterator();
try{
// 在迭代的時候會去載入META-INF/services/java.sql.Driver檔案，
// 檔案內容為 com.mysql.cj.jdbc.Driver
// 然後例項化 com.mysql.cj.jdbc.Driver
while(driversIterator.hasNext()) {
driversIterator.next();
}
} catch(Throwable t) {
// Do nothing
}
return null;
}
});
println("DriverManager.initialize: jdbc.drivers = " + drivers);
if (drivers == null || drivers.equals("")) {
return;
}
String[] driversList = drivers.split(":");
println("number of Drivers:" + driversList.length);
for (String aDriver : driversList) {
try {
println("DriverManager.Initialize: loading " + aDriver);
Class.forName(aDriver, true,
ClassLoader.getSystemClassLoader());
} catch (Exception ex) {
println("DriverManager.Initialize: load failed: " + ex);
}
}
}這裡主要是利用了Java的SPI機制去例項化MySQL驅動類，下面檢視MySQL驅動類是如何註冊到DriverManager類的registeredDrivers集合中
驅動類註冊到DriverManager
檢視com.mysql.cj.jdbc.Driver的靜態塊程式碼
public class Driver extends NonRegisteringDriver implements java.sql.Driver {
//
// Register ourselves with the DriverManager
//
static {
try {
// 這裡會將 com.mysql.cj.jdbc.Driver 例項註冊到
// DriverManager類的registeredDrivers集合中
java.sql.DriverManager.registerDriver(new Driver());
} catch (SQLException E) {
throw new RuntimeException("Can't register driver!");
}
}
}看到這裡可以知道，com.mysql.cj.jdbc.Driver在例項化的時候會執行它的靜態塊程式碼，此時會將自己註冊到DriverManager類的registeredDrivers集合中。
MySQL驅動連線資料庫
com.mysql.cj.jdbc.Driver已經註冊到DriverManager類的registeredDrivers集合中，下面檢視它是何時被呼叫的。
透過前面的例子可以知道，透過DriverManager.getConnection(String url,String user, String password)可以獲取Connection連線資訊，檢視這個方法的程式碼：
// java.sql.DriverManager
public static Connection getConnection(String url, String user, String password) throws SQLException {
java.util.Properties info = new java.util.Properties();
if (user != null) {
info.put("user", user);
}
if (password != null) {
info.put("password", password);
}
return (getConnection(url, info, Reflection.getCallerClass()));
}繼續往下看
// java.sql.DriverManager
private static Connection getConnection(
String url, java.util.Properties info, Class<?> caller) throws SQLException {
ClassLoader callerCL = caller != null ? caller.getClassLoader() : null;
synchronized(DriverManager.class) {
// synchronize loading of the correct classloader.
if (callerCL == null) {
callerCL = Thread.currentThread().getContextClassLoader();
}
}
if(url == null) {
throw new SQLException("The url cannot be null", "08001");
}
println("DriverManager.getConnection(\"" + url + "\")");
// Walk through the loaded registeredDrivers attempting to make a connection.
// Remember the first exception that gets raised so we can reraise it.
SQLException reason = null;
// 主要檢視這裡
// 遍歷 registeredDrivers 集合
for(DriverInfo aDriver : registeredDrivers) {
// If the caller does not have permission to load the driver then
// skip it.
if(isDriverAllowed(aDriver.driver, callerCL)) {
try {
println(" trying " + aDriver.driver.getClass().getName());
// 利用驅動類來連線資料庫
Connection con = aDriver.driver.connect(url, info);
// 只要連線上就直接放回 Connection，如果有多個驅動類，其餘的就會被忽略
if (con != null) {
// Success!
println("getConnection returning " + aDriver.driver.getClass().getName());
return (con);
}
} catch (SQLException ex) {
if (reason == null) {
reason = ex;
}
}
} else {
println(" skipping: " + aDriver.getClass().getName());
}
}
// if we got here nobody could connect.
if (reason != null) {
println("getConnection failed: " + reason);
throw reason;
}
println("getConnection: no suitable driver found for "+ url);
throw new SQLException("No suitable driver found for "+ url, "08001");
}本作品採用《CC 協議》，轉載必須註明作者和本文連結