package cc.ccoder.loader;

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

@SPI("http")
public interface DownloadStrategy {

    void download();
}

http=cc.ccoder.loader.HttpDownloadStrategy
sftp=cc.ccoder.loader.SftpDownloadStrategy

package cc.ccoder.loader;

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

public class DubboSpiLoaderTest {

    public static void main(String[] args) {
        ExtensionLoader<DownloadStrategy> extensionLoader = ExtensionLoader.getExtensionLoader(DownloadStrategy.class);
        //这里getExtension方法进行加载具体扩展点
        DownloadStrategy downloadStrategy = extensionLoader.getExtension("http");
        downloadStrategy.download();
    }
}

采用Http下载方式
Process finished with exit code 0

    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 an interface!");
        }
        if (!withExtensionAnnotation(type)) {
            throw new IllegalArgumentException("Extension type (" + type +
                    ") is not an extension, because it is NOT annotated with @" + SPI.class.getSimpleName() + "!");
        }
        // 查看本地是否存在扩展点类型的Loader
        // 创建一个ExtensionLoader 并且将ExtensionFactory 的实现类均放入这个EXTENSION_LOADERS的本地map缓存中
        // ExtensionFactory 的实现有SpiExtensionFactory 和 SpringExtensionFactory
        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;
    }

getExtension(name)
    -> createExtension(name) #缓存获取 无缓存则创建
        -> getExtensionClasses().get(name) #从缓存中获取name的扩展点类型
        -> 实例化扩展类
        -> injectExtension(instance) # 扩展点IOC注入
        -> instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance)) 
  #循环遍历所有wrapper实现，实例化wrapper并进行扩展点IOC注入

    public T getExtension(String name, boolean wrap) {
        if (StringUtils.isEmpty(name)) {
            throw new IllegalArgumentException("Extension name == null");
        }
        //如果传入的name为字符串true 则返回默认的扩展点
        if ("true".equals(name)) {
            return getDefaultExtension();
        }
        //从缓存中获取Holder 不存在则创建该缓存对象 并且从缓存中拿，可以防止放入缓存中失败的情况、
        //dubbo 实际将扩展类封装在Holder类中
        final Holder<Object> holder = getOrCreateHolder(name);
        Object instance = holder.get();
        if (instance == null) {
            //double-check 保证线程安全
            synchronized (holder) {
                instance = holder.get();
                if (instance == null) {
                    //缓存中没有就创建该扩展点
                    instance = createExtension(name, wrap);
                    //放入缓存 下次直接从缓存中拿取
                    holder.set(instance);
                }
            }
        }
        return (T) instance;
    }

 private T createExtension(String name, boolean wrap) {
        //name:spi 获取到SpiExtensionFactory
        Class<?> clazz = getExtensionClasses().get(name);
        if (clazz == null || unacceptableExceptions.contains(name)) {
            throw findException(name);
        }
        try {
            //加载本地缓存Map(SpringExtensionFactory. SpiExtensionFactory)中的SpiExtensionFactory
            T instance = (T) EXTENSION_INSTANCES.get(clazz);
            if (instance == null) {
                //name:spi clazz:SpiExtensionFactory 这里反射将其加载到缓存中
                EXTENSION_INSTANCES.putIfAbsent(clazz, clazz.getDeclaredConstructor().newInstance());
                instance = (T) EXTENSION_INSTANCES.get(clazz);
            }
            //IOC注入
            injectExtension(instance);


            if (wrap) {
            //包装类装饰
                List<Class<?>> wrapperClassesList = new ArrayList<>();
                if (cachedWrapperClasses != null) {
                    wrapperClassesList.addAll(cachedWrapperClasses);
                    wrapperClassesList.sort(WrapperComparator.COMPARATOR);
                    Collections.reverse(wrapperClassesList);
                }

                if (CollectionUtils.isNotEmpty(wrapperClassesList)) {
                    for (Class<?> wrapperClass : wrapperClassesList) {
                        Wrapper wrapper = wrapperClass.getAnnotation(Wrapper.class);
                        if (wrapper == null
                                || (ArrayUtils.contains(wrapper.matches(), name) && !ArrayUtils.contains(wrapper.mismatches(), name))) {
                            instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance));
                        }
                    }
                }
            }

            initExtension(instance);
            return instance;
        } catch (Throwable t) {
            throw new IllegalStateException("Extension instance (name: " + name + ", class: " +
                    type + ") couldn't be instantiated: " + t.getMessage(), t);
        }
    }

    private Map<String, Class<?>> getExtensionClasses() {
        //缓存加载
        Map<String, Class<?>> classes = cachedClasses.get();
        if (classes == null) {
            //double-check
            synchronized (cachedClasses) {
                classes = cachedClasses.get();
                if (classes == null) {
                    //关键方法:获取所有扩展点 
                    classes = loadExtensionClasses();
                    cachedClasses.set(classes);
                }
            }
        }
        return classes;
    }

