下面列出了怎么用org.springframework.core.env.PropertySource的API类实例代码及写法,或者点击链接到github查看源代码。
private PropertySource createPropertySource(AnnotationAttributes attributes, ConfigurableEnvironment environment, ResourceLoader resourceLoader, EncryptablePropertyResolver resolver, EncryptablePropertyFilter propertyFilter, List<PropertySourceLoader> loaders) throws Exception {
String name = generateName(attributes.getString("name"));
String[] locations = attributes.getStringArray("value");
boolean ignoreResourceNotFound = attributes.getBoolean("ignoreResourceNotFound");
CompositePropertySource compositePropertySource = new CompositePropertySource(name);
Assert.isTrue(locations.length > 0, "At least one @PropertySource(value) location is required");
for (String location : locations) {
String resolvedLocation = environment.resolveRequiredPlaceholders(location);
Resource resource = resourceLoader.getResource(resolvedLocation);
if (!resource.exists()) {
if (!ignoreResourceNotFound) {
throw new IllegalStateException(String.format("Encryptable Property Source '%s' from location: %s Not Found", name, resolvedLocation));
} else {
log.info("Ignoring NOT FOUND Encryptable Property Source '{}' from locations: {}", name, resolvedLocation);
}
} else {
String actualName = name + "#" + resolvedLocation;
loadPropertySource(loaders, resource, actualName)
.ifPresent(psources -> psources.forEach(compositePropertySource::addPropertySource));
}
}
return new EncryptableEnumerablePropertySourceWrapper<>(compositePropertySource, resolver, propertyFilter);
}
private void conditionallyExcludeRabbitAutoConfiguration() {
if (appIsBoundToRabbitMQ()) {
return;
}
Map<String, Object> properties = new LinkedHashMap<>();
String existingExcludes = environment.getProperty(SPRING_AUTOCONFIGURE_EXCLUDE);
if (existingExcludes == null) {
properties.put(SPRING_AUTOCONFIGURE_EXCLUDE, RABBIT_AUTOCONFIG_CLASS);
} else if (!existingExcludes.contains(RABBIT_AUTOCONFIG_CLASS)) {
properties.put(SPRING_AUTOCONFIGURE_EXCLUDE, RABBIT_AUTOCONFIG_CLASS + "," + existingExcludes);
}
PropertySource<?> propertySource = new MapPropertySource("springCloudServicesRabbitAutoconfigExcluder",
properties);
environment.getPropertySources().addFirst(propertySource);
}
@Test
public void fromEnvironmentIsSuccessful() {
ConfigurableEnvironment mockEnvironment = mock(ConfigurableEnvironment.class);
MutablePropertySources propertySources = spy(new MutablePropertySources());
PropertySource mockVcapPropertySource = mock(EnumerablePropertySource.class);
when(mockEnvironment.getPropertySources()).thenReturn(propertySources);
doReturn(mockVcapPropertySource).when(propertySources).get(eq("vcap"));
when(mockVcapPropertySource.containsProperty(anyString())).thenReturn(true);
when(mockVcapPropertySource.getName()).thenReturn("vcap");
VcapPropertySource propertySource = VcapPropertySource.from(mockEnvironment);
assertThat(propertySource).isNotNull();
assertThat(propertySource.getSource()).isEqualTo(mockVcapPropertySource);
verify(mockEnvironment, times(1)).getPropertySources();
verify(propertySources, times(1)).get(eq("vcap"));
verify(mockVcapPropertySource, times(1))
.containsProperty(eq("vcap.application.name"));
verify(mockVcapPropertySource, times(1))
.containsProperty(eq("vcap.application.uris"));
}
@SuppressWarnings({ "rawtypes", "unchecked" })
@Override
public void updateFlatConfig() {
super.updateFlatConfig();
if(this.environment instanceof ConfigurableEnvironment) {
ConfigurableEnvironment configurableEnv = ((ConfigurableEnvironment)environment);
for(PropertySource<?> propertySource : configurableEnv.getPropertySources()) {
if(propertySource instanceof EnumerablePropertySource) {
EnumerablePropertySource<?> enumerablePropertySource = (EnumerablePropertySource)propertySource;
for(String propertyName : enumerablePropertySource.getPropertyNames()) {
flatConfig.put(propertyName, enumerablePropertySource.getProperty(propertyName));
}
}
}
}
}
@Test
public void contextShouldLoadPropertiesInACorrectOrder() {
assertThat(environment.getPropertySources())
.extracting(PropertySource::getName)
.containsExactly(
"configurationProperties",
"Inlined Test Properties",
"systemProperties",
"systemEnvironment",
"random",
"class path resource [db.properties]",
"class path resource [engine.properties]",
"applicationConfig: [classpath:/application.properties]",
"flowableDefaultConfig: [classpath:/flowable-default.properties]",
"flowable-liquibase-override",
"Management Server"
);
}
@Test
public void orderingIsCorrect() {
refresher.refresh();
MutablePropertySources propertySources = environment.getPropertySources();
PropertySource<?> test1 = propertySources
.get("bootstrapProperties-testContextRefresherOrdering1");
PropertySource<?> test2 = propertySources
.get("bootstrapProperties-testContextRefresherOrdering2");
PropertySource<?> test3 = propertySources
.get("bootstrapProperties-testContextRefresherOrdering3");
int index1 = propertySources.precedenceOf(test1);
int index2 = propertySources.precedenceOf(test2);
int index3 = propertySources.precedenceOf(test3);
assertThat(index1).as("source1 index not less then source2").isLessThan(index2);
assertThat(index2).as("source2 index not less then source3").isLessThan(index3);
}
@Test
public void withNonEnumerablePropertySource() {
DefaultListableBeanFactory bf = new DefaultListableBeanFactory();
bf.registerBeanDefinition("testBean",
genericBeanDefinition(TestBean.class)
.addPropertyValue("name", "${foo}")
.getBeanDefinition());
PropertySourcesPlaceholderConfigurer ppc = new PropertySourcesPlaceholderConfigurer();
PropertySource<?> ps = new PropertySource<Object>("simplePropertySource", new Object()) {
@Override
public Object getProperty(String key) {
return "bar";
}
};
MockEnvironment env = new MockEnvironment();
env.getPropertySources().addFirst(ps);
ppc.setEnvironment(env);
ppc.postProcessBeanFactory(bf);
assertThat(bf.getBean(TestBean.class).getName(), equalTo("bar"));
}
/**
* Create {@link PropertySource}s given {@link Environment} from the property
* configuration.
* @param environment must not be {@literal null}.
* @return a {@link List} of ordered {@link PropertySource}s.
*/
protected List<PropertySource<?>> doCreatePropertySources(Environment environment) {
Collection<SecretBackendMetadata> secretBackends = this.propertySourceLocatorConfiguration
.getSecretBackends();
List<SecretBackendMetadata> sorted = new ArrayList<>(secretBackends);
List<PropertySource<?>> propertySources = new ArrayList<>();
AnnotationAwareOrderComparator.sort(sorted);
propertySources.addAll(doCreateKeyValuePropertySources(environment));
for (SecretBackendMetadata backendAccessor : sorted) {
PropertySource<?> vaultPropertySource = createVaultPropertySource(
backendAccessor);
propertySources.add(vaultPropertySource);
}
return propertySources;
}
public Map<String, Map<String, Object>> getAllEnv() {
Map<String, Map<String, Object>> result = new LinkedHashMap<String, Map<String, Object>>();
for (Entry<String, PropertySource<?>> entry : getPropertySources().entrySet()) {
PropertySource<?> source = entry.getValue();
String sourceName = entry.getKey();
if (source instanceof EnumerablePropertySource) {
EnumerablePropertySource<?> enumerable = (EnumerablePropertySource<?>) source;
Map<String, Object> properties = new LinkedHashMap<String, Object>();
for (String name : enumerable.getPropertyNames()) {
properties.put(name, sanitize(name, enumerable.getProperty(name)));
}
result.put(sourceName, properties);
}
}
return result;
}
@Override
public PropertySource<?> createPropertySource(String name, EncodedResource resource) throws IOException {
PropertySource<?> propSource = null;
String propName = name;
if (StringUtils.isEmpty(propName)) {
propName = getNameForResource(resource.getResource());
}
if (resource.getResource().exists()) {
String fileName = resource.getResource().getFilename();
for (PropertySourceLoader loader : loaders) {
if (checkFileType(fileName, loader.getFileExtensions())) {
List<PropertySource<?>> propertySources = loader.load(propName, resource.getResource());
if (!propertySources.isEmpty()) {
propSource = propertySources.get(0);
}
}
}
} else {
throw new FileNotFoundException(propName + "对应文件'" + resource.getResource().getFilename() + "'不存在");
}
return propSource;
}
public Map<String, Map<String, Object>> getAllEnv() {
Map<String, Map<String, Object>> result = new LinkedHashMap<String, Map<String, Object>>();
for (Entry<String, PropertySource<?>> entry : getPropertySources().entrySet()) {
PropertySource<?> source = entry.getValue();
String sourceName = entry.getKey();
if (source instanceof EnumerablePropertySource) {
EnumerablePropertySource<?> enumerable = (EnumerablePropertySource<?>) source;
Map<String, Object> properties = new LinkedHashMap<String, Object>();
for (String name : enumerable.getPropertyNames()) {
properties.put(name, sanitize(name, enumerable.getProperty(name)));
}
result.put(sourceName, properties);
}
}
return result;
}
@Override
public void postProcessEnvironment(ConfigurableEnvironment environment, SpringApplication application) {
PropertySource<?> system = environment.getPropertySources()
.get(SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME);
Map<String, Object> prefixed = new LinkedHashMap<>();
if (!hasOurPriceProperties(system)) {
// Baeldung-internal code so this doesn't break other examples
logger.warn("System environment variables [calculation_mode,gross_calculation_tax_rate] not detected, fallback to default value [calcuation_mode={},gross_calcuation_tax_rate={}]", CALCUATION_MODE_DEFAULT_VALUE,
GROSS_CALCULATION_TAX_RATE_DEFAULT_VALUE);
prefixed = names.stream()
.collect(Collectors.toMap(this::rename, this::getDefaultValue));
environment.getPropertySources()
.addAfter(SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME, new MapPropertySource("prefixer", prefixed));
return;
}
prefixed = names.stream()
.collect(Collectors.toMap(this::rename, system::getProperty));
environment.getPropertySources()
.addAfter(SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME, new MapPropertySource("prefixer", prefixed));
}
public PropertySource<?> load(String name, Resource resource, String profile) throws IOException {
logger.info("load PropertySource -> name:{},profile:{}", name, profile);
if (profile == null) {
Properties properties = loadProperties(name,resource);
if (profiles == null) {
profiles = properties.getProperty("spring.profiles.active");
} else {
logger.info("spring.profiles.active = " + profiles + ",ignore load remote config");
}
// 如果指定了profile,则也不加载远程配置
if (profiles == null && ccContext.isRemoteEnabled() && !ccContext.isProcessed()) {
ccContext.init(properties, true);
ccContext.mergeRemoteProperties(properties);
}
if (!properties.isEmpty()) {
return new PropertiesPropertySource(name, properties);
}
}
return null;
}
@Test
public void shouldLocateLeaseAwareSources() {
RequestedSecret rotating = RequestedSecret.rotating("secret/rotating");
DefaultSecretBackendConfigurer configurer = new DefaultSecretBackendConfigurer();
configurer.add(rotating);
configurer.add("database/mysql/creds/readonly");
this.propertySourceLocator = new LeasingVaultPropertySourceLocator(
new VaultProperties(), configurer, this.secretLeaseContainer);
PropertySource<?> propertySource = this.propertySourceLocator
.locate(this.configurableEnvironment);
assertThat(propertySource).isInstanceOf(CompositePropertySource.class);
verify(this.secretLeaseContainer).addRequestedSecret(rotating);
verify(this.secretLeaseContainer).addRequestedSecret(
RequestedSecret.renewable("database/mysql/creds/readonly"));
}
private void logActiveProperties(ConfigurableEnvironment env) {
List<MapPropertySource> propertySources = new ArrayList<>();
for (PropertySource<?> source : env.getPropertySources()) {
if (source instanceof MapPropertySource && source.getName().contains("applicationConfig")) {
propertySources.add((MapPropertySource) source);
}
}
propertySources.stream()
.map(propertySource -> propertySource.getSource().keySet())
.flatMap(Collection::stream)
.distinct()
.sorted()
.forEach(key -> {
try {
log.debug(key + "=" + env.getProperty(key));
} catch (Exception e) {
log.warn("{} -> {}", key, e.getMessage());
}
});
}
/**
* Attach a {@link ConfigurationPropertySource} support to the specified
* {@link Environment}. Adapts each {@link PropertySource} managed by the environment
* to a {@link ConfigurationPropertySource} and allows classic
* {@link PropertySourcesPropertyResolver} calls to resolve using
* {@link ConfigurationPropertyName configuration property names}.
* <p>
* The attached resolver will dynamically track any additions or removals from the
* underlying {@link Environment} property sources.
*
* @param environment the source environment (must be an instance of
* {@link ConfigurableEnvironment})
* @see #get(Environment)
*/
public static void attach(Environment environment) {
Assert.isInstanceOf(ConfigurableEnvironment.class, environment);
MutablePropertySources sources = ((ConfigurableEnvironment) environment)
.getPropertySources();
PropertySource<?> attached = sources.get(ATTACHED_PROPERTY_SOURCE_NAME);
if (attached != null && attached.getSource() != sources) {
sources.remove(ATTACHED_PROPERTY_SOURCE_NAME);
attached = null;
}
if (attached == null) {
sources.addFirst(new ConfigurationPropertySourcesPropertySource(
ATTACHED_PROPERTY_SOURCE_NAME,
new SpringConfigurationPropertySources(sources)));
}
}
@Override
protected PropertySource<?> toSimplePropertySource() {
Properties props = new Properties();
AtomicInteger index = new AtomicInteger(0);
getProperties().getArchives().forEach(archive -> {
props.setProperty("archives[" + index.get() + "]", archive);
index.getAndIncrement();
});
copyIfSet(props, "git.branch");
String commitId = getProperties().getGit().getShortCommitId();
if (commitId != null) {
props.put("git.commit.id", commitId);
}
copyIfSet(props, "git.commit.time");
return new PropertiesPropertySource("launcher", props);
}
private static void addOrUpdateRemoteConfig(Environment env, boolean isUpdateOrNot) {
StandardEnvironment environment = (StandardEnvironment) env;
PropertySource propertySource = environment.getPropertySources().get("bootstrapProperties");
if(propertySource == null) {
return;
}
CompositePropertySource source = (CompositePropertySource) propertySource;
for (String key: source.getPropertyNames()) {
Object val = source.getProperty(key);
if(val == null) {
continue;
}
if(isUpdateOrNot) {
logger.info("update remote config => " + key + " = " + source.getProperty(key));
BDPConfiguration.set(key, val.toString());
} else {
logger.info("add remote config => " + key + " = " + source.getProperty(key));
BDPConfiguration.setIfNotExists(key, val.toString());
}
}
}
private Function<ConfigurableApplicationContext, ConfigurableApplicationContext> newSpringSessionGemFirePropertiesConfigurationFunction() {
return applicationContext -> {
PropertySource springSessionGemFireProperties = new MockPropertySource("TestSpringSessionGemFireProperties")
.withProperty(springSessionPropertyName("cache.client.region.shortcut"), "LOCAL")
.withProperty(springSessionPropertyName("session.attributes.indexable"), "one, two")
.withProperty(springSessionPropertyName("session.expiration.max-inactive-interval-seconds"), "600")
.withProperty(springSessionPropertyName("cache.client.pool.name"), "MockPool")
.withProperty(springSessionPropertyName("session.region.name"), "MockRegion")
.withProperty(springSessionPropertyName("cache.server.region.shortcut"), "REPLICATE")
.withProperty(springSessionPropertyName("session.serializer.bean-name"), "MockSessionSerializer");
applicationContext.getEnvironment().getPropertySources().addFirst(springSessionGemFireProperties);
return applicationContext;
};
}
private PropertySource<?> createVaultPropertySource(RequestedSecret secret,
SecretBackendMetadata accessor) {
if (accessor instanceof LeasingSecretBackendMetadata) {
((LeasingSecretBackendMetadata) accessor).beforeRegistration(secret,
this.secretLeaseContainer);
}
LeaseAwareVaultPropertySource propertySource = new LeaseAwareVaultPropertySource(
accessor.getName(), this.secretLeaseContainer, secret,
accessor.getPropertyTransformer());
if (accessor instanceof LeasingSecretBackendMetadata) {
((LeasingSecretBackendMetadata) accessor).afterRegistration(secret,
this.secretLeaseContainer);
}
return propertySource;
}
@Test
public void withNonEnumerablePropertySource() {
DefaultListableBeanFactory bf = new DefaultListableBeanFactory();
bf.registerBeanDefinition("testBean",
genericBeanDefinition(TestBean.class)
.addPropertyValue("name", "${foo}")
.getBeanDefinition());
PropertySourcesPlaceholderConfigurer ppc = new PropertySourcesPlaceholderConfigurer();
PropertySource<?> ps = new PropertySource<Object>("simplePropertySource", new Object()) {
@Override
public Object getProperty(String key) {
return "bar";
}
};
MockEnvironment env = new MockEnvironment();
env.getPropertySources().addFirst(ps);
ppc.setEnvironment(env);
ppc.postProcessBeanFactory(bf);
assertThat(bf.getBean(TestBean.class).getName(), equalTo("bar"));
}
private void mergeDefaultProperties(MutablePropertySources environment,
MutablePropertySources bootstrap) {
String name = DEFAULT_PROPERTIES;
if (bootstrap.contains(name)) {
PropertySource<?> source = bootstrap.get(name);
if (!environment.contains(name)) {
environment.addLast(source);
}
else {
PropertySource<?> target = environment.get(name);
if (target instanceof MapPropertySource && target != source
&& source instanceof MapPropertySource) {
Map<String, Object> targetMap = ((MapPropertySource) target)
.getSource();
Map<String, Object> map = ((MapPropertySource) source).getSource();
for (String key : map.keySet()) {
if (!target.containsProperty(key)) {
targetMap.put(key, map.get(key));
}
}
}
}
}
mergeAdditionalPropertySources(environment, bootstrap);
}
static Collection<PropertySource<?>> locateCollection(PropertySourceLocator locator,
Environment environment) {
PropertySource<?> propertySource = locator.locate(environment);
if (propertySource == null) {
return Collections.emptyList();
}
if (CompositePropertySource.class.isInstance(propertySource)) {
Collection<PropertySource<?>> sources = ((CompositePropertySource) propertySource)
.getPropertySources();
List<PropertySource<?>> filteredSources = new ArrayList<>();
for (PropertySource<?> p : sources) {
if (p != null) {
filteredSources.add(p);
}
}
return filteredSources;
}
else {
return Arrays.asList(propertySource);
}
}
@Override
@SuppressWarnings("unchecked")
public void initialize(ConfigurableApplicationContext configurableApplicationContext) {
try {
Resource resource = configurableApplicationContext.getResource("classpath:configprops.json");
Map readValue = new ObjectMapper().readValue(resource.getInputStream(), Map.class);
Set<Map.Entry> set = readValue.entrySet();
List<MapPropertySource> propertySources = convertEntrySet(set, Optional.empty());
for (PropertySource propertySource : propertySources) {
configurableApplicationContext.getEnvironment()
.getPropertySources()
.addFirst(propertySource);
}
} catch (IOException e) {
throw new RuntimeException(e);
}
}
private ConfigurationPropertySource fetchNext() {
if (this.next == null) {
if (this.iterators.isEmpty()) {
return null;
}
if (!this.iterators.peek().hasNext()) {
this.iterators.pop();
return fetchNext();
}
PropertySource<?> candidate = this.iterators.peek().next();
if (candidate.getSource() instanceof ConfigurableEnvironment) {
push((ConfigurableEnvironment) candidate.getSource());
return fetchNext();
}
if (isIgnored(candidate)) {
return fetchNext();
}
this.next = this.adapter.apply(candidate);
}
return this.next;
}
@Test
public void shouldLocatePropertySourcesInEachPathSpecifiedWhenApplicationNameContainsSeveral() {
VaultKeyValueBackendProperties backendProperties = new VaultKeyValueBackendProperties();
backendProperties.setApplicationName("wintermute,straylight,icebreaker/armitage");
backendProperties.setProfiles(Arrays.asList("vermillion", "periwinkle"));
this.propertySourceLocator = new VaultPropertySourceLocator(this.operations,
new VaultProperties(),
VaultPropertySourceLocatorSupport.createConfiguration(backendProperties));
PropertySource<?> propertySource = this.propertySourceLocator
.locate(this.configurableEnvironment);
assertThat(propertySource).isInstanceOf(CompositePropertySource.class);
CompositePropertySource composite = (CompositePropertySource) propertySource;
assertThat(composite.getPropertySources()).extracting("name").contains(
"secret/wintermute", "secret/straylight", "secret/icebreaker/armitage",
"secret/wintermute/vermillion", "secret/wintermute/periwinkle",
"secret/straylight/vermillion", "secret/straylight/periwinkle",
"secret/icebreaker/armitage/vermillion",
"secret/icebreaker/armitage/periwinkle");
}
/**
* Create a new {@link SpringConfigurationPropertySource} implementation.
*
* @param propertySource the source property source
* @param mapper the property mapper
* @param containsDescendantOf function used to implement
* {@link #containsDescendantOf(ConfigurationPropertyName)} (may be {@code null})
*/
SpringConfigurationPropertySource(PropertySource<?> propertySource,
PropertyMapper mapper,
Function<ConfigurationPropertyName, ConfigurationPropertyState> containsDescendantOf) {
Assert.notNull(propertySource, "PropertySource must not be null");
Assert.notNull(mapper, "Mapper must not be null");
this.propertySource = propertySource;
this.mapper = (mapper instanceof DelegatingPropertyMapper) ? mapper
: new DelegatingPropertyMapper(mapper);
this.containsDescendantOf = (containsDescendantOf != null) ? containsDescendantOf
: (n) -> ConfigurationPropertyState.UNKNOWN;
}
/**
* Creates a {@link CompositePropertySource}.
* @param environment must not be {@literal null}.
* @return the composite {@link PropertySource}.
*/
protected CompositePropertySource createCompositePropertySource(
Environment environment) {
List<PropertySource<?>> propertySources = doCreatePropertySources(environment);
return doCreateCompositePropertySource(this.propertySourceName, propertySources);
}
@Override
protected PropertySource<?> toPropertySource(EurekaServiceInfo eurekaServiceInfo) {
Map<String, Object> map = new LinkedHashMap<>();
map.put(EUREKA_CLIENT + "serviceUrl.defaultZone", eurekaServiceInfo.getUri() + EUREKA_API_PREFIX);
map.put(EUREKA_CLIENT + "region", DEFAULT_REGION);
map.put(EUREKA_CLIENT_OAUTH2 + "clientId", eurekaServiceInfo.getClientId());
map.put(EUREKA_CLIENT_OAUTH2 + "clientSecret", eurekaServiceInfo.getClientSecret());
map.put(EUREKA_CLIENT_OAUTH2 + "accessTokenUri", eurekaServiceInfo.getAccessTokenUri());
return new MapPropertySource(PROPERTY_SOURCE_NAME, map);
}
/**
* Get prefixed {@link Properties}
*
* @param propertySources {@link PropertySources}
* @param propertyResolver {@link PropertyResolver} to resolve the placeholder if present
* @param prefix the prefix of property name
* @return Map
* @see Properties
* @since 1.0.3
*/
public static Map<String, Object> getSubProperties(PropertySources propertySources, PropertyResolver propertyResolver, String prefix) {
Map<String, Object> subProperties = new LinkedHashMap<String, Object>();
String normalizedPrefix = normalizePrefix(prefix);
Iterator<PropertySource<?>> iterator = propertySources.iterator();
while (iterator.hasNext()) {
PropertySource<?> source = iterator.next();
if (source instanceof EnumerablePropertySource) {
for (String name : ((EnumerablePropertySource<?>) source).getPropertyNames()) {
if (!subProperties.containsKey(name) && name.startsWith(normalizedPrefix)) {
String subName = name.substring(normalizedPrefix.length());
if (!subProperties.containsKey(subName)) { // take first one
Object value = source.getProperty(name);
if (value instanceof String) {
// Resolve placeholder
value = propertyResolver.resolvePlaceholders((String) value);
}
subProperties.put(subName, value);
}
}
}
}
}
return unmodifiableMap(subProperties);
}