dubbo的spi機制

dubbo的擴充套件點載入機制源自於java的spi擴充套件機制。那麼,何為java的spi擴充套件機制?

java的spi擴充套件機制

作為介面程式設計的一種典型應用,系統在設計某個功能模組時(需要其他的框架提供),只定義了介面,而服務提供者需要根據spi的相關規範,進行介面實現類的實現。而我們的系統不需要重新進行編譯或者生成,即可以使用介面的新的實現類。

java的spi的步驟:

  1. 在META-INF/services/目錄中建立以介面全限定名命名的檔案該檔案內容為Api具體實現類的全限定名
  2. 使用ServiceLoader類動態載入META-INF中的實現類
  3. 如SPI的實現類為Jar則需要放在主程式classPath中
  4. Api具體實現類必須有一個不帶引數的構造方法
    具體案例:
    https://download.csdn.net/download/andyzhu_2005/10808099

dubbo的spi

dubbo的spi源於java的spi,但是做了如下兩點改進:
1、java的spi一次性初始化所有的擴充套件實現,比較浪費時間。(這一點不太理解,其實dubbo中對於相關的介面的擴充套件實現,貌似也是一次性載入所有的)
2、dubbo存在介面名字命名的檔案是以鍵值對形式儲存的,可以通過名字快速尋找,而不需要像java原生的spi,需要通過iterator.hasNext()迭代尋找
3、擴充套件點自動裝配功能(IOC)和aop功能(filter以及listener等wrapper)

何為 實現了ioc及aop功能

就是當載入一個擴充套件點時,會自動的注入這個擴充套件點所依賴的其他擴充套件點,如果描述不清楚的話,可以看下下面的例子:

介面A,實現類A1,A2
介面B,實現類B1,B2
其中實現類A1含有setB()方法,當通過擴充套件機制載入A的實現的時候,會自動的注入一個B的實現類,但是,此時不是注入B1,也不是注入B2,而是注入一個自適應的B的實現類:B$Adpative,該實現類是動態生成的,能夠根據引數的不同,自動選擇B1或者B2來進行呼叫。

擴充套件點使用單一例項載入,需要確保執行緒安全性。?

@Adaptive註解,有兩種註解方式:一種是註解在類上,一種是註解在方法上。

註解在類上,而且是註解在實現類上,目前dubbo只有AdaptiveCompiler和AdaptiveExtensionFactory類上標註了此註解,這是些特殊的類,ExtensionLoader需要依賴他們工作,所以得使用此方式。
註解在方法上,註解在介面的方法上,除了上面兩個類之外,所有的都是註解在方法上。ExtensionLoader根據介面定義動態的生成介面卡程式碼,並例項化這個生成的動態類。被Adaptive註解的方法會生成具體的方法實現。沒有註解的方法生成的實現都是拋不支援的操作異常UnsupportedOperationException。被註解的方法在生成的動態類中,會根據url裡的引數資訊,來決定實際呼叫哪個擴充套件。

擴充套件點的載入

在dubbo中,正常的spi擴充套件基本都如下:

/這樣使用,先獲取ExtensionLoader例項,然後載入自適應的Protocol擴充套件點
Protocol protocol = ExtensionLoader.getExtensionLoader(Protocol.class).getAdaptiveExtension();
//使用
protocol.refer(Class<T> type, URL url));

1、第一步,getExtensionLoader(Protocol.class),根據要載入的介面Protocol,創建出一個ExtensionLoader例項,載入完的例項會被快取起來,下次再載入Protocol的ExtensionLoader的時候,會使用已經快取的這個,不會再新建一個例項:
2、getAdaptiveExtension()方法:相當於對於 ExtensionLoader.getExtensionLoader(Protocol.class)的ExtensionLoader例項,對相關的檔案路徑下,找到所有的此介面的實現,並例項化;
3、protocol.refer(Class type, URL url));通過介面的方法的url,找到protocol的具體實現名,比如dubbo,從而找到真正的protocol的實現,dubboprotocol的refer,執行。

每一個spi擴充套件(即有@spi註解的介面)都對應著一個ExtensionLoader,互相獨立。而每個ExtensionLoader負責載入這個spi擴充套件下所有的實現(一次性的)。比如protocol對應的ExtensionLoader。