"http" -> {Class@1390} "class cc.ccoder.loader.HttpDownloadStrategy"
"sftp" -> {Class@1391} "class cc.ccoder.loader.SftpDownloadStrategy"

    private Map<String, Class<?>> loadExtensionClasses() {
        //获取扩展点上的@SPI注解 并且缓存默认扩展点名称
        cacheDefaultExtensionName();

        //所有扩展点放入缓存
        Map<String, Class<?>> extensionClasses = new HashMap<>();

        //加载策略  这里是一个工厂方法;对指定文件夹进行加载
        //DubboInternalLoadingStrategy => META-INF/dubbo/internal/
        //DubboLoadingStrategy => META-INF/dubbo/
        //ServicesLoadingStrategy => META-INF/services/
        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;
    }

loadDirectory(extensionClasses, DUBBO_INTERNAL_DIRECTORY, type.getName());
loadDirectory(extensionClasses, DUBBO_INTERNAL_DIRECTORY, type.getName().replace("org.apache", "com.alibaba"));
loadDirectory(extensionClasses, DUBBO_DIRECTORY, type.getName());
loadDirectory(extensionClasses, DUBBO_DIRECTORY, type.getName().replace("org.apache", "com.alibaba"));
loadDirectory(extensionClasses, SERVICES_DIRECTORY, type.getName());
loadDirectory(extensionClasses, SERVICES_DIRECTORY, type.getName().replace("org.apache", "com.alibaba"));

   /**
     * extract and cache default extension name if exists
     */
    private void cacheDefaultExtensionName() {
        //拿到@SPI注解
        final SPI defaultAnnotation = type.getAnnotation(SPI.class);
        if (defaultAnnotation == null) {
            return;
        }
        //拿到@SPI注解的value
        String value = defaultAnnotation.value();
        if ((value = value.trim()).length() > 0) {
            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
                cachedDefaultName = names[0];
            }
        }
    }

private void loadDirectory(Map<String, Class<?>> extensionClasses, String dir, String type,
                               boolean extensionLoaderClassLoaderFirst, boolean overridden, String... excludedPackages) {
        //将相对路径和全限定类名作为文件路径
        //例如: META-INF/services/cc.ccoder.loader.HttpDownloadStrategy
        String fileName = dir + type;
        try {
            Enumeration<java.net.URL> urls = null;
            ClassLoader classLoader = findClassLoader();

            // try to load from ExtensionLoader's ClassLoader first
            //首先尝试从ExtensionLoader的类加载器加载 该属性在LoaderStrategy接口中是一个默认方法并且为false
            if (extensionLoaderClassLoaderFirst) {
                ClassLoader extensionLoaderClassLoader = ExtensionLoader.class.getClassLoader();
                if (ClassLoader.getSystemClassLoader() != extensionLoaderClassLoader) {
                    urls = extensionLoaderClassLoader.getResources(fileName);
                }
            }

            if (urls == null || !urls.hasMoreElements()) {
                if (classLoader != null) {
                    //根据文件路径获取文件
                    urls = classLoader.getResources(fileName);
                } else {
                    urls = ClassLoader.getSystemResources(fileName);
                }
            }

            if (urls != null) {
                while (urls.hasMoreElements()) {
                    //对文件中内容 进行逐条加载资源
                    java.net.URL resourceURL = urls.nextElement();
                    loadResource(extensionClasses, classLoader, resourceURL, overridden, excludedPackages);
                }
            }
        } catch (Throwable t) {
            logger.error("Exception occurred when loading extension class (interface: " +
                    type + ", description file: " + fileName + ").", t);
        }
    }

