Dubbo---SPI机制源码解析

JDK SPI 通过ServiceLoader加载jar中的META-INF/services/路径下的SPI实现配置文件

Dubbo SPI 通过自定义的ExtensionLoader加载jar中META-INF/dubbo/接口全限定名的SPI实现配置问文件，
配置内容为 配置名称 = 实现类的全限定类名

JDK SPI 一次性实例化扩展点所有的实现。
有可能加载应用没有用上的扩展实现类，造成资源的浪费。
扩展点加载失败时报不支持的类型，不知道具体加载失败的扩展点。

Dubbo SPI  可以指定 扩展点的配置名称加载。
提供了增强功能：
①扩展点自动装配(IOC)
②AOP的支持
③扩展点的自适应

缓存扩展类型的加载类(ExtensionLoader)实例
private static final ConcurrentMap<Class<?>, ExtensionLoader<?>> EXTENSION_LOADERS = new ConcurrentHashMap<>(64);

缓存加载过的扩展实现类实例
private static final ConcurrentMap<Class<?>, Object> EXTENSION_INSTANCES = new ConcurrentHashMap<>(64);

定义ExtensionLoader实例加载的扩展点(接口)类型
private final Class<?> type;

缓存扩展实例配置名和扩展实现类类名
private final Holder<Map<String, Class<?>>> cachedClasses = new Holder<>();

private final ConcurrentMap<String, Holder<Object>> cachedInstances = new ConcurrentHashMap<>();

定义扩展点实现IOC功能的工厂，Dubbo实现有的SpiExtensionFactory和SpringExtensionFactory，并且支持自适应适配
private final ExtensionFactory objectFactory;

私有化构造器，初始化时指定加载扩展的类型
private ExtensionLoader(Class<?> type) {
        this.type = type;
        objectFactory =(type == ExtensionFactory.class ? null : 
ExtensionLoader.getExtensionLoader(ExtensionFactory.class).getAdaptiveExtension());
 }

//获取扩展点的ExtensionLoader实例
public static <T> ExtensionLoader<T> getExtensionLoader(Class<T> type)

//获取指定配置名称的扩展实现类
public T getExtension(String name)

//没有从缓存中获取到，则创建一个实例
private T createExtension(String name)

//查询扩展点实现类的类型
private Map<Strring,Class<?> getExtensionClasses()

//如果没有从缓存中查询到对象的扩展点类型对象，则开始从配置目录加载
private Map<String, Class<?>> loadExtensionClasses()

//扫描文件路径下的SPI扩展配置文件
private void loadDirectory()

//读取配置文件实例化扩展点配置的CLass实例
private void loadResource()

//createExtension方法中初始化实例后调用InjectExtension方法通过setter方式注入依赖的属性
private T injectExtension(T instance)

//通过objectFactory进行依赖查找，进行反射调用注入
Object object = objectFactory.getExtension(pt, property);

private Set<Class<?>> cachedWrapperClasses;//缓存wrapper Class

try {  
  clazz.getConstructor(type);    
  Set<Class<?>> wrappers = cachedWrapperClasses;
  if (wrappers == null) {
    cachedWrapperClasses = new ConcurrentHashSet<Class<?>>();
    wrappers = cachedWrapperClasses;
  }
  wrappers.add(clazz);
} catch (NoSuchMethodException e) {}

//获取扩展点的自适应实例
public T getAdaptiveExtension()

Dubbo实现的Adaptive扩展点有ExtensionFactory 和AdaptiveCompiler，
其他的自适应实例都是通过拼接动态代码编译后生成的

//调用这个方法表明Dubbo的源码中没有实现当前扩展点的自适应实例，需要动态创建
private T createAdaptiveExtension()

//根据当前扩展点接口动态生成需要自适应的方法实现,包含拼接代码和编译过程
private Class<?> createAdaptiveExtensionClass()

//初始化时在构造器中加载Dubbo配置所支持的ExtensionFactory扩展实例
private final List<ExtensionFactory> factories;

//构造器中，初始化Dubbo支持的extensionFactory实例
public AdaptiveExtensionFactory(){
        ExtensionLoader<ExtensionFactory> loader = ExtensionLoader.getExtensionLoader(ExtensionFactory.class);
        List<ExtensionFactory> list = new ArrayList<>();
        //加载项目配置支持的ExtensionFactory类
        for (String extension : loader.getSupportedExtensions()) {
            ExtensionFactory factory = loader.getExtension(extension);
            list.add(factory);
        }
        factories = Collections.unmodifiableList(list);
    }

//实现ExtensionFactory接口的获取指定名称的实例，循环factories从具体的ObjectFactory实现中查找
public <T> T getExtension(Class<T> clazz, String name)

实现ExtensionLoader接口，使用Dubbo自定的ExtensionLoader加载指定name的扩展实现实例，
这里返回的实例是一个Adaptive的实例，为了实现扩展点的自适应功能

从Spring容器中加载指定name和Class对象的实例