dubbo源码阅读之自适应扩展

自适应扩展机制

刚开始看代码，其实并不能很好地理解dubbo的自适应扩展机制的作用，我们不妨先把代码的主要逻辑过一遍，梳理一下，在了解了代码细节之后，回过头再来思考自适应扩展的作用，dubbo为什么要设计这样一种扩展机制？？它的优点在什么地方？？

Adaptive注解

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD})
public @interface Adaptive {
/**
 * Decide which target extension to be injected. The name of the target extension is decided by the parameter passed
 * in the URL, and the parameter names are given by this method.
 * 该值决定了哪个扩展类会被自动注入。目标扩展名由传入的URL中的参数和Adaptive注解中的value值共同决定。
 * value相当于一些key值，用这些key值从URL中获取相应的value值，最终决定扩展名。
 * <p>
 * If the specified parameters are not found from {@link URL}, then the default extension will be used for
 * dependency injection (specified in its interface's {@link SPI}).
 * 如果传入的URL中没有符合条件的扩展名，那么使用默认扩展名（默认扩展名由SPI注解的value决定）
 * <p>
 * For examples, given <code>String[] {"key1", "key2"}</code>:
 * 例如，value的值是：String[] {"key1", "key2"}
 * <ol>
 * <li>find parameter 'key1' in URL, use its value as the extension's name</li>
 * 首先在URL中查找key1，如果存在使用key1作为扩展名
 * <li>try 'key2' for extension's name if 'key1' is not found (or its value is empty) in URL</li>
 * 如果URL中找不到key1，查找key2，如果能找到使用key2作为扩展名
 * <li>use default extension if 'key2' doesn't appear either</li>
 * 如果key2也找不到，那么使用默认扩展名
 * <li>otherwise, throw {@link IllegalStateException}</li>
 * 如果默认扩展名为空，则抛异常
 * </ol>
 * If default extension's name is not give on interface's {@link SPI}, then a name is generated from interface's
 * class name with the rule: divide classname from capital char into several parts, and separate the parts with
 * dot '.', for example: for {@code org.apache.dubbo.xxx.YyyInvokerWrapper}, its default name is
 * <code>String[] {"yyy.invoker.wrapper"}</code>. This name will be used to search for parameter from URL.
 * 如果SPI注解中没有给出默认扩展名，就会通过如下规则生成默认扩展名：将驼峰式风格的接口名转换成.号分隔的名称作为扩展名，例如
 * 接口名org.apache.dubbo.xxx.YyyInvokerWrapper会被转换成yyy.invoker.wrapper作为扩展名。用这个名称在URL参数中查找。
 *
 *
 * @return parameter key names in URL
 */
String[] value() default {};

}

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("Failed to create adaptive instance: " + t.toString(), t);
                    }
                }
            }
        } else {
            throw new IllegalStateException("Failed to create adaptive instance: " + createAdaptiveInstanceError.toString(), createAdaptiveInstanceError);
        }
    }

    return (T) instance;
}

主要逻辑就是检查缓存，如果缓存不错存在则加载自适应扩展类，使用双检查锁机制保证在多线程的情况下不会重复加载。都是惯用法，没什么可说的。

createAdaptiveExtension

private T createAdaptiveExtension() {
    try {
        //1. 获取自适应扩展类并实例化
        //2. 自动注入属性值
        return injectExtension((T) getAdaptiveExtensionClass().newInstance());
    } catch (Exception e) {
        throw new IllegalStateException("Can't create adaptive extension " + type + ", cause: " + e.getMessage(), e);
    }
}

这里使用了dubbo实现的IOC功能，ExtensionLoader的IOC特性我们再上一节已经说过，通过ExtensionFactory接口的扩展类实现对属性的自动注入，不再赘述。

我们的重点还是放在如何生成自适应扩展类上，即getAdaptiveExtensionClass的逻辑。

getAdaptiveExtensionClass

