3-Framework、Application、Module 域模型的初始化工作

private static void startWithBootstrap() {
  // 前面的文章都在说明这个服务配置对象的创建
  ServiceConfig<DemoServiceImpl> service = new ServiceConfig<>();
  service.setInterface(DemoService.class);
  service.setRef(new DemoServiceImpl());

  DubboBootstrap bootstrap = DubboBootstrap.getInstance();
  bootstrap
    .application(new ApplicationConfig("dubbo-demo-api-provider"))
    .registry(new RegistryConfig(REGISTRY_URL))
    .protocol(new ProtocolConfig(CommonConstants.DUBBO, -1))
    .service(service)
    .start()
    .await();
}

DubboBootstrap bootstrap = DubboBootstrap.getInstance();

/**
 * See {@link ApplicationModel} and {@link ExtensionLoader} for why DubboBootstrap is designed to be singleton.
 */
public static DubboBootstrap getInstance() {
  // 双重检查锁第一次判断空
  if (instance == null) {
    // 为空都进行排队等待
    synchronized (DubboBootstrap.class) {
      // 双重检查锁第二次判断空
      if (instance == null) {
        // 调用重载方法获取对象
        instance = DubboBootstrap.getInstance(ApplicationModel.defaultModel());
      }
    }
  }
  return instance;
}

public static DubboBootstrap getInstance(ApplicationModel applicationModel) {
    return ConcurrentHashMapUtils.computeIfAbsent(
          instanceMap, applicationModel, _k -> new DubboBootstrap(applicationModel));
}

ApplicationModel.defaultModel()

public static ApplicationModel defaultModel() {
  // should get from default FrameworkModel, avoid out of sync
  return FrameworkModel.defaultModel().defaultApplication();
}

/**
 * 在源码的注释上有这么一句话：在销毁默认的 FrameworkModel 时
 * FrameworkModel.defaultModel() 或 ApplicationModel.defaultModel() 将返回一个损坏的模型，可能会导致不可预知的问题
 * 建议：尽量避免使用默认模型
 * @return the global default FrameworkModel
 */
public static FrameworkModel defaultModel() {
  // 双重校验锁的形式创建单例对象
  FrameworkModel instance = defaultInstance;
  if (instance == null) {
    synchronized (globalLock) {
      // 重置默认框架模型
      resetDefaultFrameworkModel();
      if (defaultInstance == null) {
        defaultInstance = new FrameworkModel();
      }
      instance = defaultInstance;
    }
  }
  Assert.notNull(instance, "Default FrameworkModel is null");
  return instance;
}

private static void resetDefaultFrameworkModel() {
  // 全局悲观锁，同一个时刻只能有一个线程执行重置操作
  synchronized (globalLock) {
    // defaultInstance：当前成员变量 FrameworkModel 类型代表当前默认的 FrameworkModel 类型的实例对象
    if (defaultInstance != null && !defaultInstance.isDestroyed()) {
      return;
    }
    FrameworkModel oldDefaultFrameworkModel = defaultInstance;
    // 存在实例模型列表则直接从内存缓存中查后续不需要创建了
    if (allInstances.size() > 0) {
      // 当前 FrameworkModel 框架实例存在多个，则取第一个作为默认的
      defaultInstance = allInstances.get(0);
    } else {
      defaultInstance = null;
    }
    if (oldDefaultFrameworkModel != defaultInstance) {
      if (LOGGER.isInfoEnabled()) {
        LOGGER.info("Reset global default framework from " + safeGetModelDesc(oldDefaultFrameworkModel)
                    + " to " + safeGetModelDesc(defaultInstance));
      }
    }
  }
}

