com.google.common.io.PatternFilenameFilter#org.apache.kafka.common.config.ConfigDef源码实例Demo

public static ConfigDef conf() {
    int order = 0;
    return new ConfigDef()
            .define(
                    FS_URIS,
                    Type.LIST,
                    ConfigDef.NO_DEFAULT_VALUE,
                    Importance.HIGH,
                    FS_URIS_DOC,
                    CONNECTOR_GROUP,
                    ++order,
                    ConfigDef.Width.LONG,
                    FS_URIS_DISPLAY
            ).define(
                    TOPIC,
                    Type.STRING,
                    ConfigDef.NO_DEFAULT_VALUE,
                    Importance.HIGH,
                    TOPIC_DOC,
                    CONNECTOR_GROUP,
                    ++order,
                    ConfigDef.Width.LONG,
                    TOPIC_DISPLAY
            );
}
 

@Override
public Config validate(Map<String, String> connectorConfigs) {
    ConfigDef configDef = config();
    Map<String, ConfigValue> configValues = ClickHouseConfigDef.emptyValidate(connectorConfigs, configDef);
    JdbcDataSource dataSource = ClickHouseConfigDef.clickHouseConnectValidate(configValues);
    String sinkDb = connectorConfigs.get(CLICKHOUSE_SINK_DATABASE);
    ConfigValue sinkTablesVal = configValues.get(CLICKHOUSE_SINK_TABLES);
    ConfigValue sinkLocalTablesVal = configValues.get(CLICKHOUSE_SINK_LOCAL_TABLES);
    String topics = connectorConfigs.get(TOPICS);

    validateTables(sinkTablesVal, sinkLocalTablesVal, topics);

    ClickHouseConfigDef.clusterTableExist(dataSource, sinkTablesVal, sinkDb);
    ClickHouseConfigDef.localTableExist(dataSource, sinkLocalTablesVal, sinkDb);
    ClickHouseConfigDef.validateSinkDateColumns(configValues, dataSource, sinkDb, sinkTablesVal);
    ClickHouseConfigDef.validateSourceDateColumns(configValues, dataSource, sinkTablesVal);
    ClickHouseConfigDef.validateDateFormat(configValues, dataSource, sinkTablesVal);

    if (dataSource != null) {
        dataSource.close();
    }
    return new Config(new LinkedList<>(configValues.values()));
}
 

private static List<String> validList(ConfigDef.ConfigKey key) {
    try {
        Field f = ConfigDef.ValidList.class.getDeclaredField("validString");
        f.setAccessible(true);
        ConfigDef.ValidString itemValidator = (ConfigDef.ValidString) f.get(key.validator);
        List<String> validItems = enumer(itemValidator);
        return validItems;
    } catch (ReflectiveOperationException e) {
        throw new RuntimeException(e);
    }
}
 

@Test
public void testValidateMissingConfigKey() {
    Map<String, ConfigValue> expected = new HashMap<>();
    String errorMessageB = "Missing required configuration \"b\" which has no default value.";
    String errorMessageC = "Missing required configuration \"c\" which has no default value.";
    String errorMessageD = "d is referred in the dependents, but not defined.";

    ConfigValue configA = new ConfigValue("a", 1, Arrays.<Object>asList(1, 2, 3), Collections.<String>emptyList());
    ConfigValue configB = new ConfigValue("b", null, Arrays.<Object>asList(4, 5), Arrays.asList(errorMessageB));
    ConfigValue configC = new ConfigValue("c", null, Arrays.<Object>asList(4, 5), Arrays.asList(errorMessageC));
    ConfigValue configD = new ConfigValue("d", null, Collections.emptyList(), Arrays.asList(errorMessageD));
    configD.visible(false);

    expected.put("a", configA);
    expected.put("b", configB);
    expected.put("c", configC);
    expected.put("d", configD);

    ConfigDef def = new ConfigDef()
        .define("a", Type.INT, Importance.HIGH, "docs", "group", 1, Width.SHORT, "a", Arrays.asList("b", "c", "d"), new IntegerRecommender(false))
        .define("b", Type.INT, Importance.HIGH, "docs", "group", 2, Width.SHORT, "b", new IntegerRecommender(true))
        .define("c", Type.INT, Importance.HIGH, "docs", "group", 3, Width.SHORT, "c", new IntegerRecommender(true));

    Map<String, String> props = new HashMap<>();
    props.put("a", "1");

    List<ConfigValue> configs = def.validate(props);
    for (ConfigValue config: configs) {
        String name = config.name();
        ConfigValue expectedConfig = expected.get(name);
        assertEquals(expectedConfig, config);
    }
}
 