private Class<?> getAdaptiveExtensionClass() {
    //首先查找所有 资源文件，加载全部扩展类，但并未实例化
    // 在加载扩展类的过程中，如果遇到带Adaptive注解的类，会把该类设到缓存cachedAdaptiveClass
    //这种情况，由用户来实现自适应扩展的逻辑，比较简单
    getExtensionClasses();
    if (cachedAdaptiveClass != null) {
        return cachedAdaptiveClass;
    }
    //大部分情况下，自适应扩展的逻辑不是由用户实现，而是由框架自动生成的，生成的逻辑就在下面的方法中
    return cachedAdaptiveClass = createAdaptiveExtensionClass();
}

没啥好说的，继续看下一个方法

createAdaptiveExtensionClass

//重点来了，这个方法定义了生成自适应扩展类代码的总体方案，
//这个方法引出了自适应扩展机制的核心类AdaptiveClassCodeGenerator
private Class<?> createAdaptiveExtensionClass() {
    //AdaptiveClassCodeGenerator类是关键代码
    String code = new AdaptiveClassCodeGenerator(type, cachedDefaultName).generate();
    ClassLoader classLoader = findClassLoader();
    //Compiler接口也是通过dubbo自己的spi机制加载的，
    // Compiler接口的自适应扩展类是预先写好的代码，即AdaptiveCompiler
    // 这里有一个有意思的问题，如果compiler的自适应扩展类也由框架自动生成，那么这里就会出现循环调用
    org.apache.dubbo.common.compiler.Compiler compiler = ExtensionLoader.getExtensionLoader(org.apache.dubbo.common.compiler.Compiler.class).getAdaptiveExtension();
    //返回编译后的Class对象
    return compiler.compile(code, classLoader);
}

AdaptiveClassCodeGenerator.generate

生成自适应扩展类代码的核心逻辑被封装在AdaptiveClassCodeGenerator类中，AdaptiveClassCodeGenerator的构造方法仅仅设置了要扩展的接口类型以及默认扩展类名（可能为空），我们直接从generate方法看起，

/**
 * generate and return class code
 * 生成自适应扩展类代码
 */
public String generate() {
    // no need to generate adaptive class since there's no adaptive method found.
    // 如果接口中没有带Adaptive注解的方法，说名该类型不需要自适应扩展，直接抛异常
    if (!hasAdaptiveMethod()) {
        throw new IllegalStateException("No adaptive method exist on extension " + type.getName() + ", refuse to create the adaptive class!");
    }

    StringBuilder code = new StringBuilder();
    // 生成package信息，与接口的包名相同
    code.append(generatePackageInfo());
    //生成import信息, 生成了如下的import语句
    //import org.apache.dubbo.common.extension.ExtensionLoader
    code.append(generateImports());
    //生成类定义信息
    // public class <接口名>$Adaptive implements <接口全限定名> {
    code.append(generateClassDeclaration());

    //生成方法信息，这一步是重点
    Method[] methods = type.getMethods();
    for (Method method : methods) {
        code.append(generateMethod(method));
    }
    //最后在末尾加上一个花括号
    code.append("}");

    if (logger.isDebugEnabled()) {
        logger.debug(code.toString());
    }
    return code.toString();
}

总体来看，逻辑还是比较简单的，就是我们平时写代码的步骤，依次生成包信息，import内容，类的具体代码包括每个方法的实现代码。

其中比较重要的是生成方法的实现代码，我们重点看一下这段代码。

generateMethod

private String generateMethod(Method method) {
    // 方法的返回类型
    String methodReturnType = method.getReturnType().getCanonicalName();
    // 方法名称
    String methodName = method.getName();
    // 方法体，即方法的实现代码，这一步最关键
    String methodContent = generateMethodContent(method);
    // 方法参数，
    // (ParamType0 arg0, ParamType1 arg1, ParamType2 arg2)
    String methodArgs = generateMethodArguments(method);
    // 异常信息，throws内容
    String methodThrows = generateMethodThrows(method);
    //最后按照java代码的规范拼接成一个完整的方法代码
    return String.format(CODE_METHOD_DECLARATION, methodReturnType, methodName, methodArgs, methodThrows, methodContent);
}