public FrameworkModel() {
  // 调用父类型 ScopeModel 传递参数
  // 第一个为空代表这是一个顶层的域模型
  // 第二个 FRAMEWORK 表示是框架域 
  // 第三个 false 表示不是内部域
  super(null, ExtensionScope.FRAMEWORK, false);
  synchronized (globalLock) {
    synchronized (instLock) {
      // 内部id用于表示模型树的层次结构，如层次结构:
      // FrameworkModel（索引=1）-> ApplicationModel（索引=2）-> ModuleModel（索引=1，第一个用户模块）
      // 这个 index 变量是 static 类型的为静态全局变量默认值从1开始，如果有多个框架模型对象则 internalId 编号从 1 开始依次递增
      this.setInternalId(String.valueOf(index.getAndIncrement()));
      // register FrameworkModel instance early
      // 将当前新创建的框架实例对象添加到容器中
      allInstances.add(this);
      if (LOGGER.isInfoEnabled()) {
        LOGGER.info(getDesc() + " is created");
      }
      // 初始化框架模型领域对象 -> 调用父类 ScopeModel#initialize 方法
      initialize();
      // 使用 TypeDefinitionBuilder 静态方法 initBuilders 来初始化类型构建器 TypeBuilder 类型集合
      TypeDefinitionBuilder.initBuilders(this);
      // 框架服务存储仓库对象，可以用于快速查询服务提供者信息
      serviceRepository = new FrameworkServiceRepository(this);
      // 获取 ScopeModelInitializer 类型(域模型初始化器)的扩展加载器 ExtensionLoader，每个扩展类型都会创建一个扩展加载器缓存起来
      ExtensionLoader<ScopeModelInitializer> initializerExtensionLoader = this.getExtensionLoader(ScopeModelInitializer.class);
      // 获取 ScopeModelInitializer 类型的支持的扩展集合，当前版本存在 13 个扩展类型实现
      Set<ScopeModelInitializer> initializers = initializerExtensionLoader.getSupportedExtensionInstances();
      // 遍历这些扩展实现调用他们的 initializeFrameworkModel 方法来传递 FrameworkModel 类型对象，细节我们待会再详细说下
      for (ScopeModelInitializer initializer : initializers) {
        initializer.initializeFrameworkModel(this);
      }
      // 创建一个内部的ApplicationModel类型，细节下面说
      internalApplicationModel = new ApplicationModel(this, true);
      // 创建 ApplicationConfig 类型对象同时传递应用程序模型对象internalApplicationModel
      // 获取 ConfigManager 类型对象，然后设置添加当前应用配置对象
      internalApplicationModel
        .getApplicationConfigManager()
        .setApplication(new ApplicationConfig(
          internalApplicationModel, CommonConstants.DUBBO_INTERNAL_APPLICATION));
      // 设置公开的模块名字为常量 DUBBO_INTERNAL_APPLICATION
      internalApplicationModel.setModelName(CommonConstants.DUBBO_INTERNAL_APPLICATION);
    }
  }
}

protected void initialize() {
  synchronized (instLock) {
    // 初始化 ExtensionDirector 是一个作用域扩展加载程序管理器
    // ExtensionDirector 支持多个级别，子级可以继承父级的扩展实例
    // 查找和创建扩展实例的方法类似于 Java classloader
    this.extensionDirector = new ExtensionDirector(parent != null ? parent.getExtensionDirector() : null, scope, this);
    // 这个参考了 Spring 生命周期回调思想，添加一个扩展初始化的前后调用的处理器
    // 在扩展初始化之前或之后调用的后处理器，参数类型为 ExtensionPostProcessor
    this.extensionDirector.addExtensionPostProcessor(new ScopeModelAwareExtensionProcessor(this));
    // 创建一个内部共享的域工厂对象，用于注册Bean、创建Bean、获取Bean、初始化Bean等
    this.beanFactory = new ScopeBeanFactory(parent != null ? parent.getBeanFactory() : null, extensionDirector);
    // Add Framework's ClassLoader by default
    // 将当前类的加载器存入加载器集合 classLoaders 中
    ClassLoader dubboClassLoader = ScopeModel.class.getClassLoader();
    if (dubboClassLoader != null) {
      this.addClassLoader(dubboClassLoader);
    }
  }
}

