摘要：對于這個矛盾的問題，通過自適應拓展機制很好的解決了。自適應拓展機制的實現邏輯比較復雜，首先會為拓展接口生成具有代理功能的代碼。

在 Dubbo 中，很多拓展都是通過 SPI 機制進行加載的，比如 Protocol、Cluster、LoadBalance 等。有時，有些拓展并不想在框架啟動階段被加載，而是希望在拓展方法被調用時，根據運行時參數進行加載。這聽起來有些矛盾。拓展未被加載，那么拓展方法就無法被調用（靜態方法除外）。拓展方法未被調用，拓展就無法被加載。對于這個矛盾的問題，Dubbo 通過自適應拓展機制很好的解決了。自適應拓展機制的實現邏輯比較復雜，首先 Dubbo 會為拓展接口生成具有代理功能的代碼。然后通過 javassist 或 jdk 編譯這段代碼，得到 Class 類。最后再通過反射創建代理類，整個過程比較復雜。

為了很好的理解，下面結合實例進行分析，在Dubbbo暴露服務中，ServiceConfig類中doExportUrlsFor1Protocol方法中有如下這樣一條語句：

Exporter exporter = protocol.export(wrapperInvoker);

接下來咱們就根據這條語句進行深入分析Dubbo SPI自適應擴展機制。

根據源碼查詢得知，protocol對象是通過以下語句創建：

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

