Dubbo源碼分析-SPI實(shí)現(xiàn)源碼解析（一）

Dubbo約定如下

SPI文件存儲(chǔ)路徑在META-INF/dubbo/internal目錄下柿隙，并且文件名為接口名的全路徑名接口包名+接口名
每個(gè)SPI文件里面格式定義為:擴(kuò)展名=具體類名,例如dubbo=org.apache.dubbo.rpc.protocol.dubbo.DubboProtocol

實(shí)現(xiàn)路徑:

getExtensionLoader(Class<T> type) 就是為該接口new一個(gè)ExtensionLoader,然后緩存起來(lái)叶洞。
getAdaptiveExtension()獲取一個(gè)拓展裝飾類的對(duì)象，如果@Adaptive注解在類上就是一個(gè)裝飾類禀崖，如果注釋在方法上就是一個(gè)動(dòng)態(tài)代理類衩辟，例如Protocol$Adaptive對(duì)象（如果是動(dòng)態(tài)代理類，與dubbo中URL配合可以在運(yùn)行時(shí)動(dòng)態(tài)決定使用的實(shí)現(xiàn)類）波附。
getExtension(String name) 獲取一個(gè)對(duì)象

這些方法都在ExtensionLoader中艺晴，ExtensionLoader是最核心的類昼钻，負(fù)責(zé)擴(kuò)展點(diǎn)的加載和生命周期管理。

getExtensionLoader(Class<T> type)

getExtensionLoader方法這是一個(gè)靜態(tài)工廠方法封寞，入?yún)⑹且粋€(gè)可擴(kuò)展的接口然评，返回一個(gè)該接口的ExtensionLoader實(shí)體類。通過(guò)這個(gè)實(shí)體類狈究，可以根據(jù)name獲得具體的擴(kuò)展碗淌，也可以獲得一個(gè)自適應(yīng)擴(kuò)展。

 public static <T> ExtensionLoader<T> getExtensionLoader(Class<T> type) {
        if (type == null) {
            throw new IllegalArgumentException("Extension type == null");
        }
         // 擴(kuò)展點(diǎn)必須是接口
        if (!type.isInterface()) {
            throw new IllegalArgumentException("Extension type(" + type + ") is not interface!");
        }
        // 必須要有@SPI注解
        if (!withExtensionAnnotation(type)) {
            throw new IllegalArgumentException("Extension type(" + type +
                    ") is not extension, because WITHOUT @" + SPI.class.getSimpleName() + " Annotation!");
        }
        // 從緩存中根據(jù)接口獲取對(duì)應(yīng)的ExtensionLoader
        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中沒(méi)有獲取到對(duì)應(yīng)的ExtensionLoader則新建一個(gè)ExtensionLoader

在ExtensionLoader結(jié)構(gòu)體中有兩個(gè)成員變量type和objectFactory抖锥。

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

type是我們傳入的class類型亿眠，objectFactory是通過(guò)ExtensionLoader.getExtensionLoader(ExtensionFactory.class).getAdaptiveExtension()獲取的一個(gè)被@Adaptive標(biāo)注的ExtensionFactory的實(shí)現(xiàn)類AdaptiveExtensionFactory

最后生成的ExtensionLoader會(huì)被放入EXTENSION_LOADERS中。

關(guān)于objectFactory的一些細(xì)節(jié)

objectFactory就是ExtensionFactory磅废，它就是通過(guò) ExtensionLoader.getExtensionLoader(ExtensionFactory.class)來(lái)實(shí)現(xiàn)的纳像，但是它的objectFactory=null
-objectFactory作用，它就是為dubbo的IOC提供所有對(duì)象还蹲。
objectFactory的IOC對(duì)象具體由ExtensionFactory的子類SpiExtensionFactory和SpringExtensionFactory提供爹耗。

getAdaptiveExtension()

在對(duì)自適應(yīng)拓展生成過(guò)程進(jìn)行深入分析之前，我們先來(lái)看一下與自適應(yīng)拓展息息相關(guān)的一個(gè)注解谜喊，即 @Adaptive 注解潭兽。該注解的定義如下：

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD})
public @interface Adaptive {
   String[] value() default {};
}

@Adaptive可以標(biāo)注在類或者接口方法上

標(biāo)注在類上getAdaptiveExtension會(huì)直接返回被@Adaptive注解實(shí)現(xiàn)類。