public static void initBuilders(FrameworkModel model) {
  // 通过域模型 ScopeModel 初始化方法内部创建的 ExtensionDirector，获取所有 TypeBuilder
  Set<TypeBuilder> tbs = model.getExtensionLoader(TypeBuilder.class).getSupportedExtensionInstances();
  BUILDERS = new ArrayList<>(tbs);
}

public FrameworkServiceRepository(FrameworkModel frameworkModel) {
  this.frameworkModel = frameworkModel;
}

// 获取 ScopeModelInitializer 类型(域模型初始化器)的扩展加载器 ExtensionLoader，每个扩展类型都会创建一个扩展加载器缓存起来
ExtensionLoader<ScopeModelInitializer> initializerExtensionLoader = this.getExtensionLoader(ScopeModelInitializer.class);
// 获取 ScopeModelInitializer 类型的支持的扩展集合，这里当前版本存在 13 个扩展类型实现
Set<ScopeModelInitializer> initializers = initializerExtensionLoader.getSupportedExtensionInstances();
// 采用责任链模式调用 initializeFrameworkModel 方法来传递 FrameworkModel 类型对象，细节我们待会再详细说下
for (ScopeModelInitializer initializer : initializers) {
  initializer.initializeFrameworkModel(this);
}

AdaptiveScopeModelInitializer
ClusterScopeModelInitializer
MergeableClusterScopeModelInitializer
CommonScopeModelInitializer
ConfigScopeModelInitializer
MetadataScopeModelInitializer
MetricsScopeModelInitializer
RegistryScopeModelInitializer
Fastjson2ScopeModelInitializer
Hessian2ScopeModelInitializer
MeshScopeModelInitializer
RpcScopeModelInitializer
SerializationScopeModelInitializer

public class ClusterScopeModelInitializer implements ScopeModelInitializer {
  // 往框架域模型注入 Bean RouterSnapshotSwitcher
  @Override
  public void initializeFrameworkModel(FrameworkModel frameworkModel) {
    ScopeBeanFactory beanFactory = frameworkModel.getBeanFactory();
    beanFactory.registerBean(RouterSnapshotSwitcher.class);
  }
  // 往应用域模型注入 Bean ClusterUtils
  @Override
  public void initializeApplicationModel(ApplicationModel applicationModel) {
    ScopeBeanFactory beanFactory = applicationModel.getBeanFactory();
    beanFactory.registerBean(ClusterUtils.class);
  }
  @Override
  public void initializeModuleModel(ModuleModel moduleModel) {}
}

public class CommonScopeModelInitializer implements ScopeModelInitializer {
  	// 往框架域模型注入 Bean 
  	// FrameworkExecutorRepository、ConverterUtil、SerializeSecurityManager
  	// DefaultSerializeClassChecker、CertManager、ClassHolder
    @Override
    public void initializeFrameworkModel(FrameworkModel frameworkModel) {
        ScopeBeanFactory beanFactory = frameworkModel.getBeanFactory();
        beanFactory.registerBean(FrameworkExecutorRepository.class);
        beanFactory.registerBean(ConverterUtil.class);
        beanFactory.registerBean(SerializeSecurityManager.class);
        beanFactory.registerBean(DefaultSerializeClassChecker.class);
        beanFactory.registerBean(CertManager.class);
        beanFactory.registerBean(ClassHolder.class);
    }
		// 往应用域模型注入 Bean 
  	// ShutdownHookCallbacks、FrameworkStatusReportService、ConfigurationCache
    @Override
    public void initializeApplicationModel(ApplicationModel applicationModel) {
        ScopeBeanFactory beanFactory = applicationModel.getBeanFactory();
        beanFactory.registerBean(ShutdownHookCallbacks.class);
        beanFactory.registerBean(FrameworkStatusReportService.class);
        beanFactory.registerBean(new ConfigurationCache());
    }
  	// 往模块域模型注入 Bean 
  	// ConfigurationCache、SerializeSecurityConfigurator
    @Override
    public void initializeModuleModel(ModuleModel moduleModel) {
        ScopeBeanFactory beanFactory = moduleModel.getBeanFactory();
        beanFactory.registerBean(new ConfigurationCache());
        beanFactory.registerBean(SerializeSecurityConfigurator.class);
    }
}

