org.springframework.beans.factory.config.YamlPropertiesFactoryBean Java Examples

@Bean(name = "graviteeProperties")
public static Properties graviteeProperties() throws IOException {
    LOGGER.info("Loading Gravitee Management configuration.");

    YamlPropertiesFactoryBean yaml = new YamlPropertiesFactoryBean();

    String yamlConfiguration = System.getProperty(GRAVITEE_CONFIGURATION);
    Resource yamlResource = new FileSystemResource(yamlConfiguration);

    LOGGER.info("\tGravitee Management configuration loaded from {}", yamlResource.getURL().getPath());

    yaml.setResources(yamlResource);
    Properties properties = yaml.getObject();
    LOGGER.info("Loading Gravitee Management configuration. DONE");

    return properties;
}
 

protected Properties generateProperties(String value,
                                        Format format) {
    final Properties props = new Properties();

    if (format == Format.PROPERTIES) {
        try {
            // Must use the ISO-8859-1 encoding because Properties.load(stream)
            // expects it.
            props.load(new ByteArrayInputStream(value.getBytes(StandardCharsets.ISO_8859_1)));
        } catch (IOException e) {
            logger.error("Can't be encoded with exception: ", e);
            throw new IllegalArgumentException(
                    value + " can't be encoded using ISO-8859-1");
        }
        return props;
    } else if (format == Format.YAML) {
        final YamlPropertiesFactoryBean yaml = new YamlPropertiesFactoryBean();
        yaml.setResources(new ByteArrayResource(value.getBytes(StandardCharsets.UTF_8)));
        return yaml.getObject();
    } else {
        return props;
    }
}
 

private void doSyntaxCheck(NamespaceTextModel model) {
  if (StringUtils.isBlank(model.getConfigText())) {
    return;
  }

  // only support yaml syntax check
  if (model.getFormat() != ConfigFileFormat.YAML && model.getFormat() != ConfigFileFormat.YML) {
    return;
  }

  // use YamlPropertiesFactoryBean to check the yaml syntax
  YamlPropertiesFactoryBean yamlPropertiesFactoryBean = new YamlPropertiesFactoryBean();
  yamlPropertiesFactoryBean.setResources(new ByteArrayResource(model.getConfigText().getBytes()));
  // this call converts yaml to properties and will throw exception if the conversion fails
  yamlPropertiesFactoryBean.getObject();
}
 

static Function<String, Properties> yamlParserGenerator(Environment environment) {
	return s -> {
		YamlPropertiesFactoryBean yamlFactory = new YamlPropertiesFactoryBean();
		yamlFactory.setDocumentMatchers(properties -> {
			String profiles = properties.getProperty("spring.profiles");
			if (environment != null && StringUtils.hasText(profiles)) {
				return environment.acceptsProfiles(Profiles.of(profiles)) ? FOUND
						: NOT_FOUND;
			}
			else {
				return ABSTAIN;
			}
		});
		yamlFactory.setResources(new ByteArrayResource(s.getBytes()));
		return yamlFactory.getObject();
	};
}
 

/**
 * Binds the YAML formatted value of a deployment property to a {@link KubernetesDeployerProperties} instance.
 *
 * @param kubernetesDeployerProperties the map of Kubernetes deployer properties
 * @param propertyKey the property key to obtain the value to bind for
 * @param yamlLabel the label representing the field to bind to
 * @return a {@link KubernetesDeployerProperties} with the bound property data
 */