private static ConfigDef getConfig() {
  Map<String, ConfigDef.ConfigKey> everything = new HashMap<>(conf().configKeys());
  ConfigDef visible = new ConfigDef();
  for (ConfigDef.ConfigKey key : everything.values()) {
    visible.define(key);
  }
  return visible;
}
 

@Override
public ConfigDef config() {
  return new ConfigDef()
      .define("testing.foo", ConfigDef.Type.INT, ConfigDef.Importance.HIGH, "Lorem Ipsum is simply " +
          "dummy text fromConnector the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy " +
          "text ever since the 1500s, when an unknown printer took a galley fromConnector type and scrambled it to make a type " +
          "specimen book. It has survived not only five centuries, but also the leap into electronic typesetting, " +
          "remaining essentially unchanged. It was popularised in the 1960s with the release fromConnector Letraset sheets " +
          "containing Lorem Ipsum passages, and more recently with desktop publishing software like Aldus PageMaker " +
          "including versions fromConnector Lorem Ipsum.")
      .define("port", ConfigDef.Type.INT, 8080, ConfigDef.Range.between(1000, 65535), ConfigDef.Importance.HIGH, "This is the port number that we will listen on.");
}
 

private static ConfigDef defineConfiguration() {
  final ConfigDef definitions = new ConfigDef();
  ZeebeClientConfigDef.defineClientGroup(definitions);
  defineMessageGroup(definitions);

  return definitions;
}
 

@Test
public void testBasicTypes() {
    ConfigDef def = new ConfigDef().define("a", Type.INT, 5, Range.between(0, 14), Importance.HIGH, "docs")
                                   .define("b", Type.LONG, Importance.HIGH, "docs")
                                   .define("c", Type.STRING, "hello", Importance.HIGH, "docs")
                                   .define("d", Type.LIST, Importance.HIGH, "docs")
                                   .define("e", Type.DOUBLE, Importance.HIGH, "docs")
                                   .define("f", Type.CLASS, Importance.HIGH, "docs")
                                   .define("g", Type.BOOLEAN, Importance.HIGH, "docs")
                                   .define("h", Type.BOOLEAN, Importance.HIGH, "docs")
                                   .define("i", Type.BOOLEAN, Importance.HIGH, "docs")
                                   .define("j", Type.PASSWORD, Importance.HIGH, "docs");

    Properties props = new Properties();
    props.put("a", "1   ");
    props.put("b", 2);
    props.put("d", " a , b, c");
    props.put("e", 42.5d);
    props.put("f", String.class.getName());
    props.put("g", "true");
    props.put("h", "FalSE");
    props.put("i", "TRUE");
    props.put("j", "password");

    Map<String, Object> vals = def.parse(props);
    assertEquals(1, vals.get("a"));
    assertEquals(2L, vals.get("b"));
    assertEquals("hello", vals.get("c"));
    assertEquals(asList("a", "b", "c"), vals.get("d"));
    assertEquals(42.5d, vals.get("e"));
    assertEquals(String.class, vals.get("f"));
    assertEquals(true, vals.get("g"));
    assertEquals(false, vals.get("h"));
    assertEquals(true, vals.get("i"));
    assertEquals(new Password("password"), vals.get("j"));
    assertEquals(Password.HIDDEN, vals.get("j").toString());
}
 

public CamelZookeeperSinkConnectorConfig(
        ConfigDef config,
        Map<String, String> parsedConfig) {
    super(config, parsedConfig);
}
 