原始碼分析(以dubboprotocol為例):

 private static final Protocol protocol = ExtensionLoader.getExtensionLoader(Protocol.class).getAdaptiveExtension();

這句程式碼就是獲取protocol 的自適應實現。返回的protocol 例項會根據url的protocol的名稱來載入不同的實現類。

ExtensionLoader.getExtensionLoader(Protocol.class)原始碼解析

    @SuppressWarnings("unchecked")
    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;
    }

看下面這兩句程式碼:

 EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader<T>(type));
            loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);
ExtensionLoader<T> loader = (ExtensionLoader<T>) 

將斷點打在 EXTENSION_LOADERS.get(type);上,當tpye是protocol時候,F6單句執行。
上面方法中

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

EXTENSION_LOADERS是一個執行緒安全的ExtensionLoader的hashmap集合,集合的名就是各個type,比如com.alibaba.dubbo.rpc.Protocol,com.alibaba.dubbo.common.extension.ExtensionFactory等,都是被@spi註解的介面名稱。第一次載入的時候,loader 為空,則執行 EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader(type));
關注 new ExtensionLoader(type)方法,就是獲得這個type(這裡就是protocol)的ExtensionLoader。dubbo中大量的使用了這種快取技術。

看ExtensionLoader的構造方法。是private的,即只能在類裡內部呼叫,

    private ExtensionLoader(Class<?> type) {
        this.type = type;
        //如果type不是ExtensionFactory,則objectFactory 就是ExtensionFactory.class的擴充套件。
        objectFactory = (type == ExtensionFactory.class ? null : ExtensionLoader.getExtensionLoader(ExtensionFactory.class).getAdaptiveExtension());
    }

這裡的objectFactory 可以理解為dubbo的容器,類似於spring的beanfactory,主要用於dubbo的ioc功能。後續再研究。
new ExtensionLoader(type)執行完,返回了protocol所屬的ExtensionLoader,主要工作就是獲得了一個objectFactory。

.getAdaptiveExtension();原始碼解析

接下來執行 private static final Protocol protocol = ExtensionLoader.getExtensionLoader(Protocol.class).getAdaptiveExtension();的getAdaptiveExtension()方法。
用於獲取protocol的自適應類。(這些工作都是在ExtensionLoader類裡執行,目前type=protocol)。

    public T getAdaptiveExtension() {
        Object instance = cachedAdaptiveInstance.get();
        //這裡雙重的instance == null有點像單例模式的雙重檢測,避免執行緒不安全
        if (instance == null) {
            if(createAdaptiveInstanceError == null) {
                synchronized (cachedAdaptiveInstance) {
                    instance = cachedAdaptiveInstance.get();
                    if (instance == null) {
                        try {
                        //instance ==null,進入createAdaptiveExtension()
                            instance = createAdaptiveExtension();
                            cachedAdaptiveInstance.set(instance);
                        } catch (Throwable t) {
                            createAdaptiveInstanceError = t;
                            throw new IllegalStateException("fail to create adaptive instance: " + t.toString(), t);
                        }
                    }
                }
            }
            else {
                throw new IllegalStateException("fail to create adaptive instance: " + createAdaptiveInstanceError.toString(), createAdaptiveInstanceError);
            }
        }

        return (T) instance;
    }

    private T createAdaptiveExtension() {
        try {
            return injectExtension((T) getAdaptiveExtensionClass().newInstance());
        } catch (Exception e) {
            throw new IllegalStateException("Can not create adaptive extenstion " + type + ", cause: " + e.getMessage(), e);
        }
    }

instance為空,進入createAdaptiveExtension()方法,建立自適應擴充套件實現。 return injectExtension((T) getAdaptiveExtensionClass().newInstance());先看看getAdaptiveExtensionClass(),根據名稱應該是獲取到類名,後面的newInstance()是java的根據類名生成例項的操作。

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