private void loadResource(Map<String, Class<?>> extensionClasses, ClassLoader classLoader,
                              java.net.URL resourceURL, boolean overridden, String... excludedPackages) {
        try {
            //创建流 准备读取文件中内容
            try (BufferedReader reader = new BufferedReader(new InputStreamReader(resourceURL.openStream(), StandardCharsets.UTF_8))) {
                String line;
                String clazz = null;
                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
                                // = 右边的为class,扩展点的全限定类名
                                name = line.substring(0, i).trim();
                                clazz = line.substring(i + 1).trim();
                            } else {
                                // 当然也可以为空 直接整行记录为扩展点的全限定类名
                                clazz = line;
                            }
                            if (StringUtils.isNotEmpty(clazz) && !isExcluded(clazz, excludedPackages)) {
                                //加载类，利用反射预加载上面读取到的全限定类名
                                loadClass(extensionClasses, resourceURL, Class.forName(clazz, true, classLoader), name, overridden);
                            }
                        } 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);
                        }
                    }
                }
            }
        } catch (Throwable t) {
            logger.error("Exception occurred when loading extension class (interface: " +
                    type + ", class file: " + resourceURL + ") in " + resourceURL, t);
        }
    }

   private void loadClass(Map<String, Class<?>> extensionClasses, java.net.URL resourceURL, Class<?> clazz, String name,
                           boolean overridden) throws NoSuchMethodException {
        //扩展类对象必须是扩展点接口的子类
        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.");
        }
        //自适应扩展点
        if (clazz.isAnnotationPresent(Adaptive.class)) {
            //将cachedWrapperClasses变量设置为clazz
            cacheAdaptiveClass(clazz, overridden);
        } else if (isWrapperClass(clazz)) {
            //判断扩展点构造函数中是否有参数是当前扩展接口类型
            //如果有，则为包装装饰类，将cachedWrapperClasses变量添加到当前clazz
            cacheWrapperClass(clazz);
        } else {
            //此处为普通的扩展点
            //获取默认的构造函数，没有默认构造函数则抛出异常
            clazz.getConstructor();
            if (StringUtils.isEmpty(name)) {
                //如果name为空 则判断类上是否存在@Extension注解，并且该注解的value为name =>extension.value
                //没有此注解则以小写类名为name =>clazz.getSimpleName()
                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)) {
                //如果类中有@Activate注解，则将name与注解对象缓存在cacheActivateClass变量中 cachedActivates.put(name, activate)
                cacheActivateClass(clazz, names[0]);
                for (String n : names) {
                    //缓存name key:clazz, value:name cachedNames.put(clazz, name);
                    cacheName(clazz, n);
                    //最后将拿到的扩展类放入map中 extensionClasses.put(name, clazz);
                    saveInExtensionClass(extensionClasses, clazz, n, overridden);
                }
            }
        }
    }

    /**
     * put clazz in extensionClasses
     */
    private void saveInExtensionClass(Map<String, Class<?>> extensionClasses, Class<?> clazz, String name, boolean overridden) {
        Class<?> c = extensionClasses.get(name);
        if (c == null || overridden) {
            //放入extensionClasses
            extensionClasses.put(name, clazz);
        } else if (c != clazz) {
            // duplicate implementation is unacceptable
            unacceptableExceptions.add(name);
            String duplicateMsg =
                    "Duplicate extension " + type.getName() + " name " + name + " on " + c.getName() + " and " + clazz.getName();
            logger.error(duplicateMsg);
            throw new IllegalStateException(duplicateMsg);
        }
    }

   private T injectExtension(T instance) {
        //objectFactory 是ExtensionFactory 的变量，在类构造器根据自适应扩展点进行初始化
        //类似于IOC容器工厂 实现的有SpiExtensionFactory SpringExtensionFactory
        if (objectFactory == null) {
            return instance;
        }

        try {
            //反射遍历实例中所有的方法
            for (Method method : instance.getClass().getMethods()) {
                //判断是否为setter方法:
                //方法名以set开头 startWith('set')
                // 方法参数只有一个 getParameterTypes.length()==1
                // 方法为public类型 Modifier.isPublic
                if (!isSetter(method)) {
                    continue;
                }
                /**
                 * Check {@link DisableInject} to see if we need auto injection for this property
                 */
                //判断校验该属性是否需要自动注入
                //打上了@DisableInject注解则不需要注入操作
                if (method.getAnnotation(DisableInject.class) != null) {
                    continue;
                }
                //获取该方法参数的clazz
                Class<?> pt = method.getParameterTypes()[0];
                if (ReflectUtils.isPrimitives(pt)) {
                    continue;
                }

                try {
                    //获取方法名中需要注入的属性property
                    //例如:方法setVersion 获取属性为version 并且将第四个小写 便是version
                    String property = getSetterProperty(method);
                    //使用参数的clazz与参数名称去ExtensionFactory 的 IOC容器中拿取扩展点类
                    Object object = objectFactory.getExtension(pt, property);
                    if (object != null) {
                        //调用set方法，完成注入
                        method.invoke(instance, object);
                    }
                } catch (Exception e) {
                    logger.error("Failed to inject via method " + method.getName()
                            + " of interface " + type.getName() + ": " + e.getMessage(), e);
                }

            }
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        }
        return instance;
    }

            if (wrap) {
            //包装类装饰
                List<Class<?>> wrapperClassesList = new ArrayList<>();
                if (cachedWrapperClasses != null) {
                    wrapperClassesList.addAll(cachedWrapperClasses);
                    wrapperClassesList.sort(WrapperComparator.COMPARATOR);
                    Collections.reverse(wrapperClassesList);
                }
                //前面提到在loadClass中如果扩展类时包装装饰类,便会将其放入cachedWrapperClasses 那么此处wrapperClassList也不会为空
                if (CollectionUtils.isNotEmpty(wrapperClassesList)) {
                    for (Class<?> wrapperClass : wrapperClassesList) {
                        Wrapper wrapper = wrapperClass.getAnnotation(Wrapper.class);
                        if (wrapper == null
                                || (ArrayUtils.contains(wrapper.matches(), name) && !ArrayUtils.contains(wrapper.mismatches(), name))) {
                            //在此处进行注入包装
                            //同样利用反射创建此包装扩展点的实例，并将普通扩展点作为构造器参数传入包装扩展点进行实例化，此时返回的是包装器扩展点
                            //将其理解为装饰器模式 在原有的普通扩展点上进行增强 在RPC服务发布与调用时可以提现
                            instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance));
                        }
                    }
                }
            }

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