private static KubernetesDeployerProperties bindProperties(Map<String, String> kubernetesDeployerProperties,
		String propertyKey, String yamlLabel) {
	String deploymentPropertyValue = kubernetesDeployerProperties.getOrDefault(propertyKey, "");

	KubernetesDeployerProperties deployerProperties = new KubernetesDeployerProperties();

	if (!StringUtils.isEmpty(deploymentPropertyValue)) {
		try {
			YamlPropertiesFactoryBean properties = new YamlPropertiesFactoryBean();
			String tmpYaml = "{ " + yamlLabel + ": " + deploymentPropertyValue + " }";
			properties.setResources(new ByteArrayResource(tmpYaml.getBytes()));
			Properties yaml = properties.getObject();
			MapConfigurationPropertySource source = new MapConfigurationPropertySource(yaml);
			deployerProperties = new Binder(source)
					.bind("", Bindable.of(KubernetesDeployerProperties.class)).get();
		} catch (Exception e) {
			throw new IllegalArgumentException(
					String.format("Invalid binding property '%s'", deploymentPropertyValue), e);
		}
	}

	return deployerProperties;
}
 

InitializrProperties toProperties(String url) {
	return CACHE.computeIfAbsent(url, s -> {
		String retrievedFile = this.rawGithubRetriever.raw(s);
		if (StringUtils.isEmpty(retrievedFile)) {
			return null;
		}
		YamlPropertiesFactoryBean yamlProcessor = new YamlPropertiesFactoryBean();
		yamlProcessor.setResources(new InputStreamResource(new ByteArrayInputStream(
				retrievedFile.getBytes(StandardCharsets.UTF_8))));
		Properties properties = yamlProcessor.getObject();
		return new Binder(
				new MapConfigurationPropertySource(properties.entrySet().stream()
						.collect(Collectors.toMap(e -> e.getKey().toString(),
								e -> e.getValue().toString()))))
										.bind("initializr",
												InitializrProperties.class)
										.get();
	});
}
 

@Bean(name = "graviteeProperties")
public static Properties graviteeProperties() throws IOException {
    LOGGER.info("Loading Gravitee Management configuration.");

    YamlPropertiesFactoryBean yaml = new YamlPropertiesFactoryBean();

    String yamlConfiguration = System.getProperty(GRAVITEE_CONFIGURATION);
    Resource yamlResource = new FileSystemResource(yamlConfiguration);

    LOGGER.info("\tGravitee Management configuration loaded from {}", yamlResource.getURL().getPath());

    yaml.setResources(yamlResource);
    Properties properties = yaml.getObject();
    LOGGER.info("Loading Gravitee Management configuration. DONE");

    return properties;
}
 

@Override
public Environment findOne(String application, String profile, String label) {
	String[] profiles = StringUtils.commaDelimitedListToStringArray(profile);
	List<String> scrubbedProfiles = scrubProfiles(profiles);

	List<String> keys = findKeys(application, scrubbedProfiles);

	Environment environment = new Environment(application, profiles, label, null,
			getWatchState());

	for (String key : keys) {
		// read raw 'data' key from vault
		String data = read(key);
		if (data != null) {
			// data is in json format of which, yaml is a superset, so parse
			final YamlPropertiesFactoryBean yaml = new YamlPropertiesFactoryBean();
			yaml.setResources(new ByteArrayResource(data.getBytes()));
			Properties properties = yaml.getObject();

			if (!properties.isEmpty()) {
				environment.add(new PropertySource("vault:" + key, properties));
			}
		}
	}

	return environment;
}
 

private static void contributeDefaults(Map<String, Object> defaults, Resource resource) {
	if (resource.exists()) {
		YamlPropertiesFactoryBean yamlPropertiesFactoryBean = new YamlPropertiesFactoryBean();
		yamlPropertiesFactoryBean.setResources(resource);
		yamlPropertiesFactoryBean.afterPropertiesSet();
		Properties p = yamlPropertiesFactoryBean.getObject();
		for (Object k : p.keySet()) {
			String key = k.toString();
			defaults.put(key, p.get(key));
		}
	}
}
 

@Override
public Properties read() {
	final YamlPropertiesFactoryBean yaml = new YamlPropertiesFactoryBean();
	try (InputStream in = inputStream) {
		yaml.setResources(new InputStreamResource(in));
		return yaml.getObject();
	}
	catch (IOException e) {
		throw new IllegalStateException("Cannot load environment", e);
	}
}
 