如上述所說(shuō)的ExtensionLoader.getExtensionLoader(ExtensionFactory.class).getAdaptiveExtension()返回的就是AdaptiveExtensionFactory

@Adaptive
public class AdaptiveExtensionFactory implements ExtensionFactory {

    private final List<ExtensionFactory> factories;

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

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

}

標(biāo)注在接口的方法上斗遏，方法參數(shù)必定有URL或者傳入的方法入?yún)?duì)象中有getUrl方法山卦，dubbo動(dòng)態(tài)編譯生成如Protocol$Adaptive類，運(yùn)行時(shí)會(huì)根據(jù)URL中的參數(shù)诵次，決定使用哪個(gè)實(shí)現(xiàn)類账蓉。

從Protocol獲取自適應(yīng)類的過(guò)程來(lái)解析getAdaptiveExtension執(zhí)行過(guò)程

@SPI("dubbo")
public interface Protocol {
      ............. 刪除多余代碼
    @Adaptive
    <T> Exporter<T> export(Invoker<T> invoker) throws RpcException;

    @Adaptive
    <T> Invoker<T> refer(Class<T> type, URL url) throws RpcException;
   ............刪除多余代碼
}

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

getAdaptiveExtension 方法首先會(huì)檢查緩存，緩存未命中逾一，則調(diào)用 createAdaptiveExtension方法創(chuàng)建自適應(yīng)拓展铸本。

    public T getAdaptiveExtension() {
        // 從緩存中獲取自適應(yīng)拓展
        Object instance = cachedAdaptiveInstance.get();
        //雙重檢查
        if (instance == null) {
            if (createAdaptiveInstanceError == null) {
                synchronized (cachedAdaptiveInstance) {
                    instance = cachedAdaptiveInstance.get();
                    if (instance == null) {
                        try {
                        // 創(chuàng)建自適應(yīng)拓展
                            instance = createAdaptiveExtension();
                           // 設(shè)置自適應(yīng)拓展到緩存中  
                           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;
    }

重要的方法是createAdaptiveExtension

    private T createAdaptiveExtension() {
        try {
         // 獲取自適應(yīng)拓展類，并通過(guò)反射實(shí)例化
            return injectExtension((T) getAdaptiveExtensionClass().newInstance());
        } catch (Exception e) {
            throw new IllegalStateException("Can not create adaptive extension " + type + ", cause: " + e.getMessage(), e);
        }
    }

createAdaptiveExtension 主要執(zhí)行三個(gè)動(dòng)作：

調(diào)用 getAdaptiveExtensionClass 方法獲取自適應(yīng)拓展 Class 對(duì)象
通過(guò)反射進(jìn)行實(shí)例化
調(diào)用injectExtension 方法向拓展實(shí)例中注入依賴

接下來(lái)遵堵，分析 getAdaptiveExtensionClass 方法的邏輯箱玷。

private Class<?> getAdaptiveExtensionClass() {
    // 通過(guò) SPI 獲取所有的拓展類
    getExtensionClasses();
    // cachedAdaptiveClass緩存中存儲(chǔ)的是有Adaptive注解的類，如AdaptiveExtensionFactory陌宿，若緩存不為空锡足，則直接返回緩存
    if (cachedAdaptiveClass != null) {
        return cachedAdaptiveClass;
    }
    // 創(chuàng)建自適應(yīng)拓展類
    return cachedAdaptiveClass = createAdaptiveExtensionClass();
}

getAdaptiveExtensionClass 方法同樣包含了三個(gè)邏輯，如下：

調(diào)用 getExtensionClasses 獲取所有的拓展類
檢查緩存cachedAdaptiveClass,若緩存不為空壳坪，則直接返回緩存(cachedAdaptiveClass緩存的是被@Adaptive注解的類)
若緩存為空舶得，則調(diào)用 createAdaptiveExtensionClass 創(chuàng)建自適應(yīng)拓展類

首先從第一個(gè)邏輯說(shuō)起，getExtensionClasses 這個(gè)方法用于獲取某個(gè)接口的所有實(shí)現(xiàn)類其實(shí)就是解析META-INF/dubbo/internal/爽蝴，META-INF/dubbo/,META-INF/services/里面放置的文件沐批。比如該方法可以獲取 Protocol 接口的DubboProtocol纫骑、HttpProtocol、InjvmProtocol 等實(shí)現(xiàn)類珠插。在獲取實(shí)現(xiàn)類的過(guò)程中惧磺，如果某個(gè)某個(gè)實(shí)現(xiàn)類被 Adaptive 注解修飾了,如AdaptiveExtensionFactory，那么該類就會(huì)被賦值給 cachedAdaptiveClass 變量捻撑。此時(shí)磨隘，上面步驟中的第二步條件成立（緩存不為空），直接返回 cachedAdaptiveClass顾患。如果所有的實(shí)現(xiàn)類均未被 Adaptive 注解修飾番捂，那么執(zhí)行第三步邏輯，創(chuàng)建自適應(yīng)拓展類：

getExtensionClasses

先分析第一個(gè)邏輯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;
    }

getExtensionClasses 主要執(zhí)行兩個(gè)動(dòng)作:

檢查緩存cachedClasses中是否有值江解。
如果沒(méi)有則loadExtensionClasses()獲取所有的拓展類设预。
最后將classes放入cachedClasses中。

接著看loadExtensionClasses()是如何獲取所有的擴(kuò)展類的犁河。

 private Map<String, Class<?>> loadExtensionClasses() {
        cacheDefaultExtensionName();

        Map<String, Class<?>> extensionClasses = new HashMap<>();

        for (LoadingStrategy strategy : strategies) {
            loadDirectory(extensionClasses, strategy.directory(), type.getName(), strategy.preferExtensionClassLoader(),
                    strategy.overridden(), strategy.excludedPackages());
            loadDirectory(extensionClasses, strategy.directory(), type.getName().replace("org.apache", "com.alibaba"),
                    strategy.preferExtensionClassLoader(), strategy.overridden(), strategy.excludedPackages());
        }

        return extensionClasses;
    }

loadExtensionClasses 主要做兩件事情鳖枕。

從META-INF/dubbo/internal/，從META-INF/dubbo/(DubboSPI路徑)和META-INF/services/(JDK SPI路徑)獲取所有擴(kuò)展桨螺。

繼續(xù)看loadDirectory方法

 private void loadDirectory(Map<String, Class<?>> extensionClasses, String dir, String 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();
                    //加載文件資源宾符，其實(shí)就是SPI接口實(shí)現(xiàn)
                    loadResource(extensionClasses, classLoader, resourceURL);
                }
            }
        } catch (Throwable t) {
            logger.error("Exception when load extension class(interface: " +
                    type + ", description file: " + fileName + ").", t);
        }
    }

loadDirectory 主要包含三個(gè)邏輯:

獲取一個(gè)類加載器。
通過(guò)加載器灭翔，加載文件名為META-INF/dubbo/internal/ 魏烫，META-INF/dubbo/,META-INF/services/下的資源，如org.apache.dubbo.rpc.Protocol肝箱。
遍歷urls獲取META-INF/dubbo/internal/org.apache.dubbo.rpc.Protocol中的SPI實(shí)現(xiàn)哄褒。

解析的邏輯在loadResource代碼如下:

 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(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);
                        }
                    }
                }
            } finally {
                reader.close();
            }
        } catch (Throwable t) {
            logger.error("Exception when load extension class(interface: " +
                    type + ", class file: " + resourceURL + ") in " + resourceURL, t);
        }
    }