重点是生成方法具体实现代码的逻辑，generateMethodContent方法。

generateMethodContent

生成方法体的逻辑。这个方法比较长，我们分开来看。

/**
 * generate method content
 * 生成方法体
 */
private String generateMethodContent(Method method) {
    Adaptive adaptiveAnnotation = method.getAnnotation(Adaptive.class);
    // 这一句应该放到else分支内部
    StringBuilder code = new StringBuilder(512);
    // 如果方法不带Adaptive注解，就直接生成抛Unsupported异常的实现，
    // 也就是说，自适应扩展机制必须要在需要自适应的方法上加Adaptive注解
    if (adaptiveAnnotation == null) {
        return generateUnsupported(method);
    } else {
        // 找到URL类型的参数的下标
        int urlTypeIndex = getUrlTypeIndex(method);

        // found parameter in URL type
        if (urlTypeIndex != -1) {
            // Null Point check
            // 如果方法参数列表中有URL类型的参数，那么添加对参数做非空检查的代码
            code.append(generateUrlNullCheck(urlTypeIndex));
        } else {
            // did not find parameter in URL type
            // 如果方法参数中没有URL类型，那么查找能够简介获取到URL的参数，这个参数类型应该含有返回类型的是URL的方法
            code.append(generateUrlAssignmentIndirectly(method));
        }

        // 获取Adaptive注解的value
        // 如果Adaptive注解的value为空，获取会麻烦一些，将接口的驼峰式名称转换成.分隔的名称
        // 如LoadBalance转换成load.balance
        String[] value = getMethodAdaptiveValue(adaptiveAnnotation);

        // 检查Invocation类型的参数
        boolean hasInvocation = hasInvocationArgument(method);

        // 生成检查Invocation类型参数非空的代码段，
        // 只检查第一个参数？？Invocation类型的参数只会有一个？？
        code.append(generateInvocationArgumentNullCheck(method));

        // 生成获取扩展名的代码段，
        // 扩展名就是资源文件中以k-v存储的key值
        code.append(generateExtNameAssignment(value, hasInvocation));
        // check extName == null?
        // 生成扩展名非空检查语句
        code.append(generateExtNameNullCheck(value));

        // 获取到扩展名后，就可以生成扩展类的获取语句了
        code.append(generateExtensionAssignment());

        // return statement
        // 最后加上函数调用和返回语句
        code.append(generateReturnAndInovation(method));
    }

    return code.toString();
}

生成的方法体大致分为三块

• 获取URL的值。如果参数中有URL类型直接赋值；如果没有就间接获取，查找参数中包含返回URL类型的方法，调用这个方法。此外加上一些非空判断语句。
• 获取扩展名。这一步比较复杂，要考虑的情况比较多。如果Adaptive注解中有protocol就要调用URL的getProtocol方法；用以Adaptive的value数组中的key值依次去URL中获取参数，直到获取到不为空的参数。加上扩展名的非空检查语句。
• 通过ExtensionLoader获取扩展名对应的扩展类，赋值给变量extension
• 最后调用扩展类的相应方法，如果返回值不是void就加上return。

其中获取扩展名代码的生成逻辑较为复杂，我们看一下这段代码。

generateExtNameAssignment

private String generateExtNameAssignment(String[] value, boolean hasInvocation) {
    // TODO: refactor it
    String getNameCode = null;
    // 从后向前遍历可选的扩展名
    for (int i = value.length - 1; i >= 0; --i) {
        // 对于最后一个value值做如下处理
        if (i == value.length - 1) {
            if (null != defaultExtName) {
                // 如果不是protocol
                if (!"protocol".equals(value[i])) {
                    if (hasInvocation) {
                        // 如果存在Invocation参数，生成获取方法参数的代码段
                        getNameCode = String.format("url.getMethodParameter(methodName, \"%s\", \"%s\")", value[i], defaultExtName);
                    } else {
                        getNameCode = String.format("url.getParameter(\"%s\", \"%s\")", value[i], defaultExtName);
                    }
                } else {
                    // 如果是protocol，生成扩区protocol的代码段
                    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()";
                }
            }
            //对于不是最后一个的value值做如下处理
        } 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);
            }
        }
    }

    // 拼接成赋值语句
    // String extName = %s;
    return String.format(CODE_EXT_NAME_ASSIGNMENT, getNameCode);
}

