順著dubbo入口擼ExtensionLoader源碼

參考

屬于在這篇Dubbo擴(kuò)展點(diǎn)加載基礎(chǔ)上的展開學(xué)習(xí)。但原文有點(diǎn)小問題（Container啟動(dòng)那里），所以本文直接按自己的理解來組織。不加說明的引用都來自該文。

問題

Dubbo的原理、核心的概念很多文章都有詳細(xì)的介紹（什么SPI、擴(kuò)展點(diǎn)、Adaptive、ExtensionLoader等等），但是我的問題是它們是如何運(yùn)行、如何起作用、整體的流程是什么？

1. Dubbo入口

執(zhí)行Dubbo，實(shí)際上是執(zhí)行了com.alibaba.dubbo.container.Main.main

Main這個(gè)類中有一些靜態(tài)成員變量，最重要的是這個(gè)：

private static final ExtensionLoader<Container> loader = ExtensionLoader.getExtensionLoader(Container.class);

從這里開始使用ExtensionLoader。

2. 初始化Main的靜態(tài)成員，獲得Container類型的ExtensionLoader

ExtensionLoader類中有個(gè)靜態(tài)的final變量EXTENSION_LOADERS緩存了各種類型的ExtensionLoader，如果已有緩存，就直接獲取，如果沒有就調(diào)用new方法新建。

啟動(dòng)時(shí)getExtensionLoader(Container.class)獲取Container類型的ExtensionLoader肯定不存在，去構(gòu)造：

private ExtensionLoader(Class<?> type) {
        this.type = type;
        objectFactory = (type == ExtensionFactory.class ? null : ExtensionLoader.getExtensionLoader(ExtensionFactory.class).getAdaptiveExtension());
    }

在ExtensionLoader的構(gòu)造方法中可以看到，ExtensionLoader有兩個(gè)屬性，一個(gè)是type，標(biāo)識(shí)了這個(gè)ExtensionLoader所屬的類型，另一個(gè)是ObjectFactory，類型是ExtensionFactory。

那么，ExtensionLoader<Container>的this.type=Container.class，
而根據(jù)構(gòu)造函數(shù)，欲要得到Container.Class的ObjectFactory，須先得到ExtensionFactory類型的ExtensionLoader。

2.1 獲取ExtensionFactory類型的ExtensionLoader

同樣沒有，去構(gòu)造，根據(jù)構(gòu)造函數(shù)ExtensionLoader<ExtensionFactory>的this.type=ExtensionFactory.Class，ObjectFactory=null。
繼續(xù)。

2.2 獲取ExtensionFactory的擴(kuò)展實(shí)現(xiàn)：getAdaptiveExtension()

Dubbo的微內(nèi)核做得非常的徹底，ExtensionFactory也是一個(gè)擴(kuò)展點(diǎn)，也需要通過ExtensionLoader<ExtensionFactory>加載

因?yàn)椋?code>Container的）ObjectFactory是ExtensionFactory類型，而ExtensionFactory是一個(gè)擴(kuò)展點(diǎn)，那么就要用ExtensionFactory.Class的ExtensionLoader通過getAdaptiveExtension()獲取到ExtensionFactory.Class的Adaptive實(shí)現(xiàn)，再給到（Container的）ObjectFactory。

在getAdaptiveExtension()中，首先也是試圖從ExtensionLoader<ExtensionFactory>的一個(gè)緩存cachedAdaptiveInstance中取，取不到就調(diào)用createAdaptiveExtension()創(chuàng)建。

2.2.1 創(chuàng)建ExtensionFactory擴(kuò)展： createAdaptiveExtension()

邏輯就一句：

injectExtension((T) getAdaptiveExtensionClass().newInstance());

先看 getAdaptiveExtensionClass()。

2.2.1.1 獲取ExtensionFactory擴(kuò)展類：getAdaptiveExtensionClass()

private Class<?> getAdaptiveExtensionClass() {
        getExtensionClasses();
        if (cachedAdaptiveClass != null) {
            return cachedAdaptiveClass;
        }
        return cachedAdaptiveClass = createAdaptiveExtensionClass();
    }

這里整體的邏輯是，先getExtensionClasses()，看看有沒有已經(jīng)存在的擴(kuò)展實(shí)現(xiàn)類，有的話取到這些類，把標(biāo)記了@Adaptive的緩存到cachedAdaptiveClass（比如說ExtensionFactory就是有的），把沒有標(biāo)記@Adaptive的擴(kuò)展實(shí)現(xiàn)類緩存到cachedClasses，返回。