loadResource 邏輯比較簡(jiǎn)單就是一行行讀取，然后獲取擴(kuò)展名和擴(kuò)展實(shí)現(xiàn)類煌张，然后調(diào)用loadClass方法

繼續(xù)看loadClass方法

    private void loadClass(Map<String, Class<?>> extensionClasses, java.net.URL resourceURL, Class<?> clazz, String name,
                           boolean overridden) throws NoSuchMethodException {
        //判斷擴(kuò)展clazz呐赡，是不是type的子類
        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是否注釋在類上。如果是且`cachedAdaptiveClass`為空則為`cachedAdaptiveClass`賦值骏融。
        if (clazz.isAnnotationPresent(Adaptive.class)) {
            cacheAdaptiveClass(clazz, overridden);
        } else if (isWrapperClass(clazz)) {
            //判斷clazz構(gòu)造函數(shù)中是否有其父類接口罚舱，在Protocol只有ProtocolFilterWrapper和ProtocolListenerWrapper構(gòu)造函數(shù)中有Protocol屬性
            cacheWrapperClass(clazz);
        } else {
            clazz.getConstructor();
            if (StringUtils.isEmpty(name)) {
                name = findAnnotationName(clazz);
                if (name.length() == 0) {
                    throw new IllegalStateException(
                            "No such extension name for the class " + clazz.getName() + " in the config " + resourceURL);
                }
            }

            String[] names = NAME_SEPARATOR.split(name);
            if (ArrayUtils.isNotEmpty(names)) {
                //判斷clazz是否有Activate注解
                cacheActivateClass(clazz, names[0]);
                for (String n : names) {
                    cacheName(clazz, n);
                    saveInExtensionClass(extensionClasses, clazz, n, overridden);
                }
            }
        }

執(zhí)行loadClass方法主要是為以下幾個(gè)屬性賦值

cachedAdaptiveClass 如果這個(gè)類class含有adaptive注解就賦值，例如 AdaptiveExtensionFactory 绎谦，而例如Protocol在這個(gè)環(huán)節(jié)是沒(méi)有的。
2.cachedWrapperClasses 只有當(dāng)該class無(wú)adaptive注解粥脚，并且構(gòu)造函數(shù)包含目標(biāo)接口(type)類型例如Protocol里面的spi就只有ProtocolFilterWapper和ProtocolListenerWrapper能命中
cachedActivates 被Activate注解的類
剩下的類就存儲(chǔ)在cachedNames 和extensionClasses窃肠，extensionClasses是從外部傳入的，之后它的值會(huì)放入cachedClasses緩存中刷允。

至此加載SPI擴(kuò)展的方法就執(zhí)行完了冤留。

createAdaptiveExtensionClass

回到getAdaptiveExtensionClass方法碧囊，像Protocol所有的實(shí)現(xiàn)類均未被 Adaptive 注解修飾，就會(huì)調(diào)用createAdaptiveExtensionClass生成一個(gè)動(dòng)態(tài)類纤怒。相關(guān)代碼如下

private Class<?> createAdaptiveExtensionClass() {
        //構(gòu)建自適應(yīng)拓展代碼
        String code = createAdaptiveExtensionClassCode();
        ClassLoader classLoader = findClassLoader();
        //獲取編譯器實(shí)現(xiàn)類
        org.apache.dubbo.common.compiler.Compiler compiler = ExtensionLoader.getExtensionLoader(org.apache.dubbo.common.compiler.Compiler.class).getAdaptiveExtension();
        // 編譯代碼糯而，生成 Class
        return compiler.compile(code, classLoader);
    }

createAdaptiveExtensionClass 方法用于生成自適應(yīng)拓展類，該方法首先會(huì)生成自適應(yīng)拓展類的源碼泊窘，然后通過(guò) Compiler 實(shí)例（Dubbo 默認(rèn)使用 javassist 作為編譯器）編譯源碼熄驼，得到代理類 Class 實(shí)例。生成動(dòng)態(tài)類的代碼比較復(fù)雜烘豹，但是所有的動(dòng)態(tài)類都是根據(jù)一個(gè)模板來(lái)生成的瓜贾。

package <擴(kuò)展點(diǎn)接口所在包>

public class <擴(kuò)展點(diǎn)接口名>$Adpative implements <擴(kuò)展點(diǎn)接口>{
   public <有@Adaptive注解的接口方法>(<方法參數(shù)>){
          if(是否有URL類型參數(shù)?)  使用該URL參數(shù)
          else if(是否方法類型上有URL屬性) 使用該URL屬性
          #<else 在加載擴(kuò)展點(diǎn)生成自適應(yīng)擴(kuò)展點(diǎn)類時(shí)拋異常，即加載擴(kuò)展點(diǎn)失敗!>
          
          if(獲取的URL == null){
             throw new IllegalArgumentException("url = null")
          }
          
          根據(jù)@Adaptive注解上聲明的Key的順序,從URL獲取Value,作為實(shí)際擴(kuò)展點(diǎn)名携悯。
          如URL沒(méi)有Value祭芦，則使用缺省擴(kuò)展點(diǎn)實(shí)現(xiàn)。如沒(méi)有擴(kuò)展點(diǎn)憔鬼，throw new IllegalArgumentException("Fail to get extension");
          
          擴(kuò)展點(diǎn)實(shí)現(xiàn)調(diào)用方法龟劲，并返回結(jié)果
   }
   
   public <沒(méi)有@Adaptive注解的接口方法>(<方法參數(shù)>){
      throw new UnsupportedOperationException("is not adaptive method!")
   }

}

下面是動(dòng)態(tài)生成Protocol$Adpative的代碼

package org.apache.dubbo.rpc;

import org.apache.dubbo.common.extension.ExtensionLoader;

public class Protocol$Adaptive implements org.apache.dubbo.rpc.Protocol {
    private static final org.apache.dubbo.common.logger.Logger logger = org.apache.dubbo.common.logger.LoggerFactory
            .getLogger(ExtensionLoader.class);
    private java.util.concurrent.atomic.AtomicInteger count = new java.util.concurrent.atomic.AtomicInteger(0);

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

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

    public org.apache.dubbo.rpc.Invoker refer(java.lang.Class arg0, org.apache.dubbo.common.URL arg1)
            throws org.apache.dubbo.rpc.RpcException {
        if (arg1 == null)
            throw new IllegalArgumentException("url == null");
        org.apache.dubbo.common.URL url = arg1;
        String extName = (url.getProtocol() == null ? "dubbo" : url.getProtocol());
        if (extName == null)
            throw new IllegalStateException("Fail to get extension(org.apache.dubbo.rpc.Protocol) name from url("
                    + url.toString() + ") use keys([protocol])");
        org.apache.dubbo.rpc.Protocol extension = null;
        try {
            extension = (org.apache.dubbo.rpc.Protocol) ExtensionLoader
                    .getExtensionLoader(org.apache.dubbo.rpc.Protocol.class).getExtension(extName);
        } catch (Exception e) {
            if (count.incrementAndGet() == 1) {
                logger.warn(
                        "Failed to find extension named " + extName
                                + " for type org.apache.dubbo.rpc.Protocol, will use default extension dubbo instead.",
                        e);
            }
            extension = (org.apache.dubbo.rpc.Protocol) ExtensionLoader
                    .getExtensionLoader(org.apache.dubbo.rpc.Protocol.class).getExtension("dubbo");
        }
        return extension.refer(arg0, arg1);
    }

    public org.apache.dubbo.rpc.Exporter export(org.apache.dubbo.rpc.Invoker arg0)
            throws org.apache.dubbo.rpc.RpcException {
        if (arg0 == null)
            throw new IllegalArgumentException("org.apache.dubbo.rpc.Invoker argument == null");
        if (arg0.getUrl() == null)
            throw new IllegalArgumentException("org.apache.dubbo.rpc.Invoker argument getUrl() == null");
        org.apache.dubbo.common.URL url = arg0.getUrl();
        String extName = (url.getProtocol() == null ? "dubbo" : url.getProtocol());
        if (extName == null)
            throw new IllegalStateException("Fail to get extension(org.apache.dubbo.rpc.Protocol) name from url("
                    + url.toString() + ") use keys([protocol])");
        org.apache.dubbo.rpc.Protocol extension = null;
        try {
            extension = (org.apache.dubbo.rpc.Protocol) ExtensionLoader
                    .getExtensionLoader(org.apache.dubbo.rpc.Protocol.class).getExtension(extName);
        } catch (Exception e) {
            if (count.incrementAndGet() == 1) {
                logger.warn(
                        "Failed to find extension named " + extName
                                + " for type org.apache.dubbo.rpc.Protocol, will use default extension dubbo instead.",
                        e);
            }
            extension = (org.apache.dubbo.rpc.Protocol) ExtensionLoader
                    .getExtensionLoader(org.apache.dubbo.rpc.Protocol.class)
                    .getExtension("dubbo");
        }
        return extension.export(arg0);
    }
}

生成動(dòng)態(tài)類之后,在createAdaptiveExtension方法會(huì)通過(guò)反射生成實(shí)例，并調(diào)用injectExtension方法進(jìn)入IOC反轉(zhuǎn)控制模式轴或，實(shí)現(xiàn)依賴注入昌跌。

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

到此，關(guān)于getAdaptiveExtension自適應(yīng)拓展的原理侮叮，實(shí)現(xiàn)就分析完了避矢。有關(guān)動(dòng)態(tài)編譯和依賴注入的原理下一章再分析。

getExtension(String name)

上一節(jié)我們分析了Dubbo自適應(yīng)擴(kuò)展機(jī)制囊榜，下面我們從 ExtensionLoader 的 getExtension 方法作為入口审胸，對(duì)拓展類對(duì)象的獲取過(guò)程進(jìn)行詳細(xì)的分析。

  public T getExtension(String name) {
        
        if (StringUtils.isEmpty(name)) {
            throw new IllegalArgumentException("Extension name == null");
        }
        // 獲取默認(rèn)的拓展實(shí)現(xiàn)類
        if ("true".equals(name)) {
            return getDefaultExtension();
        }
         // Holder卸勺，用于持有目標(biāo)對(duì)象
        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;
    }

上面了邏輯比較簡(jiǎn)單首先判斷是否使用默認(rèn)擴(kuò)展砂沛，如果不是查找緩存，若未命中則調(diào)用createExtension創(chuàng)建拓展對(duì)象曙求。

 private T createExtension(String name) {
        //1. 在上一節(jié)中我們也講述過(guò)這個(gè)方法碍庵，它的作用就是從配置文件中加載所有的拓展類
        Class<?> clazz = getExtensionClasses().get(name);
        if (clazz == null) {
            throw findException(name);
        }
        try {
        // 2. 查找緩存EXTENSION_INSTANCES中，是否有擴(kuò)展實(shí)例悟狱，沒(méi)有則通過(guò)反射創(chuàng)建拓展對(duì)象静浴。
            T instance = (T) EXTENSION_INSTANCES.get(clazz);
            if (instance == null) {
            // 通過(guò)反射創(chuàng)建實(shí)例
                EXTENSION_INSTANCES.putIfAbsent(clazz, clazz.newInstance());
                instance = (T) EXTENSION_INSTANCES.get(clazz);
            }
            // 向?qū)嵗凶⑷胍蕾?            injectExtension(instance);
            Set<Class<?>> wrapperClasses = cachedWrapperClasses;
            if (CollectionUtils.isNotEmpty(wrapperClasses)) {
               // 循環(huán)創(chuàng)建 Wrapper 實(shí)例
                for (Class<?> wrapperClass : wrapperClasses) {
                   // 將當(dāng)前 instance 作為參數(shù)傳給 Wrapper 的構(gòu)造方法，并通過(guò)反射創(chuàng)建 Wrapper 實(shí)例挤渐。
                // 然后向 Wrapper 實(shí)例中注入依賴苹享，最后將 Wrapper 實(shí)例再次賦值給 instance 變量
                    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);
        }
    }

createExtension 方法的邏輯稍復(fù)雜一下，主要執(zhí)行以下四個(gè)步驟：

通過(guò) getExtensionClasses 獲取所有的拓展類(在上一節(jié)中我們已經(jīng)講解過(guò)這個(gè)方法)浴麻。
查找緩存EXTENSION_INSTANCES中得问，是否有擴(kuò)展實(shí)例囤攀，沒(méi)有則通過(guò)反射創(chuàng)建拓展對(duì)象。
將拓展對(duì)象包裹在相應(yīng)的 Wrapper 對(duì)象中宫纬，以Protocol為例焚挠，它最終被getExtensionClasses解析出的wrapper類ProtocolFilterWrapper和 ProtocolListenerWrapper包裹，
調(diào)用injectExtension向拓展對(duì)象中注入依賴漓骚。

第一個(gè)步驟是加載拓展類的關(guān)鍵蝌衔，第三和第四個(gè)步驟是 Dubbo IOC 與 AOP 的具體實(shí)現(xiàn)。

有關(guān)getExtensionClasses分析认境，請(qǐng)看上一節(jié)胚委，下面著重分析第三和第四步驟，先分析

Dubbo IOC

  private T injectExtension(T instance) {
        try {
            if (objectFactory != null) {
            // 遍歷目標(biāo)類的所有方法
                for (Method method : instance.getClass().getMethods()) {
                 // 檢測(cè)方法是否以 set 開(kāi)頭叉信，且方法僅有一個(gè)參數(shù)亩冬，且方法訪問(wèn)級(jí)別為 public
                    if (method.getName().startsWith("set")
                            && method.getParameterTypes().length == 1
                            && Modifier.isPublic(method.getModifiers())) {
                            //判斷是否需要自動(dòng)注入
                        if (method.getAnnotation(DisableInject.class) != null) {
                            continue;
                        }
                         // 獲取 setter 方法參數(shù)類型
                        Class<?> pt = method.getParameterTypes()[0];
                        if (ReflectUtils.isPrimitives(pt)) {
                            continue;
                        }
                        try {
                          // 獲取屬性名，比如 setName 方法對(duì)應(yīng)屬性名 name
                            String property = method.getName().length() > 3 ? method.getName().substring(3, 4).toLowerCase() + method.getName().substring(4) : "";
                            // 從 ObjectFactory 中獲取依賴對(duì)象
                            Object object = objectFactory.getExtension(pt, property);
                            if (object != null) {
                             // 通過(guò)反射調(diào)用 setter 方法設(shè)置依賴
                                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 變量的類型為 AdaptiveExtensionFactory硅急，AdaptiveExtensionFactory 內(nèi)部維護(hù)了一個(gè) ExtensionFactory 列表，用于存儲(chǔ)其他類型的 ExtensionFactory佳遂。Dubbo 目前提供了兩種 ExtensionFactory营袜，分別是 SpiExtensionFactory和 SpringExtensionFactory。前者用于創(chuàng)建自適應(yīng)的拓展丑罪，后者是用于從 Spring 的 IOC 容器中獲取所需的拓展荚板。Dubbo的IOC反轉(zhuǎn)控制，就是從spi和spring里面提取對(duì)象賦值吩屹。

Dubbo AOP

下面只截取了createExtension部分代碼

  if (CollectionUtils.isNotEmpty(wrapperClasses)) {
                for (Class<?> wrapperClass : wrapperClasses) {
                    instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance));
                }
            }

在Protocol中wrapperClass類是ProtocolFilterWrapper或ProtocolListenerWrapper這兩個(gè)類中的構(gòu)造函數(shù)都有Protocol參數(shù)跪另，

public class ProtocolFilterWrapper implements Protocol {

    private final Protocol protocol;

    public ProtocolFilterWrapper(Protocol protocol) {
        if (protocol == null) {
            throw new IllegalArgumentException("protocol == null");
        }
        this.protocol = protocol;
    }
}

Dubbo AOP 獲取wrapperClass然通過(guò)反射生成對(duì)象，進(jìn)行AOP煤搜，然后調(diào)用injectExtension進(jìn)行IOC.最后將值重新賦給instance免绿，所以getExtension方法最后返回的是一個(gè)wrapper類。

好了Dubbo SPI實(shí)現(xiàn)源碼解析講完了擦盾，本篇文章就先到這里了嘲驾。

最后編輯于：2022.03.18 21:37:27

?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請(qǐng)聯(lián)系作者

人面猴
序言：七十年代末，一起剝皮案震驚了整個(gè)濱河市迹卢，隨后出現(xiàn)的幾起案子辽故，更是在濱河造成了極大的恐慌，老刑警劉巖腐碱，帶你破解...
沈念sama閱讀 221,548評(píng)論 6贊 515
死咒
序言：濱河連續(xù)發(fā)生了三起死亡事件榕暇，死亡現(xiàn)場(chǎng)離奇詭異，居然都是意外死亡，警方通過(guò)查閱死者的電腦和手機(jī)彤枢，發(fā)現(xiàn)死者居然都...
沈念sama閱讀 94,497評(píng)論 3贊 399
救了他兩次的神仙讓他今天三更去死
文/潘曉璐我一進(jìn)店門，熙熙樓的掌柜王于貴愁眉苦臉地迎上來(lái)筒饰，“玉大人缴啡，你說(shuō)我怎么就攤上這事〈擅牵” “怎么了业栅？”我有些...
開(kāi)封第一講書(shū)人閱讀 167,990評(píng)論 0贊 360
道士緝兇錄：失蹤的賣姜人
文/不壞的土叔我叫張陵，是天一觀的道長(zhǎng)谬晕。經(jīng)常有香客問(wèn)我碘裕，道長(zhǎng)，這世上最難降的妖魔是什么攒钳？我笑而不...
開(kāi)封第一講書(shū)人閱讀 59,618評(píng)論 1贊 296
?港島之戀（遺憾婚禮）
正文為了忘掉前任帮孔，我火速辦了婚禮，結(jié)果婚禮上不撑，老公的妹妹穿的比我還像新娘文兢。我一直安慰自己，他們只是感情好焕檬，可當(dāng)我...
茶點(diǎn)故事閱讀 68,618評(píng)論 6贊 397
惡毒庶女頂嫁案：這布局不是一般人想出來(lái)的
文/花漫我一把揭開(kāi)白布姆坚。她就那樣靜靜地躺著，像睡著了一般实愚。火紅的嫁衣襯著肌膚如雪兼呵。梳的紋絲不亂的頭發(fā)上，一...
開(kāi)封第一講書(shū)人閱讀 52,246評(píng)論 1贊 308
城市分裂傳說(shuō)
那天腊敲，我揣著相機(jī)與錄音击喂，去河邊找鬼。笑死兔仰，一個(gè)胖子當(dāng)著我的面吹牛茫负，可吹牛的內(nèi)容都是我干的。我是一名探鬼主播乎赴，決...
沈念sama閱讀 40,819評(píng)論 3贊 421
雙鴛鴦連環(huán)套：你想象不到人心有多黑
文/蒼蘭香墨我猛地睜開(kāi)眼忍法，長(zhǎng)吁一口氣：“原來(lái)是場(chǎng)噩夢(mèng)啊……” “哼！你這毒婦竟也來(lái)了榕吼？” 一聲冷哼從身側(cè)響起饿序，我...
開(kāi)封第一講書(shū)人閱讀 39,725評(píng)論 0贊 276
萬(wàn)榮殺人案實(shí)錄
序言：老撾萬(wàn)榮一對(duì)情侶失蹤，失蹤者是張志新（化名）和其女友劉穎羹蚣，沒(méi)想到半個(gè)月后原探，有當(dāng)?shù)厝嗽跇?shù)林里發(fā)現(xiàn)了一具尸體，經(jīng)...
沈念sama閱讀 46,268評(píng)論 1贊 320
?護(hù)林員之死
正文獨(dú)居荒郊野嶺守林人離奇死亡，尸身上長(zhǎng)有42處帶血的膿包…… 初始之章·張勛以下內(nèi)容為張勛視角年9月15日...
茶點(diǎn)故事閱讀 38,356評(píng)論 3贊 340
?白月光啟示錄
正文我和宋清朗相戀三年咽弦，在試婚紗的時(shí)候發(fā)現(xiàn)自己被綠了徒蟆。大學(xué)時(shí)的朋友給我發(fā)了我未婚夫和他白月光在一起吃飯的照片。...
茶點(diǎn)故事閱讀 40,488評(píng)論 1贊 352
活死人
序言：一個(gè)原本活蹦亂跳的男人離奇死亡型型，死狀恐怖段审，靈堂內(nèi)的尸體忽然破棺而出，到底是詐尸還是另有隱情闹蒜，我是刑警寧澤寺枉，帶...
沈念sama閱讀 36,181評(píng)論 5贊 350
?日本核電站爆炸內(nèi)幕
正文年R本政府宣布，位于F島的核電站绷落，受9級(jí)特大地震影響姥闪，放射性物質(zhì)發(fā)生泄漏。R本人自食惡果不足惜砌烁，卻給世界環(huán)境...
茶點(diǎn)故事閱讀 41,862評(píng)論 3贊 333
男人毒藥：我在死后第九天來(lái)索命
文/蒙蒙一筐喳、第九天我趴在偏房一處隱蔽的房頂上張望。院中可真熱鬧往弓，春花似錦疏唾、人聲如沸。這莊子的主人今日做“春日...
開(kāi)封第一講書(shū)人閱讀 32,331評(píng)論 0贊 24
一樁弒父案槐脏，背后竟有這般陰謀
文/蒼蘭香墨我抬頭看了看天上的太陽(yáng)。三九已至撇寞，卻和暖如春顿天，著一層夾襖步出監(jiān)牢的瞬間，已是汗流浹背蔑担。一陣腳步聲響...
開(kāi)封第一講書(shū)人閱讀 33,445評(píng)論 1贊 272
情欲美人皮
我被黑心中介騙來(lái)泰國(guó)打工牌废，沒(méi)想到剛下飛機(jī)就差點(diǎn)兒被人妖公主榨干…… 1. 我叫王不留，地道東北人啤握。一個(gè)月前我還...
沈念sama閱讀 48,897評(píng)論 3贊 376
代替公主和親
正文我出身青樓鸟缕，卻偏偏與公主長(zhǎng)得像，于是被迫代替她去往敵國(guó)和親排抬。傳聞我的和親對(duì)象是個(gè)殘疾皇子懂从，可洞房花燭夜當(dāng)晚...
茶點(diǎn)故事閱讀 45,500評(píng)論 2贊 359