4-Dubbo Extension 扩展机制源码解析.md

// 扩展访问器
this.extensionDirector = new ExtensionDirector(parent != null ? parent.getExtensionDirector() : null, scope, this);
// 使用扩展机制获取 TypeBuilder
Set<TypeBuilder> tbs = model.getExtensionLoader(TypeBuilder.class).getSupportedExtensionInstances();
// 获取域模型初始化器
ExtensionLoader<ScopeModelInitializer> initializerExtensionLoader = this.getExtensionLoader(ScopeModelInitializer.class);
Set<ScopeModelInitializer> initializers = initializerExtensionLoader.getSupportedExtensionInstances();

// 获取应用模型初始化器
ExtensionLoader<ApplicationInitListener> extensionLoader = this.getExtensionLoader(ApplicationInitListener.class);
Set<String> listenerNames = extensionLoader.getSupportedExtensions();
// 应用模型获取应用扩展器对象
Set<ApplicationExt> exts = this.getExtensionLoader(ApplicationExt.class).getSupportedExtensionInstances();

// 模块模型获取模块扩展器对象
Set<ModuleExt> exts = this.getExtensionLoader(ModuleExt.class).getSupportedExtensionInstances();
// OrderedPropertiesConfiguration 获取有序配置提供器对象
ExtensionLoader<OrderedPropertiesProvider> propertiesProviderExtensionLoader = moduleModel.getExtensionLoader(OrderedPropertiesProvider.class);

TypeDefinitionBuilder.initBuilders(this);

public static void initBuilders(FrameworkModel model) {
  Set<TypeBuilder> tbs = model.getExtensionLoader(TypeBuilder.class).getSupportedExtensionInstances();
  BUILDERS = new ArrayList<>(tbs);
}

model.getExtensionLoader(TypeBuilder.class)

default <T> ExtensionLoader<T> getExtensionLoader(Class<T> type) {
  return getExtensionDirector().getExtensionLoader(type);
}

this.extensionDirector = new ExtensionDirector(parent != null ? parent.getExtensionDirector() : null, scope, this);

@SPI(scope = ExtensionScope.FRAMEWORK)
public interface TypeBuilder extends Prioritized {

    /**
     * Whether the build accept the class passed in.
     */
    boolean accept(Class<?> clazz);

    /**
     * Build type definition with the type or class.
     */
    TypeDefinition build(Type type, Class<?> clazz, Map<String, TypeDefinition> typeCache);
}

public <T> ExtensionLoader<T> getExtensionLoader(Class<T> type) {
  // 若扩展加载器已经被销毁则抛出异常
  checkDestroyed();
  // eg.使用 TypeBuilder 对象创建扩展加载器对象
  if (type == null) {
    throw new IllegalArgumentException("Extension type == null");
  }
  // 扩展类型不为接口也要抛出异常，TypeBuilder 类型是一个接口
  if (!type.isInterface()) {
    throw new IllegalArgumentException("Extension type (" + type + ") is not an interface!");
  }
  // 若扩展加载器没有被标注为 SPI 则抛出异常
  if (!withExtensionAnnotation(type)) {
    throw new IllegalArgumentException("Extension type (" + type
                                       + ") is not an extension, because it is NOT annotated with @" + SPI.class.getSimpleName() + "!");
  }

  // 1. find in local cache
  // 被加载的扩展类型对应的扩展加载器会放到 extensionLoadersMap 集合中方便缓存
  ExtensionLoader<T> loader = (ExtensionLoader<T>) extensionLoadersMap.get(type);
  // 查询扩展所属域，这个类型的扩展域是框架级别的 ExtensionScope.FRAMEWORK
  ExtensionScope scope = extensionScopeMap.get(type);
  if (scope == null) {
    SPI annotation = type.getAnnotation(SPI.class);
    scope = annotation.scope();
    extensionScopeMap.put(type, scope);
  }
  // 首次访问的时候当前类型的扩展加载器类型肯定是空的，会走如下两个逻辑中的其中一个进行创建扩展加载器
  // 若扩展域为 SELF 自给自足，为每个作用域创建一个实例，用于特殊 SPI 扩展，如{@link ExtensionInjector}
  if (loader == null && scope == ExtensionScope.SELF) {
    // create an instance in self scope
    loader = createExtensionLoader0(type);
  }

  // 2. find in parent
  // 从父扩展加载器中查询当前扩展加载器是否存在
  // TypeBuilder 作为 FRAMEWORK 框架域 -> parent 是空的先不考虑
  if (loader == null) {
    if (this.parent != null) {
      loader = this.parent.getExtensionLoader(type);
    }
  }

  // 3. create it
  // 这个是我们本次会走的逻辑，大部分是会走这个逻辑来创建扩展加载器对象的
  if (loader == null) {
    loader = createExtensionLoader(type);
  }

  return loader;
}