代码生成示例

这样光看代码很难对这块代码有直观的认识，理解也不够深刻，既然这段代码的作用主要是生成代码，那么我们就定义一个自己的接口，并实现一个扩展类，用AdaptiveClassCodeGenerator来生成一下，看生成的代码到底是什么样子。

• 首先是接口

    package org.apache.dubbo.common.extension.adaptive.codeGen;
  
    import org.apache.dubbo.common.URL;
    import org.apache.dubbo.common.extension.Adaptive;
    import org.apache.dubbo.common.extension.SPI;
  
    @SPI("default")
    public interface MyExtension {
  
    @Adaptive
    String adaptiveMethod(String param1, int param2, URL url) throws Exception;
  
    @Adaptive("protocol")
    String adaptiveMethod2(String param1, int param2, URLGetter urlGetter) throws Exception;
  
    void noAdaptiveMethod(String param1, URLGetter urlGetter) throws Exception;
    }
  

• 实现类

    package org.apache.dubbo.common.extension.adaptive.codeGen.impl;
  
    import org.apache.dubbo.common.URL;
    import org.apache.dubbo.common.extension.adaptive.codeGen.MyExtension;
    import org.apache.dubbo.common.extension.adaptive.codeGen.URLGetter;
  
    public class DefaultMyExtension implements MyExtension {
        @Override
        public String adaptiveMethod(String param1, int param2, URL url) {
            return String.format("Params passed in are: param1:%s, param2:%d, url:%s");
        }
  
        @Override
        public String adaptiveMethod2(String param1, int param2, URLGetter urlGetter) throws Exception {
            return String.format("Params passed in are: param1:%s, param2:%d, urlGetter:%s");
        }
  
        @Override
        public void noAdaptiveMethod(String param1, URLGetter urlGetter) throws Exception {
  
        }
    }
  

• URL获取类。为了测试简介获取URL

    package org.apache.dubbo.common.extension.adaptive.codeGen;
  
    import org.apache.dubbo.common.URL;
  
    public class URLGetter {
        private URL url;
  
        public URLGetter(URL url){
            this.url=url;
        }
  
        public URL getUrl() {
            return url;
        }
  
        public void setUrl(URL url) {
            this.url = url;
        }
  
        @Override
        public String   toString() {
            return "URLGetter{" +
                    "url=" + url +
                    '}';
        }
    }
  

• 测试类

    package org.apache.dubbo.common.extension.adaptive.codeGen;
  
    import org.apache.dubbo.common.extension.AdaptiveClassCodeGenerator;
    import org.junit.jupiter.api.Test;
  
    public class AdaptiveClassCodeGeneratorTest {
  
        @Test
        public void testProtocolCodeGen() {
            AdaptiveClassCodeGenerator generator=
                    new AdaptiveClassCodeGenerator(MyExtension.class,"default");
            String code=generator.generate();
            System.out.println(code);
        }
    }
  

