本文主要參考自Dubbo官方文檔、Dubbo項目源碼以及網絡文章和相關書籍，並附上自身的一些理解，如有遺漏或錯誤，還望海涵並指出。謝謝！
------本文基於Dubbo-2.6.1版本
一、什麼是SPI
SPI 全稱爲 Service Provider Interface，是一種服務發現機制。SPI 的本質是將接口實現類的全限定名配置在文件中，並由服務加載器讀取配置文件，加載實現類。這樣可以在運行時，動態爲接口替換實現類。正因此特性，我們可以很容易的通過 SPI 機制爲我們的程序提供拓展功能。SPI 機制在第三方框架中也有所應用，比如 Dubbo 就是通過 SPI 機制加載所有的組件。不過，Dubbo 並未使用 Java 原生的 SPI 機制，而是對其進行了增強，使其能夠更好的滿足需求。在 Dubbo 中，SPI 是一個非常重要的模塊。基於 SPI，我們可以很容易的對 Dubbo 進行拓展。
Java中的框架大量使用了SPI機制來實現接口的動態拓展，譬如數據庫連接驅動Driver(META-INF/services)，以及SpringBoot的Starter提供了自己的SPI機制(META-INF/spring.factories)。
dubbo對Java的SPI進行了增強，提供了對拓展點的IoC以及AOP的支持，並且相對於Java SPI來說，無需加載全部實現類，避免資源的浪費。dubbo SPI用以拓展協議、路由等26個拓展點，這也是整個dubbo體系的核心功能之一。
具體的SPI拓展用法參考dubbo文檔：
http://dubbo.apache.org/zh-cn/docs/dev/SPI.html
二、基本使用
2.1、核心註解和URL類
首先介紹下三個SPI核心註解：@SPI、@Adaptive、@Activate，整個dubbo項目中只要有使用SPI的地方就需要用到這三個註解來實現底層的SPI機制，它們的作用是：
-
@SPI：
指定當前接口爲可拓展接口，@SPI(“impl1”)表示該接口點默認實現類爲"impl1"。 -
@Adaptive：
表明該可拓展接口的方法是可以被動態替換的（具有多個不同的實現類可以執行這個方法），@Adaptive({“key1”, “key2”})可以動態地通知指定key1或key2的實現類，來動態地執行制定實現類的該方法。 -
@Activate：
擴展點自動激活加載的註解，就是用條件來控制該擴展點實現是否被自動激活加載，在擴展實現類上面使用
注意：
1.所有擴展點都通過傳遞URL類攜帶配置信息，所以適配器中的方法必須攜帶URL參數，才能根據URL中的配置來選擇對應的擴展實現。
2.@Adaptive註解中有一些key值，比如適配方法的註解中有兩個key，分別爲“key1”和“key2”，URL會首先去取key1對應的value來作爲@SPI註解中寫到的key值（也就是要執行的具體實現類方法），如果爲空，則去取key2對應的value，如果還是爲空，則會根據SPI默認的key去調用擴展的實現類，如果@SPI沒有設定默認值，則會拋出IllegalStateException異常。
2.2、單元測試
來看看dubbo-common模塊下的關於SPI的單元測試，就可以知道SPI是如何使用的了：
- 定義拓展接口
- SimpleExt
package com.alibaba.dubbo.common.extensionloader.ext1;
/**
* Simple extension, has no wrapper
*/
// 該接口的默認實現爲impl1
@SPI("impl1")
public interface SimpleExt {
// @Adaptive example, do not specify a explicit key.
@Adaptive
String echo(URL url, String s);
@Adaptive({"key1", "key2"})
String yell(URL url, String s);
// no @Adaptive
String bang(URL url, int i);
}
- 定義實現類
- SimpleExtImpl1
package com.alibaba.dubbo.common.extensionloader.ext1.impl;
public class SimpleExtImpl1 implements SimpleExt {
public String echo(URL url, String s) {
return "Ext1Impl1-echo";
}
public String yell(URL url, String s) {
return "Ext1Impl1-yell";
}
public String bang(URL url, int i) {
return "bang1";
}
}
- SimpleExtImpl2
package com.alibaba.dubbo.common.extensionloader.ext1.impl;
public class SimpleExtImpl2 implements SimpleExt {
public String echo(URL url, String s) {
return "Ext1Impl2-echo";
}
public String yell(URL url, String s) {
return "Ext1Impl2-yell";
}
public String bang(URL url, int i) {
return "bang2";
}
}
- SimpleExtImpl3
package com.alibaba.dubbo.common.extensionloader.ext1.impl;
public class SimpleExtImpl3 implements SimpleExt {
public String echo(URL url, String s) {
return "Ext1Impl3-echo";
}
public String yell(URL url, String s) {
return "Ext1Impl3-yell";
}
public String bang(URL url, int i) {
return "bang3";
}
}
- 定義SPI配置文件
根據SPI的規則，爲了實現對SimpleExt的動態拓展，需要在resource/META-INF/dubbo目錄下以SimpleExt接口全限定名作爲文本文件，並且在該文件中以xxx=全限定名Xxx實現類標示該接口的所有可能實現類：
- META-INF/dubbo/internal/com.alibaba.dubbo.common.extensionloader.ext1.SimpleExt
# Comment 1
impl1=com.alibaba.dubbo.common.extensionloader.ext1.impl.SimpleExtImpl1#Hello World
impl2=com.alibaba.dubbo.common.extensionloader.ext1.impl.SimpleExtImpl2 # Comment 2
impl3=com.alibaba.dubbo.common.extensionloader.ext1.impl.SimpleExtImpl3 # with head space
注意，這裏的dubbo/internal表明這是dubbo自身內置的實現
- 單元測試
- ExtensionLoader_Adaptive_Test
@Test
public void test_getAdaptiveExtension_defaultAdaptiveKey() throws Exception {
{
// URL中不指定key，使用默認的impl1作爲實現類
SimpleExt ext = ExtensionLoader.getExtensionLoader(SimpleExt.class).getAdaptiveExtension();
Map<String, String> map = new HashMap<String, String>();
URL url = new URL("p1", "1.2.3.4", 1010, "path1", map);
String echo = ext.echo(url, "haha");
assertEquals("Ext1Impl1-echo", echo);
}
{
// URL中通過SimleExt接口的拆分名simple.ext指定實現類爲impl2
SimpleExt ext = ExtensionLoader.getExtensionLoader(SimpleExt.class).getAdaptiveExtension();
Map<String, String> map = new HashMap<String, String>();
map.put("simple.ext", "impl2");
URL url = new URL("p1", "1.2.3.4", 1010, "path1", map);
String echo = ext.echo(url, "haha");
assertEquals("Ext1Impl2-echo", echo);
}
}
@Test
public void test_getAdaptiveExtension_customizeAdaptiveKey() throws Exception {
// URL通過key2和key1來分別指定實現類爲impl2和impl3
SimpleExt ext = ExtensionLoader.getExtensionLoader(SimpleExt.class).getAdaptiveExtension();
Map<String, String> map = new HashMap<String, String>();
map.put("key2", "impl2");
URL url = new URL("p1", "1.2.3.4", 1010, "path1", map);
String echo = ext.yell(url, "haha");
assertEquals("Ext1Impl2-yell", echo);
url = url.addParameter("key1", "impl3"); // note: URL is value's type
echo = ext.yell(url, "haha");
assertEquals("Ext1Impl3-yell", echo);
}
三、SPI機制源碼解析
- Dubbo SPI機制源碼的官方文檔解讀：http://dubbo.apache.org/zh-cn/docs/source_code_guide/dubbo-spi.html
整個SPI機制的實現代碼都位於dubbo-common模塊中的com.alibaba.dubbo.common.extension包下，來看看extension包所含的內容：
所含的Java代碼量（不含註釋）爲900行左右：
其中，ExtensionLoader是Dubbo SPI機制的核心類，相當於Java SPI機制中的ServiceLoader，ServiceLoader通過加載的是META-INF/services下的內容，而ExtensionLoader加載的是META-INF/dubbo下的內容並且做出了更復雜的定製。
3.1、ExtensionLoader
ExtensionLoader是整個Dubbo SPI的核心類，用來實現對META-INF/dubbo下的實現類做SPI判斷、動態加載、自動裝配、封裝成Wrapper給用戶所使用。
3.1.1、屬性
// logger
private static final Logger logger = LoggerFactory.getLogger(ExtensionLoader.class);
// JDK SPI文件夾
private static final String SERVICES_DIRECTORY = "META-INF/services/";
// Dubbo 用戶SPI文件夾
private static final String DUBBO_DIRECTORY = "META-INF/dubbo/";
// Dubbo 內置SPI文件夾
private static final String DUBBO_INTERNAL_DIRECTORY = DUBBO_DIRECTORY + "internal/";
// 正則表達式，以,分割成字符串數組
private static final Pattern NAME_SEPARATOR = Pattern.compile("\\s*[,]+\\s*");
// 拓展加載器集合，key爲拓展接口，value爲對應的加載器
private static final ConcurrentMap<Class<?>, ExtensionLoader<?>> EXTENSION_LOADERS = new ConcurrentHashMap<Class<?>, ExtensionLoader<?>>();
// 拓展加載器實例集合，key爲拓展實現類，value爲拓展接口
private static final ConcurrentMap<Class<?>, Object> EXTENSION_INSTANCES = new ConcurrentHashMap<Class<?>, Object>();
// ==============================
// 被拓展的接口對象
private final Class<?> type;
// 當前拓展對象工廠，內含getExtension方法
private final ExtensionFactory objectFactory;
// 緩存的拓展接口與拓展名
private final ConcurrentMap<Class<?>, String> cachedNames = new ConcurrentHashMap<Class<?>, String>();
// 緩存的拓展實現類集合（Holder是拓展對象的包裝實現類，在其中包裝了實現類）
private final Holder<Map<String, Class<?>>> cachedClasses = new Holder<Map<String, Class<?>>>();
// 擴展名與加有@Activate的自動激活類的映射
private final Map<String, Activate> cachedActivates = new ConcurrentHashMap<String, Activate>();
// 緩存的擴展對象集合，key爲擴展名，value爲擴展對象
private final ConcurrentMap<String, Holder<Object>> cachedInstances = new ConcurrentHashMap<String, Holder<Object>>();
// 緩存的@Adaptive對象
private final Holder<Object> cachedAdaptiveInstance = new Holder<Object>();
// 緩存的自適應擴展對象的類
private volatile Class<?> cachedAdaptiveClass = null;
// 緩存的默認擴展名，@SPI中設置的值
private String cachedDefaultName;
// 創建@Adaptive對象失敗異常
private volatile Throwable createAdaptiveInstanceError;
// 拓展Wrapper實現類集合
private Set<Class<?>> cachedWrapperClasses;
// 拓展名與加載對應拓展類發生的異常的映射
private Map<String, IllegalStateException> exceptions = new ConcurrentHashMap<String, IllegalStateException>();
3.1.2、拓展類資源加載
首先， 爲了獲取到拓展類，ExtensionLoader做的的一件事就是對拓展類資源進行加載，這個步驟依次調用了getExtensionClasses方法、loadExtensionClasses和loadFile方法：
1）getExtensionClasses
private Map<String, Class<?>> getExtensionClasses() {
// 從緩存中獲取拓展實現類
Map<String, Class<?>> classes = cachedClasses.get();
// 雙重檢查加鎖，若classes不存在，則使用loadExtensionClasses方法
// 將實現類加入cachedClasses中，再進行獲取
if (classes == null) {
synchronized (cachedClasses) {
classes = cachedClasses.get();
if (classes == null) {
classes = loadExtensionClasses();
cachedClasses.set(classes);
}
}
}
return classes;
}
2）loadExtensionClasses
private Map<String, Class<?>> loadExtensionClasses() {
// 獲取到該拓展接口的@SPI註解
final SPI defaultAnnotation = type.getAnnotation(SPI.class);
// 將@SPI註解的默認實現類名稱放入cachedDefaultName中
if (defaultAnnotation != null) {
String value = defaultAnnotation.value();
if (value != null && (value = value.trim()).length() > 0) {
String[] names = NAME_SEPARATOR.split(value);
if (names.length > 1) {
throw new IllegalStateException("more than 1 default extension name on extension " + type.getName()
+ ": " + Arrays.toString(names));
}
if (names.length == 1) cachedDefaultName = names[0];
}
}
// 創建extensionClasses，以拓展類名稱爲key，以具體拓展類爲value放入map中
Map<String, Class<?>> extensionClasses = new HashMap<String, Class<?>>();
// 從3個SPI文件夾中加載拓展類
loadFile(extensionClasses, DUBBO_INTERNAL_DIRECTORY);
loadFile(extensionClasses, DUBBO_DIRECTORY);
loadFile(extensionClasses, SERVICES_DIRECTORY);
return extensionClasses;
}
3）loadFile
/*
* 根據SPI DIR加載拓展類到Map中
*/
private void loadFile(Map<String, Class<?>> extensionClasses, String dir) {
String fileName = dir + type.getName();
try {
Enumeration<java.net.URL> urls;
// 獲取ExtensionLoader的ClassLoader
ClassLoader classLoader = findClassLoader();
if (classLoader != null) {
urls = classLoader.getResources(fileName);
} else {
urls = ClassLoader.getSystemResources(fileName);
}
// h獲取到SPI DIR下的urls，對其解析
if (urls != null) {
while (urls.hasMoreElements()) {
java.net.URL url = urls.nextElement();
try {
BufferedReader reader = new BufferedReader(new InputStreamReader(url.openStream(), "utf-8"));
try {
String line = null;
while ((line = reader.readLine()) != null) {
// 忽略註釋
final int ci = line.indexOf('#');
if (ci >= 0) line = line.substring(0, ci);
line = line.trim();
if (line.length() > 0) {
try {
String name = null;
// 用=號分割出實現類名稱和全限定名
int i = line.indexOf('=');
if (i > 0) {
name = line.substring(0, i).trim();
line = line.substring(i + 1).trim();
}
if (line.length() > 0) {
// 用反射+全限定名+ClassLoader獲取到實現類的Class對象
Class<?> clazz = Class.forName(line, true, classLoader);
if (!type.isAssignableFrom(clazz)) {
// 如果clazz並不是type的實現類，拋出異常
throw new IllegalStateException("Error when load extension class(interface: " +
type + ", class line: " + clazz.getName() + "), class "
+ clazz.getName() + "is not subtype of interface.");
}
// 如果class已經聲明瞭@Adaptive註解，那麼設置默認的cachedAdaptiveClass爲class
if (clazz.isAnnotationPresent(Adaptive.class)) {
if (cachedAdaptiveClass == null) {
cachedAdaptiveClass = clazz;
} else if (!cachedAdaptiveClass.equals(clazz)) {
// 如果多個實現類都聲明瞭@Adaptive註解，拋出異常
throw new IllegalStateException("More than 1 adaptive class found: "
+ cachedAdaptiveClass.getClass().getName()
+ ", " + clazz.getClass().getName());
}
} else {
// 緩存拓展 Wrapper 實現類到 cachedWrapperClasses
try {
clazz.getConstructor(type);
Set<Class<?>> wrappers = cachedWrapperClasses;
if (wrappers == null) {
cachedWrapperClasses = new ConcurrentHashSet<Class<?>>();
wrappers = cachedWrapperClasses;
}
wrappers.add(clazz);
} catch (NoSuchMethodException e) {
clazz.getConstructor();
if (name == null || name.length() == 0) {
name = findAnnotationName(clazz);
if (name == null || name.length() == 0) {
if (clazz.getSimpleName().length() > type.getSimpleName().length()
&& clazz.getSimpleName().endsWith(type.getSimpleName())) {
name = clazz.getSimpleName().substring(0, clazz.getSimpleName().length() - type.getSimpleName().length()).toLowerCase();
} else {
throw new IllegalStateException("No such extension name for the class " + clazz.getName() + " in the config " + url);
}
}
}
String[] names = NAME_SEPARATOR.split(name);
// 將拓展實現類加載到extensionClasses這個Map中
if (names != null && names.length > 0) {
Activate activate = clazz.getAnnotation(Activate.class);
if (activate != null) {
cachedActivates.put(names[0], activate);
}
for (String n : names) {
if (!cachedNames.containsKey(clazz)) {
cachedNames.put(clazz, n);
}
Class<?> c = extensionClasses.get(n);
if (c == null) {
extensionClasses.put(n, clazz);
} else if (c != clazz) {
throw new IllegalStateException("Duplicate extension " + type.getName() + " name " + n + " on " + c.getName() + " and " + clazz.getName());
}
}
}
}
}
}
} catch (Throwable t) {
// 發生異常，記錄到異常集合
IllegalStateException e = new IllegalStateException("Failed to load extension class(interface: " + type + ", class line: " + line + ") in " + url + ", cause: " + t.getMessage(), t);
exceptions.put(line, e);
}
}
} // end of while read lines
} finally {
reader.close();
}
} catch (Throwable t) {
logger.error("Exception when load extension class(interface: " +
type + ", class file: " + url + ") in " + url, t);
}
} // end of while urls
}
} catch (Throwable t) {
logger.error("Exception when load extension class(interface: " +
type + ", description file: " + fileName + ").", t);
}
}
3.1.3、獲取指定Extension
當完成了拓展點的實現資源加載之後，需要獲取到特定的拓展類（Extension）以調用相應的方法，第一種獲取Extension的方法是通過getExtension方法並指定拓展類名稱（在SPI文件中配置的那個xxx=XxxProtocol中的xxx就是名稱）：
ExtensionLoader.getExtensionLoader(Protocol.class).getExtension(name)
2）createExtension
創建指定拓展類對象並緩存。
private T createExtension(String name) {
// 首先獲取到第一步資源加載中已經加載好的實現類class
Class<?> clazz = getExtensionClasses().get(name);
if (clazz == null) {
throw findException(name);
}
try {
T instance = (T) EXTENSION_INSTANCES.get(clazz);
if (instance == null) {
EXTENSION_INSTANCES.putIfAbsent(clazz, (T) clazz.newInstance());
instance = (T) EXTENSION_INSTANCES.get(clazz);
}
// Dubbo自實現的IoC，通過setter方法注入實例所需的對象或屬性
injectExtension(instance);
// 構建Wrapper對象
Set<Class<?>> wrapperClasses = cachedWrapperClasses;
if (wrapperClasses != null && !wrapperClasses.isEmpty()) {
for (Class<?> wrapperClass : wrapperClasses) {
instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance));
}
}
return instance;
} catch (Throwable t) {
throw new IllegalStateException("Extension instance(name: " + name + ", class: " +
type + ") could not be instantiated: " + t.getMessage(), t);
}
}
3）injectExtension
Dubbo 自實現的IoC（通過過setter方法注入）
private T injectExtension(T instance) {
try {
if (objectFactory != null) {
// 獲取到實例的Method對象，解析出setter方法
for (Method method : instance.getClass().getMethods()) {
if (method.getName().startsWith("set")
&& method.getParameterTypes().length == 1
&& Modifier.isPublic(method.getModifiers())) {
Class<?> pt = method.getParameterTypes()[0];
try {
// 獲取setter方法中的參數
String property = method.getName().length() > 3 ? method.getName().substring(3, 4).toLowerCase() + method.getName().substring(4) : "";
// 通過參數獲取到所需注入的對象
Object object = objectFactory.getExtension(pt, property);
if (object != null) {
// 執行setter方法注入
method.invoke(instance, object);
}
} catch (Exception e) {
logger.error("fail to inject via method " + method.getName()
+ " of interface " + type.getName() + ": " + e.getMessage(), e);
}
}
}
}
} catch (Exception e) {
logger.error(e.getMessage(), e);
}
return instance;
}
3.1.4、獲取自適應Extension
要獲取到Extension實現類，除第一種直接指定名稱獲取Extension方法外，還可以用更簡單的方式獲取到Extension，也就是通過getAdaptiveExtension方法獲取到自適應的Extension，由Dubbo SPI機制來決定獲取到哪個Extension。
ExtensionLoader.getExtensionLoader(Protocol.class).getAdaptiveExtension()
1）getAdaptiveExtension
該方法獲取到自適應的拓展實現類對象。
public T getAdaptiveExtension() {
// 獲取緩存的Adaptive實例對象
Object instance = cachedAdaptiveInstance.get();
// 若instance不存在
if (instance == null) {
// 雙重檢查加鎖,通過createAdaptiveExtension方法創建instance
if (createAdaptiveInstanceError == null) {
synchronized (cachedAdaptiveInstance) {
instance = cachedAdaptiveInstance.get();
if (instance == null) {
try {
// 創建AdaptiveExtension
instance = createAdaptiveExtension();
// 將該instance存儲到cachedAdaptiveInstance中
cachedAdaptiveInstance.set(instance);
} catch (Throwable t) {
createAdaptiveInstanceError = t;
throw new IllegalStateException("fail to create adaptive instance: " + t.toString(), t);
}
}
}
} else {
throw new IllegalStateException("fail to create adaptive instance: " + createAdaptiveInstanceError.toString(), createAdaptiveInstanceError);
}
}
// 返回該instance
return (T) instance;
}
2）createAdaptiveExtension
該方法，創建自適應拓展實現類對象。
private T createAdaptiveExtension() {
try {
// 還是通過injectExtension做IoC注入
return injectExtension((T) getAdaptiveExtensionClass().newInstance());
} catch (Exception e) {
throw new IllegalStateException("Can not create adaptive extension " + type + ", cause: " + e.getMessage(), e);
}
}
3）getAdaptiveExtensionClass
private Class<?> getAdaptiveExtensionClass() {
getExtensionClasses();
if (cachedAdaptiveClass != null) {
return cachedAdaptiveClass;
}
return cachedAdaptiveClass = createAdaptiveExtensionClass();
}
4）createAdaptiveExtensionClass
創建自適應拓展類的代碼並進行編譯返回，生成Xxx$Adaptive自適應類。
private Class<?> createAdaptiveExtensionClass() {
// 生成自適應類的代碼字符串
String code = createAdaptiveExtensionClassCode();
// 獲取ClassLoader
ClassLoader classLoader = findClassLoader();
// 對代碼進行編譯，生成相應的Class返回
com.alibaba.dubbo.common.compiler.Compiler compiler = ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.common.compiler.Compiler.class).getAdaptiveExtension();
return compiler.compile(code, classLoader);
}
3.2、ExtensionFactory
整個SPI體系最重要的ExtensionLoader的主要源碼看完了，現在來看看一些Factory接口和實現類。
該接口自身也是一個可拓展的接口，在ExtensionLoader中injectExtension方法中被用來獲取到setter方法注入的對象：
try {
// 獲取setter方法中的參數
String property = method.getName().length() > 3 ? method.getName().substring(3, 4).toLowerCase() + method.getName().substring(4) : "";
// 通過參數獲取到所需注入的對象
Object object = objectFactory.getExtension(pt, property);
if (object != null) {
// 執行setter方法注入
method.invoke(instance, object);
}
} catch (Exception e) {
logger.error("fail to inject via method " + method.getName()
+ " of interface " + type.getName() + ": " + e.getMessage(), e);
}
代碼：
@SPI
public interface ExtensionFactory {
/**
* 獲取拓展實例
*
* @param type object 拓展接口.
* @param name object 拓展名.
* @return object 拓展實例.
*/
<T> T getExtension(Class<T> type, String name);
}
ExtensionFactory有兩個實現類，其實新版本中存在三個實現類，分別是：
AdaptiveExtensionFactory、SpiExtensionFactory和SpringExtensionFactory，其中AdaptiveExtensionFactory是自適應的實現類，使用的是ExtensionLoader來注入對象；而SpiExtensionFactory也是使用ExtensionLoader來注入對象，但是它會直接獲取到當前type的自適應對象進行注入；而SpringExtensionFactory則是使用Spring IoC容器中的Bean進行注入。
- AdaptiveExtensionFactory
@Adaptive
public class AdaptiveExtensionFactory implements ExtensionFactory {
private final List<ExtensionFactory> factories;
public AdaptiveExtensionFactory() {
ExtensionLoader<ExtensionFactory> loader = ExtensionLoader.getExtensionLoader(ExtensionFactory.class);
List<ExtensionFactory> list = new ArrayList<ExtensionFactory>();
for (String name : loader.getSupportedExtensions()) {
list.add(loader.getExtension(name));
}
factories = Collections.unmodifiableList(list);
}
public <T> T getExtension(Class<T> type, String name) {
for (ExtensionFactory factory : factories) {
T extension = factory.getExtension(type, name);
if (extension != null) {
return extension;
}
}
return null;
}
}
- SpiExtensionFactory
public class SpiExtensionFactory implements ExtensionFactory {
/**
* 獲得拓展對象
*
* @param type object type. 拓展接口
* @param name object name. 拓展名
* @param <T> 泛型
* @return 拓展對象
*/
public <T> T getExtension(Class<T> type, String name) {
if (type.isInterface() && type.isAnnotationPresent(SPI.class)) { // 校驗是 @SPI
// 加載拓展接口對應的 ExtensionLoader 對象
ExtensionLoader<T> loader = ExtensionLoader.getExtensionLoader(type);
// 加載拓展對象
if (!loader.getSupportedExtensions().isEmpty()) {
return loader.getAdaptiveExtension();
}
}
return null;
}
}
- SpringExtensionFactory
public class SpringExtensionFactory implements ExtensionFactory {
/**
* Spring Context 集合
*/
private static final Set<ApplicationContext> contexts = new ConcurrentHashSet<ApplicationContext>();
public static void addApplicationContext(ApplicationContext context) {
contexts.add(context);
}
public static void removeApplicationContext(ApplicationContext context) {
contexts.remove(context);
}
@Override
@SuppressWarnings("unchecked")
public <T> T getExtension(Class<T> type, String name) {
for (ApplicationContext context : contexts) {
if (context.containsBean(name)) {
// 獲得屬性
Object bean = context.getBean(name);
// 判斷類型
if (type.isInstance(bean)) {
return (T) bean;
}
}
}
return null;
}
}