然後進入getExtensionClasses()

	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() {
    //獲得介面的spi註解
        final SPI defaultAnnotation = type.getAnnotation(SPI.class);
        if(defaultAnnotation != null) {
            String value = defaultAnnotation.value();
            if(value != null && (value = value.trim()).length() > 0) {
            //正則表示式,如果spi註解的名字不止一個的話報錯
                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<?>>();
        //把相關路徑下的類(對於protocol介面而言)全都載入到extensionClasses 中來
        loadFile(extensionClasses, DUBBO_INTERNAL_DIRECTORY);
        loadFile(extensionClasses, DUBBO_DIRECTORY);
        loadFile(extensionClasses, SERVICES_DIRECTORY);
        return extensionClasses;
    }

檢視loadFile的方法,這個類主要就是把路徑下的下面的protocol的介面實現類全部根據類名通過反射例項化

registry=com.alibaba.dubbo.registry.integration.RegistryProtocol
filter=com.alibaba.dubbo.rpc.protocol.ProtocolFilterWrapper
listener=com.alibaba.dubbo.rpc.protocol.ProtocolListenerWrapper
mock=com.alibaba.dubbo.rpc.support.MockProtocol
injvm=com.alibaba.dubbo.rpc.protocol.injvm.InjvmProtocol
dubbo=com.alibaba.dubbo.rpc.protocol.dubbo.DubboProtocol
rmi=com.alibaba.dubbo.rpc.protocol.rmi.RmiProtocol
hessian=com.alibaba.dubbo.rpc.protocol.hessian.HessianProtocol
com.alibaba.dubbo.rpc.protocol.http.HttpProtocol
com.alibaba.dubbo.rpc.protocol.webservice.WebServiceProtocol
thrift=com.alibaba.dubbo.rpc.protocol.thrift.ThriftProtocol
memcached=memcom.alibaba.dubbo.rpc.protocol.memcached.MemcachedProtocol
redis=com.alibaba.dubbo.rpc.protocol.redis.RedisProtocol
  private void loadFile(Map<String, Class<?>> extensionClasses, String dir) {
        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 url = urls.nextElement();
                    try {
                        BufferedReader reader = new BufferedReader(new InputStreamReader(url.openStream(), "utf-8"));
                        try {
                            String line = null;
                            while ((line = reader.readLine()) != null) {
                                final int ci = line.indexOf('#');
                                if (ci >= 0) line = line.substring(0, ci);
                                //line的形式 registry=com.alibaba.dubbo.registry.integration.RegistryProtocol
                                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) {
                                        //返回類,
                                            Class<?> clazz = Class.forName(line, true, classLoader);
                                            if (! type.isAssignableFrom(clazz)) {
                                                throw new IllegalStateException("Error when load extension class(interface: " +
                                                        type + ", class line: " + clazz.getName() + "), class " 
                                                        + clazz.getName() + "is not subtype of interface.");
                                            }
                                            //這裡判斷類的註解是否有Adaptive.class註解,如果有的話,說明這個類就是這個spi擴充套件的預設強制實現類(即不會根據url的spi的名稱來找對應的實現類,並存入cachedAdaptiveClass 中)
                                            if (clazz.isAnnotationPresent(Adaptive.class)) {
                                                if(cachedAdaptiveClass == null) {
                                                    cachedAdaptiveClass = clazz;
                                                } else if (! cachedAdaptiveClass.equals(clazz)) {
                                                    throw new IllegalStateException("More than 1 adaptive class found: "
                                                            + cachedAdaptiveClass.getClass().getName()
                                                            + ", " + clazz.getClass().getName());
                                                }
                                            } else {
                                                try {
                                                //判斷這個類有沒有以protocol介面實現類作為構造方法的引數,如果有,就說明是wrapper類,把它放入cachedWrapperClasses 類中,比如就是ProtocolFilterWrapper  。如果不是的話,直接進入下面的catch塊
                                                    clazz.getConstructor(type);
                                                    Set<Class<?>> wrappers = cachedWrapperClasses;
                                                    if (wrappers == null) {
                                                        cachedWrapperClasses = new ConcurrentHashSet<Class<?>>();
                                                        wrappers = cachedWrapperClasses;
                                                    }
                                                    wrappers.add(clazz);
                                                } catch (NoSuchMethodException e) {
                                                //獲得無參的構造方法
                                                    clazz.getConstructor();
                                                    if (name == null || name.length() == 0) {
                                                        name = findAnnotationName(clazz);
                                                        if (name == null || name.length() == 0) {
                                                            if (clazz.getSimpleName().length() > type.getSimpleName().length()
                                                                    && clazz.getSimpleName().endsWith(type.getSimpleName())) {
                                                                name = clazz.getSimpleName().substring(0, clazz.getSimpleName().length() - type.getSimpleName().length()).toLowerCase();
                                                            } else {
                                                                throw new IllegalStateException("No such extension name for the class " + clazz.getName() + " in the config " + url);
                                                            }
                                                        }
                                                    }
                                                    String[] names = NAME_SEPARATOR.split(name);
                                                    if (names != null && names.length > 0) {
                                                        Activate activate = clazz.getAnnotation(Activate.class);
                                                        if (activate != null) {
                                                            cachedActivates.put(names[0], activate);
                                                        }
                                                        for (String n : names) {
                                                            if (! cachedNames.containsKey(clazz)) {
                                                                cachedNames.put(clazz, n);
                                                            }
                                                            Class<?> c = extensionClasses.get(n);
                                                            if (c == null) {
                                                            //把類放入extensionClasses中
                                                                extensionClasses.put(n, clazz);
                                                            } else if (c != clazz) {
                                                                throw new IllegalStateException("Duplicate extension " + type.getName() + " name " + n + " on " + c.getName() + " and " + clazz.getName());
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    } catch (Throwable t) {
                                        IllegalStateException e = new IllegalStateException("Failed to load extension class(interface: " + type + ", class line: " + line + ") in " + url + ", cause: " + t.getMessage(), t);
                                        exceptions.put(line, e);
                                    }
                                }
                            } // end of while read lines
                        } finally {
                            reader.close();
                        }
                    } catch (Throwable t) {
                        logger.error("Exception when load extension class(interface: " +
                                            type + ", class file: " + url + ") in " + url, t);
                    }
                } // end of while urls
            }
        } catch (Throwable t) {
            logger.error("Exception when load extension class(interface: " +
                    type + ", description file: " + fileName + ").", t);
        }
    }

getExtensionClasses()執行完, 我們的extensionClasses已經存了關於protocol介面所有的以<名稱,類>的hashmap集合了。下面進入createAdaptiveExtensionClass()方法,用於

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


    private Class<?> createAdaptiveExtensionClass() {
        String code = createAdaptiveExtensionClassCode();
        ClassLoader classLoader = findClassLoader();
        com.alibaba.dubbo.common.compiler.Compiler compiler = ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.common.compiler.Compiler.class).getAdaptiveExtension();
        return compiler.compile(code, classLoader);
    }

createAdaptiveExtensionClass()方法會自動的拼接一個關於protocol介面的自適應類,並會通過dubbo的編譯器對這個類進行編譯。生成的類如下:

package com.alibaba.dubbo.rpc;
import com.alibaba.dubbo.common.extension.ExtensionLoader;

public class Protocol$Adpative implements com.alibaba.dubbo.rpc.Protocol {
    @SuppressWarnings("unchecked")
	public com.alibaba.dubbo.rpc.Invoker refer(java.lang.Class arg0, com.alibaba.dubbo.common.URL arg1) {
        if (arg1 == null) 
            throw new IllegalArgumentException("url == null");

        com.alibaba.dubbo.common.URL url = arg1;
        String extName = ( url.getProtocol() == null ? "dubbo" : url.getProtocol() );
        if(extName == null) 
            throw new IllegalStateException("Fail to get extension(com.alibaba.dubbo.rpc.Protocol) name from url(" + url.toString() + ") use keys([protocol])");

        com.alibaba.dubbo.rpc.Protocol extension = (com.alibaba.dubbo.rpc.Protocol)ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.rpc.Protocol.class).getExtension(extName);

        return extension.refer(arg0, arg1);
    }

    @SuppressWarnings("unchecked")
	public com.alibaba.dubbo.rpc.Exporter export(com.alibaba.dubbo.rpc.Invoker arg0)  {
        if (arg0 == null) 
            throw new IllegalArgumentException("com.alibaba.dubbo.rpc.Invoker argument == null");

        if (arg0.getUrl() == null) 
            throw new IllegalArgumentException("com.alibaba.dubbo.rpc.Invoker argument getUrl() == null");com.alibaba.dubbo.common.URL url = arg0.getUrl();
        //根據URL配置資訊獲取Protocol協議,預設是dubbo
        String extName = ( url.getProtocol() == null ? "dubbo" : url.getProtocol() );
        if(extName == null) 
            throw new IllegalStateException("Fail to get extension(com.alibaba.dubbo.rpc.Protocol) name from url(" + url.toString() + ") use keys([protocol])");
            //根據協議名,獲取Protocol的實現
            //獲得Protocol的實現過程中,會對Protocol先進行依賴注入,然後進行Wrapper包裝,最後返回被修改過的Protocol
            //包裝經過了ProtocolFilterWrapper,ProtocolListenerWrapper,RegistryProtocol
        com.alibaba.dubbo.rpc.Protocol extension = (com.alibaba.dubbo.rpc.Protocol)ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.rpc.Protocol.class).getExtension(extName);

        return extension.export(arg0);
    }

    public void destroy() {
        throw new UnsupportedOperationException("method public abstract void com.alibaba.dubbo.rpc.Protocol.destroy() of interface com.alibaba.dubbo.rpc.Protocol is not adaptive method!");
    }

    public int getDefaultPort() {
        throw new UnsupportedOperationException("method public abstract int com.alibaba.dubbo.rpc.Protocol.getDefaultPort() of interface com.alibaba.dubbo.rpc.Protocol is not adaptive method!");
    }
}