public T getAdaptiveExtension()
    -> createAdaptiveExtension() #从缓存中获取 否则创建
        -> getAdaptiveExtensionClass().newInstance() #获取AdaptiveExtensionClass
            -> getExtensionClasses() # 加载当前扩展所有实现，看是否有实现被标注为@Adaptive
            -> createAdaptiveExtensionClass() #如果没有实现被标注为@Adaptive，则动态创建一个Adaptive实现类
                -> createAdaptiveExtensionClassCode() #动态生成实现类java代码
                -> compiler.compile(code, classLoader) #动态编译java代码，加载类并实例化
        -> injectExtension(instance)

    public T getAdaptiveExtension() {
        //缓存获取
        Object instance = cachedAdaptiveInstance.get();
        if (instance == null) {
            if (createAdaptiveInstanceError != null) {
                throw new IllegalStateException("Failed to create adaptive instance: " +
                        createAdaptiveInstanceError.toString(),
                        createAdaptiveInstanceError);
            }

            //double-check
            synchronized (cachedAdaptiveInstance) {
                instance = cachedAdaptiveInstance.get();
                if (instance == null) {
                    try {
                        //创建自适应扩展实例
                        //这里需要关注createAdaptiveExtension方法
                        instance = createAdaptiveExtension();
                        cachedAdaptiveInstance.set(instance);
                    } catch (Throwable t) {
                        createAdaptiveInstanceError = t;
                        throw new IllegalStateException("Failed to create adaptive instance: " + t.toString(), t);
                    }
                }
            }
        }

        return (T) instance;
    }

    private T createAdaptiveExtension() {
        try {
            //getAdaptiveExtensionClass获取到自适应类后进行IOC注入，IOC注入和之前的逻辑一样
            return injectExtension((T) getAdaptiveExtensionClass().newInstance());
        } catch (Exception e) {
            throw new IllegalStateException("Can't create adaptive extension " + type + ", cause: " + e.getMessage(), e);
        }
    }

    private Class<?> getAdaptiveExtensionClass() {
        //加载所有扩展点
        getExtensionClasses();
        //如果扩展点上存在@Adaptive注解 则cachedAdaptiveClass缓存变量不为空
        if (cachedAdaptiveClass != null) {
            //存在@Adaptive注解作用在类上 表示该自适应扩展类为人工编码 直接返回
            return cachedAdaptiveClass;
        }
        //表示没有@Adaptive注解标志 那么dubbo将生成自适应扩展类
        return cachedAdaptiveClass = createAdaptiveExtensionClass();
    }

