Dubbo源碼分析（三）Dubbo中的SPI和自適應擴展機制

時間  2019-11-17
標籤 dubbo 源碼 分析 spi 自適應 擴展 機制 欄目 Dubbo 简体版
原文   原文鏈接

前言

咱們在往期文章中，曾經深刻分析過Java的SPI機制，它是一種服務發現機制。具體詳見：深刻理解JDK的SPI機制java

在繼續深刻Dubbo以前，咱們必須先要明白Dubbo中的SPI機制。由於有位大神（佚名）曾這樣說過：redis

要想理解Dubbo，必需要先搞明白Dubbo SPI機制，否則會很是暈。緩存

1、背景

一、來源

Dubbo 的擴展點加載從 JDK 標準的 SPI (Service Provider Interface) 擴展點發現機制增強而來。但還有所不一樣，它改進了JDK標準的 SPI的如下問題：安全

  • JDK 標準的 SPI 會一次性實例化擴展點全部實現，若是有擴展實現初始化很耗時，但若是沒用上也加載，會很浪費資源。ruby

  • 若是擴展點加載失敗，連擴展點的名稱都拿不到了。好比：JDK 標準的 ScriptEngine，經過 getName() 獲取腳本類型的名稱，但若是 RubyScriptEngine 由於所依賴的 jruby.jar 不存在，致使 RubyScriptEngine 類加載失敗，這個失敗緣由被吃掉了，和 ruby 對應不起來，當用戶執行 ruby 腳本時，會報不支持 ruby，而不是真正失敗的緣由。bash

  • 增長了對擴展點 IoC 和 AOP 的支持，一個擴展點能夠直接 setter 注入其它擴展點。數據結構

二、約定

在擴展類的 jar 包內，放置擴展點配置文件 META-INF/dubbo/接口全限定名，內容爲：配置名=擴展實現類全限定名，多個實現類用換行符分隔。app

三、配置文件

Dubbo SPI 所需的配置文件需放置在 META-INF/dubbo 路徑下，幾乎全部的功能都有擴展點實現。框架

Dubbo擴展點配置文件

咱們以Protocol接口爲例，它裏面有不少實現。 jvm

Protocol接口實現

2、Dubbo SPI

經過上圖咱們能夠看到，Dubbo SPI和JDK SPI配置的不一樣，在Dubbo SPI中能夠經過鍵值對的方式進行配置，這樣就能夠按需加載指定的實現類。 Dubbo SPI的相關邏輯都被封裝到ExtensionLoader類中，經過ExtensionLoader咱們能夠加載指定的實現類，一個擴展接口就對應一個ExtensionLoader對象，在這裏咱們把它親切的稱爲：擴展點加載器。

咱們先看下它的屬性：

public class ExtensionLoader<T> {
	
    //擴展點配置文件的路徑，能夠從3個地方加載到擴展點配置文件
    private static final String SERVICES_DIRECTORY = "META-INF/services/";
    private static final String DUBBO_DIRECTORY = "META-INF/dubbo/";
    private static final String DUBBO_INTERNAL_DIRECTORY = DUBBO_DIRECTORY + "internal/";	
    //擴展點加載器的集合
    private static final ConcurrentMap<Class<?>, ExtensionLoader<?>> EXTENSION_LOADERS = new ConcurrentHashMap<Class<?>, ExtensionLoader<?>>();
    //擴展點實現的集合
    private static final ConcurrentMap<Class<?>, Object> EXTENSION_INSTANCES = new ConcurrentHashMap<Class<?>,Object>();
    //擴展點名稱和實現的映射緩存
    private final ConcurrentMap<Class<?>, String> cachedNames = new ConcurrentHashMap<Class<?>, String>();
    //拓展點實現類集合緩存
    private final Holder<Map<String, Class<?>>> cachedClasses = new Holder<Map<String, Class<?>>>();
    //擴展點名稱和@Activate的映射緩存
    private final Map<String, Activate> cachedActivates = new ConcurrentHashMap<String, Activate>();
    //擴展點實現的緩存
    private final ConcurrentMap<String, Holder<Object>> cachedInstances = new ConcurrentHashMap<String, Holder<Object>>();
}
複製代碼

ExtensionLoader會把不一樣的擴展點配置和實現都緩存起來。同時，Dubbo在官網上也給了咱們提醒：擴展點使用單一實例加載（請確保擴展實現的線程安全性），緩存在 ExtensionLoader中。下面咱們看幾個重點方法。

一、獲取擴展點加載器

