Dubbo拓展点加载机制源码分析

Dubbo拓展类的特性

(1)自动包装：ExtensionLoader在加载拓展时，如果发现这个拓展类包含其他拓展点作为构造函数的参数，这个拓展类就会被认为是Wrapper类。

这是一种装饰器模式，把通用的抽象逻辑进行封装或对子类进行增强，让子类可以更加专注具体的实现。

(2)自动加载：如果某个拓展类是另一个拓展点类的成员属性，并且拥有setter方法，那么框架也会自动注入对应的拓展点实例。

(3)自适应：使用@Adaptive注解可以动态通过URL中的参数来确定要使用哪个具体的实现类，从而解决自动加载中的实例注入问题。

(4)自动激活：使用@Activate注解，可以标记对应的拓展点默认被激活启用。该注解可以通过传入不同的参数，设置拓展点在不同的条件下被自动激活。主要使用场景是某个拓展点的多个实现类需要同时启用。

ExtensionFactory

ExtensionFactory有三个子类实现，包括：AdaptiveExtensionFactory、SpiExtensionFactory和SpringExtensionFactory。其中AdaptiveExtensionFactory优先级最高，因为AdaptiveExtensionFactory类上面带有@Adaptive注解。

AdaptiveExtensionFactory 的构造方法会先构造一个ExtensionFactory的拓展加载器，然后从资源文件获取SpiExtensionFactory和SpringExtensionFactory放入factories中。AdaptiveExtensionFactory#getExtension就是调用SpiExtensionFactory#getExtension和SpringExtensionFactory#getExtension获取拓展类。SpringExtensionFactory先根据名称从IOC容器中获取拓展类，获取不到，再根据类型从IOC容器获取。SpiExtensionFactory针对带有@SPI注解的接口，返回Adapative拓展实现类(如果不存在带有@Adaptive的实现类，就由Dubbo通过javassist自动生成)。

@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()) {
   
            list.add(loader.getExtension(name));
        }
        factories = Collections.unmodifiableList(list);
    }

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

}

ExtensionLoader

ExtensionLoader#getExtensionLoader先从集合中获取指定Class类型的拓展加载器，如果获取不到就创建一个，并放入集合中。

//拓展加载器集合
private static final ConcurrentMap<Class<?>, ExtensionLoader<?>> EXTENSION_LOADERS = new ConcurrentHashMap<>();

public static <T> ExtensionLoader<T> getExtensionLoader(Class<T> type) {
   
    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;
}

ExtensionLoader的构造方法会去判断传入的Class类型是否是ExtensionFactory，如果不是就会获取ExtensionFactory的Adaptive自适应拓展类。

//对象工厂
private final ExtensionFactory objectFactory;

//实例化一个ExtensionLoader的时候会去创建一个对象工厂
private ExtensionLoader(Class<?> type) {
   
    this.type = type;
    objectFactory = (type == ExtensionFactory.class ? null : ExtensionLoader.getExtensionLoader(ExtensionFactory.class).getAdaptiveExtension());
}

ExtensionLoader#getAdaptiveExtension用于获取自适应的拓展类。会先从一个Holder对象中获取实例，如果获取不到，对Holder对象进行同步，再次判断实例是否为空，如果为空，调用ExtensionLoader#createAdaptiveExtension进行创建。

private final Holder<Object> cachedAdaptiveInstance = new Holder<>();

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;
}

通过Class.newInstance方法实例化一个对象，并通过ExtensionLoader#injectExtension替实例对象的属性赋值(依赖注入)。

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);
    }
}

先调用ExtensionLoader#getExtensionClasses获取一个带有@Adaptive注解的拓展类。如果获取不到，再调用ExtensionLoader#createAdaptiveExtensionClass生成一个。

private Class<?> getAdaptiveExtensionClass() {
   
    getExtensionClasses();
    if (cachedAdaptiveClass != null) {
   
        return cachedAdaptiveClass;
    }
    return cachedAdaptiveClass = createAdaptiveExtensionClass();