public class ConfigScopeModelInitializer implements ScopeModelInitializer {
  	// 往框架域添加销毁监听器：FrameworkModelCleaner
    @Override
    public void initializeFrameworkModel(FrameworkModel frameworkModel) {
        frameworkModel.addDestroyListener(new FrameworkModelCleaner());
    }
  	// 往应用域注入 DefaultConfigValidator 校验器
  	// 注入应用发布者并提前设置好应用域模型的 deployer 属性
    @Override
    public void initializeApplicationModel(ApplicationModel applicationModel) {
        ScopeBeanFactory beanFactory = applicationModel.getBeanFactory();
        beanFactory.registerBean(DefaultConfigValidator.class);
        // applicationDeployer
        ApplicationDeployer applicationDeployer = beanFactory.registerBean(DefaultApplicationDeployer.class);
        applicationModel.setDeployer(applicationDeployer);
    }
  	// 往模块域模型注入模块发布者并提前设置好模块域模型的 deployer 属性 
    @Override
    public void initializeModuleModel(ModuleModel moduleModel) {
        ScopeBeanFactory beanFactory = moduleModel.getBeanFactory();
        // moduleDeployer
        ModuleDeployer moduleDeployer = beanFactory.registerBean(DefaultModuleDeployer.class);
        moduleModel.setDeployer(moduleDeployer);
    }
}

// 创建一个内部的 ApplicationModel 类型，细节下面说
internalApplicationModel = new ApplicationModel(this, true);
// 创建 ApplicationConfig 类型对象同时传递应用程序模型对象 internalApplicationModel
// 获取 ConfigManager 类型对象，然后设置添加当前应用配置对象
internalApplicationModel
        .getApplicationConfigManager()
        .setApplication(new ApplicationConfig(
                internalApplicationModel, CommonConstants.DUBBO_INTERNAL_APPLICATION));
// 设置公开的模块名字为常量 DUBBO_INTERNAL_APPLICATION
internalApplicationModel.setModelName(CommonConstants.DUBBO_INTERNAL_APPLICATION);

internalApplicationModel = new ApplicationModel(this, true);
internalApplicationModel
  .getApplicationConfigManager()
  .setApplication(new ApplicationConfig(
    internalApplicationModel, CommonConstants.DUBBO_INTERNAL_APPLICATION));

public ApplicationModel defaultApplication() {
  ApplicationModel appModel = this.defaultAppModel;
  if (appModel == null) {
    // check destroyed before acquire inst lock, avoid blocking during destroying
    checkDestroyed();
    resetDefaultAppModel();
    if ((appModel = this.defaultAppModel) == null) {
      synchronized (instLock) {
        if (this.defaultAppModel == null) {
          this.defaultAppModel = newApplication();
        }
        appModel = this.defaultAppModel;
      }
    }
  }
  Assert.notNull(appModel, "Default ApplicationModel is null");
  return appModel;
}

public ApplicationModel newApplication() {
  synchronized (instLock) {
    return new ApplicationModel(this);
  }
}

protected ApplicationModel(FrameworkModel frameworkModel) {
  this(frameworkModel, false);
}

