dubbo SPI
dubbo SPI擴展框架java
- dubbo採用微內核+插件式擴展體系，得到極佳的擴展性。
- dubbo沒有藉助spring，guice等IOC框架來管理，而是運用JDK SPI思路本身實現了一個IOC框架,減小了對外部框架的依賴
- 在Dubbo中，SPI是一個很是核心的機制，貫穿在幾乎全部的流程中。搞懂這塊內容，是接下來了解Dubbo更多源碼的關鍵因素。
- Dubbo是基於Java原生SPI機制思想的一個改進，因此，先從JAVA SPI機制開始瞭解什麼是SPI之後再去學習Dubbo的SPI，就比較容易了
關於JAVA 的SPI機制mysql
- SPI全稱（service provider interface），是JDK內置的一種服務提供發現機制，
- 目前市面上有不少框架都是用它來作服務的擴展發現，你們耳熟能詳的如JDBC、日誌框架都有用到；
- 簡單來講，它是一種動態替換髮現的機制。
- 舉個簡單的例子，
- 若是咱們定義了一個規範，須要第三方廠商去實現，
- 那麼對於咱們應用方來講，只須要集成對應廠商的插件，既能夠完成對應規範的實現機制。
- 造成一種插拔式的擴展手段。
- SPI規範總結
- 實現SPI，就須要按照SPI自己定義的規範來進行配置，SPI規範以下：
- 須要在classpath下建立一個目錄，該目錄命名必須是：META-INF/services
- 在該目錄下建立一個properties文件，該文件須要知足如下幾個條件
- 文件名必須是擴展的接口的全路徑名稱
- 文件內部描述的是該擴展接口的全部實現類
- 文件的編碼格式是UTF-8
- 經過java.util.ServiceLoader的加載機制來發現
- SPI的實際應用
- SPI在不少地方有應用，你們能夠看看最經常使用的java.sql.Driver驅動。
- JDK官方提供了java.sql.Driver這個驅動擴展點，可是大家並無看到JDK中有對應的Driver實現。
- 那在哪裏實現呢？
- 以鏈接Mysql爲例，咱們須要添加mysql-connector-java依賴。
- 大家能夠在這個jar包中找到SPI的配置信息。
- 因此java.sql.Driver由各個數據庫廠商自行實現。
- SPI的缺點
- JDK標準的SPI會一次性加載實例化擴展點的全部實現
- 就是若是你在META-INF/service下的文件裏面加了N個實現類，那麼JDK啓動的時候都會一次性所有加載。
- 那麼若是有的擴展點實現初始化很耗時或者若是有些實現類並無用到，那麼會很浪費資源
- 若是擴展點加載失敗，會致使調用方報錯，並且這個錯誤很難定位到是這個緣由
- JDK標準的SPI會一次性加載實例化擴展點的全部實現
- 實現SPI，就須要按照SPI自己定義的規範來進行配置，SPI規範以下：
dubbo擴展框架特性spring
- 1). 內嵌在dubbo中
- 2). 支持經過SPI文件聲明擴展實現(interfce必須有@SPI註解)，
- 格式爲extensionName=extensionClassName，extensionName相似於spring的beanName
- 3). 支持經過配置指定extensionName來從SPI文件中選出對應實現
Protocol protocol = ExtensionLoader.getExtensionLoader(Protocol.class).getExtension("defineProtocol");
Dubbo SPI機制源碼閱讀
Protocol protocol = ExtensionLoader.getExtensionLoader(Protocol.class). getAdaptiveExtension();
- 把上面這段代碼分紅兩段，一段是getExtensionLoader、 另外一段是getAdaptiveExtension。
-
- 第一段是經過一個Class參數去得到一個ExtensionLoader對象，有點相似一個工廠模式。
- 第二段getAdaptiveExtension，去得到一個自適應的擴展點
Extension源碼的結構sql
Protocol 源碼數據庫
- 一個是在類級別上的@SPI(「dubbo」)
- @SPI 表示當前這個接口是一個擴展點，能夠實現本身的擴展實現，默認的擴展點是DubboProtocol。
- 另外一個是@Adaptive
- @Adaptive 表示一個自適應擴展點，在方法級別上，會動態生成一個適配器類
/**
* Protocol. (API/SPI, Singleton, ThreadSafe)
*
* @author william.liangf
*/
@SPI("dubbo")
public interface Protocol {
/**
* 獲取缺省端口，當用戶沒有配置端口時使用。
*
* @return 缺省端口
*/
int getDefaultPort();
/**
* 暴露遠程服務：<br>
* 1. 協議在接收請求時，應記錄請求來源方地址信息：RpcContext.getContext().setRemoteAddress();<br>
* 2. export()必須是冪等的，也就是暴露同一個URL的Invoker兩次，和暴露一次沒有區別。<br>
* 3. export()傳入的Invoker由框架實現並傳入，協議不須要關心。<br>
*
* @param <T> 服務的類型
* @param invoker 服務的執行體
* @return exporter 暴露服務的引用，用於取消暴露
* @throws RpcException 當暴露服務出錯時拋出，好比端口已佔用
*/
@Adaptive
<T> Exporter<T> export(Invoker<T> invoker) throws RpcException;
/**
* 引用遠程服務：<br>
* 1. 當用戶調用refer()所返回的Invoker對象的invoke()方法時，協議需相應執行同URL遠端export()傳入的Invoker對象的invoke()方法。<br>
* 2. refer()返回的Invoker由協議實現，協議一般須要在此Invoker中發送遠程請求。<br>
* 3. 當url中有設置check=false時，鏈接失敗不能拋出異常，並內部自動恢復。<br>
*
* @param <T> 服務的類型
* @param type 服務的類型
* @param url 遠程服務的URL地址
* @return invoker 服務的本地代理
* @throws RpcException 當鏈接服務提供方失敗時拋出
*/
@Adaptive
<T> Invoker<T> refer(Class<T> type, URL url) throws RpcException;
/**
* 釋放協議：<br>
* 1. 取消該協議全部已經暴露和引用的服務。<br>
* 2. 釋放協議所佔用的全部資源，好比鏈接和端口。<br>
* 3. 協議在釋放後，依然能暴露和引用新的服務。<br>
*/
void destroy();
}
getExtensionLoader
- 該方法須要一個Class類型的參數，該參數表示但願加載的擴展點類型，該參數必須是接口，且該接口必須被@SPI註解註釋，不然拒絕處理。
- 檢查經過以後首先會檢查ExtensionLoader緩存中是否已經存在該擴展對應的ExtensionLoader，
- 若是有則直接返回，不然建立一個新的ExtensionLoader負責加載該擴展實現，同時將其緩存起來。
@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!");
}
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;
}
- ExtensionLoader提供了一個私有的構造函數，而且在這裏面對兩個成員變量type/objectFactory進行賦值。而objectFactory賦值的意義是什麼呢？先留個懸念
private ExtensionLoader(Class < ? > type){
this.type = type;
objectFactory = (type == ExtensionFactory.class ? null :
ExtensionLoader.getExtensionLoader(ExtensionFactory.class).getAdaptiveExtension());
}
getAdaptiveExtension
- 經過getExtensionLoader得到了對應的ExtensionLoader實例之後，
- 再調用getAdaptiveExtension()方法來得到一個自適應擴展點。
-
ps：簡單對自適應擴展點作一個解釋，你們必定了解過適配器設計模式，而這個自適應擴展點實際上就是一個適配器。設計模式
-
主要作幾個事情：api
- 從cacheAdaptiveInstance 這個內存緩存中得到一個對象實例
- 若是實例爲空，說明是第一次加載，則經過雙重檢查鎖的方式去建立一個適配器擴展點
- createAdaptiveExtension
-
這段代碼裏面有兩個結構，一個是injectExtension. 另外一個是getAdaptiveExtensionClass()緩存
-
-
-
getAdaptiveExtensionClass()app
-
從類名來看，是得到一個適配器擴展點的類。框架
-
在這段代碼中，作了兩個事情：
- getExtensionClasses() 加載全部路徑下的擴展點
- createAdaptiveExtensionClass() 動態建立一個擴展點
- cachedAdaptiveClass這裏有個判斷，用來判斷當前Protocol這個擴展點是否存在一個自定義的適配器，
- 若是有，則直接返回自定義適配器，不然，就動態建立，這個值是在getExtensionClasses中賦值的，這塊代碼咱們稍後再看
-
createAdaptiveExtensionClass
-
動態生成適配器代碼，以及動態編譯：
- createAdaptiveExtensionClassCode, 動態建立一個字節碼文件。返回code這個字符串
- 經過compiler.compile進行編譯（默認狀況下使用的是javassist）
- 經過ClassLoader加載到jvm中
-
-
//建立一個適配器擴展點。（建立一個動態的字節碼文件） 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(); //動態編譯字節碼 return compiler.compile(code, classLoader); }code的字節碼內容：-
public class Protocol$Adaptive implements com.alibaba.dubbo.rpc.Protocol { 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!"); } 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 com.alibaba.dubbo.rpc.Invoker refer(java.lang.Class arg0, com.alibaba.dubbo.common.URL arg1) throws com.alibaba.dubbo.rpc.RpcException { if (arg1 == null) throw new IllegalArgumentException("url == null"); com.alibaba.dubbo.common.URL url = arg1; String extName = (url.getProtocol() == null ? "dubbo" : url.getProtocol()); if (extName == null) throw new IllegalStateException("Fail to " + "get extension(com.alibaba.dubbo.rpc.Protocol) name " + "from url(" + url.toString() + ") use keys([protocol])"); com.alibaba.dubbo.rpc.Protocol extension = (com.alibaba.dubbo.rpc.Protocol) ExtensionLoader .getExtensionLoader(com.alibaba.dubbo.rpc.Protocol.class).getExtension(extName); return extension.refer(arg0, arg1); } public com.alibaba.dubbo.rpc.Exporter export(com.alibaba.dubbo.rpc.Invoker arg0) throws com.alibaba.dubbo.rpc.RpcException { if (arg0 == null) throw new IllegalArgumentException("com.alibaba.dubbo.rpc.Invoker argument == null"); if (arg0.getUrl() == null) throw new IllegalArgumentException("com.alibaba.dubbo.rpc.Invoker argument getUrl() == null"); com.alibaba.dubbo.common.URL url = arg0.getUrl(); String extName = (url.getProtocol() == null ? "dubbo" : url.getProtocol()); if (extName == null) throw new IllegalStateException("Fail to " + "get extension(com.alibaba.dubbo.rpc.Protocol) name " + "from url(" + url.toString() + ") use keys([protocol])"); com.alibaba.dubbo.rpc.Protocol extension = (com.alibaba.dubbo.rpc.Protocol) ExtensionLoader .getExtensionLoader(com.alibaba.dubbo.rpc.Protocol.class) .getExtension(extName); return extension.export(arg0); } }Protocol$Adaptive的主要功能：
-
1. 從url或擴展接口獲取擴展接口實現類的名稱；
-
2.根據名稱，獲取實現類ExtensionLoader.getExtensionLoader(擴展接口類).getExtension(擴展接口實現類名稱)，
-
而後調用實現類的方法。
-
-
-
- getExtensionClasses() 加載全部路徑下的擴展點
-
須要明白一點dubbo的內部傳參基本上都是基於Url來實現的，也就是說Dubbo是基於URL驅動的技術
-
因此，適配器類的目的是在運行期獲取擴展的真正實現來調用，解耦接口和實現，
-
這樣的話要不咱們本身實現適配器類，要不dubbo幫咱們生成，而這些都是經過Adpative來實現。
-
-
-
getExtensionClasses
- 就是加載擴展點實現類了。
- 這段代碼主要作以下幾個事情：
- 從cachedClasses中得到一個結果，
- 這個結果實際上就是全部的擴展點類，key對應name，value對應class
- 經過雙重檢查鎖進行判斷
- 調用loadExtensionClasses，去加載左右擴展點的實現
- 從cachedClasses中得到一個結果，
- loadExtensionClasses
-
從不一樣目錄去加載擴展點的實現，在最開始的時候講到過的。
-
META-INF/dubbo ；META-INF/internal ; META-INF/services
-
主要邏輯：
-
得到當前擴展點的註解，也就是Protocol.class這個類的註解，@SPI
- 判斷這個註解不爲空，則再次得到@SPI中的value值
- 若是value有值，也就是@SPI(「dubbo」)，則講這個dubbo的值賦給cachedDefaultName。
- 這就是爲何咱們可以經過ExtensionLoader.getExtensionLoader(Protocol.class).getDefaultExtension() ,
- 可以得到DubboProtocol這個擴展點的緣由
- 最後，經過loadFile去加載指定路徑下的全部擴展點。
- 也就是META-INF/dubbo;META-INF/internal;META-INF/services
-
-
-
// 此方法已經getExtensionClasses方法同步過。 private Map<String, Class<?>> loadExtensionClasses() { //type->Protocol.class //獲得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)); } if(names.length == 1) cachedDefaultName = names[0]; } } Map<String, Class<?>> extensionClasses = new HashMap<String, Class<?>>(); loadFile(extensionClasses, DUBBO_INTERNAL_DIRECTORY); loadFile(extensionClasses, DUBBO_DIRECTORY); loadFile(extensionClasses, SERVICES_DIRECTORY); return extensionClasses; }loadFile
- 解析指定路徑下的文件，獲取對應的擴展點，經過反射的方式進行實例化之後，put到extensionClasses這個Map集合中
-
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; int i = line.indexOf('='); if (i > 0) {//文件採用name=value方式，經過i進行分割 name = line.substring(0, i).trim(); line = line.substring(i + 1).trim(); } if (line.length() > 0) { Class<?> clazz = Class.forName(line, true, classLoader); //加載對應的實現類，而且判斷實現類必須是當前的加載的擴展點的實現 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."); } //判斷是否有自定義適配類，若是有，則在前面講過的獲取適配類的時候，直接返回當前的自定義適配類，不須要再動態建立 // 還記得在前面講過的getAdaptiveExtensionClass中有一個判斷嗎？是用來判斷cachedAdaptiveClass是否是爲空的。若是不爲空，表示存在自定義擴展點。也就不會去動態生成字節碼了。這個地方能夠獲得一個簡單的結論； // @Adaptive若是是加在類上， 表示當前類是一個自定義的自適應擴展點 //若是是加在方法級別上，表示須要動態建立一個自適應擴展點，也就是Protocol$Adaptive if (clazz.isAnnotationPresent(Adaptive.class)) { if(cachedAdaptiveClass == null) { cachedAdaptiveClass = clazz; } else if (! cachedAdaptiveClass.equals(clazz)) { throw new IllegalStateException("More than 1 adaptive class found: " + cachedAdaptiveClass.getClass().getName() + ", " + clazz.getClass().getName()); } } else { try { //若是沒有Adaptive註解，則判斷當前類是否帶有參數是type類型的構造函數，若是有，則認爲是 //wrapper類。這個wrapper實際上就是對擴展類進行裝飾. //能夠在dubbo-rpc-api/internal下找到Protocol文件，發現Protocol配置了3個裝飾 //分別是,filter/listener/mock. 因此Protocol這個實例來講，會增長對應的裝飾器 clazz.getConstructor(type);// //獲得帶有public DubboProtocol(Protocol protocol)的擴展點。進行包裝 Set<Class<?>> wrappers = cachedWrapperClasses; if (wrappers == null) { cachedWrapperClasses = new ConcurrentHashSet<Class<?>>(); wrappers = cachedWrapperClasses; } wrappers.add(clazz);//包裝類 ProtocolFilterWrapper(ProtocolListenerWrapper(Protocol)) } 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); 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); } }
階段性小結
-
截止到目前，咱們已經把基於Protocol的自適應擴展點看完了。
-
也明白最終這句話應該返回的對象是什麼了.
Protocol protocol = ExtensionLoader.getExtensionLoader(Protocol.class). getAdaptiveExtension();
也就是，這段代碼中，最終的protocol應該等於= Protocol$Adaptive
injectExtension
- 簡單來講，這個方法的做用，是爲這個自適應擴展點進行依賴注入。相似於spring裏面的依賴注入功能。
- 爲適配器類的setter方法插入其餘擴展點或實現。
- 前面全部的相關類都加載完了，這裏會把成員變量，進行賦值（所謂依賴注入）
-
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); } }
getExtensionLoader這個方法中，會調用ExtensionLoader的私有構造方法進行初始化，其中有一個objectFactory.
- 這個是幹嗎的呢？
- 構建bean的工廠，方便Extension 託管給 Spring等容器
- objectFactory是一個 ExtensionFactory，用來獲取全部的託管bean
相關文章
- 1. Java SPI 與 Dubbo SPI
- 2. java spi與dubbo spi區別
- 3. JDK的spi和dubbo的spi
- 4. Dubbo Spi機制
- 5. 3 dubbo SPI
- 6. dubbo SPI設計
- 7. dubbo之SPI
- 8. dubbo spi（續）
- 9. dubbo源碼—SPI
- 10. dubbo解析-SPI
- 更多相關文章...
- • 高併發系統的分析和設計 - 紅包項目實戰
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. Java SPI 與 Dubbo SPI
- 2. java spi與dubbo spi區別
- 3. JDK的spi和dubbo的spi
- 4. Dubbo Spi機制
- 5. 3 dubbo SPI
- 6. dubbo SPI設計
- 7. dubbo之SPI
- 8. dubbo spi（續）
- 9. dubbo源碼—SPI
- 10. dubbo解析-SPI