Dubbo源碼分析之ExtensionLoader源碼分析

參考：http://dubbo.apache.org/zh-cn/docs/source_code_guide/dubbo-spi.html

上篇演示了dubbo spi 的一個小demo,這篇來看看源碼，能力有限，不喜勿噴。

上篇的測試用例如下：

@Test
public void testExt2() throws Exception {
    ExtensionLoader<Ext2> extensionLoader = ExtensionLoader.getExtensionLoader(Ext2.class);
    Ext2 impl1 = extensionLoader.getExtension("impl1");
    String value = impl1.echo(new UrlHolder(), "2");
    System.err.println(value);
    //==========================
    Ext2 impl2 = extensionLoader.getExtension("impl2");
    String value2 = impl2.echo(new UrlHolder(), "2");
    System.err.println(value2);
}

我們從getExtensionLoader方法跟進。

@SuppressWarnings("unchecked")
//從緩存當中獲取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 an interface!");
    }
    if (!withExtensionAnnotation(type)) {
        throw new IllegalArgumentException("Extension type (" + type +
                ") is not an extension, because it is NOT annotated with @" + SPI.class.getSimpleName() + "!");
    }
    ExtensionLoader<T> loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);
    //沒有獲取到
    if (loader == null) {
        /***
         * putIfAbsent是ConcurrentHashMap的一個方法。
         * putIfAbsent方法主要是在向ConcurrentHashMap中添加鍵—值對的時候，它會先判斷該鍵值對是否已經存在。
         如果不存在（新的entry），那麼會向map中添加該鍵值對，並返回null。
         如果已經存在，那麼不會覆蓋已有的值，直接返回已經存在的值。
         */
        EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader<T>(type));
        loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);
    }
    return loader;
}

回到testExt2方法

現在來看Ext2 impl1 = extensionLoader.getExtension("impl1");

參數爲一個配置文件裏面配置的key,跟進getExtension方法。

public T getExtension(String name) {
    if (StringUtils.isEmpty(name)) {
        throw new IllegalArgumentException("Extension name == null");
    }
    //如果name傳入的是true則使用默認的
    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;
}

跟進createExtension方法找到getExtensionClasses方法

/**
 * 獲取所有的拓展類
 我們在通過名稱獲取拓展類之前，首先需要根據配置文件解析出拓展項名稱到拓展類的映射關係表（Map<名稱, 拓展類>），
 之後再根據拓展項名稱從映射關係表中取出相應的拓展類即可。相關過程的代碼分析如下：
 * @return
 */
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方法

/**
 * synchronized in getExtensionClasses
 * 則通過 loadExtensionClasses 加載拓展類
 * */
private Map<String, Class<?>> loadExtensionClasses() {

    //SPI操作
    cacheDefaultExtensionName();
    Map<String, Class<?>> extensionClasses = new HashMap<>();
    // 加載指定文件夾下的配置文件
    loadDirectory(extensionClasses, DUBBO_INTERNAL_DIRECTORY, type.getName());
    loadDirectory(extensionClasses, DUBBO_INTERNAL_DIRECTORY, type.getName().replace("org.apache", "com.alibaba"));
    loadDirectory(extensionClasses, DUBBO_DIRECTORY, type.getName());
    loadDirectory(extensionClasses, DUBBO_DIRECTORY, type.getName().replace("org.apache", "com.alibaba"));
    loadDirectory(extensionClasses, SERVICES_DIRECTORY, type.getName());
    loadDirectory(extensionClasses, SERVICES_DIRECTORY, type.getName().replace("org.apache", "com.alibaba"));
    return extensionClasses;
}

再來看一下SPI的操作，跟進cacheDefaultExtensionName方法

/**
 * extract and cache default extension name if exists
 */
private void cacheDefaultExtensionName() {
    // 獲取 SPI 註解，這裏的 type 變量是在調用 getExtensionLoader 方法時傳入的
    final SPI defaultAnnotation = type.getAnnotation(SPI.class);
    if (defaultAnnotation == null) {
        return;
    }
    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 " + type.getName()
                    + ": " + Arrays.toString(names));
        }
        // 設置默認名稱，參考 getDefaultExtension 方法
        if (names.length == 1) {
            cachedDefaultName = names[0];
        }
    }
}

回到loadExtensionClasses方法看loadDirectory方法

private void loadDirectory(Map<String, Class<?>> extensionClasses, String dir, String type) {
    // fileName = 文件夾路徑 + type 全限定名
    String fileName = dir + type;
    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("Exception occurred when loading extension class (interface: " +
                type + ", description file: " + fileName + ").", t);
    }
}

看一下加載資源的方法loadResource方法

private void loadResource(Map<String, Class<?>> extensionClasses, ClassLoader classLoader, java.net.URL resourceURL) {
    try {
        try (BufferedReader reader = new BufferedReader(new InputStreamReader(resourceURL.openStream(), StandardCharsets.UTF_8))) {
            // 按行讀取配置內容
            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;
                        // 以等於號 = 爲界，截取鍵與值這裏也就是我們在文件裏看見的    key=value
                        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 (interface: " + type + ", class line: " + line + ") in " + resourceURL + ", cause: " + t.getMessage(), t);
                        exceptions.put(line, e);
                    }
                }
            }
        }
    } catch (Throwable t) {
        logger.error("Exception occurred when loading extension class (interface: " +
                type + ", class file: " + resourceURL + ") in " + resourceURL, t);
    }
}

