dubbo源碼學習(一)之ExtensionLoader

【轉載請注明作者和原文鏈接，歡迎討論，相互學習。】

 

一、前言

     ExtensionLoader類，主要是根據擴展點名稱來對擴展點接口實現進行的一系列操作，如果獲取擴展點接口實現實例、適配類實例、更新實現實例等等。

    ExtensionLoader類是dubbo對JDK SPI做了擴展，主要體現在方面：

    （1）jdk spi僅僅通過接口類名獲取所有實現，而ExtensionLoader則通過接口類名和key值獲取一個實現；

    （2）Adaptive實現，就是生成一個代理類，這樣就可以根據實際調用時的一些參數動態決定要調用的類了。

    （3）自動包裝實現，這種實現的類一般是自動激活的，常用於包裝類，比如Protocol的兩個實現類：ProtocolFilterWrapper、ProtocolListenerWrapper。 3、url總線設計 Dubbo為了使得各層解耦，采用了url總線的設計。我們通常的設計會把層與層之間的交互參數做成Model，這樣層與層之間溝通成本比較大，擴展起來也比較麻煩。因此，Dubbo把各層之間的通信都采用url的形式。比如，注冊中心啟動時，參數的url為： registry://0.0.0.0:9090?codec=registry&transporter=netty 這就表示當前是注冊中心，綁定到所有ip，端口是9090，解析器類型是registry，使用的底層網絡通信框架是netty。

 

二、代碼分析

     這邊說明如果獲取擴展點接口實現實例步驟流程作為說明重點，其他的類似，套路都差不多。具體流程如下：

     1.獲取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(" + 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;
    }

       這個方法有如下幾個重點：

       1)判斷是否為擴展點接口

       2)是否帶有SPI注解

       3)該擴展點如果為null，則新建該擴展實現實例並返回。

2.獲取指定擴展點名稱對應的實例

   /**
     * 返回指定名字的擴展。如果指定名字的擴展不存在，則拋異常 {@link IllegalStateException}.
     *
     * @param name
     * @return
     */
    @SuppressWarnings("unchecked")
    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;
    }

這個步驟稍微復雜，我們詳細分解一下：

1)9～13行，對擴展點名稱進行合法性判斷，如果是true，返回默認的擴展點接口實現。

2)14～19行，在cachedInstances中put一個存放擴展點接口實現實例的對象。

3)24行是創建擴展點接口實現的關鍵，方法：createExtension。

    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, (T) clazz.newInstance());
                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) {
            throw new IllegalStateException("Extension instance(name: " + name + ", class: " +
                    type + ")  could not be instantiated: " + t.getMessage(), t);
        }
    }

這個方法的關鍵在於，也就是我們需要的實現類了：Class<?> clazz = getExtensionClasses().get(name);

它會從META-INF/services/，META-INF/dubbo/，META-INF/dubbo/internal/這個三個目錄下掃描所有的擴展點信息，存放到extensionClasses這個Map<String, Class<?>> 里邊，

然后我們根據擴展點接口名稱就可以獲取到擴展點接口實現實例了，具體代碼如下。

    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;
    }

    private Map<String, Class<?>> loadExtensionClasses() {
        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;
    }