Dubbo 源码阅读（一）getExtensionLoader 和 getExtension

Dubbo 拿实例可以用下面这两步：

//获取InfoService的 Loader 实例
ExtensionLoader<InfoService> extensionLoader = ExtensionLoader.getExtensionLoader(InfoService.class);
//获取a拓展类实例
InfoService infoServiceA = extensionLoader.getExtension("a");

getExtensionLoader

类 ExtensionLoader

														//接口类型
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 interface!");
    }
    if (!withExtensionAnnotation(type)) {
        throw new IllegalArgumentException("Extension type(" + type +
                ") is not extension, because WITHOUT @" + SPI.class.getSimpleName() + " Annotation!");
    }

	//从缓存里拿
    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

类 ExtensionLoader

public T getExtension(String name) {
	if (name == null || name.length() == 0)
	    throw new IllegalArgumentException("Extension name == null");
	if ("true".equals(name)) {
	    return getDefaultExtension();
	}
	//从缓存里拿实例（holder是对实例的包装）
	Holder<Object> holder = cachedInstances.get(name);
	if (holder == null) {
	    cachedInstances.putIfAbsent(name, new Holder<Object>());
	    holder = cachedInstances.get(name);
	}
	Object instance = holder.get();
	if (instance == null) {
	    synchronized (holder) {
	        instance = holder.get();
	        if (instance == null) {
	            instance = createExtension(name);
	            holder.set(instance);
	        }
	    }
	}
	return (T) instance;
}

跟 createExtension：

private T createExtension(String name) {
	//从缓存cachedClasses里拿，
	//没有就根据"META-INF/dubbo/" "META-INF/dubbo/internal/" "META-INF/services/" 
	//里面的文件创建Class对象并缓存
    Class<?> clazz = getExtensionClasses().get(name);
    if (clazz == null) {
        throw findException(name);
    }
    try {
        T instance = (T) EXTENSION_INSTANCES.get(clazz);
        if (instance == null) {
            EXTENSION_INSTANCES.putIfAbsent(clazz, clazz.newInstance());
            instance = (T) EXTENSION_INSTANCES.get(clazz);
        }
        injectExtension(instance);
        Set<Class<?>> wrapperClasses = cachedWrapperClasses;
        if (wrapperClasses != null && !wrapperClasses.isEmpty()) {
            for (Class<?> wrapperClass : wrapperClasses) {
            											//反射拿对象
                instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance));
            }
        }
        return instance;
    } catch (Throwable t) {
        throw new IllegalStateException("Extension instance(name: " + name + ", class: " +
                type + ")  could not be instantiated: " + t.getMessage(), t);
    }
}

跟 getExtensionClasses：

private Map<String, Class<?>> getExtensionClasses() {
    Map<String, Class<?>> classes = cachedClasses.get();
    if (classes == null) {
        synchronized (cachedClasses) {
            classes = cachedClasses.get();
            if (classes == null) {
            	//加载所有的Class
                classes = loadExtensionClasses();
                cachedClasses.set(classes);
            }
        }
    }
    return classes;
}

跟 loadExtensionClasses：

private Map<String, Class<?>> loadExtensionClasses() {
	//类上必须有@SPI注解
    final SPI defaultAnnotation = type.getAnnotation(SPI.class);
    if (defaultAnnotation != null) {
        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 = names[0];
        }
    }

    Map<String, Class<?>> extensionClasses = new HashMap<String, Class<?>>();
    //加载"META-INF/dubbo/internal/"文件夹下定义的类 
    loadDirectory(extensionClasses, DUBBO_INTERNAL_DIRECTORY);
    //加载"META-INF/dubbo/"文件夹下定义的类 
    loadDirectory(extensionClasses, DUBBO_DIRECTORY);
    //加载"META-INF/services/"文件夹下定义的类 
    loadDirectory(extensionClasses, SERVICES_DIRECTORY);
    return extensionClasses;
}

当然，是加载当前项目和所有依赖的 resources 文件夹下的。