如果沒有的話，就調(diào)用createAdaptiveExtensionClass()現(xiàn)生成code并compile一個(gè)Adaptive類出來，同樣緩存到cachedAdaptiveClass，返回。

Adaptive注解可以標(biāo)記在類上，也可以標(biāo)記在方法上。
如果Adaptive類選擇擴(kuò)展點(diǎn)實(shí)現(xiàn)的依據(jù)是根據(jù)上下文信息，即URL中的信息選擇不同的實(shí)現(xiàn)，那么可以把Adaptive注解標(biāo)記在服務(wù)的方法上，ExtensionLoader可以自動(dòng)生成這種情況的Adaptive類。
如果是自己實(shí)現(xiàn)Adaptive類，那么需要在類上標(biāo)記Adaptive注解，ExtensionLoader在加載擴(kuò)展點(diǎn)時(shí)就能發(fā)現(xiàn)并創(chuàng)建Adaptive實(shí)現(xiàn)。

（來自Dubbo源碼解析-2：Adaptive類，同樣很厲害的文章嗯，本文對(duì)其也多有引用不一一列舉了）

下面詳細(xì)分析一下這兩步。

2.2.1.1.1 獲取已存在的擴(kuò)展類：getExtensionClasses()

首先檢查ExtensionLoader<ExtensionFactory>的緩存cachedClasses，有就get沒有就調(diào)用loadExtensionClasses()創(chuàng)建。

  • loadExtensionClasses()
    首先去拿SPI注解，如果注解不為null，獲取注解的value：
final SPI defaultAnnotation = type.getAnnotation(SPI.class);
...
String value = defaultAnnotation.value();

ExtensionFactory定義如下：

@SPI
public interface ExtensionFactory {

    /**
     * Get extension.
     * 
     * @param type object type.
     * @param name object name.
     * @return object instance.
     */
    <T> T getExtension(Class<T> type, String name);

}

SPI注解類定義如下：

public @interface SPI {

    /**
     * 缺省擴(kuò)展點(diǎn)名。
     */
    String value() default "";

}

可以看到ExtensionFactory沒有定義缺省擴(kuò)展點(diǎn)名（后面會(huì)看到Container類有缺省定義）。

有缺省擴(kuò)展點(diǎn)名就緩存到ExtensionLoader<ExtensionFactory>的另一個(gè)緩存cachedDefaultName，沒有就繼續(xù)。

繼續(xù)，調(diào)用loadFile裝載擴(kuò)展實(shí)現(xiàn)類。

Map<String, Class<?>> extensionClasses = new HashMap<String, Class<?>>();
loadFile(extensionClasses, DUBBO_INTERNAL_DIRECTORY);
loadFile(extensionClasses, DUBBO_DIRECTORY);
loadFile(extensionClasses, SERVICES_DIRECTORY);
return extensionClasses;
  • loadFile（Map<String, Class<?>> extensionClasses, String dir）

loadFile首先在指定目錄下找名字是type的配置文件，然后讀出來：

String fileName = dir + type.getName();

對(duì) 于 ExtensionFactory來 說 ， 會(huì)讀到：

//META-INF/dubbo/internal/com.alibaba.dubbo.common.extension.ExtensionFactory
adaptive=com.alibaba.dubbo.common.extension.factory.AdaptiveExtensionFactory
spi=com.alibaba.dubbo.common.extension.factory.SpiExtensionFactory

//META-INF/dubbo/internal/com.alibaba.dubbo.common.extension.ExtensionFactory
spring=com.alibaba.dubbo.config.spring.extension.SpringExtensionFactory

隨后:

  1. loadfile讀入第一行數(shù)據(jù)，初始化：name=adaptive, line = com.alibaba.dubbo.common.extension.factory.AdaptiveExtensionFactory。

  2. 使用Class<?> clazz = Class.forName(line, true, classLoader)加載類。

  3. !type.isAssignableFrom(clazz)：驗(yàn)證加載的類是否是當(dāng)前type的一個(gè)實(shí)現(xiàn)。

  4. clazz.isAnnotationPresent(Adaptive.class)：檢查如果設(shè)置了@Adaptive，則把clazz保存在cachedAdaptiveClass中
    對(duì)于ExtensionFactory來說，AdaptiveExtensionFactory設(shè)置了@Adaptive注解：

