dubbo之SPI自適應擴展機制
一、背景
在 Dubbo 中，不少拓展都是經過 SPI 機制進行加載的，好比 Protocol、Cluster、LoadBalance 等。有時，有些拓展並不想在框架啓動階段被加載，而是但願在拓展方法被調用時，根據運行時參數進行加載。這聽起來有些矛盾。拓展未被加載，那麼拓展方法就沒法被調用（靜態方法除外）。拓展方法未被調用，拓展就沒法被加載。對於這個矛盾的問題，Dubbo 經過自適應拓展機制很好的解決了。自適應拓展機制的實現邏輯比較複雜，首先 Dubbo 會爲拓展接口生成具備代理功能的代碼。而後經過 javassist 或 jdk 編譯這段代碼，獲得 Class 類。最後再經過反射建立代理類，整個過程比較複雜。java
二、原理
爲了很好的理解，下面結合實例進行分析，在Dubbbo暴露服務中，ServiceConfig類中doExportUrlsFor1Protocol方法中有以下這樣一條語句：apache
Exporter<?> exporter = protocol.export(wrapperInvoker);
接下來我們就根據這條語句進行深刻分析Dubbo SPI自適應擴展機制。緩存
根據源碼查詢得知，protocol對象是經過如下語句建立：app
private static final Protocol protocol = ExtensionLoader.getExtensionLoader(Protocol.class).getAdaptiveExtension();
根據上篇文章，我們得知getExtensionLoader只是獲取ExtensionLoader對象，因此自適應擴展的核心在getAdaptiveExtension()方法中：框架
public T getAdaptiveExtension() {
// 緩存獲取實例對象
Object instance = cachedAdaptiveInstance.get();
// 雙重檢測
if (instance == null) {
if (createAdaptiveInstanceError == null) {
synchronized (cachedAdaptiveInstance) {
instance = cachedAdaptiveInstance.get();
if (instance == null) {
try {
// 建立實例對象
instance = createAdaptiveExtension();
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);
}
}
return (T) instance;
}
在getAdaptiveExtension方法中先從緩存中獲取，緩存中不存在在建立實例，並存入緩存中，邏輯比較簡單，我們在來分析createAdaptiveExtension方法：jvm
private T createAdaptiveExtension() {
try {
// 獲取自適應拓展類，並經過反射實例化
return injectExtension((T) getAdaptiveExtensionClass().newInstance());
} catch (Exception e) {
throw new IllegalStateException("Can not create adaptive extension " + type + ", cause: " + e.getMessage(), e);
}
}
createAdaptiveExtension 方法的代碼比較少，但卻包含了三個邏輯，分別以下：ide
- 調用 getAdaptiveExtensionClass 方法獲取自適應拓展 Class 對象
- 經過反射進行實例化
- 調用 injectExtension 方法向拓展實例中注入依賴
前兩個邏輯比較好理解，第三個邏輯用於向自適應拓展對象中注入依賴。這個邏輯看似多餘，但有存在的必要，這裏簡單說明一下。前面說過，Dubbo 中有兩種類型的自適應拓展，一種是手工編碼的，一種是自動生成的。手工編碼的自適應拓展中可能存在着一些依賴，而自動生成的 Adaptive 拓展則不會依賴其餘類。這裏調用 injectExtension 方法的目的是爲手工編碼的自適應拓展注入依賴，這一點須要你們注意一下。關於 injectExtension 方法，前文已經分析過了，這裏再也不贅述。接下來，分析 getAdaptiveExtensionClass 方法的邏輯。ui
private Class<?> getAdaptiveExtensionClass() {
// 經過 SPI 獲取全部的拓展類
getExtensionClasses();
// 檢查緩存，若緩存不爲空，則直接返回緩存
if (cachedAdaptiveClass != null) {
return cachedAdaptiveClass;
}
// 建立自適應拓展類
return cachedAdaptiveClass = createAdaptiveExtensionClass();
}
getAdaptiveExtensionClass 方法一樣包含了三個邏輯，以下：編碼
- 調用 getExtensionClasses 獲取全部的拓展類
- 檢查緩存，若緩存不爲空，則返回緩存
- 若緩存爲空，則調用 createAdaptiveExtensionClass 建立自適應拓展類
這三個邏輯看起來平淡無奇，彷佛沒有多講的必要。可是這些平淡無奇的代碼中隱藏了着一些細節，須要說明一下。首先從第一個邏輯提及，getExtensionClasses 這個方法用於獲取某個接口的全部實現類。好比該方法能夠獲取 Protocol 接口的 DubboProtocol、HttpProtocol、InjvmProtocol 等實現類。在獲取實現類的過程當中，若是某個某個實現類被 Adaptive 註解修飾了，那麼該類就會被賦值給 cachedAdaptiveClass 變量。此時，上面步驟中的第二步條件成立（緩存不爲空），直接返回 cachedAdaptiveClass 便可。若是全部的實現類均未被 Adaptive 註解修飾，那麼執行第三步邏輯，建立自適應拓展類。相關代碼以下：url
private Class<?> createAdaptiveExtensionClass() {
// 構建自適應拓展代碼
String code = createAdaptiveExtensionClassCode();
ClassLoader classLoader = findClassLoader();
// 獲取編譯器實現類
com.alibaba.dubbo.common.compiler.Compiler compiler = ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.common.compiler.Compiler.class).getAdaptiveExtension();
// 編譯代碼，生成 Class
return compiler.compile(code, classLoader);
}
createAdaptiveExtensionClass 方法用於生成自適應拓展類，該方法首先會生成自適應拓展類的源碼，而後經過 Compiler 實例（Dubbo 默認使用 javassist 做爲編譯器）編譯源碼，獲得代理類 Class 實例。接下來，咱們把重點放在代理類代碼生成的邏輯上，其餘邏輯你們自行分析。
private String createAdaptiveExtensionClassCode() {
StringBuilder codeBuilder = new StringBuilder();
Method[] methods = type.getMethods();
boolean hasAdaptiveAnnotation = false;
// 循環遍歷方法
for (Method m : methods) {
// 判斷類中的方法是否有Adaptive註解
if (m.isAnnotationPresent(Adaptive.class)) {
hasAdaptiveAnnotation = true;
break;
}
}
// 若是類中方法沒有Adaptive註解，則直接拋出異常
if (!hasAdaptiveAnnotation) {
throw new IllegalStateException("No adaptive method on extension " + type.getName() + ", refuse to create the adaptive class!");
}
// 引入類的包名、類的依賴
codeBuilder.append("package ").append(type.getPackage().getName()).append(";");
codeBuilder.append("\nimport ").append(ExtensionLoader.class.getName()).append(";");
codeBuilder.append("\npublic class ").append(type.getSimpleName()).append("$Adaptive").append(" implements ").append(type.getCanonicalName()).append(" {");
for (Method method : methods) {
// 獲取方法返回類型
Class<?> rt = method.getReturnType();
// 獲取方法參數類型
Class<?>[] pts = method.getParameterTypes();
// 獲取方法拋出的異常類型
Class<?>[] ets = method.getExceptionTypes();
Adaptive adaptiveAnnotation = method.getAnnotation(Adaptive.class);
StringBuilder code = new StringBuilder(512);
// 方法沒有Adaptive註解，方法體就是一條拋出異常的語句
if (adaptiveAnnotation == null) {
code.append("throw new UnsupportedOperationException(\"method ")
.append(method.toString()).append(" of interface ")
.append(type.getName()).append(" is not adaptive method!\");");
} else {
// 標記方法中參數類型爲URL的是第幾個參數
int urlTypeIndex = -1;
for (int i = 0; i < pts.length; ++i) {
if (pts[i].equals(URL.class)) {
urlTypeIndex = i;
break;
}
}
// 若是方法參數中有URL類型的，則須要校驗參數是否爲空
if (urlTypeIndex != -1) {
String s = String.format("\nif (arg%d == null) throw new IllegalArgumentException(\"url == null\");",
urlTypeIndex);
code.append(s);
// 並建立一個URL變量，將參數賦值給變量：URL url = url
s = String.format("\n%s url = arg%d;", URL.class.getName(), urlTypeIndex);
code.append(s);
}
else {
// 參數中沒有URL類型的參數
String attribMethod = null;
// 查找參數所屬類中是否有返回URL的方法，如：Invoker.getUrl()方法，則attribMethod = getUrl()
LBL_PTS:
for (int i = 0; i < pts.length; ++i) {
Method[] ms = pts[i].getMethods();
for (Method m : ms) {
String name = m.getName();
if ((name.startsWith("get") || name.length() > 3)
&& Modifier.isPublic(m.getModifiers())
&& !Modifier.isStatic(m.getModifiers())
&& m.getParameterTypes().length == 0
&& m.getReturnType() == URL.class) {
urlTypeIndex = i;
attribMethod = name;
break LBL_PTS;
}
}
}
// 若是參數中沒有返回URL的方法，則拋出異常
if (attribMethod == null) {
throw new IllegalStateException("fail to create adaptive class for interface " + type.getName()
+ ": not found url parameter or url attribute in parameters of method " + method.getName());
}
// 校驗有返回URL類型方法的參數是否爲空
String s = String.format("\nif (arg%d == null) throw new IllegalArgumentException(\"%s argument == null\");",
urlTypeIndex, pts[urlTypeIndex].getName());
code.append(s);
// 校驗參數調用返回URL方法返回值是否爲空，如：if Invoker.getUrl() == null
s = String.format("\nif (arg%d.%s() == null) throw new IllegalArgumentException(\"%s argument %s() == null\");",
urlTypeIndex, attribMethod, pts[urlTypeIndex].getName(), attribMethod);
code.append(s);
// 建立URL變量，賦值爲返回值，如 URL url = Invoker.getUrl()
s = String.format("%s url = arg%d.%s();", URL.class.getName(), urlTypeIndex, attribMethod);
code.append(s);
}
String[] value = adaptiveAnnotation.value();
if (value.length == 0) {
String splitName = StringUtils.camelToSplitName(type.getSimpleName(), ".");
value = new String[]{splitName};
}
// 判斷方法參數中是否有Invocation類型的參數
boolean hasInvocation = false;
for (int i = 0; i < pts.length; ++i) {
if (("org.apache.dubbo.rpc.Invocation").equals(pts[i].getName())) {
// Null Point check
String s = String.format("\nif (arg%d == null) throw new IllegalArgumentException(\"invocation == null\");", i);
code.append(s);
s = String.format("\nString methodName = arg%d.getMethodName();", i);
code.append(s);
hasInvocation = true;
break;
}
}
String defaultExtName = cachedDefaultName;
String getNameCode = null;
// 若是Adaptive註解時Protocol，則根據參數url所屬協議來適配加載，如dubbo:// 則調用返回DubboProtocol擴展類實例
for (int i = value.length - 1; i >= 0; --i) {
if (i == value.length - 1) {
if (null != defaultExtName) {
if (!"protocol".equals(value[i])) {
if (hasInvocation) {
getNameCode = String.format("url.getMethodParameter(methodName, \"%s\", \"%s\")", value[i], defaultExtName);
} else {
getNameCode = String.format("url.getParameter(\"%s\", \"%s\")", value[i], defaultExtName);
}
} else {
getNameCode = String.format("( url.getProtocol() == null ? \"%s\" : url.getProtocol() )", defaultExtName);
}
} else {
if (!"protocol".equals(value[i])) {
if (hasInvocation) {
getNameCode = String.format("url.getMethodParameter(methodName, \"%s\", \"%s\")", value[i], defaultExtName);
} else {
getNameCode = String.format("url.getParameter(\"%s\")", value[i]);
}
} else {
getNameCode = "url.getProtocol()";
}
}
} else {
if (!"protocol".equals(value[i])) {
if (hasInvocation) {
getNameCode = String.format("url.getMethodParameter(methodName, \"%s\", \"%s\")", value[i], defaultExtName);
} else {
getNameCode = String.format("url.getParameter(\"%s\", %s)", value[i], getNameCode);
}
} else {
getNameCode = String.format("url.getProtocol() == null ? (%s) : url.getProtocol()", getNameCode);
}
}
}
code.append("\nString extName = ").append(getNameCode).append(";");
String s = String.format("\nif(extName == null) " +
"throw new IllegalStateException(\"Fail to get extension(%s) name from url(\" + url.toString() + \") use keys(%s)\");",
type.getName(), Arrays.toString(value));
code.append(s);
// 根據上面獲取的type調用ExtensionLoader中的getExtension(type)方法
s = String.format("\n%s extension = (%<s)%s.getExtensionLoader(%s.class).getExtension(extName);",
type.getName(), ExtensionLoader.class.getSimpleName(), type.getName());
code.append(s);
// 拼裝返回語句
if (!rt.equals(void.class)) {
code.append("\nreturn ");
}
// 拼裝調用適配擴展類中的方法，如：RegistryProtocol.export()方法
s = String.format("extension.%s(", method.getName());
code.append(s);
for (int i = 0; i < pts.length; i++) {
if (i != 0) {
code.append(", ");
}
code.append("arg").append(i);
}
code.append(");");
}
// 拼裝方法聲明語句
codeBuilder.append("\npublic ").append(rt.getCanonicalName()).append(" ").append(method.getName()).append("(");
for (int i = 0; i < pts.length; i++) {
if (i > 0) {
codeBuilder.append(", ");
}
codeBuilder.append(pts[i].getCanonicalName());
codeBuilder.append(" ");
codeBuilder.append("arg").append(i);
}
codeBuilder.append(")");
if (ets.length > 0) {
codeBuilder.append(" throws ");
for (int i = 0; i < ets.length; i++) {
if (i > 0) {
codeBuilder.append(", ");
}
codeBuilder.append(ets[i].getCanonicalName());
}
}
codeBuilder.append(" {");
codeBuilder.append(code.toString());
codeBuilder.append("\n}");
}
codeBuilder.append("\n}");
if (logger.isDebugEnabled()) {
logger.debug(codeBuilder.toString());
}
return codeBuilder.toString();
}
createAdaptiveExtensionClassCode方法比較複雜，要靜下心來慢慢研究，最好結合實例進行分析，例子protocol.export()自適應擴展類以下所示：
類名是Protocol$Adaptive：
/*
* Decompiled with CFR 0_132.
*/
package com.alibaba.dubbo.rpc;
import com.alibaba.dubbo.common.URL;
import com.alibaba.dubbo.common.extension.ExtensionLoader;
import com.alibaba.dubbo.rpc.Exporter;
import com.alibaba.dubbo.rpc.Invoker;
import com.alibaba.dubbo.rpc.Protocol;
import com.alibaba.dubbo.rpc.RpcException;
public class Protocol$Adpative
implements Protocol {
@Override
public void destroy() {
throw new UnsupportedOperationException("method public abstract void com.alibaba.dubbo.rpc.Protocol.destroy() of interface com.alibaba.dubbo.rpc.Protocol is not adaptive method!");
}
@Override
public int getDefaultPort() {
throw new UnsupportedOperationException("method public abstract int com.alibaba.dubbo.rpc.Protocol.getDefaultPort() of interface com.alibaba.dubbo.rpc.Protocol is not adaptive method!");
}
public Invoker refer(Class class_, URL uRL) throws RpcException {
String string;
if (uRL == null) {
throw new IllegalArgumentException("url == null");
}
URL uRL2 = uRL;
String string2 = string = uRL2.getProtocol() == null ? "dubbo" : uRL2.getProtocol();
if (string == null) {
throw new IllegalStateException(new StringBuffer().append("Fail to get extension(com.alibaba.dubbo.rpc.Protocol) name from url(").append(uRL2.toString()).append(") use keys([protocol])").toString());
}
Protocol protocol = ExtensionLoader.getExtensionLoader(Protocol.class).getExtension(string);
return protocol.refer(class_, uRL);
}
public Exporter export(Invoker invoker) throws RpcException {
String string;
if (invoker == null) {
throw new IllegalArgumentException("com.alibaba.dubbo.rpc.Invoker argument == null");
}
if (invoker.getUrl() == null) {
throw new IllegalArgumentException("com.alibaba.dubbo.rpc.Invoker argument getUrl() == null");
}
URL uRL = invoker.getUrl();
String string2 = string = uRL.getProtocol() == null ? "dubbo" : uRL.getProtocol();
if (string == null) {
throw new IllegalStateException(new StringBuffer().append("Fail to get extension(com.alibaba.dubbo.rpc.Protocol) name from url(").append(uRL.toString()).append(") use keys([protocol])").toString());
}
Protocol protocol = ExtensionLoader.getExtensionLoader(Protocol.class).getExtension(string);
return protocol.export(invoker);
}
}
在調用方法時，根據方法參數進行動態自適應擴展，加載擴展類。
相關文章
- 1. dubbo之SPI自適應擴展機制
- 2. Dubbo SPI之自適應擴展機制 @Adaptive
- 3. dubbo的自適應擴展機制
- 4. dubbo擴展機制SPI（一）
- 5. 【Dubbo源碼分析】Dubbo SPI自適應拓展機制
- 6. Dubbo源碼分析（三）Dubbo中的SPI和自適應擴展機制
- 7. dubbo spi擴展實現機制javassist
- 8. [轉] 理解 Dubbo SPI 擴展機制
- 9. 理解 Dubbo SPI 擴展機制
- 10. 淺析Dubbo的SPI擴展機制
- 更多相關文章...
- • Kotlin 擴展 - Kotlin 教程
- • Swift 擴展 - Swift 教程
- • 漫談MySQL的鎖機制
- • 適用於PHP初學者的學習線路和建議
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
- 1. 安裝cuda+cuDNN
- 2. GitHub的使用說明
- 3. phpDocumentor使用教程【安裝PHPDocumentor】
- 4. yarn run build報錯Component is not found in path 「npm/taro-ui/dist/weapp/components/rate/index「
- 5. 精講Haproxy搭建Web集羣
- 6. 安全測試基礎之MySQL
- 7. C/C++編程筆記：C語言中的複雜聲明分析，用實例帶你完全讀懂
- 8. Python3教程(1)----搭建Python環境
- 9. 李宏毅機器學習課程筆記2：Classification、Logistic Regression、Brief Introduction of Deep Learning
- 10. 阿里雲ECS配置速記
歡迎關注本站公眾號,獲取更多信息