@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()) {
            //扩展点类加载得到后 直接放入factories中
            list.add(loader.getExtension(name));
        }
        factories = Collections.unmodifiableList(list);
    }

    @Override
    public <T> T getExtension(Class<T> type, String name) {
        //由于factories已经获取到了ExtensionFactory的所有扩展点类 这里依次读取即可
        for (ExtensionFactory factory : factories) {
            T extension = factory.getExtension(type, name);
            //获取到type name 这样的扩展点 直接返回
            if (extension != null) {
                return extension;
            }
        }
        return null;
    }

}

    private Class<?> createAdaptiveExtensionClass() {
        //创建一个生成类 类型=DownloadStrategy 扩展点类型 ，扩展点接口的class对象 和 默认扩展点名称
        //这里需要看看generate方法是如何生成的
        String code = new AdaptiveClassCodeGenerator(type, cachedDefaultName).generate();
        //拿到ExtensionLoader的ClassLoader
        ClassLoader classLoader = findClassLoader();
        //自适应方式拿到编译类 然后将代码进行编译 classLoader进行加载 最终编程一个Class对象
        org.apache.dubbo.common.compiler.Compiler compiler =
                ExtensionLoader.getExtensionLoader(org.apache.dubbo.common.compiler.Compiler.class).getAdaptiveExtension();
        return compiler.compile(code, classLoader);
    }

 public String generate() {
        // no need to generate adaptive class since there's no adaptive method found.g
        //方法上无法找到@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 cc.ccoder.loader;
        code.append(generatePackageInfo());
        //导入依赖 import org.apache.dubbo.common.extension.ExtensionLoader;
        code.append(generateImports());
        //这里生成类名 之前说到的添加一个$Adaptive后缀 例如ProxyFactory生成的自适应代码ProxyFactory$Adaptive
        //public class %s$Adaptive implements %s {
        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();
    }

    private String generateMethod(Method method) {
        //获取方法的返回值类型
        String methodReturnType = method.getReturnType().getCanonicalName();
        //获取方法的名称
        String methodName = method.getName();
        //获取方法内容
        String methodContent = generateMethodContent(method);
        //获取方法的参数
        String methodArgs = generateMethodArguments(method);
        //获取方法抛出异常
        String methodThrows = generateMethodThrows(method);
        //通过这个模板生成方法
        //"public %s %s(%s) %s {\n%s}\n";
        return String.format(CODE_METHOD_DECLARATION, methodReturnType, methodName, methodArgs, methodThrows, methodContent);
    }

 private String generateMethodContent(Method method) {
        //首选获取到方法上的@Adaptive注解
        Adaptive adaptiveAnnotation = method.getAnnotation(Adaptive.class);
        StringBuilder code = new StringBuilder(512);
        if (adaptiveAnnotation == null) {
            //如果此方法上面没有@Adaptive注解 便不为此方法生成动态方法 并且抛出一个异常UnsupportedOperationException
            return generateUnsupported(method);
        } else {
            //获取URL参数索引
            int urlTypeIndex = getUrlTypeIndex(method);

            // found parameter in URL type
            //在URL类型中找到参数,如果不为-1表示找到
            if (urlTypeIndex != -1) {
                // Null Point check
                //添加一个arg == null的校验
                code.append(generateUrlNullCheck(urlTypeIndex));
            } else {
                // did not find parameter in URL type
                //没有找到 在其他方法中判断是否可以获取到URL getUrl这个方法
                code.append(generateUrlAssignmentIndirectly(method));
            }
            //获取注解上的value值 代表获取扩展点时get的name值 ，如果不存在则使用类名的值作为键
            String[] value = getMethodAdaptiveValue(adaptiveAnnotation);

            //判断参数中是否有Invocation类型的参数，org.apache.dubbo.rpc.Invocation
            boolean hasInvocation = hasInvocationArgument(method);
            
            //生成Invocation参数值的代码 并且进行null校验
            code.append(generateInvocationArgumentNullCheck(method));
            
            //生成从url获取参数的代码 getMethodParameter getParameter getProtocol
            code.append(generateExtNameAssignment(value, hasInvocation));
            // check extName == null?
            //校验extName==null 的代码
            code.append(generateExtNameNullCheck(value));
            
            //生成getExtensionLoader(xxx.class).getExtension(extName)的代码
            code.append(generateExtensionAssignment());

            // return statement
            // 生成return语句 扩展点类执行方法
            code.append(generateReturnAndInvocation(method));
        }

        return code.toString();
    }

    /**
     * 1, test if argi is null
     * 2, test if argi.getXX() returns null
     * 3, assign url with argi.getXX()
     */
    private String generateGetUrlNullCheck(int index, Class<?> type, String method) {
        // Null point check
        StringBuilder code = new StringBuilder();
        code.append(String.format("if (arg%d == null) throw new IllegalArgumentException(\"%s argument == null\");\n",
                index, type.getName()));
        code.append(String.format("if (arg%d.%s() == null) throw new IllegalArgumentException(\"%s argument %s() == null\");\n",
                index, method, type.getName(), method));

        code.append(String.format("%s url = arg%d.%s();\n", URL.class.getName(), index, method));
        return code.toString();
    }

