http://dubbo.apache.org/zh-cn/docs/source_code_guide/adaptive-extension.html
在Dubbo中，很多拓展都是通過SPI機制進行加載的，比如Protocol、Cluster、LoadBalance等。
有時，有些拓展類並不想在框架啟動階段被加載，而是希望在拓展方法被調用時，根據運行參數進行加載。
拓展未被加載，那么拓展方法就無法被調用。拓展方法未被調用，拓展舊無法被加載。
dubbo通過自適應拓展機制很好的解決了:首先Dubbo會為拓展接口生成具有代理功能的代碼。然后通過javassist或jdk編譯這段代碼，得到Class類，最后通過反射創建代理類
一、四個測試用例
准備如下
import com.alibaba.dubbo.common.URL;
import com.alibaba.dubbo.common.extension.Adaptive;
import com.alibaba.dubbo.common.extension.SPI;
@SPI
public interface AdaptiveExt2 {
@Adaptive
String echo(String msg, URL url);
}
三個實現類
public class DubboAdaptiveExt2 implements AdaptiveExt2 {
@Override
public String echo(String msg, URL url) {
return "dubbo";
}
}
public class SpringCloudAdaptiveExt2 implements AdaptiveExt2 {
@Override
public String echo(String msg, URL url) {
return "spirng cloud";
}
}
public class ThriftAdaptiveExt2 implements AdaptiveExt2 {
@Override
public String echo(String msg, URL url) {
return "thrift";
}
}
在Resource目錄下，添加/META-INF/dubbo/internal/com.example.dubbo.adaptive.AdaptiveExt2
dubbo=com.example.dubbo.adaptive.DubboAdaptiveExt2
cloud=com.example.dubbo.adaptive.SpringCloudAdaptiveExt2
thrift=com.example.dubbo.adaptive.ThriftAdaptiveExt2
測試1. SPI注解上有value值
@SPI("dubbo") public interface AdaptiveExt2 { @Adaptive String echo(String msg, URL url); } @Test public void testdubbo(){ // @SPI("dubbo") ExtensionLoader<AdaptiveExt2> loader = ExtensionLoader.getExtensionLoader(AdaptiveExt2.class); AdaptiveExt2 adaptiveExtension = loader.getAdaptiveExtension(); URL url = URL.valueOf("test://loalhost/test"); System.out.println(adaptiveExtension.echo("d",url)); }
結果
dubbo
測試2 SPI注解上有value值，URL上也有具體的值
@SPI("dubbo")
public interface AdaptiveExt2 {
@Adaptive
String echo(String msg, URL url);
}
@Test
public void testdubbo2(){
// @SPI("dubbo")
// +?adaptive.ext2=cloud
ExtensionLoader<AdaptiveExt2> loader = ExtensionLoader.getExtensionLoader(AdaptiveExt2.class);
AdaptiveExt2 adaptiveExtension = loader.getAdaptiveExtension();
URL url = URL.valueOf("test://loalhost/test?adaptive.ext2=cloud");
System.out.println(adaptiveExtension.echo("d",url));
}
結果
spirng cloud
說明 RUL優先於SPI注解的value值
測試3 SPI注解有value值，URL中也有具體的值，實現類上有@Adaptive注解
@SPI("dubbo")
public interface AdaptiveExt2 {
@Adaptive
String echo(String msg, URL url);
}
@Adaptive
public class ThriftAdaptiveExt2 implements AdaptiveExt2 {
@Override
public String echo(String msg, URL url) {
return "thrift";
}
}
@Test
public void testdubbo3(){
// @Adaptive
//public class ThriftAdaptiveExt2
//+?adaptive.ext2=cloud
ExtensionLoader<AdaptiveExt2> loader = ExtensionLoader.getExtensionLoader(AdaptiveExt2.class);
AdaptiveExt2 adaptiveExtension = loader.getAdaptiveExtension();
URL url = URL.valueOf("test://loalhost/test?adaptive.ext2=cloud");
System.out.println(adaptiveExtension.echo("d",url));
}
結果
thrift
說明 實現類的@Adaptive注解優先於URL
測試4 SPI注解中有value值，實現類上沒有@Adaptive注解，在方法上打上@Adaptive注解，注解中的value與鏈接中的參數key一致，
@SPI("dubbo")
public interface AdaptiveExt2 {
@Adaptive({"t"})
String echo(String msg, URL url);
}
@Test
public void testdubbo4(){
// @SPI("dubbo")
//public interface AdaptiveExt2 {
// @Adaptive({"t"})
// String echo(String msg, URL url);
// ?t=cloud
ExtensionLoader<AdaptiveExt2> loader = ExtensionLoader.getExtensionLoader(AdaptiveExt2.class);
AdaptiveExt2 adaptiveExtension = loader.getAdaptiveExtension();
URL url = URL.valueOf("test://loalhost/test?t=cloud");
System.out.println(adaptiveExtension.echo("d",url));
}
結果
spirng cloud
測試結論：
1.在類上加@Adaptive注解的類，是最明確的創建對應類型的Adaptive類。所有它的優先級最高
2.@SPI注解的value值是默認值，如果通過URL獲取不到關於取那個類作為Adaptive類的話，就是用這個默認值，當然如果URL中可以獲取到，就用URL中的
3.可以在方法上增加@Adaptive注解，注解中value與鏈接中的參數key一致，連接中的key對應的value就是spi中的name，獲取對應的實現類
源碼分析:
ExtensionLoader<AdaptiveExt2> loader = ExtensionLoader.getExtensionLoader(AdaptiveExt2.class);
@SuppressWarnings("unchecked")
public static <T> ExtensionLoader<T> getExtensionLoader(Class<T> type) {
if (type == null)
throw new IllegalArgumentException("Extension type == null");
if(!type.isInterface()) {
throw new IllegalArgumentException("Extension type(" + type + ") is not interface!");
}
// 這個類型必須加上SPI注解，否則報錯
if(!withExtensionAnnotation(type)) {
throw new IllegalArgumentException("Extension type(" + type +
") is not extension, because WITHOUT @" + SPI.class.getSimpleName() + " Annotation!");
}
// 從緩存中獲取
ExtensionLoader<T> loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);
if (loader == null) {
EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader<T>(type));
loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);
}
return loader;
}
先檢查SPI注解，再緩存中查詢對應ExtensionLoader,dubbo中的spi大量利用了本地緩存。
// 構造方法私有化
private ExtensionLoader(Class<?> type) {
this.type = type;
// 如果type是ExtensionFactory類型，那么objectFactory是null，否則是ExtensionFactory類型的適配器
objectFactory = (type == ExtensionFactory.class ? null : ExtensionLoader.getExtensionLoader(ExtensionFactory.class).getAdaptiveExtension());
}
兩點：
1.構造方法私有化，不能通過外部實例化
2.objectFactory是ioc功能
開始獲取adaptive對象
@SuppressWarnings("unchecked")
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;
}
第一次從緩存中獲取就創建
@SuppressWarnings("unchecked")
private T createAdaptiveExtension() {
try {
return injectExtension((T) getAdaptiveExtensionClass().newInstance());
} catch (Exception e) {
throw new IllegalStateException("Can not create adaptive extenstion " + type + ", cause: " + e.getMessage(), e);
}
}
獲取到適配器類的Class，利用反射船艦適配器類的實例，injectExtension是dubbo的DI，依賴注入，如果適配器類有屬性的set方法，就會自動注入。
private Class<?> getAdaptiveExtensionClass() {
// 觸發SPI流程的掃描
getExtensionClasses();
// 如果通過上面的步驟可以獲取到cacheAdaptiveClass直接返回，如果不行就自行利用動態代理創建一個
if (cachedAdaptiveClass != null) {
return cachedAdaptiveClass;
}
// 利用動態代理創建一個擴展類
return cachedAdaptiveClass = createAdaptiveExtensionClass();
}
首先先看getExtensionClasses
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;
}
從緩存中取，也就是說加載流程只觸發一次，然后放入緩存，后續從緩存中取
// 此方法已經getExtensionClasses方法同步過。 private Map<String, Class<?>> loadExtensionClasses() {
// 獲取到類型SPI注解，所以利用SPI擴展點的地方，需要加入SPI注解 final SPI defaultAnnotation = type.getAnnotation(SPI.class); 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)); }
// 如果注解中有value，說明有默認的實現，那么將value放到cacheDefaultName中 if(names.length == 1) cachedDefaultName = names[0]; } } // 從 META-INF/dubbo/internal/...讀取數據 Map<String, Class<?>> extensionClasses = new HashMap<String, Class<?>>(); loadFile(extensionClasses, DUBBO_INTERNAL_DIRECTORY); loadFile(extensionClasses, DUBBO_DIRECTORY); loadFile(extensionClasses, SERVICES_DIRECTORY); return extensionClasses; }
獲取type上SPI注解，如果里面有value值就賦值給cacheDefaultName變量，隨后從META-INF/dubbo/internal/ 、META-INF/dubbo/、META-INF/services/ 這三個路徑下搜索對應的文件。
private void loadFile(Map<String, Class<?>> extensionClasses, String dir) { 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 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;
// 使用 = 進行分割 name=全路徑名稱 int i = line.indexOf('='); if (i > 0) { name = line.substring(0, i).trim(); line = line.substring(i + 1).trim(); } if (line.length() > 0) {
// 加載解析出的類的全限定名稱 Class<?> clazz = Class.forName(line, true, classLoader);
// 判斷新家在的clazz是否是type的子類，不是則報錯 if (! type.isAssignableFrom(clazz)) { throw new IllegalStateException("Error when load extension class(interface: " + type + ", class line: " + clazz.getName() + "), class " + clazz.getName() + "is not subtype of interface."); }
// 判斷這個加載的類上有沒有@Adaptive注解， if (clazz.isAnnotationPresent(Adaptive.class)) { if(cachedAdaptiveClass == null) {
// 將此類作為cacheAdaptiveClass cachedAdaptiveClass = clazz; } else if (! cachedAdaptiveClass.equals(clazz)) {
// 多個adaptive類的實例，報錯 throw new IllegalStateException("More than 1 adaptive class found: " + cachedAdaptiveClass.getClass().getName() + ", " + clazz.getClass().getName()); } } else {
// 如果這個類沒有@Adaptive注解 try {
// 查看這個類有沒有此類型的構造方法（主要是為了Wrapper類使用，如果有說明是個wrapper類） clazz.getConstructor(type); Set<Class<?>> wrappers = cachedWrapperClasses; if (wrappers == null) { cachedWrapperClasses = new ConcurrentHashSet<Class<?>>(); wrappers = cachedWrapperClasses; }
// 將此warpper放入warpper容器中,也就是cacheWrapperClasses里面 wrappers.add(clazz); } catch (NoSuchMethodException e) {
// 不是wrapper類，就會拋出異常執行這里， clazz.getConstructor(); if (name == null || name.length() == 0) {
// 如果name沒有寫，就是用默認規則生成一個 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); if (names != null && names.length > 0) {
// 看下這個類上有沒有@adaptive注解 Activate activate = clazz.getAnnotation(Activate.class); if (activate != null) {
// 存在就在cacheAdaptivates里面添加名稱與注解 cachedActivates.put(names[0], activate); } for (String n : names) { if (! cachedNames.containsKey(clazz)) {
// 將此類型的實例與name放入cacheNames cachedNames.put(clazz, n); } Class<?> c = extensionClasses.get(n); if (c == null) {
// 最后往wxtensionClasses添加名稱與class 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); } }
classLoader.getResources 方法獲取到的Enumeration<java.net.URL>類型的對象，隨后就是遍歷
dubbo=shuqi.dubbotest.spi.adaptive.DubboAdaptiveExt2 cloud=shuqi.dubbotest.spi.adaptive.SpringCloudAdaptiveExt2 thrift=shuqi.dubbotest.spi.adaptive.ThriftAdaptiveExt2
如果有#,#后面就是注釋，前面是業務數據
如果有=,就按照=進行分割，前面是擴展名稱，后面是擴展的全限定類名，方便利用反射加載進來
首先判斷一下是不是傳入類(type)類型的實例，不是的話：報錯
如果類上有@Adaptive注解，那么將這個類賦值給擦車的AdaptiveClass，因為是系統指定的適配類，優先級最高。
如果多個類上打了@Adaptive注解會報錯，“More than 1 adaptive class found:.....”
如果擴展類上沒有打上@Adaptive注解:
第一步:會驗證有沒有type這個類型作為入參的構造方法 (因為Wrapper,有的類型需要包裝一下例如ProtocolFilterWoapper和ProtocolListenerWrapper)
第二步:沒有這種類型的構造方法,就是正常的type類型的實例
如果沒有聲明name名稱就根據類名創建一個名稱
查看類上有沒有@Adaptive注解:
有:將名稱與注解放到擦車的Activates這個Map中進行緩存
將擴展類和名稱放入cachedNames這個Map中進行緩存，將名稱和擴展類的class放入傳遞進來的extensionClsses中
最后這個extensionClasses會被返回出來被使用。
接下來回到getAdaptiveExtensionClss()方法
private Class<?> getAdaptiveExtensionClass() {
// 觸發SPI流程的掃描
getExtensionClasses();
// 如果通過上面的步驟可以獲取到cacheAdaptiveClass直接返回，如果不行就自行利用動態代理創建一個
if (cachedAdaptiveClass != null) {
return cachedAdaptiveClass;
}
// 利用動態代理創建一個擴展類
return cachedAdaptiveClass = createAdaptiveExtensionClass();
}
如果cachedAdaptiveClss不為空就返回，那什么情況下不為空？當擴展類打上@Adaptive注解的時候，就會直接將這個類返回。如果沒有注解，就得自己生成一個也就是createAdaptiveExtensionClass
private Class<?> createAdaptiveExtensionClass() {
// 創建代碼的字符串形式 String code = createAdaptiveExtensionClassCode();
// 尋找類加載器 ClassLoader classLoader = findClassLoader();
// 尋找Compiler的適配器擴展類 com.alibaba.dubbo.common.compiler.Compiler compiler = ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.common.compiler.Compiler.class).getAdaptiveExtension(); // 進行編譯成class的實例返回
return compiler.compile(code, classLoader); }
將類以字符串的形式拼接出來，然后利用編譯器進行編譯，返回編譯后的class對象。
/**
* 創建適配器的擴展類的string
*/
private String createAdaptiveExtensionClassCode() { StringBuilder codeBuidler = new StringBuilder();
// 獲取這個類的所有方法 Method[] methods = type.getMethods(); boolean hasAdaptiveAnnotation = false; for(Method m : methods) {
// 遍歷方法，如果有方法上@Adaptive注解 if(m.isAnnotationPresent(Adaptive.class)) { hasAdaptiveAnnotation = true; break; } } // 完全沒有Adaptive方法，則不需要生成Adaptive類 if(! hasAdaptiveAnnotation) throw new IllegalStateException("No adaptive method on extension " + type.getName() + ", refuse to create the adaptive class!"); codeBuidler.append("package " + type.getPackage().getName() + ";"); codeBuidler.append("\nimport " + ExtensionLoader.class.getName() + ";"); codeBuidler.append("\npublic class " + type.getSimpleName() + "$Adpative" + " implements " + type.getCanonicalName() + " {"); for (Method method : methods) { Class<?> rt = method.getReturnType(); Class<?>[] pts = method.getParameterTypes();//獲取參數列表的類型 Class<?>[] ets = method.getExceptionTypes();//異常列表的類型 // 獲得Adaptive的注解 Adaptive adaptiveAnnotation = method.getAnnotation(Adaptive.class); StringBuilder code = new StringBuilder(512);
// 如果這個方法沒有注解，添加不支持調用此方法的異常 if (adaptiveAnnotation == null) { code.append("throw new UnsupportedOperationException(\"method ") .append(method.toString()).append(" of interface ") .append(type.getName()).append(" is not adaptive method!\");"); } else { int urlTypeIndex = -1;
// 尋找列表中類型是URL.class，記錄它的位置，數據放到urlTypeIndex中 for (int i = 0; i < pts.length; ++i) { if (pts[i].equals(URL.class)) { urlTypeIndex = i; break; } } // 有類型為URL的參數 if (urlTypeIndex != -1) { // Null Point check String s = String.format("\nif (arg%d == null) throw new IllegalArgumentException(\"url == null\");", urlTypeIndex); code.append(s); s = String.format("\n%s url = arg%d;", URL.class.getName(), urlTypeIndex); code.append(s); } // 參數沒有URL類型 else { String attribMethod = null; // 找到參數的URL屬性 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; } } } if(attribMethod == null) { throw new IllegalStateException("fail to create adative class for interface " + type.getName() + ": not found url parameter or url attribute in parameters of method " + method.getName()); } // Null point check String s = String.format("\nif (arg%d == null) throw new IllegalArgumentException(\"%s argument == null\");", urlTypeIndex, pts[urlTypeIndex].getName()); code.append(s); s = String.format("\nif (arg%d.%s() == null) throw new IllegalArgumentException(\"%s argument %s() == null\");", urlTypeIndex, attribMethod, pts[urlTypeIndex].getName(), attribMethod); code.append(s); s = String.format("%s url = arg%d.%s();",URL.class.getName(), urlTypeIndex, attribMethod); code.append(s); } // 獲取Adaptive設置的value String[] value = adaptiveAnnotation.value(); // 沒有設置Key，則使用“擴展點接口名的點分隔 作為Key if(value.length == 0) { char[] charArray = type.getSimpleName().toCharArray(); StringBuilder sb = new StringBuilder(128); for (int i = 0; i < charArray.length; i++) { if(Character.isUpperCase(charArray[i])) { if(i != 0) { sb.append("."); } sb.append(Character.toLowerCase(charArray[i])); } else { sb.append(charArray[i]); } } value = new String[] {sb.toString()}; } boolean hasInvocation = false;
// 如果參數列表中有Invocation的實例 for (int i = 0; i < pts.length; ++i) { if (pts[i].getName().equals("com.alibaba.dubbo.rpc.Invocation")) { // 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; } } // defaultExtName位注解中的value String defaultExtName = cachedDefaultName; String getNameCode = null; 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(";"); // check extName == null? 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); s = String.format("\n%s extension = (%<s)%s.getExtensionLoader(%s.class).getExtension(extName);", type.getName(), ExtensionLoader.class.getSimpleName(), type.getName()); code.append(s); // return statement if (!rt.equals(void.class)) { code.append("\nreturn "); } 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(");"); } codeBuidler.append("\npublic " + rt.getCanonicalName() + " " + method.getName() + "("); for (int i = 0; i < pts.length; i ++) { if (i > 0) { codeBuidler.append(", "); } codeBuidler.append(pts[i].getCanonicalName()); codeBuidler.append(" "); codeBuidler.append("arg" + i); } codeBuidler.append(")"); if (ets.length > 0) { codeBuidler.append(" throws "); for (int i = 0; i < ets.length; i ++) { if (i > 0) { codeBuidler.append(", "); } codeBuidler.append(pts[i].getCanonicalName()); } } codeBuidler.append(" {"); codeBuidler.append(code.toString()); codeBuidler.append("\n}"); } codeBuidler.append("\n}"); if (logger.isDebugEnabled()) { logger.debug(codeBuidler.toString()); } return codeBuidler.toString(); }
首先尋找這個類中所有的方法，查看方法中有沒有打@Adaptive注解的，一個沒有，直接報錯，對於哪些沒有加@Adaptive的方法，直接在要創建的Adaptive類上添加此方法不支持操作的異常。在方法中的注解上可以添加value值，如果填寫了，使用此值，沒有添加將更具類名創建的值作為value值。
public class AdaptiveExt2$Adpative implements shuqi.dubbotest.spi.adaptive.AdaptiveExt2 {
public java.lang.String echo(java.lang.String arg0, com.alibaba.dubbo.common.URL arg1) {
if (arg1 == null) throw new IllegalArgumentException("url == null");
com.alibaba.dubbo.common.URL url = arg1;
String extName = url.getParameter("t", "dubbo");
if (extName == null)
throw new IllegalStateException("Fail to get extension(shuqi.dubbotest.spi.adaptive.AdaptiveExt2) name from url(" + url.toString() + ") use keys([t])");
shuqi.dubbotest.spi.adaptive.AdaptiveExt2 extension = (shuqi.dubbotest.spi.adaptive.AdaptiveExt2) ExtensionLoader.getExtensionLoader(shuqi.dubbotest.spi.adaptive.AdaptiveExt2.class).getExtension(extName);
return extension.echo(arg0, arg1);
}
}