private static boolean withExtensionAnnotation(Class<?> type) {
  return type.isAnnotationPresent(SPI.class);
}

private <T> ExtensionLoader<T> createExtensionLoader(Class<T> type) {
  ExtensionLoader<T> loader = null;
  // 匹配当前域是否匹配
  if (isScopeMatched(type)) {
    // if scope is matched, just create it
    loader = createExtensionLoader0(type);
  }
  return loader;
}

private <T> ExtensionLoader<T> createExtensionLoader0(Class<T> type) {
  // 检查当前扩展访问器是否被销毁
  checkDestroyed();
  ExtensionLoader<T> loader;
  // 为当前扩展类型创建一个扩展访问器并缓存到当前成员变量 extensionLoadersMap 中
  extensionLoadersMap.putIfAbsent(type, new ExtensionLoader<T>(type, this, scopeModel));
  loader = (ExtensionLoader<T>) extensionLoadersMap.get(type);
  return loader;
}

ExtensionLoader(Class<?> type, ExtensionDirector extensionDirector, ScopeModel scopeModel) {
  // 当前要加载的扩展类型
  this.type = type;
  // 创建扩展加载器的扩展访问器对象
  this.extensionDirector = extensionDirector;
  // 从扩展访问器中获取扩展执行前后的回调器
  this.extensionPostProcessors = extensionDirector.getExtensionPostProcessors();
  // 创建实例化策略对象
  initInstantiationStrategy();
  // 若当前扩展类型为扩展注入器类型则设置当前注入器变量为空,否则的话获取一个扩展注入器扩展对象
  this.injector = (type == ExtensionInjector.class ? null : extensionDirector.getExtensionLoader(ExtensionInjector.class).getAdaptiveExtension());
  // 创建 Activate 注解的排序器
  this.activateComparator = new ActivateComparator(extensionDirector);
  this.scopeModel = scopeModel;
}

private void initInstantiationStrategy() {
  // 初始化 ScopeModel 域模型对象时为扩展访问器添加了这个域模型扩展处理器对象 ScopeModelAwareExtensionProcessor
  // 这个类型实现了 ScopeModelAccessor 域模型访问器，可以用来获取域模型对象
  instantiationStrategy = extensionPostProcessors.stream()
    .filter(extensionPostProcessor -> extensionPostProcessor instanceof ScopeModelAccessor)
    .map(extensionPostProcessor -> new InstantiationStrategy((ScopeModelAccessor) extensionPostProcessor))
    .findFirst()
    .orElse(new InstantiationStrategy());
}

/*
 * 1) 扩展类型肯定不是 ExtensionInjector 类型，这里必定会为每个非扩展注入 ExtensionInjector 类型创建一个 ExtensionInjector 类型的扩展对象
 * 2) 代码会走 extensionDirector.getExtensionLoader(ExtensionInjector.class) 这一步进去之后的代码在 4.5.2 介绍过了
 *    此处会创建一个扩展加载器 ExtensionLoader 用于创建 ExtensionInjector 类型
 * 3) getAdaptiveExtension() 这个方法就是通过扩展加载器获取具体的扩展对象的方法
 */
this.injector = (type == ExtensionInjector.class ? null : extensionDirector.getExtensionLoader(ExtensionInjector.class).getAdaptiveExtension());