ExtensionLoader<ABC> LOADER = ExtensionLoader.getExtensionLoader(ABC.class);
// 用法1：通过@SPI注解获取默认的实现（有可能为空）
ABC defaultImpl = LOADER.getDefaultExtension();

// 用法2: spi其他的实现（可根据配置文件中的key精准获取）
ABC instance = LOADER.getExtension("key");

// 用法3：获取自适应实现。（这个一般开发人员用不到）
ABC adaptiveExtension = LOADER.getAdaptiveExtension();

// 用法4：根据@Activate注解的配置，获取有效的spi实例
// 比如注解@Active(value={"key1:value1", "key2:value2"}, group="consumer")
List<T> activeExtension = LOADER.getActivateExtension(URL url, String[] values); //  从spi实现中找对应的名称（参数values为spi实现类中的名称）
activeExtension = LOADER.getActivateExtension(URL url, String[] values, String group); // 和上面一样，多了个参数group(只保留和注解@activate中group一样的)
activeExtension = LOADER.getActivateExtension(URL url, String key, String group); // 结合上面两个，都是根据名称查找实现类。只不过名称是以参数key从url中取

List<T> getActivateExtension(URL url, String[] values);  //  从spi实现中找对应的名称（参数values为spi实现类中的名称）
List<T> getActivateExtension(URL url, String[] values, String group); // 和上面一样，多了个参数group(只保留和注解@activate中group一样的)
List<T> getActivateExtension(URL url, String key, String group); // 结合上面两个，都是根据名称查找实现类。只不过名称是以参数key从url中取

public @interface Activate {
    String[] group() default {};// 分组

    String[] value() default {};// {"key1:value1", "key2:value2"} 从url中匹配对应的，如果只有key没有value，那么url的参数中只要有key即可
    ...
    int order() default 0; // 值越小越靠前
}

public interface LoadingStrategy extends Prioritized {
    String directory();
}

public class ExtensionLoader<T> {
  ...
  // 加载路径，如上图的通过javaSPI寻找默认的实现
  private static volatile LoadingStrategy[] strategies = stream(ServiceLoader.load(LoadingStrategy.class).spliterator(), false)
          .sorted()
          .toArray(LoadingStrategy[]::new);

  // 解析spi所有的配置文件
  private Map<String, Class<?>> getExtensionClasses() {
    cacheDefaultExtensionName();// 根据@SPI注解获取到默认的实现名称，可以为空

    Map<String, Class<?>> extensionClasses = new HashMap<>();

    // 加载路径，如上图的默认实现
    for (LoadingStrategy strategy : strategies) {
      // 例如：ExtensionLoader.getExtensionLoader(ABC.class)
      // type为当前的SPI接口,即ABC.class
      loadDirectory(extensionClasses, strategy.directory(), type.getName(), strategy.preferExtensionClassLoader(), strategy.overridden(), strategy.excludedPackages());
      // alibaba变为apache，兼容之前老的实现
      loadDirectory(extensionClasses, strategy.directory(), type.getName().replace("org.apache", "com.alibaba"), strategy.preferExtensionClassLoader(), strategy.overridden(), strategy.excludedPackages());
      // loadDirectory 通过解析配置文件里面的内容，最终会调用loadClass，
    }
    return extensionClasses;
  }

  // 配置文件中的value字符转为class，并分类管理
  private void loadClass(Map<String, Class<?>> extensionClasses, java.net.URL resourceURL, Class<?> clazz, String name, boolean overridden) {
    ... 
    if (clazz.isAnnotationPresent(Adaptive.class)) {
      cacheAdaptiveClass(clazz, overridden);// 缓存自适应的实现，如果有多个overridden用来控制是否可覆盖，不能覆盖则直接报错
    }
    else if (isWrapperClass(clazz)) { // 如过有一个有参构造，参数类型是spi的接口，那么就是wrapper
      cacheWrapperClass(clazz); // 缓存包装类，可以有多个。
    } else {
      String[] names = Pattern.compile("\\s*[,]+\\s*").split(name);
      cacheActivateClass(clazz, names[0]);// 进行分类如果有@Activate注解的话
      for (String n : names) {
        cacheName(clazz, n); // 缓存class与对应的名称,不能覆盖。
        saveInExtensionClass(extensionClasses, clazz, n, overridden);// 保存到 extensionClasses 中，如果name已经存在，overridden用来控制是否可覆盖，否则抛异常
      }
    }
  }
  
  // 根据name获取实例（初始化）
  private T createExtension(String name, boolean wrap) {
    Class<?> clazz = getExtensionClasses().get(name);
    ...
    // 实例化，忽略缓存的逻辑，只会初始化，一次
    T instance = clazz.newInstance();
    injectExtension(instance); // 注入操作，对当前实体中如果有set方法，且没有DisableInject注解，那么以此方法的第一个参数的类型+名称，再次从dubboSPI容器中寻找对应的实例。并set

    // 如果wrap为true
    if (wrap) {

      List<Class<?>> wrapperClassesList = new ArrayList<>();
      wrapperClassesList.addAll(cachedWrapperClasses);
      wrapperClassesList.sort(WrapperComparator.COMPARATOR);
      Collections.reverse(wrapperClassesList);

      if (CollectionUtils.isNotEmpty(wrapperClassesList)) {
        for (Class<?> wrapperClass : wrapperClassesList) {
          Wrapper wrapper = wrapperClass.getAnnotation(Wrapper.class);
          // 如果有@Wrapper注解，则根据注解判断是否符合要求
          if (wrapper == null || (ArrayUtils.contains(wrapper.matches(), name) && !ArrayUtils.contains(wrapper.mismatches(), name))) {
            // 进行包装
            instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance));
          }
        }
      }
    }
    ...
    initExtension(instance); // 如果实现了Lifecycle接口，则调用其生命周期的方法
    return instance;
  }
}