Dubbo源碼解析之SPI機制
1. 簡介
Dubbo 並未使用 Java 原生的 SPI 機制，而是對其進行了加強，使其可以更好的知足需求。在 Dubbo 中，SPI 是一個很是重要的模塊。基於 SPI，咱們能夠很容易的對 Dubbo 進行拓展。java
2. 源碼分析
Dubbo SPI 的相關邏輯被封裝在了 ExtensionLoader 類中，經過 ExtensionLoader，咱們能夠加載指定的實現類。Dubbo SPI 所需的配置文件需放置在 META-INF/dubbo 路徑下。數組
咱們首先經過 ExtensionLoader 的 getExtensionLoader 方法獲取一個 ExtensionLoader 實例，而後再經過 ExtensionLoader 的 getExtension 方法獲取拓展類對象。這其中，getExtensionLoader 方法用於從緩存中獲取與拓展類對應的 ExtensionLoader，若緩存未命中，則建立一個新的實例。該方法的邏輯比較簡單，本章就不進行分析了。緩存
下面咱們從 ExtensionLoader 的 getExtension 方法做爲入口，對拓展類對象的獲取過程進行詳細的分析。架構
public T getExtension(String name) {
if (name == null || name.length() == 0)
throw new IllegalArgumentException("Extension name == null");
if ("true".equals(name)) {
// 獲取默認的拓展實現類
return getDefaultExtension();
}
// Holder，顧名思義，用於持有目標對象
Holder<Object> holder = cachedInstances.get(name);
if (holder == null) {
cachedInstances.putIfAbsent(name, new Holder<Object>());
holder = cachedInstances.get(name);
}
Object instance = holder.get();
// 雙重檢查
if (instance == null) {
synchronized (holder) {
instance = holder.get();
if (instance == null) {
// 建立拓展實例
instance = createExtension(name);
// 設置實例到 holder 中
holder.set(instance);
}
}
}
return (T) instance;
}
複製代碼
上面代碼的邏輯比較簡單，首先檢查緩存，緩存未命中則建立拓展對象。下面咱們來看一下建立拓展對象的過程是怎樣的。app
private T createExtension(String name) {
// 從配置文件中加載全部的拓展類，可獲得「配置項名稱」到「配置類」的映射關係表
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, clazz.newInstance());
instance = (T) EXTENSION_INSTANCES.get(clazz);
}
// 向實例中注入依賴
injectExtension(instance);
Set<Class<?>> wrapperClasses = cachedWrapperClasses;
if (wrapperClasses != null && !wrapperClasses.isEmpty()) {
// 循環建立 Wrapper 實例
for (Class<?> wrapperClass : wrapperClasses) {
// 將當前 instance 做爲參數傳給 Wrapper 的構造方法，並經過反射建立 Wrapper 實例。
// 而後向 Wrapper 實例中注入依賴，最後將 Wrapper 實例再次賦值給 instance 變量
instance = injectExtension(
(T) wrapperClass.getConstructor(type).newInstance(instance));
}
}
return instance;
} catch (Throwable t) {
throw new IllegalStateException("...");
}
}
複製代碼
createExtension 方法的邏輯稍複雜一下，包含了以下的步驟：源碼分析
- 經過 getExtensionClasses 獲取全部的拓展類
- 經過反射建立拓展對象
- 向拓展對象中注入依賴
- 將拓展對象包裹在相應的 Wrapper 對象中
以上步驟中，第一個步驟是加載拓展類的關鍵，第三和第四個步驟是 Dubbo IOC 與 AOP 的具體實現。在接下來的章節中，將會重點分析 getExtensionClasses 方法的邏輯，以及簡單介紹 Dubbo IOC 的具體實現。url
3. 獲取全部的拓展類
咱們在經過名稱獲取拓展類以前，首先須要根據配置文件解析出拓展項名稱到拓展類的映射關係表（Map<名稱, 拓展類>），以後再根據拓展項名稱從映射關係表中取出相應的拓展類便可。相關過程的代碼分析以下：spa
private Map<String, Class<?>> getExtensionClasses() {
// 從緩存中獲取已加載的拓展類
Map<String, Class<?>> classes = cachedClasses.get();
// 雙重檢查
if (classes == null) {
synchronized (cachedClasses) {
classes = cachedClasses.get();
if (classes == null) {
// 加載拓展類
classes = loadExtensionClasses();
cachedClasses.set(classes);
}
}
}
return classes;
}
複製代碼
這裏也是先檢查緩存，若緩存未命中，則經過 synchronized 加鎖。加鎖後再次檢查緩存，並判空。此時若是 classes 仍爲 null，則經過 loadExtensionClasses 加載拓展類。下面分析 loadExtensionClasses 方法的邏輯。.net
private Map<String, Class<?>> loadExtensionClasses() {
// 獲取 SPI 註解，這裏的 type 變量是在調用 getExtensionLoader 方法時傳入的
final SPI defaultAnnotation = type.getAnnotation(SPI.class);
if (defaultAnnotation != null) {
String value = defaultAnnotation.value();
if ((value = value.trim()).length() > 0) {
// 對 SPI 註解內容進行切分
String[] names = NAME_SEPARATOR.split(value);
// 檢測 SPI 註解內容是否合法，不合法則拋出異常
if (names.length > 1) {
throw new IllegalStateException("more than 1 default extension name on extension...");
}
// 設置默認名稱，參考 getDefaultExtension 方法
if (names.length == 1) {
cachedDefaultName = names[0];
}
}
}
Map<String, Class<?>> extensionClasses = new HashMap<String, Class<?>>();
// 加載指定文件夾下的配置文件
loadDirectory(extensionClasses, DUBBO_INTERNAL_DIRECTORY);
loadDirectory(extensionClasses, DUBBO_DIRECTORY);
loadDirectory(extensionClasses, SERVICES_DIRECTORY);
return extensionClasses;
}
複製代碼
loadExtensionClasses 方法總共作了兩件事情，一是對 SPI 註解進行解析，二是調用 loadDirectory 方法加載指定文件夾配置文件。SPI 註解解析過程比較簡單，無需多說。下面咱們來看一下 loadDirectory 作了哪些事情。調試
private void loadDirectory(Map<String, Class<?>> extensionClasses, String dir) {
// fileName = 文件夾路徑 + type 全限定名
String fileName = dir + type.getName();
try {
Enumeration<java.net.URL> urls;
ClassLoader classLoader = findClassLoader();
// 根據文件名加載全部的同名文件
if (classLoader != null) {
urls = classLoader.getResources(fileName);
} else {
urls = ClassLoader.getSystemResources(fileName);
}
if (urls != null) {
while (urls.hasMoreElements()) {
java.net.URL resourceURL = urls.nextElement();
// 加載資源
loadResource(extensionClasses, classLoader, resourceURL);
}
}
} catch (Throwable t) {
logger.error("...");
}
}
複製代碼
loadDirectory 方法先經過 classLoader 獲取全部資源連接，而後再經過 loadResource 方法加載資源。咱們繼續跟下去，看一下 loadResource 方法的實現。
private void loadResource(Map<String, Class<?>> extensionClasses, ClassLoader classLoader, java.net.URL resourceURL) {
try {
BufferedReader reader = new BufferedReader(
new InputStreamReader(resourceURL.openStream(), "utf-8"));
try {
String line;
// 按行讀取配置內容
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) {
// 加載類，並經過 loadClass 方法對類進行緩存
loadClass(extensionClasses, resourceURL,
Class.forName(line, true, classLoader), name);
}
} catch (Throwable t) {
IllegalStateException e = new IllegalStateException("Failed to load extension class...");
}
}
}
} finally {
reader.close();
}
} catch (Throwable t) {
logger.error("Exception when load extension class...");
}
}
複製代碼
loadResource 方法用於讀取和解析配置文件，並經過反射加載類，最後調用 loadClass 方法進行其餘操做。loadClass 方法用於主要用於操做緩存，該方法的邏輯以下：
private void loadClass(Map<String, Class<?>> extensionClasses, java.net.URL resourceURL, Class<?> clazz, String name) throws NoSuchMethodException {
if (!type.isAssignableFrom(clazz)) {
throw new IllegalStateException("...");
}
// 檢測目標類上是否有 Adaptive 註解
if (clazz.isAnnotationPresent(Adaptive.class)) {
if (cachedAdaptiveClass == null) {
// 設置 cachedAdaptiveClass緩存
cachedAdaptiveClass = clazz;
} else if (!cachedAdaptiveClass.equals(clazz)) {
throw new IllegalStateException("...");
}
// 檢測 clazz 是不是 Wrapper 類型
} else if (isWrapperClass(clazz)) {
Set<Class<?>> wrappers = cachedWrapperClasses;
if (wrappers == null) {
cachedWrapperClasses = new ConcurrentHashSet<Class<?>>();
wrappers = cachedWrapperClasses;
}
// 存儲 clazz 到 cachedWrapperClasses 緩存中
wrappers.add(clazz);
// 程序進入此分支，代表 clazz 是一個普通的拓展類
} else {
// 檢測 clazz 是否有默認的構造方法，若是沒有，則拋出異常
clazz.getConstructor();
if (name == null || name.length() == 0) {
// 若是 name 爲空，則嘗試從 Extension 註解中獲取 name，或使用小寫的類名做爲 name
name = findAnnotationName(clazz);
if (name.length() == 0) {
throw new IllegalStateException("...");
}
}
// 切分 name
String[] names = NAME_SEPARATOR.split(name);
if (names != null && names.length > 0) {
Activate activate = clazz.getAnnotation(Activate.class);
if (activate != null) {
// 若是類上有 Activate 註解，則使用 names 數組的第一個元素做爲鍵，
// 存儲 name 到 Activate 註解對象的映射關係
cachedActivates.put(names[0], activate);
}
for (String n : names) {
if (!cachedNames.containsKey(clazz)) {
// 存儲 Class 到名稱的映射關係
cachedNames.put(clazz, n);
}
Class<?> c = extensionClasses.get(n);
if (c == null) {
// 存儲名稱到 Class 的映射關係
extensionClasses.put(n, clazz);
} else if (c != clazz) {
throw new IllegalStateException("...");
}
}
}
}
}
複製代碼
如上，loadClass 方法操做了不一樣的緩存，好比 cachedAdaptiveClass、cachedWrapperClasses 和 cachedNames 等等。除此以外，該方法沒有其餘什麼邏輯了。
到此，關於緩存類加載的過程就分析完了。整個過程沒什麼特別複雜的地方，你們循序漸進的分析便可，不懂的地方能夠調試一下。接下來，咱們來聊聊 Dubbo IOC 方面的內容。
4. Dubbo IOC
Dubbo IOC 是經過 setter 方法注入依賴。Dubbo 首先會經過反射獲取到實例的全部方法，而後再遍歷方法列表，檢測方法名是否具備 setter 方法特徵。如有，則經過 ObjectFactory 獲取依賴對象，最後經過反射調用 setter 方法將依賴設置到目標對象中。整個過程對應的代碼以下：
private T injectExtension(T instance) {
try {
if (objectFactory != null) {
// 遍歷目標類的全部方法
for (Method method : instance.getClass().getMethods()) {
// 檢測方法是否以 set 開頭，且方法僅有一個參數，且方法訪問級別爲 public
if (method.getName().startsWith("set")
&& method.getParameterTypes().length == 1
&& Modifier.isPublic(method.getModifiers())) {
// 獲取 setter 方法參數類型
Class<?> pt = method.getParameterTypes()[0];
try {
// 獲取屬性名，好比 setName 方法對應屬性名 name
String property = method.getName().length() > 3 ?
method.getName().substring(3, 4).toLowerCase() +
method.getName().substring(4) : "";
// 從 ObjectFactory 中獲取依賴對象
Object object = objectFactory.getExtension(pt, property);
if (object != null) {
// 經過反射調用 setter 方法設置依賴
method.invoke(instance, object);
}
} catch (Exception e) {
logger.error("fail to inject via method...");
}
}
}
}
} catch (Exception e) {
logger.error(e.getMessage(), e);
}
return instance;
}
複製代碼
在上面代碼中，objectFactory 變量的類型爲 AdaptiveExtensionFactory，AdaptiveExtensionFactory 內部維護了一個 ExtensionFactory 列表，用於存儲其餘類型的 ExtensionFactory。Dubbo 目前提供了兩種 ExtensionFactory，分別是 SpiExtensionFactory 和 SpringExtensionFactory。前者用於建立自適應的拓展，後者是用於從 Spring 的 IOC 容器中獲取所需的拓展。這兩個類的類的代碼不是很複雜，這裏就不一一分析了。
Dubbo IOC 目前僅支持 setter 方式注入，總的來講，邏輯比較簡單易懂。
5. 總結
本篇文章簡單分別介紹了 Java SPI 與 Dubbo SPI 用法，並對 Dubbo SPI 的加載拓展類的過程進行了分析。另外，在 Dubbo SPI 中還有一塊重要的邏輯這裏沒有進行分析，即 Dubbo SPI 的擴展點自適應機制。該機制的邏輯較爲複雜，咱們將會在下一篇文章中進行詳細的分析。
歡迎你們加入Java高級架構羣 378461078
- 1. Dubbo源碼解析之SPI
- 2. dubbo源碼分析系列——dubbo的SPI機制源碼分析
- 3. Dubbo源碼通~SPI機制
- 4. dubbo源碼分析01：SPI機制
- 5. Dubbo 源碼分析 - SPI 機制
- 6. Dubbo 源碼分析 —— 拓展機制 SPI
- 7. dubbo源碼分析-spi機制
- 8. 【java】從java SPI機制到dubbo SPI機制(源碼淺析)
- 9. 【Dubbo 源碼解析】02_Dubbo SPI
- 10. 2.2 dubbo-spi源碼解析
- 更多相關文章...
- • ARP協議的工作機制詳解 - TCP/IP教程
- • XML DOM 解析器 - XML DOM 教程
- • 漫談MySQL的鎖機制
- • 互聯網組織的未來：剖析GitHub員工的任性之源
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. Duang!超快Wi-Fi來襲
- 2. 機器學習-補充03 神經網絡之**函數(Activation Function)
- 3. git上開源maven項目部署 多module maven項目（多module maven+redis+tomcat+mysql）後臺部署流程學習記錄
- 4. ecliple-tomcat部署maven項目方式之一
- 5. eclipse新導入的項目經常可以看到「XX cannot be resolved to a type」的報錯信息
- 6. Spark RDD的依賴於DAG的工作原理
- 7. VMware安裝CentOS-8教程詳解
- 8. YDOOK：Java 項目 Spring 項目導入基本四大 jar 包 導入依賴，怎樣在 IDEA 的項目結構中導入 jar 包 導入依賴
- 9. 簡單方法使得putty（windows10上）可以免密登錄樹莓派
- 10. idea怎麼用本地maven