根據上篇文章，咱們得知getExtensionLoader只是獲取ExtensionLoader對象，所以自適應擴展的核心在getAdaptiveExtension()方法中：

    public T getAdaptiveExtension() {
        // 緩存獲取實例對象
        Object instance = cachedAdaptiveInstance.get();
        // 雙重檢測
        if (instance == null) {
            if (createAdaptiveInstanceError == null) {
                synchronized (cachedAdaptiveInstance) {
                    instance = cachedAdaptiveInstance.get();
                    if (instance == null) {
                        try {
                            // 創建實例對象
                            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;
    }

在getAdaptiveExtension方法中先從緩存中獲取，緩存中不存在在創建實例，并存入緩存中，邏輯比較簡單，咱們在來分析createAdaptiveExtension方法：

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

createAdaptiveExtension 方法的代碼比較少，但卻包含了三個邏輯，分別如下：

調用 getAdaptiveExtensionClass 方法獲取自適應拓展 Class 對象

通過反射進行實例化

調用 injectExtension 方法向拓展實例中注入依賴

前兩個邏輯比較好理解，第三個邏輯用于向自適應拓展對象中注入依賴。這個邏輯看似多余，但有存在的必要，這里簡單說明一下。前面說過，Dubbo 中有兩種類型的自適應拓展，一種是手工編碼的，一種是自動生成的。手工編碼的自適應拓展中可能存在著一些依賴，而自動生成的 Adaptive 拓展則不會依賴其他類。這里調用 injectExtension 方法的目的是為手工編碼的自適應拓展注入依賴，這一點需要大家注意一下。關于 injectExtension 方法，前文已經分析過了，這里不再贅述。接下來，分析 getAdaptiveExtensionClass 方法的邏輯。

private Class getAdaptiveExtensionClass() {
    // 通過 SPI 獲取所有的拓展類
    getExtensionClasses();
    // 檢查緩存，若緩存不為空，則直接返回緩存
    if (cachedAdaptiveClass != null) {
        return cachedAdaptiveClass;
    }
    // 創建自適應拓展類
    return cachedAdaptiveClass = createAdaptiveExtensionClass();
}

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

調用 getExtensionClasses 獲取所有的拓展類

檢查緩存，若緩存不為空，則返回緩存

若緩存為空，則調用 createAdaptiveExtensionClass 創建自適應拓展類

這三個邏輯看起來平淡無奇，似乎沒有多講的必要。但是這些平淡無奇的代碼中隱藏了著一些細節，需要說明一下。首先從第一個邏輯說起，getExtensionClasses 這個方法用于獲取某個接口的所有實現類。比如該方法可以獲取 Protocol 接口的 DubboProtocol、HttpProtocol、InjvmProtocol 等實現類。在獲取實現類的過程中，如果某個某個實現類被 Adaptive 注解修飾了，那么該類就會被賦值給 cachedAdaptiveClass 變量。此時，上面步驟中的第二步條件成立（緩存不為空），直接返回 cachedAdaptiveClass 即可。如果所有的實現類均未被 Adaptive 注解修飾，那么執行第三步邏輯，創建自適應拓展類。相關代碼如下：

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();
    // 編譯代碼，生成 Class
    return compiler.compile(code, classLoader);
}

createAdaptiveExtensionClass 方法用于生成自適應拓展類，該方法首先會生成自適應拓展類的源碼，然后通過 Compiler 實例（Dubbo 默認使用 javassist 作為編譯器）編譯源碼，得到代理類 Class 實例。接下來，我們把重點放在代理類代碼生成的邏輯上，其他邏輯大家自行分析。

    private String createAdaptiveExtensionClassCode() {
        StringBuilder codeBuilder = new StringBuilder();
        Method[] methods = type.getMethods();
        boolean hasAdaptiveAnnotation = false;
        // 循環遍歷方法
        for (Method m : methods) {
            // 判斷類中的方法是否有Adaptive注解
            if (m.isAnnotationPresent(Adaptive.class)) {
                hasAdaptiveAnnotation = true;
                break;
            }
        }
        
        // 如果類中方法沒有Adaptive注解，則直接拋出異常
        if (!hasAdaptiveAnnotation) {
            throw new IllegalStateException("No adaptive method on extension " + type.getName() + ", refuse to create the adaptive class!");
        }

        // 引入類的包名、類的依賴
        codeBuilder.append("package ").append(type.getPackage().getName()).append(";");
        codeBuilder.append("
import ").append(ExtensionLoader.class.getName()).append(";");
        codeBuilder.append("
public class ").append(type.getSimpleName()).append("$Adaptive").append(" implements ").append(type.getCanonicalName()).append(" {");

        for (Method method : methods) {
            // 獲取方法返回類型
            Class rt = method.getReturnType();
            // 獲取方法參數類型
            Class[] pts = method.getParameterTypes();
            // 獲取方法拋出的異常類型
            Class[] ets = method.getExceptionTypes();

            Adaptive adaptiveAnnotation = method.getAnnotation(Adaptive.class);
            StringBuilder code = new StringBuilder(512);
            // 方法沒有Adaptive注解，方法體就是一條拋出異常的語句
            if (adaptiveAnnotation == null) {
                code.append("throw new UnsupportedOperationException("method ")
                        .append(method.toString()).append(" of interface ")
                        .append(type.getName()).append(" is not adaptive method!");");
            } else {
                // 標記方法中參數類型為URL的是第幾個參數
                int urlTypeIndex = -1;
                for (int i = 0; i < pts.length; ++i) {
                    if (pts[i].equals(URL.class)) {
                        urlTypeIndex = i;
                        break;
                    }
                }
                
                // 如果方法參數中有URL類型的，則需要校驗參數是否為空
                if (urlTypeIndex != -1) {
                
                    String s = String.format("
if (arg%d == null) throw new IllegalArgumentException("url == null");",
                            urlTypeIndex);
                    code.append(s);

                    // 并創建一個URL變量，將參數賦值給變量：URL url = url
                    s = String.format("
%s url = arg%d;", URL.class.getName(), urlTypeIndex);
                    code.append(s);
                }
                else {
                    // 參數中沒有URL類型的參數
                    String attribMethod = null;
                    
                    // 查找參數所屬類中是否有返回URL的方法，如：Invoker.getUrl()方法，則attribMethod = getUrl()
                    LBL_PTS:
                    for (int i = 0; i < pts.length; ++i) {
                        Method[] ms = pts[i].getMethods();
                        for (Method m : ms) {
                            String name = m.getName();
                            if ((name.startsWith("get") || name.length() > 3)
                                    && Modifier.isPublic(m.getModifiers())
                                    && !Modifier.isStatic(m.getModifiers())
                                    && m.getParameterTypes().length == 0
                                    && m.getReturnType() == URL.class) {
                                urlTypeIndex = i;
                                attribMethod = name;
                                break LBL_PTS;
                            }
                        }
                    }
                    // 如果參數中沒有返回URL的方法，則拋出異常
                    if (attribMethod == null) {
                        throw new IllegalStateException("fail to create adaptive class for interface " + type.getName()
                                + ": not found url parameter or url attribute in parameters of method " + method.getName());
                    }
                    
                    // 校驗有返回URL類型方法的參數是否為空
                    String s = String.format("
if (arg%d == null) throw new IllegalArgumentException("%s argument == null");",
                            urlTypeIndex, pts[urlTypeIndex].getName());
                    code.append(s);
                    // 校驗參數調用返回URL方法返回值是否為空，如：if Invoker.getUrl() == null
                    s = String.format("
if (arg%d.%s() == null) throw new IllegalArgumentException("%s argument %s() == null");",
                            urlTypeIndex, attribMethod, pts[urlTypeIndex].getName(), attribMethod);
                    code.append(s);

                    // 創建URL變量，賦值為返回值，如 URL url = Invoker.getUrl()
                    s = String.format("%s url = arg%d.%s();", URL.class.getName(), urlTypeIndex, attribMethod);
                    code.append(s);
                }

                String[] value = adaptiveAnnotation.value();
                if (value.length == 0) {
                    String splitName = StringUtils.camelToSplitName(type.getSimpleName(), ".");
                    value = new String[]{splitName};
                }

                // 判斷方法參數中是否有Invocation類型的參數
                boolean hasInvocation = false;
                for (int i = 0; i < pts.length; ++i) {
                    if (("org.apache.dubbo.rpc.Invocation").equals(pts[i].getName())) {
                        // Null Point check
                        String s = String.format("
if (arg%d == null) throw new IllegalArgumentException("invocation == null");", i);
                        code.append(s);
                        s = String.format("
String methodName = arg%d.getMethodName();", i);
                        code.append(s);
                        hasInvocation = true;
                        break;
                    }
                }

                String defaultExtName = cachedDefaultName;
                String getNameCode = null;
                // 如果Adaptive注解時Protocol，則根據參數url所屬協議來適配加載，如dubbo:// 則調用返回DubboProtocol擴展類實例
                for (int i = value.length - 1; i >= 0; --i) {
                    if (i == value.length - 1) {
                        if (null != defaultExtName) {
                            if (!"protocol".equals(value[i])) {
                                if (hasInvocation) {
                                    getNameCode = String.format("url.getMethodParameter(methodName, "%s", "%s")", value[i], defaultExtName);
                                } else {
                                    getNameCode = String.format("url.getParameter("%s", "%s")", value[i], defaultExtName);
                                }
                            } else {
                                getNameCode = String.format("( url.getProtocol() == null ? "%s" : url.getProtocol() )", defaultExtName);
                            }
                        } else {
                            if (!"protocol".equals(value[i])) {
                                if (hasInvocation) {
                                    getNameCode = String.format("url.getMethodParameter(methodName, "%s", "%s")", value[i], defaultExtName);
                                } else {
                                    getNameCode = String.format("url.getParameter("%s")", value[i]);
                                }
                            } else {
                                getNameCode = "url.getProtocol()";
                            }
                        }
                    } else {
                        if (!"protocol".equals(value[i])) {
                            if (hasInvocation) {
                                getNameCode = String.format("url.getMethodParameter(methodName, "%s", "%s")", value[i], defaultExtName);
                            } else {
                                getNameCode = String.format("url.getParameter("%s", %s)", value[i], getNameCode);
                            }
                        } else {
                            getNameCode = String.format("url.getProtocol() == null ? (%s) : url.getProtocol()", getNameCode);
                        }
                    }
                }
                code.append("
String extName = ").append(getNameCode).append(";");
                
                String s = String.format("
if(extName == null) " +
                                "throw new IllegalStateException("Fail to get extension(%s) name from url(" + url.toString() + ") use keys(%s)");",
                        type.getName(), Arrays.toString(value));
                code.append(s);

                // 根據上面獲取的type調用ExtensionLoader中的getExtension(type)方法
                s = String.format("
%s extension = (% 0) {
                    codeBuilder.append(", ");
                }
                codeBuilder.append(pts[i].getCanonicalName());
                codeBuilder.append(" ");
                codeBuilder.append("arg").append(i);
            }
            codeBuilder.append(")");
            if (ets.length > 0) {
                codeBuilder.append(" throws ");
                for (int i = 0; i < ets.length; i++) {
                    if (i > 0) {
                        codeBuilder.append(", ");
                    }
                    codeBuilder.append(ets[i].getCanonicalName());
                }
            }
            codeBuilder.append(" {");
            codeBuilder.append(code.toString());
            codeBuilder.append("
}");
        }
        codeBuilder.append("
}");
        if (logger.isDebugEnabled()) {
            logger.debug(codeBuilder.toString());
        }
        return codeBuilder.toString();
    }

createAdaptiveExtensionClassCode方法比較復雜，要靜下心來慢慢研究，最好結合實例進行分析，例子protocol.export()自適應擴展類如下所示：
類名是Protocol$Adaptive：

/*
 * Decompiled with CFR 0_132.
 */
package com.alibaba.dubbo.rpc;

import com.alibaba.dubbo.common.URL;
import com.alibaba.dubbo.common.extension.ExtensionLoader;
import com.alibaba.dubbo.rpc.Exporter;
import com.alibaba.dubbo.rpc.Invoker;
import com.alibaba.dubbo.rpc.Protocol;
import com.alibaba.dubbo.rpc.RpcException;

public class Protocol$Adpative
implements Protocol {
    @Override
    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!");
    }

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

    public Invoker refer(Class class_, URL uRL) throws RpcException {
        String string;
        if (uRL == null) {
            throw new IllegalArgumentException("url == null");
        }
        URL uRL2 = uRL;
        String string2 = string = uRL2.getProtocol() == null ? "dubbo" : uRL2.getProtocol();
        if (string == null) {
            throw new IllegalStateException(new StringBuffer().append("Fail to get extension(com.alibaba.dubbo.rpc.Protocol) name from url(").append(uRL2.toString()).append(") use keys([protocol])").toString());
        }
        Protocol protocol = ExtensionLoader.getExtensionLoader(Protocol.class).getExtension(string);
        return protocol.refer(class_, uRL);
    }

    public Exporter export(Invoker invoker) throws RpcException {
        String string;
        if (invoker == null) {
            throw new IllegalArgumentException("com.alibaba.dubbo.rpc.Invoker argument == null");
        }
        if (invoker.getUrl() == null) {
            throw new IllegalArgumentException("com.alibaba.dubbo.rpc.Invoker argument getUrl() == null");
        }
        URL uRL = invoker.getUrl();
        String string2 = string = uRL.getProtocol() == null ? "dubbo" : uRL.getProtocol();
        if (string == null) {
            throw new IllegalStateException(new StringBuffer().append("Fail to get extension(com.alibaba.dubbo.rpc.Protocol) name from url(").append(uRL.toString()).append(") use keys([protocol])").toString());
        }
        Protocol protocol = ExtensionLoader.getExtensionLoader(Protocol.class).getExtension(string);
        return protocol.export(invoker);
    }
}

在調用方法時，根據方法參數進行動態自適應擴展，加載擴展類。