SPI服務發現機制
SPI是Java JDK內部提供的一種服務發現機制，
-
SPI->Service Provider Interface,服務提供介面，是Java JDK內置的一種服務發現機制
-
通過在ClassPath路徑下的META-INF/services檔案夾查找檔案，自動加載檔案里所定義的類
[??注意事項]：
面向物件的設計里，一般推薦模塊之間基于介面編程，模塊之間不對實作類進行編碼，如果涉及實作類就會違反可插拔的原則，針對于模塊裝配，Java SPI提供了為某個介面尋找服務的實作機制，
SPI規范
- 使用約定：
[1].撰寫服務提供介面，可以是抽象介面和函式介面，JDK1.8之后推薦使用函式介面
[2].在jar包的META-INF/services/目錄里創建一個以服務介面命名的檔案，其實就是實作該服務介面的具體實作類，
提供一個目錄：
META-INF/services/
放到ClassPath下面
[3].當外部程式裝配這個模塊的時候，就能通過該Jar包META-INF/services/組態檔找到具體的實作類名，并裝載實體化，完成模塊注入，
目錄下放置一個組態檔：
檔案名是需要拓展的介面全限定名稱
檔案內部為要實作的介面實作類
檔案必須為UTF-8編碼
[4].尋找服務介面實作，不用在代碼中提供，而是利用JDK提供服務查找工具類:java.util.ServiceLoader類來加載使用：
ServiceLoader.load(xxx.class)
ServiceLoader<XXXInterface> loads = ServiceLoader.load(xxx.class)
SPI原始碼分析
[1].ServiceLoader原始碼:
package java.util;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URL;
import java.security.AccessController;
import java.security.AccessControlContext;
import java.security.PrivilegedAction;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.List;
import java.util.NoSuchElementException;
public final class ServiceLoader<S> implements Iterable<S>
{
//[1].初始化定義全域組態檔路徑Path
private static final String PREFIX = "META-INF/services/";
//[2].初始化定義加載的服務類或介面
private final Class<S> service;
//[3].初始化定義類加載器
private final ClassLoader loader;
//[4].初始化定義訪問控制背景關系
private final AccessControlContext acc;
//[5].初始化定義加載服務類的快取集合
private LinkedHashMap<String,S> providers = new LinkedHashMap<>();
//[6].初始化定義私有內部LazyIterator類，真正加載服務類的實作類
private LazyIterator lookupIterator;
//私有化有參構造-> ServiceLoader(Class<S> svc, ClassLoader cl)
private ServiceLoader(Class<S> svc, ClassLoader cl) { //[1].實體化服務介面->Class<S>
service = Objects.requireNonNull(svc, "Service interface cannot be null");
//[2].實體化類加載器->ClassLoader
loader = (cl == null) ? ClassLoader.getSystemClassLoader() : cl;
//[3].實體化訪問控制背景關系->AccessControlContext
acc = (System.getSecurityManager() != null) ? AccessController.getContext() : null;
//[4].回呼函式->reload
reload();
}
public void reload() {
//[1].清空快取實體集合
providers.clear();
//[2].實體化私有內部LazyIterator類->LazyIterator
lookupIterator = new LazyIterator(service, loader);
}
public static <S> ServiceLoader<S> load(Class<S> service,ClassLoader loader)
{
return new ServiceLoader<>(service, loader);
}
public static <S> ServiceLoader<S> load(Class<S> service) {
ClassLoader cl = Thread.currentThread().getContextClassLoader();
return ServiceLoader.load(service, cl);
}
}
2.LazyIterator原始碼:
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;
}
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
}
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);
}
}
public void remove() {
throw new UnsupportedOperationException();
}
}
使用舉例
[1].Dubbo SPI 機制：
META-INF/dubbo.internal/xxx=介面全限定名
Dubbo 并未使用 Java SPI，而是重新實作了一套功能更強的 SPI 機制，
Dubbo SPI 的相關邏輯被封裝在了 ExtensionLoader 類中，通過 ExtensionLoader，我們可以加載指定的實作類，Dubbo SPI 所需的組態檔需放置在 META-INF/dubbo 路徑下，
與Java SPI 實作類配置不同，Dubbo SPI 是通過鍵值對的方式進行配置，這樣我們可以按需加載指定的實作類，另外，在測驗 Dubbo SPI 時，需要在 Robot 介面上標注 @SPI 注解，
[2].Cache SPI 機制:
META-INF/service/javax.cache.spi.CachingProvider=xxx
[3]Spring SPI 機制:
META-INF/services/org.apache.commons.logging.LogFactory=xxx
[4].SpringBoot SPI機制:
META-INF/spring.factories/org.springframework.boot.autoconfigure.EnableAutoConfiguration=xxx
在springboot的自動裝配程序中，最侄訓加載META-INF/spring.factories檔案，而加載的程序是由SpringFactoriesLoader加載的，從CLASSPATH下的每個Jar包中搜尋所有META-INF/spring.factories組態檔，然后將決議properties檔案，找到指定名稱的配置后回傳
原始碼：
public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";
// spring.factories檔案的格式為：key=value1,value2,value3
// 從所有的jar包中找到META-INF/spring.factories檔案
// 然后從檔案中決議出key=factoryClass類名稱的所有value值
public static List<String> loadFactoryNames(Class<?> factoryClass, ClassLoader classLoader) {
String factoryClassName = factoryClass.getName();
// 取得資源檔案的URL
Enumeration<URL> urls = (classLoader != null ? classLoader.getResources(FACTORIES_RESOURCE_LOCATION) : ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
List<String> result = new ArrayList<String>();
// 遍歷所有的URL
while (urls.hasMoreElements()) {
URL url = urls.nextElement();
// 根據資源檔案URL決議properties檔案，得到對應的一組@Configuration類
Properties properties = PropertiesLoaderUtils.loadProperties(new UrlResource(url));
String factoryClassNames = properties.getProperty(factoryClassName);
// 組裝資料，并回傳
result.addAll(Arrays.asList(StringUtils.commaDelimitedListToStringArray(factoryClassNames)));
}
return result;
}
[5].自定義序列化實作SPI:META-INF/services/xxx=介面全限定名
參考學習Java SPI 和Dubbo SPI機制原始碼,自己動手實作序列化工具類等
著作權宣告：本文為博主原創文章，遵循相關著作權協議，如若轉載或者分享請附上原文出處鏈接和鏈接來源，
轉載請註明出處，本文鏈接：https://www.uj5u.com/ruanti/3082.html
標籤：架構設計