protected ApplicationModel(FrameworkModel frameworkModel, boolean isInternal) {
  // 调用父类型ScopeModel传递参数，这个构造器的传递没与前面看到的FrameworkModel构造器的中的调用参数有些不同
  // 第一个参数我们为frameworkModel代表父域模型，第二个参数标记域为应用程序级别 APPLICATION，第三个参数我们传递的为true代表为内部域
  super(frameworkModel, ExtensionScope.APPLICATION, isInternal);
  synchronized (instLock) {
    Assert.notNull(frameworkModel, "FrameworkModel can not be null");
    // 应用程序域成员变量记录 frameworkModel 对象
    this.frameworkModel = frameworkModel;
    // frameworkModel 对象添加当前应用程序域对象
    frameworkModel.addApplication(this);
    if (LOGGER.isInfoEnabled()) {
      LOGGER.info(getDesc() + " is created");
    }
    // 初始化应用程序
    initialize();
    // 创建一个内部的模块模型对象
    this.internalModule = new ModuleModel(this, true);
    // 创建一个独立服务存储对象
    this.serviceRepository = new ServiceRepository(this);
    // 获取应用程序初始化监听器 ApplicationInitListener 扩展
    ExtensionLoader<ApplicationInitListener> extensionLoader = this.getExtensionLoader(ApplicationInitListener.class);
    // 如果存在应用程序初始化监听器扩展则执行这个初始化方法，在当前的版本还未看到有具体的扩展实现类型
    Set<String> listenerNames = extensionLoader.getSupportedExtensions();
    for (String listenerName : listenerNames) {
      extensionLoader.getExtension(listenerName).init();
    }
    // 初始化扩展(这个是应用程序生命周期的方法调用，这里调用初始化方法
    initApplicationExts();
    // 获取域模型初始化器扩展对象列表，然后执行初始化方法
    ExtensionLoader<ScopeModelInitializer> initializerExtensionLoader = this.getExtensionLoader(ScopeModelInitializer.class);
    Set<ScopeModelInitializer> initializers = initializerExtensionLoader.getSupportedExtensionInstances();
    for (ScopeModelInitializer initializer : initializers) {
      initializer.initializeApplicationModel(this);
    }

    Assert.notNull(getApplicationServiceRepository(), "ApplicationServiceRepository can not be null");
    Assert.notNull(getApplicationConfigManager(), "ApplicationConfigManager can not be null");
    Assert.assertTrue(
      getApplicationConfigManager().isInitialized(), "ApplicationConfigManager can not be initialized");
  }
}

void addApplication(ApplicationModel applicationModel) {
  // 检查 FrameworkModel 对象是否已经被标记为销毁状态，如果已经被销毁了则抛出异常无需执行逻辑
  checkDestroyed();
  synchronized (instLock) {
    // 如果还未添加过当前参数传递应用模型
    if (!this.applicationModels.contains(applicationModel)) {
      // 为当前应用模型生成内部id
      applicationModel.setInternalId(buildInternalId(getInternalId(), appIndex.getAndIncrement()));
      this.applicationModels.add(applicationModel);
      if (!applicationModel.isInternal()) {
        this.pubApplicationModels.add(applicationModel);
      }
    }
  }
}

protected String buildInternalId(String parentInternalId, long childIndex) {
  // FrameworkModel    1
  // ApplicationModel  1.1
  // ModuleModel       1.1.1
  if (StringUtils.hasText(parentInternalId)) {
    return parentInternalId + "." + childIndex;
  } else {
    return "" + childIndex;
  }
}

// 初始化应用程序
initialize();

// 创建一个内部的模块模型对象
this.internalModule = new ModuleModel(this, true);

// 创建一个独立服务存储对象
this.serviceRepository = new ServiceRepository(this);

private void initApplicationExts() {
  // 这个扩展实现一共有两个可以看下面那个图扩展类型为 ConfigManager、Environment
  Set<ApplicationExt> exts = this.getExtensionLoader(ApplicationExt.class).getSupportedExtensionInstances();
  for (ApplicationExt ext : exts) {
    ext.initialize();
  }
}