/**
 * Load application.yml from classpath.
 */
private static Properties readProperties() {
    try {
        YamlPropertiesFactoryBean factory = new YamlPropertiesFactoryBean();
        factory.setResources(new ClassPathResource("config/application.yml"));
        return factory.getObject();
    } catch (Exception e) {
        log.error("Failed to read application.yml to get default profile");
    }
    return null;
}
 

private KubernetesDeployerProperties bindDeployerProperties() throws Exception {
	YamlPropertiesFactoryBean properties = new YamlPropertiesFactoryBean();
	properties.setResources(new ClassPathResource("dataflow-server.yml"),
			new ClassPathResource("dataflow-server-tolerations.yml"),
			new ClassPathResource("dataflow-server-secretKeyRef.yml"),
			new ClassPathResource("dataflow-server-configMapKeyRef.yml"),
			new ClassPathResource("dataflow-server-podsecuritycontext.yml"),
			new ClassPathResource("dataflow-server-nodeAffinity.yml"),
			new ClassPathResource("dataflow-server-podAffinity.yml"),
			new ClassPathResource("dataflow-server-podAntiAffinity.yml"));
	Properties yaml = properties.getObject();
	MapConfigurationPropertySource source = new MapConfigurationPropertySource(yaml);
	return new Binder(source).bind("", Bindable.of(KubernetesDeployerProperties.class)).get();
}
 

/**
 * Volume mount deployment properties are specified in YAML format:
 * <p>
 * <code>
 * spring.cloud.deployer.kubernetes.volumeMounts=[{name: 'testhostpath', mountPath: '/test/hostPath'},
 * {name: 'testpvc', mountPath: '/test/pvc'}, {name: 'testnfs', mountPath: '/test/nfs'}]
 * </code>
 * <p>
 * Volume mounts can be specified as deployer properties as well as app deployment properties.
 * Deployment properties override deployer properties.
 *
 * @param deploymentProperties the deployment properties from {@link AppDeploymentRequest}
 * @return the configured volume mounts
 */
List<VolumeMount> getVolumeMounts(Map<String, String> deploymentProperties) {
	List<VolumeMount> volumeMounts = new ArrayList<>();
	String volumeMountDeploymentProperty = PropertyParserUtils.getDeploymentPropertyValue(deploymentProperties,
			this.propertyPrefix + ".volumeMounts");

	if (!StringUtils.isEmpty(volumeMountDeploymentProperty)) {
		try {
			YamlPropertiesFactoryBean properties = new YamlPropertiesFactoryBean();
			String tmpYaml = "{ volume-mounts: " + volumeMountDeploymentProperty + " }";
			properties.setResources(new ByteArrayResource(tmpYaml.getBytes()));
			Properties yaml = properties.getObject();
			MapConfigurationPropertySource source = new MapConfigurationPropertySource(yaml);
			KubernetesDeployerProperties deployerProperties = new Binder(source)
					.bind("", Bindable.of(KubernetesDeployerProperties.class)).get();
			volumeMounts.addAll(deployerProperties.getVolumeMounts());
		} catch (Exception e) {
			throw new IllegalArgumentException(
					String.format("Invalid volume mount '%s'", volumeMountDeploymentProperty), e);
		}
	}

	// only add volume mounts that have not already been added, based on the volume mount's name
	// i.e. allow provided deployment volume mounts to override deployer defined volume mounts
	volumeMounts.addAll(this.properties.getVolumeMounts().stream().filter(volumeMount -> volumeMounts.stream()
			.noneMatch(existingVolumeMount -> existingVolumeMount.getName().equals(volumeMount.getName())))
			.collect(Collectors.toList()));

	return volumeMounts;
}
 