• 生成的代码。也就是自适应扩展类

    package org.apache.dubbo.common.extension.adaptive.codeGen;
  
    import org.apache.dubbo.common.extension.ExtensionLoader;
  
    public class MyExtension$Adaptive implements org.apache.dubbo.common.extension.adaptive.codeGen.MyExtension {
        public java.lang.String adaptiveMethod(java.lang.String arg0, int arg1, org.apache.dubbo.common.URL arg2) throws java.lang.Exception {
            if (arg2 == null) throw new IllegalArgumentException("url == null");
            org.apache.dubbo.common.URL url = arg2;
            // Adaptive注解中没有value，用接口名称自动生成的key值
            String extName = url.getParameter("my.extension", "default");
            if (extName == null)
                throw new IllegalStateException("Failed to get extension (org.apache.dubbo.common.extension.adaptive.codeGen.MyExtension) name from url (" + url.toString() + ") use keys([my.extension])");
            org.apache.dubbo.common.extension.adaptive.codeGen.MyExtension extension = (org.apache.dubbo.common.extension.adaptive.codeGen.MyExtension) ExtensionLoader.getExtensionLoader(org.apache.dubbo.common.extension.adaptive.codeGen.MyExtension.class).getExtension(extName);
            return extension.adaptiveMethod(arg0, arg1, arg2);
        }
  
        public java.lang.String adaptiveMethod2(java.lang.String arg0, int arg1, org.apache.dubbo.common.extension.adaptive.codeGen.URLGetter arg2) throws java.lang.Exception {
            if (arg2 == null)
                throw new IllegalArgumentException("org.apache.dubbo.common.extension.adaptive.codeGen.URLGetter argument == null");
            if (arg2.getUrl() == null)
                throw new IllegalArgumentException("org.apache.dubbo.common.extension.adaptive.codeGen.URLGetter argument getUrl() == null");
            // 间接获取URL
            org.apache.dubbo.common.URL url = arg2.getUrl();
            // 如果有protocol的key，那么调用URL.getProtocol方法获取协议名称
            String extName = (url.getProtocol() == null ? "default" : url.getProtocol());
            if (extName == null)
                throw new IllegalStateException("Failed to get extension (org.apache.dubbo.common.extension.adaptive.codeGen.MyExtension) name from url (" + url.toString() + ") use keys([protocol])");
            org.apache.dubbo.common.extension.adaptive.codeGen.MyExtension extension = (org.apache.dubbo.common.extension.adaptive.codeGen.MyExtension) ExtensionLoader.getExtensionLoader(org.apache.dubbo.common.extension.adaptive.codeGen.MyExtension.class).getExtension(extName);
            return extension.adaptiveMethod2(arg0, arg1, arg2);
        }
  
        // 为标Adaptive注解的方法直接抛异常
        public void noAdaptiveMethod(java.lang.String arg0, org.apache.dubbo.common.extension.adaptive.codeGen.URLGetter arg1) throws java.lang.Exception {
            throw new UnsupportedOperationException("The method public abstract void org.apache.dubbo.common.extension.adaptive.codeGen.MyExtension.noAdaptiveMethod(java.lang.String,org.apache.dubbo.common.extension.adaptive.codeGen.URLGetter) throws java.lang.Exception of interface org.apache.dubbo.common.extension.adaptive.codeGen.MyExtension is not adaptive method!");
        }
    }
  

这样看是不是直观多了。回过头再去看一遍代码生成逻辑，就好懂多了。

编译加载

代码生成之后，还需要将代码编译为字节码并通过类加载器加载到虚拟机中，获取Class对象，然后才能使用。

负责编译的是org.apache.dubbo.common.compiler.Compiler接口，这个接口的实现类也是通过ExtensionLoader进行加载的，见ExtensionLoader.createAdaptiveExtensionClass方法。

我们看一下Compiler接口

Compiler

// 默认扩展名是javassist
@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-common模块中META-INF/dubbo/inetrnal/org.apache.dubbo.common.compiler.Compiler文件中的内容：

adaptive=org.apache.dubbo.common.compiler.support.AdaptiveCompiler
jdk=org.apache.dubbo.common.compiler.support.JdkCompiler
javassist=org.apache.dubbo.common.compiler.support.JavassistCompiler

AdaptiveCompiler类上带有Adaptive注解，所以ExtensionLoader在加载时AdaptiveCompiler类会被设置为自适应扩展类。而在createAdaptiveExtensionClass方法中真是通过Compiler接口的自适应扩展类来进行编译。那么我们看一下AdaptiveCompiler中的逻辑。

AdaptiveCompiler

public Class<?> compile(String code, ClassLoader classLoader) {
    Compiler compiler;
    ExtensionLoader<Compiler> loader = ExtensionLoader.getExtensionLoader(Compiler.class);
    // 可以通过设置静态变量DEFAULT_COMPILER指定默认扩展类
    String name = DEFAULT_COMPILER; // copy reference
    if (name != null && name.length() > 0) {
        compiler = loader.getExtension(name);
    } else {
        // 如果未指定，则获取SPI注解指定的默认扩展类
        compiler = loader.getDefaultExtension();
    }
    return compiler.compile(code, classLoader);
}