public void initialize() throws IllegalStateException {
  // 乐观锁判断是否初始化过
  if (!initialized.compareAndSet(false, true)) {
    return;
  }
  // 从模块环境中获取组合配置，目前 Environment 中有 6 种重要的配置，我们后面详细说
  CompositeConfiguration configuration = scopeModel.modelEnvironment().getConfiguration();

  // dubbo.config.mode
  // 获取配置模式，配置模式对应枚举类型 ConfigMode，目前有这么几个 STRICT，OVERRIDE，OVERRIDE_ALL，OVERRIDE_IF_ABSENT，IGNORE，这个配置决定了属性覆盖的顺序
  // 当有同一个配置 key 多次出现时，以最新配置为准，还是以最老的那个配置为准，还是配置重复则抛出异常
  // 默认值为严格模式STRICT重复则抛出异常
  String configModeStr = (String) configuration.getProperty(ConfigKeys.DUBBO_CONFIG_MODE);
  try {
    if (StringUtils.hasText(configModeStr)) {
      this.configMode = ConfigMode.valueOf(configModeStr.toUpperCase());
    }
  } catch (Exception e) {
    String msg = "Illegal '" + ConfigKeys.DUBBO_CONFIG_MODE + "' config value [" + configModeStr
      + "], available values " + Arrays.toString(ConfigMode.values());
    logger.error(COMMON_PROPERTY_TYPE_MISMATCH, "", "", msg, e);
    throw new IllegalArgumentException(msg, e);
  }

  // dubbo.config.ignore-duplicated-interface
  // 忽略重复的接口（服务/引用）配置。默认值为false
  String ignoreDuplicatedInterfaceStr = (String) configuration.getProperty(ConfigKeys.DUBBO_CONFIG_IGNORE_DUPLICATED_INTERFACE);
  if (ignoreDuplicatedInterfaceStr != null) {
    this.ignoreDuplicatedInterface = Boolean.parseBoolean(ignoreDuplicatedInterfaceStr);
  }

  // print 打印配置信息
  Map<String, Object> map = new LinkedHashMap<>();
  map.put(ConfigKeys.DUBBO_CONFIG_MODE, configMode);
  map.put(ConfigKeys.DUBBO_CONFIG_IGNORE_DUPLICATED_INTERFACE, this.ignoreDuplicatedInterface);
  logger.info("Config settings: " + map);
}

public void initialize() throws IllegalStateException {
  // 乐观锁判断是否进行过初始化
  if (initialized.compareAndSet(false, true)) {
    // PropertiesConfiguration: 从系统属性和 dubbo.properties 中获取配置
    this.propertiesConfiguration = new PropertiesConfiguration(scopeModel);
    // SystemConfiguration: 获取的是 JVM 参数 启动命令中 -D 指定的
    this.systemConfiguration = new SystemConfiguration();
    // EnvironmentConfiguration: 从环境变量中获取的配置
    this.environmentConfiguration = new EnvironmentConfiguration();
    // 外部的 Global 配置 config-center global/default config
    this.externalConfiguration = new InmemoryConfiguration("ExternalConfig");
    // 外部的应用配置如:config-center 中的应用配置
    this.appExternalConfiguration = new InmemoryConfiguration("AppExternalConfig");
    // 本地应用配置,如:Spring Environment/PropertySources/application.properties
    this.appConfiguration = new InmemoryConfiguration("AppConfig");
    // 服务迁移配置加载，dubbo2 升级 dubbo3 的一些配置
    loadMigrationRule();
  }
}

/**
 * 服务迁移配置加载 JVM  > env >  代码路径 dubbo-migration.yaml
 */
@Deprecated
private void loadMigrationRule() {
  if (Boolean.parseBoolean(SystemPropertyConfigUtils.getSystemProperty(
    CommonConstants.DubboProperty.DUBBO_MIGRATION_FILE_ENABLE, "false"))) {
    // JVM 参数中获取文件路径配置的 key dubbo.migration.file
    String path = SystemPropertyConfigUtils.getSystemProperty(CommonConstants.DubboProperty.DUBBO_MIGRATION_KEY);
    if (StringUtils.isEmpty(path)) {
      // env 环境变量中获取
      path = System.getenv(CommonConstants.DubboProperty.DUBBO_MIGRATION_KEY);
      if (StringUtils.isEmpty(path)) {
        // 类路径下获取文件 dubbo-migration.yaml
        path = CommonConstants.DEFAULT_DUBBO_MIGRATION_FILE;
      }
    }
    this.localMigrationRule = ConfigUtils.loadMigrationRule(scopeModel.getClassLoaders(), path);
  } else {
    this.localMigrationRule = null;
  }
}