這樣就返回了protocol的自適應擴充套件類,其通過extName ,獲取對應的實現類

protocol.export(Class type, URL url))原始碼解析

,比如我們呼叫dubboprotocol的export方法,則 通過上面的 生成的Protocol$Adpative類,根據url中的protocol的具體名字,下面的getExtension(extName)獲取到對應的例項

  com.alibaba.dubbo.rpc.Protocol extension = (com.alibaba.dubbo.rpc.Protocol)ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.rpc.Protocol.class).getExtension(extName);

        return extension.export(arg0);

看看objectFactory 是什麼東西

 private ExtensionLoader(Class<?> type) {
        this.type = type;
        //如果type不是ExtensionFactory,則objectFactory 就是ExtensionFactory.class的擴充套件。
        objectFactory = (type == ExtensionFactory.class ? null : ExtensionLoader.getExtensionLoader(ExtensionFactory.class).getAdaptiveExtension());
    }

在ExtensionLoader類中有一個引數是objectFactory ,這個引數就是dubbo中的容器。
事實上,每一個ExtensionLoader都會有這麼個objectFactory 。比如,我們在斷點除錯的時候,最先載入spi擴充套件的介面是com.alibaba.dubbo.common.threadpool.ThreadPool,那麼在通過

//這裡的tpye=com.alibaba.dubbo.common.threadpool.ThreadPool
   private ExtensionLoader(Class<?> type) {
        this.type = type;
        objectFactory = (type == ExtensionFactory.class ? null : ExtensionLoader.getExtensionLoader(ExtensionFactory.class).getAdaptiveExtension());
    }