跟進加載類的方法loadClass

/**
 * 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("Error occurred when loading extension class (interface: " +
                type + ", class line: " + clazz.getName() + "), class "
                + clazz.getName() + " is not subtype of interface.");
    }
    // 檢測目標類上是否有 Adaptive 註解
    if (clazz.isAnnotationPresent(Adaptive.class)) {
        // 設置 cachedAdaptiveClass緩存
        cacheAdaptiveClass(clazz);

    } else if (isWrapperClass(clazz)) {// 檢測 clazz 是否是 Wrapper 類型
        cacheWrapperClass(clazz);
    } else {
        // 程序進入此分支，表明 clazz 是一個普通的拓展類
        clazz.getConstructor();
        if (StringUtils.isEmpty(name)) {
            // 如果 name 爲空，則嘗試從 Extension 註解中獲取 name，或使用小寫的類名作爲 name
            name = findAnnotationName(clazz);
            if (name.length() == 0) {
                throw new IllegalStateException("No such extension name for the class " + clazz.getName() + " in the config " + resourceURL);
            }
        }
        // 切分 name
        String[] names = NAME_SEPARATOR.split(name);
        if (ArrayUtils.isNotEmpty(names)) {
            // 如果類上有 Activate 註解，則使用 names 數組的第一個元素作爲鍵，
            // 存儲 name 到 Activate 註解對象的映射關係
            cacheActivateClass(clazz, names[0]);
            for (String n : names) {
                cacheName(clazz, n);
                // 存儲 Class 到名稱的映射關係
                saveInExtensionClass(extensionClasses, clazz, n);
            }
        }
    }
}

在次回到

看見畫紅色的方法沒，這個就是dubbo的IOC實現

我們現在來分析下

跟進injectExtension方法

Dubbo IOC 是通過 setter 方法注入依賴。Dubbo 首先會通過反射獲取到實例的所有方法，然後再遍歷方法列表，檢測方法名是否具有 setter 方法特徵。若有，則通過 ObjectFactory 獲取依賴對象，最後通過反射調用 setter 方法將依賴設置到目標對象中。整個過程對應的代碼如下：

private T injectExtension(T instance) {
    if (objectFactory == null) {
        return instance;
    }
    try {
        //遍歷獲取實例對象的所有方法
        for (Method method : instance.getClass().getMethods()) {
            //判斷方法是否有setter 方法特徵
            // 檢測方法是否以 set 開頭，且方法僅有一個參數，且方法訪問級別爲 public
            if (!isSetter(method)) {
                continue;
            }
            /**
             * 看看我們是否需要這個屬性的自動注入
             * Check {@link DisableInject}
             */
            if (method.getAnnotation(DisableInject.class) != null) {
                continue;
            }
            Class<?> pt = method.getParameterTypes()[0];
            if (ReflectUtils.isPrimitives(pt)) {
                continue;
            }
            try {
                // 獲取 setter 方法參數類型
                String property = getSetterProperty(method);
                // 從 ObjectFactory 中獲取依賴對象
                Object object = objectFactory.getExtension(pt, property);
                if (object != null) {
                    // 通過反射調用 setter 方法設置依賴
                    method.invoke(instance, object);
                }
            } catch (Exception e) {
                logger.error("Failed to inject via method " + method.getName()
                        + " of interface " + type.getName() + ": " + e.getMessage(), e);
            }
        }
    } catch (Exception e) {
        logger.error(e.getMessage(), e);
    }
    return instance;
}

Dubbo 目前提供了兩種 ExtensionFactory，分別是 SpiExtensionFactory 和 SpringExtensionFactory。前者用於創建自適應的拓展，後者是用於從 Spring 的 IOC 容器中獲取所需的拓展。

Dubbo IOC 目前僅支持 setter 方式注入。

以上就是dubbo的SPI源碼，註釋都寫在代碼裏面的，如有錯誤之處歡迎各位盆友指正，謝謝@@@~~~~

Dubbo源碼分析之ExtensionLoader源碼分析

10分鐘搞定Mysql主從部署配置

如何使用 JS 判斷用戶是否處於活躍狀態

「Pygors跨平臺GUI」2：安裝MinGW-w64、MSYS2還是WSL2

[轉帖]

python列出centos7內存使用前50的進程信息

「Pygors跨平臺GUI」1：Pygors跨平臺GUI應用研究

一鍵自動化博客發佈工具,用過的人都說好(掘金篇)

lightdb數據庫超時相關控制參數

lightdb秒級增加列和刪除列（not null帶默認值）

Java ThreadPoolShutdown

TimerTask簡單測試

java 裏的 |= &= ^= 的詳細區別

Paxos算法的java實現demo（只是爲了簡單的測試）

Dubbo源碼分析之ExtensionLoader源碼分析

Dubbo源碼分析之服務註冊（例如：Zookeeper 爲註冊中心）

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結