this.internalModule = new ModuleModel(this, true);

protected ModuleModel(ApplicationModel applicationModel, boolean isInternal) {
  // 调用 ScopeModel 传递 3 个参数父模型，模型域为模块域，是否为内部模型为 true
  super(applicationModel, ExtensionScope.MODULE, isInternal);
  synchronized (instLock) {
    // 初始化成员变量 applicationModel
    Assert.notNull(applicationModel, "ApplicationModel can not be null");
    this.applicationModel = applicationModel;
    // 将模块模型添加至应用模型中
    applicationModel.addModule(this, isInternal);
    if (LOGGER.isInfoEnabled()) {
      LOGGER.info(getDesc() + " is created");
    }
    // 初始化模块模型
    initialize();
    // 创建模块服务存储库对象
    this.serviceRepository = new ModuleServiceRepository(this);
    // 初始化模块配置扩展
    initModuleExt();
    // 初始化域模型扩展
    ExtensionLoader<ScopeModelInitializer> initializerExtensionLoader = this.getExtensionLoader(ScopeModelInitializer.class);
    Set<ScopeModelInitializer> initializers = initializerExtensionLoader.getSupportedExtensionInstances();
    for (ScopeModelInitializer initializer : initializers) {
      initializer.initializeModuleModel(this);
    }
    Assert.notNull(getServiceRepository(), "ModuleServiceRepository can not be null");
    // 创建模块配置管理对象
    Assert.notNull(getConfigManager(), "ModuleConfigManager can not be null");
    Assert.assertTrue(getConfigManager().isInitialized(), "ModuleConfigManager can not be initialized");

    // notify application check state
    // 获取应用程序发布对象，通知检查状态
    ApplicationDeployer applicationDeployer = applicationModel.getDeployer();
    if (applicationDeployer != null) {
      applicationDeployer.notifyModuleChanged(this, DeployState.PENDING);
    }
  }
}

void addModule(ModuleModel moduleModel, boolean isInternal) {
  synchronized (instLock) {
    // 不存在则添加
    if (!this.moduleModels.contains(moduleModel)) {
      // 检查应用模型是否已销毁
      checkDestroyed();
      // 添加至模块模型成员变量中
      this.moduleModels.add(moduleModel);
      // 设置模块模型内部id，这个内部id生成过程与上面将应用模型添加到框架模型中的方式是一致的
      // 可以参考 3.5.1 将 ApplicationModel 添加至 FrameworkModel 容器中
      moduleModel.setInternalId(buildInternalId(getInternalId(), moduleIndex.getAndIncrement()));
      // 若不是内部模型则添加到公开模块模型中
      if (!isInternal) {
        pubModuleModels.add(moduleModel);
      }
    }
  }
}

// 初始化模块模型
initialize();

// 初始化模块配置扩展
initModuleExt();
// 初始化域模型扩展
ExtensionLoader<ScopeModelInitializer> initializerExtensionLoader = this.getExtensionLoader(ScopeModelInitializer.class);
Set<ScopeModelInitializer> initializers = initializerExtensionLoader.getSupportedExtensionInstances();
for (ScopeModelInitializer initializer : initializers) {
  initializer.initializeModuleModel(this);
}
Assert.notNull(getServiceRepository(), "ModuleServiceRepository can not be null");
// 创建模块配置管理对象
Assert.notNull(getConfigManager(), "ModuleConfigManager can not be null");
Assert.assertTrue(getConfigManager().isInitialized(), "ModuleConfigManager can not be initialized");

