8-DubboBootstrap 启动器初始化及核心配置解析

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

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

private DubboBootstrap(ApplicationModel applicationModel) {
  // 存储应用程序启动模型
  this.applicationModel = applicationModel;
  // 获取配置管理器：ConfigManager -> 配置管理器的扩展类型 ApplicationExt，扩展名字 config
  configManager = applicationModel.getApplicationConfigManager();
  // 获取环境信息 Environment：环境信息的扩展类型为 ApplicationExt，扩展名字 environment
  environment = applicationModel.modelEnvironment();
  // 执行器存储仓库（线程池）ExecutorRepository：扩展类型为 ExecutorRepository，扩展名字 executor
  executorRepository = ExecutorRepository.getInstance(applicationModel);
  // 初始化并启动应用程序实例 ApplicationDeployer，DefaultApplicationDeployer 类型
  applicationDeployer = applicationModel.getDeployer();
  // listen deploy events
  // 为发布器 设置生命周期回调
  applicationDeployer.addDeployListener(new DeployListenerAdapter<ApplicationModel>() {
    @Override
    public void onStarted(ApplicationModel scopeModel) {
      notifyStarted(applicationModel);
    }

    @Override
    public void onStopped(ApplicationModel scopeModel) {
      notifyStopped(applicationModel);
    }

    @Override
    public void onFailure(ApplicationModel scopeModel, Throwable cause) {
      notifyStopped(applicationModel);
    }
  });
  // register DubboBootstrap bean
  // 将启动器对象注册到应用程序模型 applicationModel Bean 工厂中
  applicationModel.getBeanFactory().registerBean(this);
}

bootstrap.application(new ApplicationConfig("dubbo-demo-api-provider"))

public DubboBootstrap application(ApplicationConfig applicationConfig) {
  // 将启动器构造函数中初始化的默认应用程序模型对象传递给配置对象
  applicationConfig.setScopeModel(applicationModel);
  // 将配置信息添加到配置管理器中
  configManager.setApplication(applicationConfig);
  return this;
}

public void setApplication(ApplicationConfig application) {
  addConfig(application);
}

public final <T extends AbstractConfig> T addConfig(AbstractConfig config) {
  if (config == null) {
    return null;
  }
  // ignore MethodConfig
  // 检查配置管理器可管理的配置对象
  // 目前支持的配置：ApplicationConfig、MonitorConfig、MetricsConfig、SslConfig
  // ProtocolConfig、RegistryConfig、ConfigCenterConfig、MetadataReportConfig
  if (!isSupportConfigType(config.getClass())) {
    throw new IllegalArgumentException("Unsupported config type: " + config);
  }
  if (config.getScopeModel() != scopeModel) {
    config.setScopeModel(scopeModel);
  }
  // 缓存中是否存在
  Map<String, AbstractConfig> configsMap = configsCache.computeIfAbsent(getTagName(config.getClass()), type -> new ConcurrentHashMap<>());
  // fast check duplicated equivalent config before write lock
  // 不是服务级配置则直接从缓存中读取到配置后返回
  if (!(config instanceof ReferenceConfigBase || config instanceof ServiceConfigBase)) {
    for (AbstractConfig value : configsMap.values()) {
      if (value.equals(config)) {
        return (T) value;
      }
    }
  }
  // lock by config type
  // 添加配置
  synchronized (configsMap) {
    return (T) addIfAbsent(config, configsMap);
  }
}

private <C extends AbstractConfig> C addIfAbsent(C config, Map<String, C> configsMap) throws IllegalStateException {
  // 配置信息为空直接返回
  if (config == null || configsMap == null) {
    return config;
  }
  // find by value
  // 根据配置规则判断,配置存在则返回
  Optional<C> prevConfig = findDuplicatedConfig(configsMap, config);
  if (prevConfig.isPresent()) {
    return prevConfig.get();
  }
  // 生成配置 key
  String key = config.getId();
  if (key == null) {
    do {
      // generate key if id is not set
      key = generateConfigId(config);
    } while (configsMap.containsKey(key));
  }
  // 不相同的配置 key 重复则输出告警日志
  C existedConfig = configsMap.get(key);
  if (existedConfig != null && !isEquals(existedConfig, config)) {
    String type = config.getClass().getSimpleName();
    logger.warn(
      COMMON_UNEXPECTED_EXCEPTION,
      "",
      "",
      String.format(
        "Duplicate %s found, there already has one default %s or more than two %ss have the same id, "
        + "you can try to give each %s a different id, override previous config with later config. id: %s, prev: %s, later: %s",
        type, type, type, type, key, existedConfig, config));
  }
  // override existed config if any
  // 将配置对象存入 configsMap 对象中，configsMap 来源于 configsCache
  configsMap.put(key, config);
  return config;
}

// DubboBootstrap
bootstrap.registry(new RegistryConfig("nacos://127.0.0.1:8848"))

public RegistryConfig(String address) {
  setAddress(address);
}

public void setAddress(String address) {
  // 保存地址
  this.address = address;
  // 下面是支持将参数拼接在 URL 地址后面，比如：用户名、密码、协议、端口
  // 这几个参数提前做解析并放入成员变量中
  if (address != null) {
    try {
      // 地址转 Dubbo URL 对象，该 URL 会自行实现 URL 封装信息的类型
      URL url = URL.valueOf(address);
      // Refactor since 2.7.8
      // 值不存在时更新属性，非常巧妙的代码设计，通过 泛型+Consumer 重构了多个 if 判断
      // 第一个参数值不存在则调用第二个方法，第二个方法的参数为第三个方法
      updatePropertyIfAbsent(this::getUsername, this::setUsername, url.getUsername());
      updatePropertyIfAbsent(this::getPassword, this::setPassword, url.getPassword());
      updatePropertyIfAbsent(this::getProtocol, this::setProtocol, url.getProtocol());
      updatePropertyIfAbsent(this::getPort, this::setPort, url.getPort());
      // 移除掉 url 中的 backup 自定义参数 (备份的注册中心地址)
      Map<String, String> params = url.getParameters();
      if (CollectionUtils.isNotEmptyMap(params)) {
        params.remove(BACKUP_KEY);
      }
      // 将自定义参数存储到成员变量中
      updateParameters(params);
    } catch (Exception ignored) {
    }
  }
}

public DubboBootstrap registry(RegistryConfig registryConfig) {
  // 将 ApplicationModel 对象设置给注册中心配置对象
  registryConfig.setScopeModel(applicationModel);
  // 将注册中心配置对象添加到配置管理器中
  configManager.addRegistry(registryConfig);
  return this;
}

public void addRegistry(RegistryConfig registryConfig) {
  addConfig(registryConfig);
}

// DubboBootstrap
bootstrap.protocol(new ProtocolConfig(/*dubbo*/CommonConstants.DUBBO, -1))

public DubboBootstrap protocol(ProtocolConfig protocolConfig) {
  // 配置信息转 List
  return protocols(singletonList(protocolConfig));
}

public DubboBootstrap protocols(List<ProtocolConfig> protocolConfigs) {
  if (CollectionUtils.isEmpty(protocolConfigs)) {
    return this;
  }
  for (ProtocolConfig protocolConfig : protocolConfigs) {
    // 将 ApplicationModel 对象设置给注册中心配置对象
    protocolConfig.setScopeModel(applicationModel);
    // 将协议配置对象添加到配置管理器中
    configManager.addProtocol(protocolConfig);
  }
  return this;
}