由Compiler接口上的SPI注解，我们知道默认的实现类是JavassistCompiler，所以我们看一下这个类是怎么进行编译的。

JavassistCompiler

JavassistCompiler继承自AbstractCompiler，有一部分逻辑在AbstractCompiler类中，所以我们先看一下

AbstractCompiler.compile

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+");    

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);
    }
    // 根据包名和类名拼接类的全限定名
    String className = pkg != null && pkg.length() > 0 ? pkg + "." + cls : cls;
    try {
        // 尝试直接加载？？？类的字节码已经存在？？或者类已经被加载过了？？
        // 什么情况下会出现这种情况？？
        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 {
            // 由子类实现
            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));
        }
    }
}

主要就是拼接处类的全限定名，然后做一些检查，尝试直接加载类。真正的编译过程交由子类实现。

JavassistCompiler.doCompile

@Override
public Class<?> doCompile(String name, String source) throws Throwable {
    // 实际执行编译的类
    CtClassBuilder builder = new CtClassBuilder();
    // 设置类名
    builder.setClassName(name);

    // process imported classes
    // 匹配出所有的import语句，并设置到CtClassBuilder对象中
    Matcher matcher = IMPORT_PATTERN.matcher(source);
    while (matcher.find()) {
        builder.addImports(matcher.group(1).trim());
    }

    // process extended super class
    // 匹配出extends的类型，设置到CtClassBuilder对象中
    matcher = EXTENDS_PATTERN.matcher(source);
    if (matcher.find()) {
        builder.setSuperClassName(matcher.group(1).trim());
    }

    // process implemented interfaces
    // 匹配出implements的类型，设置到CtClassBuilder对象中
    matcher = IMPLEMENTS_PATTERN.matcher(source);
    if (matcher.find()) {
        String[] ifaces = matcher.group(1).trim().split("\\,");
        Arrays.stream(ifaces).forEach(i -> builder.addInterface(i.trim()));
    }

    // process constructors, fields, methods
    // 添加方法和域
    String body = source.substring(source.indexOf('{') + 1, source.length() - 1);
    String[] methods = METHODS_PATTERN.split(body);
    String className = ClassUtils.getSimpleClassName(name);
    Arrays.stream(methods).map(String::trim).filter(m -> !m.isEmpty()).forEach(method-> {
        if (method.startsWith(className)) {
            builder.addConstructor("public " + method);
        } else if (FIELD_PATTERN.matcher(method).matches()) {
            builder.addField("private " + method);
        } else {
            builder.addMethod("public " + method);
        }
    });

    // compile
    ClassLoader classLoader = ClassHelper.getCallerClassLoader(getClass());
    // 进行编译，实际的编译过程设计到字节码操作，由javassist库实现，这里不再深入下去
    CtClass cls = builder.build(classLoader);
    return cls.toClass(classLoader, JavassistCompiler.class.getProtectionDomain());
}

实际的编译过程设计到字节码操作，由javassist库实现，这里不再深入下去。

总结

自适应扩展模块主要分为两块，一是生成自适应扩展类的代码，二是将代码进行编译并加载编译后的字节码。

• 其中dubbo实现的主要逻辑就是代码生成。
  
  自适应加载扩展类的主要思路就是从方法的参数中获取URL参数，可以是方法参数本省，也可以从参数的类型的方法中获取；
  
  然后从URL参数中查找扩展名（查找的范围通过Adaptive注解的value值和SPI注解中的默认值组成），找到扩展名后再由ExtensionLoader根据扩展名加载对应的扩展类，
  
  然后调用对应扩展类的对应方法并返回。

• 编译代码的逻辑主要有javassist库实现，dubbo在javassist库基础上进行了一些简单封装，大部分的逻辑都是直接调用javassist库，这部分不再深入下去，如果对java代码编译感兴趣可以细看。