@Adaptive
public class AdaptiveExtensionFactory implements ExtensionFactory {
...
}
  1. 對(duì)于沒有設(shè)置@Adaptive的類，則存入loadExtensionClasses()傳到loadFile()中的參數(shù)extensionClasses，返回后在getExtensionClasses() 中賦給cachedClasses緩存。
classes = loadExtensionClasses();
cachedClasses.set(classes);

對(duì)于ExtensionFactory來說，SpiExtensionFactory和SpringExtensionFactory都沒有設(shè)置@Adaptive注解（同一個(gè)類只能有一個(gè)Adaptive實(shí)現(xiàn)），所以都被存入了ExtensionLoader<ExtensionFactory>的cachedClasses。

2.2.1.1.2 動(dòng)態(tài)生成沒有自己實(shí)現(xiàn)的Adaptive類：createAdaptiveExtensionClass()

執(zhí)行完getExtensionClasses()，回到了2.2.1.1的getAdaptiveExtensionClass()，如果此時(shí)cachedAdaptiveClass仍為null，說明沒有找到標(biāo)記了@Adaptive的類，需要根據(jù)上下文動(dòng)態(tài)生成。

private Class<?> getAdaptiveExtensionClass() {
        getExtensionClasses();
        if (cachedAdaptiveClass != null) {
            return cachedAdaptiveClass;
        }
        return cachedAdaptiveClass = createAdaptiveExtensionClass();
    }

動(dòng)態(tài)生成的過程簡(jiǎn)單來說就是找到標(biāo)記了@Adaptive的方法，根據(jù)type通過StringBuilder拼接一個(gè)類，加載Compiler編譯。

前面提到的參考文章（Dubbo源碼解析-2：Adaptive類）里舉了例子，可以看到生成了什么樣子的代碼。這里不詳細(xì)說了。

2.2.1.2 為擴(kuò)展注入依賴的其他擴(kuò)展實(shí)現(xiàn)：injectExtension(T instance)

好的終于回來了，2.2.1.1節(jié)完成了getAdaptiveExtensionClass()，并返回了cachedAdaptiveClass。 為這個(gè)cachedAdaptiveClassnew了一個(gè)Instance以后，開始injectExtension注入。

擴(kuò)展點(diǎn)注入的代碼如下，首先查找以set開頭、帶一個(gè)參數(shù)的public方法，如果set方法的名稱大于3，則根據(jù)名稱獲取參數(shù)擴(kuò)展點(diǎn)的名稱，然后獲取擴(kuò)展點(diǎn)實(shí)現(xiàn)的實(shí)例，這可能又是一個(gè)次配置的解析和實(shí)例化過程。最后調(diào)用set方法將實(shí)例設(shè)置進(jìn)去。

private T injectExtension(T instance) {
        try {
            if (objectFactory != null) {
                for (Method method : instance.getClass().getMethods()) {
                    if (method.getName().startsWith("set")&&...) {
                        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) {
                            ...
                        }
                    }
                }
            }
        } catch (Exception e) {
           ...
        }
        return instance;
    }

對(duì)于ExtensionFactory來說，首先判斷，if (objectFactory != null)，則可以直接返回cachedAdaptiveClass所new的instance了。

2.2.2 ExtensionLoader<Container>構(gòu)造完畢

整個(gè)2.2.1過程結(jié)束，拿到了ExtensionFactory.class的擴(kuò)展實(shí)現(xiàn)，也就是所返回的cachedAdaptiveClass，即AdaptiveExtensionFactory。

private ExtensionLoader(Class<?> type) {
        this.type = type;
        objectFactory = (type == ExtensionFactory.class ? null : ExtensionLoader.getExtensionLoader(ExtensionFactory.class).getAdaptiveExtension());
    }

回到構(gòu)造函數(shù)，ExtensionLoader<Container>的objectFactory =AdaptiveExtensionFactory。

ExtensionLoader<Container>構(gòu)造完畢。

3. 在main()中調(diào)用loader.getExtension()加載Container的擴(kuò)展實(shí)現(xiàn)

Main函數(shù)的整體邏輯是，如果沒有傳入?yún)?shù)，就裝載Container的SPI注解指定的默認(rèn)Container，如果傳入的參數(shù)（main函數(shù)參數(shù)、JVM啟動(dòng)參數(shù)、classpath下的dubbo.properties配置等）指定了Container，就裝載通過參數(shù)指定的Container。