protected Properties generateProperties(String value,
		ConsulConfigProperties.Format format) {
	final Properties props = new Properties();

	if (format == PROPERTIES) {
		try {
			// Must use the ISO-8859-1 encoding because Properties.load(stream)
			// expects it.
			props.load(new ByteArrayInputStream(value.getBytes("ISO-8859-1")));
		}
		catch (IOException e) {
			throw new IllegalArgumentException(
					value + " can't be encoded using ISO-8859-1");
		}

		return props;
	}
	else if (format == YAML) {
		final YamlPropertiesFactoryBean yaml = new YamlPropertiesFactoryBean();
		yaml.setResources(
				new ByteArrayResource(value.getBytes(Charset.forName("UTF-8"))));

		return yaml.getObject();
	}

	return props;
}
 

@Override
public PropertySource<?> createPropertySource(String name, EncodedResource encodedResource) throws IOException {
    YamlPropertiesFactoryBean factory = new YamlPropertiesFactoryBean();
    factory.setResources(encodedResource.getResource());

    Properties properties = factory.getObject();

    return new PropertiesPropertySource(encodedResource.getResource().getFilename(), properties);
}
 

@Override
public PropertySource<?> createPropertySource(String name, EncodedResource resource) throws IOException {
    YamlPropertiesFactoryBean yamlPropertiesFactoryBean = new YamlPropertiesFactoryBean();
    yamlPropertiesFactoryBean.setResources(resource.getResource());
    Properties yamlProperties = yamlPropertiesFactoryBean.getObject();
    return new PropertiesPropertySource(name, yamlProperties);
}
 

private void check(String yamlContent) {
  YamlPropertiesFactoryBean yamlPropertiesFactoryBean = new YamlPropertiesFactoryBean();
  yamlPropertiesFactoryBean.setResources(new ByteArrayResource(yamlContent.getBytes()));
  Properties expected = yamlPropertiesFactoryBean.getObject();

  Properties actual = parser.yamlToProperties(yamlContent);

  assertTrue("expected: " + expected + " actual: " + actual, checkPropertiesEquals(expected, actual));
}
 

/**
 * Load application.yml from classpath.
 */
private static Properties readProperties() {
    try {
        YamlPropertiesFactoryBean factory = new YamlPropertiesFactoryBean();
        factory.setResources(new ClassPathResource("config/application.yml"));
        return factory.getObject();
    } catch (Exception e) {
        log.error("Failed to read application.yml to get default profile");
    }
    return null;
}
 

@Bean
public static PropertySourcesPlaceholderConfigurer properties() {
    PropertySourcesPlaceholderConfigurer propertySourcesPlaceholderConfigurer = new PropertySourcesPlaceholderConfigurer();
    YamlPropertiesFactoryBean yaml = new YamlPropertiesFactoryBean();
    yaml.setResources(new ClassPathResource(CLIENT_PROPERTY_FILE));
    propertySourcesPlaceholderConfigurer.setProperties(Objects.requireNonNull(yaml.getObject()));
    return propertySourcesPlaceholderConfigurer;
}
 

@Test
@SuppressWarnings("AccessStaticViaInstance")
public void loadProperties() {
    LogCaptor<YamlPropertiesFactoryBean> logCaptor = LogCaptor.forClass(YamlPropertiesFactoryBean.class);
    PropertySourcesPlaceholderConfigurer properties = new PropertyResolver().properties();

    assertThat(properties).isNotNull();

    List<String> debugLogs = logCaptor.getDebugLogs();

    assertThat(debugLogs).hasSize(3);
    assertThat(debugLogs.get(0)).isEqualTo("Loading from YAML: class path resource [application.yml]");
    assertThat(debugLogs.get(1)).containsSubsequence("Merging document (no matchers set): {spring={main={banner-mode=off, web-application-type=none}}, ");
    assertThat(debugLogs.get(2)).isEqualTo("Loaded 1 document from YAML resource: class path resource [application.yml]");
}
 