實現ThreadPool的spi擴充套件時候,就會進行ExtensionLoader.getExtensionLoader(ExtensionFactory.class).getAdaptiveExtension())的操作,從而又程式設計對ExtensionFactory的spi載入或者載入完成後進行獲取。
ExtensionFactory介面的spi擴充套件還是通過ExtensionLoader來實現的。
看一下他的實現。
在方法

 public static <T> ExtensionLoader<T> getExtensionLoader(Class<T> type)

中,如果傳進來的是com.alibaba.dubbo.common.extension.ExtensionFactory,則我們在初始化 ExtensionLoader(Class<?> type)時候,objectFactory 為null。(這裡的理解是我現在要通過ExtensionLoader類生成objectFactory ,所以ExtensionLoader類的構造方法中是不會有objectFactory 這個例項的,還沒有生成嘛)
返回ExtensionLoader例項後,執行getAdaptiveExtension()操作,通過上面的分析,我們先看看ExtensionFactory有幾個實現類。
adaptive=com.alibaba.dubbo.common.extension.factory.AdaptiveExtensionFactory
spi=com.alibaba.dubbo.common.extension.factory.SpiExtensionFactory
spring=com.alibaba.dubbo.config.spring.extension.SpringExtensionFactory
即有三個實現類,再檢視com.alibaba.dubbo.common.extension.factory.AdaptiveExtensionFactory
spi=com.alibaba.dubbo.common.extension.factory.SpiExtensionFactory這個類,其類上有@Adaptive註解,說明這個類是ExtensionFactory的預設強制實現。

    public AdaptiveExtensionFactory() {
        ExtensionLoader<ExtensionFactory> loader = ExtensionLoader.getExtensionLoader(ExtensionFactory.class);
        List<ExtensionFactory> list = new ArrayList<ExtensionFactory>();
        for (String name : loader.getSupportedExtensions()) {
            list.add(loader.getExtension(name));
        }
        factories = Collections.unmodifiableList(list);
    }