package org.apache.dubbo.rpc;

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

public class ProxyFactory$Adaptive implements org.apache.dubbo.rpc.ProxyFactory {
    public java.lang.Object getProxy(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.getParameter("proxy", "javassist");
        if (extName == null)
            throw new IllegalStateException("Failed to get extension (org.apache.dubbo.rpc.ProxyFactory) name from url (" + url.toString() + ") use keys([proxy])");
        org.apache.dubbo.rpc.ProxyFactory extension = ExtensionLoader.getExtensionLoader(org.apache.dubbo.rpc.ProxyFactory.class).getExtension(extName);
        return extension.getProxy(arg0);
    }

    public java.lang.Object getProxy(org.apache.dubbo.rpc.Invoker arg0, boolean arg1) 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.getParameter("proxy", "javassist");
        if (extName == null)
            throw new IllegalStateException("Failed to get extension (org.apache.dubbo.rpc.ProxyFactory) name from url (" + url.toString() + ") use keys([proxy])");
        org.apache.dubbo.rpc.ProxyFactory extension = (org.apache.dubbo.rpc.ProxyFactory) ExtensionLoader.getExtensionLoader(org.apache.dubbo.rpc.ProxyFactory.class).getExtension(extName);
        return extension.getProxy(arg0, arg1);
    }

    public org.apache.dubbo.rpc.Invoker getInvoker(java.lang.Object arg0, java.lang.Class arg1, org.apache.dubbo.common.URL arg2) throws org.apache.dubbo.rpc.RpcException {
        if (arg2 == null) throw new IllegalArgumentException("url == null");
        org.apache.dubbo.common.URL url = arg2;
        String extName = url.getParameter("proxy", "javassist");
        if (extName == null)
            throw new IllegalStateException("Failed to get extension (org.apache.dubbo.rpc.ProxyFactory) name from url (" + url.toString() + ") use keys([proxy])");
        org.apache.dubbo.rpc.ProxyFactory extension = (org.apache.dubbo.rpc.ProxyFactory) ExtensionLoader.getExtensionLoader(org.apache.dubbo.rpc.ProxyFactory.class).getExtension(extName);
        return extension.getInvoker(arg0, arg1, arg2);
    }
}

 public interface LruCache<K, V> {

    /**
     * Set the capacity of the total cache num
     * 
     * @param capacity
     *            capacity
     */
    void setCapacity(int capacity);

    /**
     * Update cache according to LRU definition. This time complexity of this method should be O(1).
     * 
     * @param cacheKey
     *            key
     * @param cacheValue
     *            value
     */
    void put(K cacheKey, V cacheValue);

    /**
     * 获取元素
     * 
     * @param cacheKey
     *            元素key
     * @return value
     */
    V get(K cacheKey);

}