@SPI("china")
public interface PersonService {
    @Adaptive
    String queryCountry(URL url);
}
public class ChinaPersonServiceImpl implements PersonService {
    @Override
    public String queryCountry(URL url) {
        System.out.println("中國人");
        return "中國人";
    }
}
public class EnglandPersonServiceImpl implements PersonService{
    @Override
    public String queryCountry(URL url) {
        System.out.println("英國人");
        return "英國人";
    }
}
public class Test {
    public static void main(String[] args) {
        URL url = URL.valueOf("dubbo://192.168.0.101:20880?person.service=china");
        PersonService service = ExtensionLoader.getExtensionLoader(PersonService.class)
                .getAdaptiveExtension();
        service.queryCountry(url);
    }
}
china=org.dubbo.spi.example.ChinaPersonServiceImpl
england=org.dubbo.spi.example.EnglandPersonServiceImpl

public class PersonService$Adaptive implements org.dubbo.spi.example.PersonService {
    public java.lang.String queryCountry(org.apache.dubbo.common.URL arg0) {
        if (arg0 == null) throw new IllegalArgumentException("url == null");
        org.apache.dubbo.common.URL url = arg0;
        String extName = url.getParameter("person.service", "china");
        if (extName == null)
            throw new IllegalStateException("Failed to get extension (org.dubbo.spi.example.PersonService) name from url (" + url.toString() + ") use keys([person.service])");
        org.dubbo.spi.example.PersonService extension = (org.dubbo.spi.example.PersonService) ExtensionLoader.getExtensionLoader(org.dubbo.spi.example.PersonService.class).getExtension(extName);
        return extension.queryCountry(arg0);
    }
}

    public T getAdaptiveExtension() {
        //從裝載適配器實例緩存里面找
        Object instance = cachedAdaptiveInstance.get();
        if (instance == null) {
            //創(chuàng)建cachedAdaptiveInstance異常
            if (createAdaptiveInstanceError != null) {
                throw new IllegalStateException("Failed to create adaptive instance: " +
                        createAdaptiveInstanceError.toString(),
                        createAdaptiveInstanceError);
            }
            synchronized (cachedAdaptiveInstance) {
                instance = cachedAdaptiveInstance.get();
                if (instance == null) {
                    try {
                        //創(chuàng)建對應(yīng)的適配器類
                        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 {
            return injectExtension((T) getAdaptiveExtensionClass().newInstance());
        } catch (Exception e) {
            throw new IllegalStateException("Can't create adaptive extension " + type + ", cause: " + e.getMessage(), e);
        }
    }

    private Class<?> getAdaptiveExtensionClass() {
        //獲取所有的擴(kuò)展類
        getExtensionClasses();
        //如果可以適配
        if (cachedAdaptiveClass != null) {
            return cachedAdaptiveClass;
        }
        //如果沒有適配擴(kuò)展類就創(chuàng)建
        return cachedAdaptiveClass = createAdaptiveExtensionClass();
    }
    private Class<?> createAdaptiveExtensionClass() {
        //生成代碼片段
        String code = new AdaptiveClassCodeGenerator(type, cachedDefaultName).generate();
        //獲取ClassLoader
        ClassLoader classLoader = findClassLoader();
        //通過jdk或者javassist的方式編譯生成的子類字符串，從而得到一個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() {
        // 判斷目標(biāo)接口是否有方法標(biāo)注了@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信息 只導(dǎo)入了ExtensionLoader類,其余的類都通過全限定名的方式來使用
        code.append(generateImports());
        //生成類聲明信息
        code.append(generateClassDeclaration());
        Method[] methods = type.getMethods();
        //為各個方法生成實現(xiàn)方法信息
        for (Method method : methods) {
            code.append(generateMethod(method));
        }
        code.append("}");
        if (logger.isDebugEnabled()) {
            logger.debug(code.toString());
        }
        //返回class代碼
        return code.toString();
    }

    private String generateMethod(Method method) {
        //獲取方法返回值
        String methodReturnType = method.getReturnType().getCanonicalName();
        //獲取方法名稱
        String methodName = method.getName();
        //獲取方法體內(nèi)容
        String methodContent = generateMethodContent(method);
        //獲取方法參數(shù)
        String methodArgs = generateMethodArguments(method);
        //生成異常信息
        String methodThrows = generateMethodThrows(method);
        //格式化
        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) {
            //如果當(dāng)前方法沒有被Adaptive修飾則需要拋出異常
            return generateUnsupported(method);
        } else {
            //獲取參數(shù)中類型為URL的參數(shù)所在的參數(shù)索引位 通過下標(biāo)獲取對應(yīng)的參數(shù)值信息
            int urlTypeIndex = getUrlTypeIndex(method);
            if (urlTypeIndex != -1) {
                //如果參數(shù)中存在URL類型的參數(shù)，那么就為該參數(shù)進(jìn)行空值檢查，如果為空，則拋出異常
                code.append(generateUrlNullCheck(urlTypeIndex));
            } else {
                //如果參數(shù)中不存在URL類型的參數(shù)，則會檢查每個參數(shù)，判斷是否有某個方法的返回類型是URL類型，
                //如果存在該方法，首先對該參數(shù)進(jìn)行空指針檢查，如果為空則拋出異常。如果不為空則調(diào)用該對象的目標(biāo)方法，
                //獲取URL對象，然后對獲取到的URL對象進(jìn)行空值檢查，為空拋出異常。
                code.append(generateUrlAssignmentIndirectly(method));
            }
            //獲取@Adaptive注解的參數(shù)，如果沒有配置，就會使用目標(biāo)接口的類型由駝峰形式轉(zhuǎn)換為點(diǎn)分形式
            //的名稱作為將要獲取的參數(shù)值的key名稱
            String[] value = getMethodAdaptiveValue(adaptiveAnnotation);
            //判斷是否存在Invocation類型的參數(shù) 關(guān)于這個對象我們在后續(xù)章節(jié)在進(jìn)行講解
            boolean hasInvocation = hasInvocationArgument(method);
            //為Invocation類型的參數(shù)添加空值檢查的邏輯
            code.append(generateInvocationArgumentNullCheck(method));
            //生成獲取extName的邏輯，獲取用戶配置的擴(kuò)展的名稱
            code.append(generateExtNameAssignment(value, hasInvocation));
            //extName空值檢查代碼
            code.append(generateExtNameNullCheck(value));
            //通過extName在ExtensionLoader中獲取其對應(yīng)的基礎(chǔ)服務(wù)類
            code.append(generateExtensionAssignment());
            //生成實例的當(dāng)前方法的調(diào)用邏輯，然后將結(jié)果返回
            code.append(generateReturnAndInvocation(method));
        }
        return code.toString();
    }