@Override
public Map<String, Object> resolve(String content) {
	YamlPropertiesFactoryBean ymlFb = new YamlPropertiesFactoryBean();

	ymlFb.setResources(new ByteArrayResource(content.getBytes(Charsets.UTF_8)));
	ymlFb.afterPropertiesSet();
	// Properties to map
	Map<String, Object> map = new HashMap<>();
	if (ymlFb.getObject() != null) {
		ymlFb.getObject().forEach((k, v) -> map.put(String.valueOf(k), v));
	}
	return map;
}
 

private Properties loadYamlIntoProperties(EncodedResource resource) throws FileNotFoundException {
    try {
        final YamlPropertiesFactoryBean factory = new YamlPropertiesFactoryBean();
        factory.setResources(resource.getResource());
        factory.afterPropertiesSet();
        return factory.getObject();
    } catch (IllegalStateException e) {
        // for ignoreResourceNotFound
        final Throwable cause = e.getCause();
        if (cause instanceof FileNotFoundException) {
            throw (FileNotFoundException) cause;
        }
        throw e;
    }
}
 

private static void contributeDefaults(Map<String, Object> defaults, Resource resource) {
	if (resource.exists()) {
		YamlPropertiesFactoryBean yamlPropertiesFactoryBean = new YamlPropertiesFactoryBean();
		yamlPropertiesFactoryBean.setResources(resource);
		yamlPropertiesFactoryBean.afterPropertiesSet();
		Properties p = yamlPropertiesFactoryBean.getObject();
		for (Object k : p.keySet()) {
			String key = k.toString();
			defaults.put(key, p.get(key));
		}
	}
}
 

private Properties loadProperties(String name, Resource resource) throws IOException{
	Properties properties = null;
	if(name.contains("properties")){
		properties = PropertiesLoaderUtils.loadProperties(resource);
	}else{
		YamlPropertiesFactoryBean bean = new YamlPropertiesFactoryBean();
		bean.setResources(resource);
		properties = bean.getObject();
	}
	return properties;
}
 

public static Map<String, String> processValueType(KVDoc kvDoc) {
  ValueType valueType = parseValueType(kvDoc.getValueType());

  Properties properties = new Properties();
  Map<String, String> kvMap = new HashMap<>();
  try {
    if (valueType == (ValueType.YAML) || valueType == (ValueType.YML)) {
      YamlPropertiesFactoryBean yamlFactory = new YamlPropertiesFactoryBean();
      yamlFactory.setResources(new ByteArrayResource(kvDoc.getValue().getBytes()));
      properties = yamlFactory.getObject();
    } else if (valueType == (ValueType.PROPERTIES)) {
      properties.load(new StringReader(kvDoc.getValue()));
    } else if (valueType == (ValueType.TEXT) || valueType == (ValueType.STRING)) {
      kvMap.put(kvDoc.getKey(), kvDoc.getValue());
      return kvMap;
    } else {
      // ValueType.JSON
      kvMap.put(kvDoc.getKey(), kvDoc.getValue());
      return kvMap;
    }
    kvMap = toMap(kvDoc.getKey(), properties);
    return kvMap;
  } catch (Exception e) {
    LOGGER.error("read config failed", e);
  }
  return Collections.emptyMap();
}
 

private Properties loadYamlIntoProperties(EncodedResource resource) {
    YamlPropertiesFactoryBean factory = new YamlPropertiesFactoryBean();
    factory.setResources(resource.getResource());
    factory.afterPropertiesSet();
    return factory.getObject();
}
 

@Bean
public static YamlPropertiesFactoryBean yamlPropertiesFactoryBean() {
    YamlPropertiesFactoryBean yaml = new YamlPropertiesFactoryBean();
    yaml.setResources(new ClassPathResource("application.yml"));
    return yaml;
}
 

