我們執行的Java程式碼，都是編譯之後的位元組碼，dubbo為了實現了基於spi思想的擴充套件特性，特別是能夠靈活新增額外功能。dubbo作為一個高擴充套件性的框架，使的使用者能夠新增自己的需求，根據配置動態生成自己的設配類程式碼，這樣就需要在執行的時候去編譯載入這個設配類的程式碼。下面我們就是來了解下Dubbo的動態編譯。

編譯介面定義

@SPI("javassist")
public interface Compiler {

    /**
     * Compile java source code.
     *
     * @param code        Java source code
     * @param
 
 classLoader classloader
     * @return Compiled class
     */
    Class<?> compile(String code, ClassLoader classLoader);

}

dubbo預設選用javassist編譯原始碼，介面方法compile第一入參是code，代表Java原始碼，第二個入參classLoader，代表載入編譯後的位元組碼的類載入器，根據當前執行緒或呼叫方classLoader載入的

@Adaptive註解在標註@SPI介面的實現類上，擴充套件類就是這個類。

例如這裡的Compiler的SPI擴充套件就是AdaptiveCompiler這個類。AdaptiveCompiler是Compiler的設配類， 它有類註解@Adaptive表示這個Compiler的設配類不是動態編譯生成的。AdaptiveCompiler作用就是策略的選擇，根據條件選擇何種編譯策略來編譯動態生成的原始碼。預設為javassist.

//@Adaptive表示這個Compiler的設配類不是動態編譯生成的
@Adaptive
public class AdaptiveCompiler implements Compiler {

    private static volatile String DEFAULT_COMPILER;

    public static void setDefaultCompiler(String compiler) {
        DEFAULT_COMPILER = compiler;
    }

    @Override
    public Class<?> compile
 
(String code, ClassLoader classLoader) {
        Compiler compiler;
        ExtensionLoader<Compiler> loader = ExtensionLoader.getExtensionLoader(Compiler.class);
        String name = DEFAULT_COMPILER; // copy reference
        if (name != null && name.length() > 0) {
            compiler = loader.getExtension(name);
        } else {
            compiler = loader.getDefaultExtension();
        }
        return compiler.compile(code, classLoader);
    }

}

AbstractCompiler是一個抽象類，它通過正則表示式獲取到物件的包名以及Class名稱。這樣就可以獲取物件的全類名(包名+Class名稱)。通過反射Class.forName()來判斷當前ClassLoader是否有這個類，如果有就返回，如果沒有就通過JdkCompiler或者JavassistCompiler通過傳入的code編譯這個類。

public abstract class AbstractCompiler implements Compiler {
    //通過正則表示式獲取到物件的包名以及Class名稱。
    private static final Pattern PACKAGE_PATTERN = Pattern.compile("package\\s+([$_a-zA-Z][$_a-zA-Z0-9\\.]*);");

    private static final Pattern CLASS_PATTERN = Pattern.compile("class\\s+([$_a-zA-Z][$_a-zA-Z0-9]*)\\s+");

    @Override
    public Class<?> compile(String code, ClassLoader classLoader) {
        code = code.trim();
        Matcher matcher = PACKAGE_PATTERN.matcher(code);
        String pkg;
        if (matcher.find()) {
            pkg = matcher.group(1);
        } else {
            pkg = "";
        }
        matcher = CLASS_PATTERN.matcher(code);
        String cls;
        if (matcher.find()) {
            cls = matcher.group(1);
        } else {
            throw new IllegalArgumentException("No such class name in " + code);
        }
       // 獲取物件的全類名(包名+Class名稱)
        String className = pkg != null && pkg.length() > 0 ? pkg + "." + cls : cls;
        try {
           //通過反射Class.forName()來判斷當前ClassLoader是否有這個類,如果有就返回
            return Class.forName(className, true, ClassHelper.getCallerClassLoader(getClass()));
        } catch (ClassNotFoundException e) {
            if (!code.endsWith("}")) {
                throw new IllegalStateException("The java code not endsWith \"}\", code: \n" + code + "\n");
            }
            try {
            //如果沒有就通過JdkCompiler或者JavassistCompiler通過傳入的code編譯這個類。
                return doCompile(className, code);
            } catch (RuntimeException t) {
                throw t;
            } catch (Throwable t) {
                throw new IllegalStateException("Failed to compile class, cause: " + t.getMessage() + ", class: " + className + ", code: \n" + code + "\n, stack: " + ClassUtils.toString(t));
            }
        }
    }

    protected abstract Class<?> doCompile(String name, String source) throws Throwable;

}