Dubbo的SPI擴展機制
Dubbo 並未使用 Java SPI，而是重新實現了一套功能更強的SPI機制。Dubbo SPI 的相關邏輯被封裝在了 ExtensionLoader 類中，通過 ExtensionLoader，我們可以加載指定的實現類。Dubbo SPI 所需的配置文件需放置在 META-INF/dubbo 路徑下，配置內容如下。
traceFilter=com.qunar.com.TraceFilter
與 Java SPI 實現類配置不同，Dubbo SPI 是通過鍵值對的方式進行配置，這樣我們可以按需加載指定的實現類。另外，在測試 Dubbo SPI 時，需要在 Robot 接口上標註@SPI 註解。下面來演示 Dubbo SPI 的用法：
@Activate(group = "provider")
public class TraceFilter implements Filter {
private static final Logger LOGGER = LoggerFactory.getLogger(TraceFilter.class);
private static String TRACE_KEY = "traceId";
@Override
public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException {
String key = String.format("%s-%s", invoker.getInterface().getName(), invocation.getMethodName());
LOGGER.info("monitor key", key);
Result result = new AppResponse();
try {
if (isConsumer()) {
addTraceInfoToProvider();
} else {
addTraceInfoFromConsumer();
}
} catch (Exception e) {
LOGGER.error("dubbo invoker failed: {}", e.getMessage());
}
try {
result = invoker.invoke(invocation);
} catch (RpcException e) {
if (e.isTimeout()) {
//超時異常只記錄監控
LOGGER.error("dubbo出現了超時異常", e);
} else {
throw e;
}
} finally {
if (result != null
&& result.getException() instanceof RuntimeException
&& result.getException().getCause() != null
&& result.getException().getCause() instanceof InterruptedException) {
//dubbo中斷異常
LOGGER.error("dubbo出現中斷異常了", result.getException().getCause());
result = new AppResponse();
}
}
return result;
}
/**
* 是否consumer
*
* @return
*/
private boolean isConsumer() {
return RpcContext.getContext().isConsumerSide();
}
/**
* consumer調用此方法
* 把TraceUtils中的信息添加到dubbo的header中，供provider使用
*/
private void addTraceInfoToProvider() {
RpcContext.getContext().setAttachment(TRACE_KEY, "testKey");
}
/**
* provider調用此方法
* 把header中的traceUtils放入
*/
private void addTraceInfoFromConsumer() {
Map<String, String> attachments = RpcContext.getContext().getAttachments();
if (attachments == null || !attachments.containsKey(TRACE_KEY)) {
return;
}
String traceInfo = attachments.get(TRACE_KEY);
System.out.println("provider 獲得 traceId" + traceInfo);
}
}
這是一個使用Dubbo SPI擴展加載的Trace傳遞過濾器，他可以在Consumer 或者 Provider端生效，當在Provider可以選擇把系統當前的trace傳遞給下游服務提供者
Dubbo SPI擴展的源碼
我們首先通過 ExtensionLoader 的 getExtensionLoader 方法獲取一個 ExtensionLoader 實例，然後再通過 ExtensionLoader 的 getExtension 方法獲取拓展類對象。這其中，getExtensionLoader 方法用於從緩存中獲取與拓展類對應的 ExtensionLoader，若緩存未命中，則創建一個新的實例。該方法的邏輯比較簡單，本章就不進行分析了。下面我們從 ExtensionLoader 的 getExtension 方法作爲入口，
/**
* Find the extension with the given name. If the specified name is not found, then {@link IllegalStateException}
* will be thrown.
*/
@SuppressWarnings("unchecked")
public T getExtension(String name) {
if (StringUtils.isEmpty(name)) {
throw new IllegalArgumentException("Extension name == null");
}
// 默認的擴展實現
if ("true".equals(name)) {
return getDefaultExtension();
}
final Holder<Object> holder = getOrCreateHolder(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;
}
創建擴展點的代碼如下:
@SuppressWarnings("unchecked")
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 獲取的是一個class的 Map緩存, 還是一個典型的雙檢鎖機制
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) {
// 對 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 註解進行解析， 這裏的SPIclass 就是我們 getExtensionClassLoader 時傳進來的class .
二是調用 loadDirectory 方法加載指定文件夾配置文件。這三個文件夾 分別是
META-INF/dubbo/internal , META-INF/dubbo , META-INF/services , 我們對某個接口的實現， 就是寫在這三個目錄裏面的 .
loadDirectory 方法主要是從我們的文件裏解析， key 和 impl的全路徑
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("...");
}
}
如何加載我們的 key=xxx.xx.xxxImpl
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...");
}
}
重點就在 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("...");
}
}
}
}
}
OK代碼進行到這裏， 我們終於從 META-INF.dubbo裏面的文件，讀到了我們的實現類的class。
剛纔代碼裏， 有一個重點的地方，就是分別處理 @Activite, Wapper的時候，到底做了什麼， 以及Dubbo是如何應用IOC來注入的， 這些內容，還需要研究下。 總的來說， getExtension()這部分代碼，先看官方文檔，知道步驟之後再來看代碼， 差不多也是可以看懂的， 還可以可以debug，來看。
參考文檔:
Dubbo官網