咱們首先經過ExtensionLoader.getExtensionLoader() 方法獲取一個 ExtensionLoader 實例，它就是擴展點加載器。而後再經過 ExtensionLoader 的 getExtension 方法獲取拓展類對象。這其中，getExtensionLoader 方法用於從緩存中獲取與拓展類對應的 ExtensionLoader，若緩存未命中，則建立一個新的實例。

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("..."); } 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; } 複製代碼

好比你能夠經過下面這樣，來獲取Protocol接口的ExtensionLoader實例： ExtensionLoader<Protocol> extensionLoader = ExtensionLoader.getExtensionLoader(Protocol.class); 就能夠拿到擴展點加載器的對象實例： com.alibaba.dubbo.common.extension.ExtensionLoader[com.alibaba.dubbo.rpc.Protocol]

二、獲取擴展類對象

上一步咱們已經拿到加載器，而後能夠根據加載器實例，經過擴展點的名稱獲取擴展類對象。

public T getExtension(String name) {
    //校驗擴展點名稱的合法性
    if (name == null || name.length() == 0)
    	throw new IllegalArgumentException("Extension name == null");
    // 獲取默認的拓展實現類
    if ("true".equals(name)) {
    	return getDefaultExtension();
    }
    //用於持有目標對象
    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.set(instance);
    	    }
    	}
    }
    return (T) instance;
}
複製代碼

它先嚐試從緩存中獲取，未命中則建立擴展對象。那麼它的建立過程是怎樣的呢？

private T createExtension(String name) {
    //從配置文件中獲取全部的擴展類，Map數據結構
    //而後根據名稱獲取對應的擴展類
    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 = 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);
    }
}
複製代碼

這裏的重點有兩個，依賴注入和Wrapper包裝類，它們是Dubbo中IOC 與 AOP 的具體實現。

2.一、依賴注入

向拓展對象中注入依賴，它會獲取類的全部方法。判斷方法是否以 set 開頭，且方法僅有一個參數，且方法訪問級別爲 public，就經過反射設置屬性值。因此說，Dubbo中的IOC僅支持以setter方式注入。

private T injectExtension(T instance) {
	
    if (objectFactory != null) {
    	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 {
    		    	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) {
    		    	    method.invoke(instance, object);
    		    	}
    			} catch (Exception e) {
    			    logger.error("");
    			}
    	    }
    	}
    }
    return instance;
}
複製代碼
2.二、Wrapper

它會將當前 instance 做爲參數傳給 Wrapper 的構造方法，並經過反射建立 Wrapper 實例。 而後向 Wrapper 實例中注入依賴，最後將 Wrapper 實例再次賦值給 instance 變量。提及來可能比較繞，咱們直接看下它最後生成的對象就明白了。 咱們以DubboProtocol爲例，它包裝後的對象爲：

Wrapper包裝對象

綜上所述，若是咱們獲取一個擴展類對象，最後拿到的就是這個Wrapper類的實例。 就像這樣：

ExtensionLoader<Protocol> extensionLoader = ExtensionLoader.getExtensionLoader(Protocol.class);
Protocol extension = extensionLoader.getExtension("dubbo");
System.out.println(extension);
複製代碼

輸出爲：com.alibaba.dubbo.rpc.protocol.ProtocolListenerWrapper@4cdf35a9

三、獲取全部的擴展類

在咱們經過名稱獲取擴展類對象以前，首先須要根據配置文件解析出全部的擴展類。 它是一個擴展點名稱和擴展類的映射表Map<String, Class<?>>

首先，仍是從緩存中cachedClasses獲取，若是沒有就調用loadExtensionClasses從配置文件中加載。配置文件有三個路徑：

META-INF/services/ META-INF/dubbo/ META-INF/dubbo/internal/

先嚐試從緩存中獲取。

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;
}	
複製代碼

若是沒有，就調用loadExtensionClasses從配置文件中讀取。

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) {
			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));
			}
			//設置默認的擴展名稱，參考getDefaultExtension 方法
			//若是名稱爲true，就是調用默認擴贊類
			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;
}
複製代碼

以Protocol接口爲例，獲取到的實現類集合以下，咱們就能夠根據名稱加載具體的擴展類對象。

{
	registry=class com.alibaba.dubbo.registry.integration.RegistryProtocol
	injvm=class com.alibaba.dubbo.rpc.protocol.injvm.InjvmProtocol
	thrift=class com.alibaba.dubbo.rpc.protocol.thrift.ThriftProtocol
	mock=class com.alibaba.dubbo.rpc.support.MockProtocol
	dubbo=class com.alibaba.dubbo.rpc.protocol.dubbo.DubboProtocol
	http=class com.alibaba.dubbo.rpc.protocol.http.HttpProtocol
	redis=class com.alibaba.dubbo.rpc.protocol.redis.RedisProtocol
	rmi=class com.alibaba.dubbo.rpc.protocol.rmi.RmiProtocol
}
複製代碼