private static Properties loadProperties(Resource resource) {
	YamlPropertiesFactoryBean yamlFactory = new YamlPropertiesFactoryBean();
	yamlFactory.setResources(resource);
	yamlFactory.afterPropertiesSet();
	return yamlFactory.getObject();
}
 

@Test
public void test2() {
    String data = "zuihou:\n" +
            "  swagger:\n" +
            "    enabled: true\n" +
            "    title: 网关模块\n" +
            "    base-package: com.github.zuihou.zuul.controller\n" +
            "\n" +
            "zuul:\n" +
            "  retryable: false\n" +
            "  servlet-path: /\n" +
            "  ignored-services: \"*\"\n" +
            "  sensitive-headers:\n" +
            "  ratelimit:\n" +
            "    key-prefix: gate_rate\n" +
            "    enabled: true\n" +
            "    repository: REDIS\n" +
            "    behind-proxy: true\n" +
            "    default-policy:\n" +
            "      cycle-type: 1\n" +
            "      limit: 10\n" +
            "      refresh-interval: 60\n" +
            "      type:\n" +
            "        - APP\n" +
            "        - URL\n" +
            "  routes:\n" +
            "    authority:\n" +
            "      path: /authority/**\n" +
            "      serviceId: zuihou-authority-server\n" +
            "    file:\n" +
            "      path: /file/**\n" +
            "      serviceId: zuihou-file-server\n" +
            "    msgs:\n" +
            "      path: /msgs/**\n" +
            "      serviceId: zuihou-msgs-server\n" +
            "    order:\n" +
            "      path: /order/**\n" +
            "      serviceId: zuihou-order-server\n" +
            "    demo:\n" +
            "      path: /demo/**\n" +
            "      serviceId: zuihou-demo-server\n" +
            "\n" +
            "authentication:\n" +
            "  user:\n" +
            "    header-name: token\n" +
            "    pub-key: client/pub.key";

    YamlPropertiesFactoryBean yamlFactory = new YamlPropertiesFactoryBean();
    yamlFactory.setResources(new ByteArrayResource(data.getBytes()));
    Properties object = yamlFactory.getObject();
    System.out.println(object);
}
 

@Override
protected void before() throws Throwable {
	try {
		String awsCredentialsDir = System.getProperty("aws.credentials.path");
		File awsCredentialsFile = new File(awsCredentialsDir, "aws.credentials.properties");
		Properties awsCredentials = new Properties();
		awsCredentials.load(new FileReader(awsCredentialsFile));
		String accessKey = awsCredentials.getProperty("cloud.aws.credentials.accessKey");
		String secretKey = awsCredentials.getProperty("cloud.aws.credentials.secretKey");
		this.cloudFormation = new AmazonCloudFormationClient(new BasicAWSCredentials(accessKey, secretKey));

		YamlPropertiesFactoryBean yamlPropertiesFactoryBean = new YamlPropertiesFactoryBean();
		yamlPropertiesFactoryBean.setResources(new ClassPathResource("application.yml"));
		Properties applicationProperties = yamlPropertiesFactoryBean.getObject();

		this.stackName = applicationProperties.getProperty("cloud.aws.stack.name");

		after();

		ClassPathResource stackTemplate = new ClassPathResource("AwsIntegrationTestTemplate.json");
		String templateBody = FileCopyUtils.copyToString(new InputStreamReader(stackTemplate.getInputStream()));

		this.cloudFormation.createStack(
				new CreateStackRequest()
						.withTemplateBody(templateBody)
						.withOnFailure(OnFailure.DELETE)
						.withStackName(this.stackName));

		waitForCompletion();

		System.setProperty("cloud.aws.credentials.accessKey", accessKey);
		System.setProperty("cloud.aws.credentials.secretKey", secretKey);
	}
	catch (Exception e) {
		if (!(e instanceof AssumptionViolatedException)) {
			Assume.assumeTrue("Can't perform AWS integration test because of: " + e.getMessage(), false);
		}
		else {
			throw e;
		}
	}
}