dubbo源码学习总结

    private static final ConcurrentMap, ExtensionLoader> EXTENSION_LOADERS = new ConcurrentHashMap<>(64);

在上面看到在获取扩展点时都是先ExtensionLoader.getExtensionLoader(type)。来获取某一个接口的扩展loader。上面的map是它的一个缓存，保证只会加载一次

ExtensionLoader.getExtensionLoader(type)是一个静态方法如下

    public static  ExtensionLoader getExtensionLoader(Class 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() + "!");
        }

        ExtensionLoader loader = (ExtensionLoader) EXTENSION_LOADERS.get(type);
        if (loader == null) {
//如果缓存没有那么新建一个
            EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader(type));
            loader = (ExtensionLoader) EXTENSION_LOADERS.get(type);
        }
        return loader;
    }

ExtensionLoader 有一个私有的构造函数，因此他只有 自己可以创建

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

objectFactory 是一个ExtensionFactory 的实现类，它本身也是扩展点

@SPI
public interface ExtensionFactory {

    
     T getExtension(Class type, String name);

}

getAdaptiveExtension 表示获取一个自适应的扩展点，但是它有一个@Adaptive的扩展类

@Adaptive
public class AdaptiveExtensionFactory implements ExtensionFactory {

    private final List factories;

    public AdaptiveExtensionFactory() {
        ExtensionLoader loader = ExtensionLoader.getExtensionLoader(ExtensionFactory.class);
        List list = new ArrayList();
        for (String name : loader.getSupportedExtensions()) {
            list.add(loader.getExtension(name));
        }
        factories = Collections.unmodifiableList(list);
    }

    @Override
    public  T getExtension(Class type, String name) {
        for (ExtensionFactory factory : factories) {
            T extension = factory.getExtension(type, name);
            if (extension != null) {
                return extension;
            }
        }
        return null;
    }

}

上面提到过， 只能有一个实现类是被标示@Adaptive，标示后，它是一个所有扩展点的代理，而标示在方法上的话就是通过参数选择一个扩展点来执行那个被标示的方法，而表示在类上，就相当于是遍历所有的扩展点，看哪一个可以执行。可以这么理解，标示在方法上 框架会自动生成一个代理类。标示在类上，这个类就是这个代理类，框架就不会自动生成了。

获取一个loader后就可以根据这个loader去获取对应的扩展点了

普通的扩展点

上面提过获取普通扩展点通过ExtensionLoader.getExtensionLoader(type).getExtension(name)。现在看看getExtension

    @SuppressWarnings("unchecked")
    public T getExtension(String name) {
        return getExtension(name, true);
    }

    public T getExtension(String name, boolean wrap) {
        if (StringUtils.isEmpty(name)) {
            throw new IllegalArgumentException("Extension name == null");
        }
        if ("true".equals(name)) {
            return getDefaultExtension();
        }
        final Holder