3、自適應擴展機制

在Dubbo中，不少拓展都是經過 SPI 機制進行加載的，好比 Protocol、Cluster、LoadBalance 等。這些擴展並不是在框架啓動階段就被加載，而是在擴展方法被調用的時候，根據URL對象參數進行加載。 那麼，Dubbo就是經過自適應擴展機制來解決這個問題。

自適應拓展機制的實現邏輯是這樣的： 首先 Dubbo 會爲拓展接口生成具備代理功能的代碼。而後經過 javassist 或 jdk 編譯這段代碼，獲得 Class 類。最後再經過反射建立代理類，在代理類中，就能夠經過URL對象的參數來肯定到底調用哪一個實現類。

一、Adaptive註解

在開始以前，咱們有必要先看一下與自適應拓展息息相關的一個註解，即 Adaptive 註解。

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD})
public @interface Adaptive {
    String[] value() default {};
}
複製代碼

從上面的代碼中可知，Adaptive 可註解在類或方法上。

  • 標註在類上 Dubbo 不會爲該類生成代理類。
  • 標註在方法上 Dubbo 則會爲該方法生成代理邏輯，表示當前方法須要根據 參數URL 調用對應的擴展點實現。

二、獲取自適應拓展類

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("", t);
    		    	}
    		    }
    		}
    	}
    }
    return (T) instance;
}
複製代碼

getAdaptiveExtension方法首先會檢查緩存，緩存未命中，則調用 createAdaptiveExtension方法建立自適應拓展。

private T createAdaptiveExtension() {
    try {
    	return injectExtension((T) getAdaptiveExtensionClass().newInstance());
    } catch (Exception e) {
    	throw new IllegalStateException("Can not create adaptive extension ....", e);
    }
}
複製代碼

這裏的代碼較少，調用 getAdaptiveExtensionClass方法獲取自適應拓展 Class 對象，而後經過反射實例化，最後調用injectExtension方法向拓展實例中注入依賴。 獲取自適應擴展類過程以下：

private Class<?> getAdaptiveExtensionClass() {
    //獲取當前接口的全部實現類
    //若是某個實現類標註了@Adaptive，此時cachedAdaptiveClass不爲空
    getExtensionClasses();
    if (cachedAdaptiveClass != null) {
    	return cachedAdaptiveClass;
    }
    //以上條件不成立，就建立自適應拓展類
    return cachedAdaptiveClass = createAdaptiveExtensionClass();
}
複製代碼

在上面方法中，它會先獲取當前接口的全部實現類，若是某個實現類標註了@Adaptive，那麼該類就被賦值給cachedAdaptiveClass變量並返回。若是沒有，就調用createAdaptiveExtensionClass建立自適應拓展類。

三、建立自適應拓展類

createAdaptiveExtensionClass方法用於生成自適應拓展類，該方法首先會生成自適應拓展類的源碼，而後經過 Compiler 實例（Dubbo 默認使用 javassist 做爲編譯器）編譯源碼，獲得代理類 Class 實例。

private Class<?> createAdaptiveExtensionClass() {
	//構建自適應拓展代碼
	String code = createAdaptiveExtensionClassCode();
	ClassLoader classLoader = findClassLoader();
	// 獲取編譯器實現類 這個Dubbo默認是採用javassist 
	Compiler compiler =ExtensionLoader.getExtensionLoader(Compiler.class).getAdaptiveExtension();
	//編譯代碼，返回類實例的對象
	return compiler.compile(code, classLoader);
}
複製代碼

在生成自適應擴展類以前，Dubbo會檢查接口方法是否包含@Adaptive。若是方法上都沒有此註解，就要拋出異常。

if (!hasAdaptiveAnnotation){
	throw new IllegalStateException(
		"No adaptive method on extension " + type.getName() + ", refuse to create the adaptive class!");
}
複製代碼

咱們仍是以Protocol接口爲例，它的export()和refer()方法，都標註爲@Adaptive。destroy和 getDefaultPort未標註 @Adaptive註解。Dubbo 不會爲沒有標註 Adaptive 註解的方法生成代理邏輯，對於該種類型的方法，僅會生成一句拋出異常的代碼。