上面方法就是把extension的兩個spi擴充套件實現
spi=com.alibaba.dubbo.common.extension.factory.SpiExtensionFactory
spring=com.alibaba.dubbo.config.spring.extension.SpringExtensionFactory
給載入進來。
上面方法中的loader.getExtension(name),(name就是extensionFactory),就是獲得spi擴充套件的具體實現。這裡的實現是指已經通過newInstance獲得類的例項。

    /**
     * 返回指定名字的擴充套件。如果指定名字的擴充套件不存在,則拋異常 {@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;
	}


  @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, (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);
        }
    }
    
    private T injectExtension(T instance) {
        try {
            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("fail to inject via method " + method.getName()
                                    + " of interface " + type.getName() + ": " + e.getMessage(), e);
                        }
                    }
                }
            }
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        }
        return instance;
    }

而在之後的方法中會用到objectFactory.getExtension(pt, property);

    public <T> T getExtension(Class<T> type, String name) {
        for (ExtensionFactory factory : factories) {
            T extension = factory.getExtension(type, name);
            if (extension != null) {
                return extension;
            }
        }
        return null;
    }

再看看兩個spi的具體實現:
第一個SpiExtensionFactory:

    public <T> T getExtension(Class<T> type, String name) {
        if (type.isInterface() && type.isAnnotationPresent(SPI.class)) {
            ExtensionLoader<T> loader = ExtensionLoader.getExtensionLoader(type);
            if (loader.getSupportedExtensions().size() > 0) {
                return loader.getAdaptiveExtension();
            }
        }
        return null;
    }

}

上面的方法是如果介面有spi註解,那就返回這個介面的自適應擴充套件實現。
而SpringExtensionFactory的實現就是正常的如果這個介面在spring容器裡有,那就從容器中取。

   @SuppressWarnings("unchecked")
    public <T> T getExtension(Class<T> type, String name) {
        for (ApplicationContext context : contexts) {
            if (context.containsBean(name)) {
                Object bean = context.getBean(name);
                if (type.isInstance(bean)) {
                    return (T) bean;
                }
            }
        }
        return null;
    }

}

所以,從上面可以看出,objectFactory就是一個容器,通過介面名獲得相應的例項。
那麼在哪裡可以用到呢。dubbo中,可以實現例項的依賴注入功能。在createAdaptiveExtension()方法中,通過spi擴充套件獲得自適應實現類的時候,前面的injectExtension()方法就是對例項中的set方法,進行屬性的自動載入。

    private T createAdaptiveExtension() {
        try {
            return injectExtension((T) getAdaptiveExtensionClass().newInstance());
        } catch (Exception e) {
            throw new IllegalStateException("Can not create adaptive extenstion " + type + ", cause: " + e.getMessage(), e);
        }
    }
    private T injectExtension(T instance) {
        try {
            if (objectFactory != null) {
                for (Method method : instance.getClass().getMethods()) {
                    if (method.getName().startsWith("set")
                            && method.getParameterTypes().length == 1
                            && Modifier.isPublic(method.getModifiers())) {
                            // pt =interface com.alibaba.dubbo.rpc.Protocol等有spi註解的介面
                        Class<?> pt = method.getParameterTypes()[0];
                        try {
                        //public void com.alibaba.dubbo.rpc.proxy.wrapper.StubProxyFactoryWrapper.setProtocol(com.alibaba.dubbo.rpc.Protocol)
                        //這裡的 method.getName().substring(3, 4)就是p,method.getName().substring(4) 就是rotocol,即把Protocol首字母小寫,取出來
                            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("fail to inject via method " + method.getName()
                                    + " of interface " + type.getName() + ": " + e.getMessage(), e);
                        }
                    }
                }
            }
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        }
        return instance;
    }