public class Main {
    public static final String CONTAINER_KEY = "dubbo.container";
    private static final ExtensionLoader<Container> loader = ExtensionLoader.getExtensionLoader(Container.class);
    ...    
    public static void main(String[] args) {
        try {
            if (args == null || args.length == 0) {
                String config = ConfigUtils.getProperty(CONTAINER_KEY, loader.getDefaultExtensionName());
                args = Constants.COMMA_SPLIT_PATTERN.split(config);
            }
            
            final List<Container> containers = new ArrayList<Container>();
            for (int i = 0; i < args.length; i ++) {
                containers.add(loader.getExtension(args[i]));
            }
            ...
            for (Container container : containers) {
                container.start();
               ...
            }
            ...
    }
    
}

首先看Container類的定義：

@SPI("spring")
public interface Container {
    
    /**
     * start.
     */
    void start();
    
    /**
     * stop.
     */
    void stop();

}

它將SPI的value值設(shè)置Spring，也就是指定默認(rèn)的擴(kuò)展實(shí)現(xiàn)名稱是spring（默認(rèn)情況只加載一個(gè)spring容器）。

再看關(guān)于Container的配置（以spring為例，其他jetty、log4j等都類似）：

\\META-INF/dubbo/internal/com.alibaba.dubbo.container.Container
spring=com.alibaba.dubbo.container.spring.SpringContainer

而SpringContainer類沒有加注解什么的，所以這里是通過SPI注解的默認(rèn)值控制的，和ExtensionFactory的機(jī)制不同。

下面詳細(xì)分析main函數(shù)加載Container擴(kuò)展點(diǎn)過程。

3.1 如果沒有傳參，獲得默認(rèn)擴(kuò)展名：loader.getDefaultExtensionName()

    public String getDefaultExtensionName() {
        getExtensionClasses();
        return cachedDefaultName;
    }

這里調(diào)用了getExtensionClasses()，與2.2.1.1.1節(jié)介紹的過程相同。

不同的是，對(duì)于ExtensionLoader<Container>，通過SPI注解定義了缺省擴(kuò)展點(diǎn)名spring，因此會(huì)將spring緩存到cachedDefaultName。

而由于Container的擴(kuò)展實(shí)現(xiàn)類都沒有設(shè)置@Adaptive，則這些實(shí)現(xiàn)類都被緩存在cachedClasses中，不會(huì)被緩存在cachedAdaptiveClass。

3.2 獲得Container：loader.getExtension()

  • getExtension()
    先去緩存cachedInstances中找，如果沒有，則調(diào)用createExtension創(chuàng)建。
public T getExtension(String name) {
        ...
        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;
    }
  • createExtension()
    通過getExtensionClasses()獲得擴(kuò)展實(shí)現(xiàn)類，調(diào)用injectExtension注入依賴的其他擴(kuò)展和包裝類。返回獲取了包裝后的擴(kuò)展instance。
private T createExtension(String name) {
        Class<?> clazz = getExtensionClasses().get(name);
        ...
        try {
            T instance = (T) EXTENSION_INSTANCES.get(clazz);
           ...
            injectExtension(instance);
            Set<Class<?>> wrapperClasses = cachedWrapperClasses;
            if (wrapperClasses != null && wrapperClasses.size() > 0) {
                for (Class<?> wrapperClass : wrapperClasses) {
                    instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance));
                }
            }
            return instance;
        } catch (Throwable t) {
            ...
        }
    }
  • getExtensionClasses()

其實(shí)是從獲取之前l(fā)oad到cachedClassed中的所有擴(kuò)展實(shí)現(xiàn)類。沒有的話就調(diào)用loadExtensionClasses()（見2.2.1.1.1節(jié)）獲取。

private Map<String, Class<?>> getExtensionClasses() {
        Map<String, Class<?>> classes = cachedClasses.get();
        if (classes == null) {
            ...
            classes = loadExtensionClasses();
            ...
        }
        return classes;
    }

3.3 獲取Container擴(kuò)展后，啟動(dòng)

擴(kuò)展加載結(jié)束，啟動(dòng)Container~

for (Container container : containers) {
       container.start();
       ...
}
最后編輯于 ：
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請(qǐng)聯(lián)系作者
平臺(tái)聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點(diǎn)，簡(jiǎn)書系信息發(fā)布平臺(tái)，僅提供信息存儲(chǔ)服務(wù)。

推薦閱讀更多精彩內(nèi)容