package com.alibaba.dubbo.rpc;
import com.alibaba.dubbo.common.URL;
import com.alibaba.dubbo.common.extension.Adaptive;
import com.alibaba.dubbo.common.extension.SPI;

@SPI("dubbo")
public interface Protocol {
    int getDefaultPort();
    @Adaptive
    <T> Exporter<T> export(Invoker<T> invoker) throws RpcException;
    @Adaptive
    <T> Invoker<T> refer(Class<T> type, URL url) throws RpcException;
    void destroy();
}
複製代碼

因此說當咱們調用這兩個方法的時候，會先拿到URL對象中的協議名稱，再根據名稱找到具體的擴展點實現類，而後去調用。下面是生成自適應擴展類實例的源代碼：

package com.viewscenes.netsupervisor.adaptive;

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$Adaptive implements Protocol {

    public void destroy() {
    	throw new UnsupportedOperationException("....");
    }
    public int getDefaultPort() {
    	throw new UnsupportedOperationException("....");
    }
    public Exporter export(Invoker invoker)throws RpcException {
    	if (invoker == null) {
    		throw new IllegalArgumentException("Invoker argument == null");
    	}
    	if (invoker.getUrl() == null) {
    		throw new IllegalArgumentException("Invoker argument getUrl() == null");
    	}
    		
    	URL url = invoker.getUrl();
    	String extName = (url.getProtocol() == null ? "dubbo" : url.getProtocol());
    	if (extName == null) {
    		throw new IllegalStateException("....");
    	}
    		
    	Protocol extension = ExtensionLoader.getExtensionLoader(Protocol.class).getExtension(extName);
    	return extension.export(invoker);
    }
    public Invoker refer(Class clazz,URL ur)throws RpcException {
    	if (ur == null) {
    		throw new IllegalArgumentException("url == null");
    	}
    	URL url = ur;
    	String extName = (url.getProtocol() == null ? "dubbo" : url.getProtocol());
    	if (extName == null) {
    		throw new IllegalStateException("....");
    	}
    	Protocol extension = ExtensionLoader.getExtensionLoader(Protocol.class).getExtension(extName);
    	return extension.refer(clazz, url);
    }
}
複製代碼

綜上所述，當咱們獲取某個接口的自適應擴展類，實際就是一個Adaptive類實例。

ExtensionLoader<Protocol> extensionLoader = ExtensionLoader.getExtensionLoader(Protocol.class);            
Protocol adaptiveExtension = extensionLoader.getAdaptiveExtension();
System.out.println(adaptiveExtension);
複製代碼

輸出爲： com.alibaba.dubbo.rpc.Protocol$Adaptive@47f6473

4、實例

咱們看完以上流程以後，若是想寫一套本身的邏輯替換Dubbo中的流程，就變得很簡單。

Dubbo默認使用dubbo協議來暴露服務。咱們能夠搞一個自定義的協議來替換它。

一、實現類

首先，咱們建立一個MyProtocol類，它實現Protocol接口。

package com.viewscenes.netsupervisor.protocol;

import com.alibaba.dubbo.common.URL;
import com.alibaba.dubbo.rpc.Exporter;
import com.alibaba.dubbo.rpc.Invoker;
import com.alibaba.dubbo.rpc.Protocol;
import com.alibaba.dubbo.rpc.RpcException;
import com.alibaba.dubbo.rpc.protocol.dubbo.DubboProtocol;

public class MyProtocol extends DubboProtocol implements Protocol{

	public int getDefaultPort() {
		return 28080;
	}
	public <T> Exporter<T> export(Invoker<T> invoker) throws RpcException {	
		URL url = invoker.getUrl();
		System.out.println("自定義協議，進行服務暴露:"+url);	
		return super.export(invoker);
	}
	public <T> Invoker<T> refer(Class<T> type, URL url) throws RpcException {
		return super.refer(type, url);
	}
	public void destroy() {}
}
複製代碼

二、擴展點配置文件

而後，在本身的項目中META-INF/services建立com.alibaba.dubbo.rpc.Protocol文件，文件內容爲： myProtocol=com.viewscenes.netsupervisor.protocol.MyProtocol

三、修改Dubbo配置文件

最後修改生產者端的配置文件：

<!-- 用自定義協議在20880端口暴露服務 -->
<dubbo:protocol name="myProtocol" port="20880"/>  
複製代碼

這樣在咱們啓動生產者端項目的時候，Dubbo在進行服務暴露的過程當中，就會調用到咱們自定義的MyProtocol類，完成相應的邏輯處理。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程