// notify application check state
// 获取应用程序发布对象，通知检查状态
ApplicationDeployer applicationDeployer = applicationModel.getDeployer();
if (applicationDeployer != null) {
  applicationDeployer.notifyModuleChanged(this, DeployState.PENDING);
}

// 创建模块服务存储库对象
this.serviceRepository = new ModuleServiceRepository(this);

public ModuleServiceRepository(ModuleModel moduleModel) {
  this.moduleModel = moduleModel;
  frameworkServiceRepository = ScopeModelUtil.getFrameworkModel(moduleModel).getServiceRepository();
}

ScopeModelUtil.getFrameworkModel(moduleModel).getServiceRepository();

public static FrameworkModel getFrameworkModel(ScopeModel scopeModel) {
  if (scopeModel == null) {
    return FrameworkModel.defaultModel();
  }
  // 通过成员变量获取（构造器初始化时将 FrameworkModel 赋值给了 ApplicationModel 的成员变量）
  if (scopeModel instanceof ApplicationModel) {
    // 直接获取
    return ((ApplicationModel) scopeModel).getFrameworkModel();
  } else if (scopeModel instanceof ModuleModel) {
    ModuleModel moduleModel = (ModuleModel) scopeModel;
    // 间接通过 ApplicationModel 获取，不越级获取
    return moduleModel.getApplicationModel().getFrameworkModel();
  } else if (scopeModel instanceof FrameworkModel) {
    return (FrameworkModel) scopeModel;
  } else {
    throw new IllegalArgumentException("Unable to get FrameworkModel from " + scopeModel);
  }
}

// 创建模块配置管理对象
Assert.notNull(getConfigManager(), "ModuleConfigManager can not be null");
Assert.assertTrue(getConfigManager().isInitialized(), "ModuleConfigManager can not be initialized");

public ModuleConfigManager getConfigManager() {
    if (moduleConfigManager == null) {
        moduleConfigManager = (ModuleConfigManager) this.getExtensionLoader(ModuleExt.class).getExtension(ModuleConfigManager.NAME);
    }
    return moduleConfigManager;
}

private void initModuleExt() {
  // 目前扩展支持类型: ModuleEnvironment、ModuleConfigManager
  Set<ModuleExt> exts = this.getExtensionLoader(ModuleExt.class).getSupportedExtensionInstances();
  for (ModuleExt ext : exts) {
    ext.initialize();
  }
}

public void initialize() throws IllegalStateException {
  if (initialized.compareAndSet(false, true)) {
    this.orderedPropertiesConfiguration = new OrderedPropertiesConfiguration(moduleModel);
  }
}

public OrderedPropertiesConfiguration(ModuleModel moduleModel) {
  this.moduleModel = moduleModel;
  refresh();
}

public void refresh() {
  properties = new Properties();
  // 有序的配置提供器扩展获取
  ExtensionLoader<OrderedPropertiesProvider> propertiesProviderExtensionLoader = moduleModel.getExtensionLoader(OrderedPropertiesProvider.class);
  Set<String> propertiesProviderNames = propertiesProviderExtensionLoader.getSupportedExtensions();
  if (CollectionUtils.isEmpty(propertiesProviderNames)) {
    return;
  }
  List<OrderedPropertiesProvider> orderedPropertiesProviders = new ArrayList<>();
  for (String propertiesProviderName : propertiesProviderNames) {
    orderedPropertiesProviders.add(propertiesProviderExtensionLoader.getExtension(propertiesProviderName));
  }

  // order the propertiesProvider according the priority descending
  // 根据优先级进行排序，值越小优先级越高
  orderedPropertiesProviders.sort((a, b) -> b.priority() - a.priority());

  // override the properties.
  // 扩展实现
  for (OrderedPropertiesProvider orderedPropertiesProvider : orderedPropertiesProviders) {
    properties.putAll(orderedPropertiesProvider.initProperties());
  }
}