public static ConfigDef config() {
    ConfigDef configDef = new ConfigDef();

    configDef.define(
        SEARCH_CLIENT_CLASS,
        ConfigDef.Type.CLASS,
        null,
        ConfigDef.Importance.LOW,
        SEARCH_CLIENT_CLASS_DOC
    ).define(
        SEARCH_CLIENT_CLASSES,
        ConfigDef.Type.STRING,
        null,
        ConfigDef.Importance.LOW,
        SEARCH_CLIENT_CLASSES_DOC
    ).define(
        SEARCH_CLIENT_INITIALIZE,
        ConfigDef.Type.BOOLEAN,
        SEARCH_CLIENT_INITIALIZE_DEFAULT,
        ConfigDef.Importance.LOW,
        SEARCH_CLIENT_INITIALIZE_DOC
    ).define(
        SEARCH_HOST,
        ConfigDef.Type.STRING,
        SEARCH_HOST_DEFAULT,
        ConfigDef.Importance.HIGH,
        SEARCH_HOST_DOC
    ).define(
        SEARCH_PORT,
        ConfigDef.Type.INT,
        SEARCH_PORT_DEFAULT,
        ConfigDef.Importance.HIGH,
        SEARCH_PORT_DOC
    ).define(
        SEARCH_USERNAME,
        ConfigDef.Type.STRING,
        SEARCH_USERNAME_DEFAULT,
        ConfigDef.Importance.MEDIUM, 
        SEARCH_USERNAME_DOC
    ).define(
        SEARCH_PASSWORD,
        ConfigDef.Type.STRING,
        SEARCH_PASSWORD_DEFAULT,
        ConfigDef.Importance.HIGH,
        SEARCH_PASSWORD_DOC
    ).define(
        SEARCH_CACHE_NAME,
        ConfigDef.Type.STRING,
        SEARCH_CACHE_NAME_DEFAULT,
        ConfigDef.Importance.LOW,
        SEARCH_CACHE_NAME_DOC
    ).define(
        SEARCH_REALM,
        ConfigDef.Type.STRING,
        SEARCH_REALM_DEFAULT,
        ConfigDef.Importance.LOW,
        SEARCH_REALM_DOC
    ).define(
        SEARCH_SERVER_NAME,
        ConfigDef.Type.STRING,
        SEARCH_SERVER_NAME_DEFAULT,
        ConfigDef.Importance.LOW,
        SEARCH_SERVER_NAME_DOC
    ).define(
        SEARCH_CLIENT_INTELLIGENCE,
        ConfigDef.Type.STRING,
        SEARCH_CLIENT_INTELLIGENCE_DEFAULT,
        ConfigDef.Importance.MEDIUM,
        SEARCH_CLIENT_INTELLIGENCE_DOC
    );

    return configDef;
}
 

public CamelElytronSinkConnectorConfig(
        ConfigDef config,
        Map<String, String> parsedConfig) {
    super(config, parsedConfig);
}
 

public CamelGooglepubsubSourceConnectorConfig(
        ConfigDef config,
        Map<String, String> parsedConfig) {
    super(config, parsedConfig);
}
 

@Override
public ConfigDef config() {
    return CamelJgroupsSinkConnectorConfig.conf();
}
 

public CamelKubernetesnamespacesSinkConnectorConfig(
        ConfigDef config,
        Map<String, String> parsedConfig) {
    super(config, parsedConfig);
}
 

public CamelKuberneteshpaSinkConnectorConfig(
        ConfigDef config,
        Map<String, String> parsedConfig) {
    super(config, parsedConfig);
}
 

public static ConfigDef conf() {
    return CONFIG_DEF;
}
 

public CamelFopSinkConnectorConfig(
        ConfigDef config,
        Map<String, String> parsedConfig) {
    super(config, parsedConfig);
}
 

public CamelXsltSinkConnectorConfig(
        ConfigDef config,
        Map<String, String> parsedConfig) {
    super(config, parsedConfig);
}
 

public CamelWekaSinkConnectorConfig(
        ConfigDef config,
        Map<String, String> parsedConfig) {
    super(config, parsedConfig);
}
 

public CamelMybatisbeanSinkConnectorConfig(
        ConfigDef config,
        Map<String, String> parsedConfig) {
    super(config, parsedConfig);
}
 

public CamelWeb3jSourceConnectorConfig(
        ConfigDef config,
        Map<String, String> parsedConfig) {
    super(config, parsedConfig);
}
 

public CamelMinaSinkConnectorConfig(
        ConfigDef config,
        Map<String, String> parsedConfig) {
    super(config, parsedConfig);
}
 

public CamelSmtpsSourceConnectorConfig(
        ConfigDef config,
        Map<String, String> parsedConfig) {
    super(config, parsedConfig);
}
 

@Override
public ConfigDef config() {
  return ExtractTimestampConfig.config();
}
 

@Override
public ConfigDef config() {
    return CamelJgroupsraftSinkConnectorConfig.conf();
}
 

public CamelJcloudsSourceConnectorConfig(
        ConfigDef config,
        Map<String, String> parsedConfig) {
    super(config, parsedConfig);
}
 

public CamelQuartzSourceConnectorConfig(
        ConfigDef config,
        Map<String, String> parsedConfig) {
    super(config, parsedConfig);
}
 

@Override
public ConfigDef config() {
    return CamelDatasetSinkConnectorConfig.conf();
}
 

@Override
public ConfigDef config() {
    return CamelIgnitesetSinkConnectorConfig.conf();
}
 

@Override
public ConfigDef config() {
    return CamelGoogledriveSinkConnectorConfig.conf();
}