Add ConfigurationPropertyCaching support

Add a `ConfigurationPropertyCaching` utility interface that can be
used to control the property source caching.

Prior to this commit, a `ConfigurationPropertySource` that was backed
by a mutable `EnumerablePropertySource` would need to call the
`getPropertyNames()` method each time a property was accessed. Since
this this operation can be expensive, we now provide a way to cache
the results for a specific length of time.

This commit also improves the performance of immutable property sources
by limiting the number of candidates that need to be searched.
Previously, all mapped names would be enumerated. Now, mappings are
grouped by `ConfigurationPropertyName`. This is especially helpful when
the `ConfigurationPropertyName` isn't mapped at all since the hash based
map lookup will be very fast and the resulting mappings will be empty.

Closes gh-20625

Author: philwebb

spring-boot-project/spring-boot/src/main/java/org/springframework/boot/context/properties/source/CachingConfigurationPropertySource.java

@@ -0,0 +1,46 @@
+/*
+ * Copyright 2012-2020 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.boot.context.properties.source;
+
+/**
+ * Interface used to indicate that a {@link ConfigurationPropertySource} supports
+ * {@link ConfigurationPropertyCaching}.
+ *
+ * @author Phillip Webb
+ */
+interface CachingConfigurationPropertySource {
+
+	/**
+	 * Return {@link ConfigurationPropertyCaching} for this source.
+	 * @return source caching
+	 */
+	ConfigurationPropertyCaching getCaching();
+
+	/**
+	 * Find {@link ConfigurationPropertyCaching} for the given source.
+	 * @param source the configuration property source
+	 * @return a {@link ConfigurationPropertyCaching} instance or {@code null} if the
+	 * source does not support caching.
+	 */
+	static ConfigurationPropertyCaching find(ConfigurationPropertySource source) {
+		if (source instanceof CachingConfigurationPropertySource) {
+			return ((CachingConfigurationPropertySource) source).getCaching();
+		}
+		return null;
+	}
+
+}

spring-boot-project/spring-boot/src/main/java/org/springframework/boot/context/properties/source/ConfigurationPropertyCaching.java

@@ -0,0 +1,110 @@
+/*
+ * Copyright 2012-2020 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.boot.context.properties.source;
+
+import java.time.Duration;
+
+import org.springframework.core.env.Environment;
+import org.springframework.util.Assert;
+
+/**
+ * Interface that can be used to control configuration property source caches.
+ *
+ * @author Phillip Webb
+ * @since 2.3.0
+ */
+public interface ConfigurationPropertyCaching {
+
+	/**
+	 * Enable caching with an unlimited time-to-live.
+	 */
+	void enable();
+
+	/**
+	 * Disable caching.
+	 */
+	void disable();
+
+	/**
+	 * Set amount of time that an item can live in the cache. Calling this method will
+	 * also enable the cache.
+	 * @param timeToLive the time to live value.
+	 */
+	void setTimeToLive(Duration timeToLive);
+
+	/**
+	 * Clear the cache and force it to be reloaded on next access.
+	 */
+	void clear();
+
+	/**
+	 * Get for all configuration property sources in the environment.
+	 * @param environment the spring environment
+	 * @return a caching instance that controls all sources in the environment
+	 */
+	static ConfigurationPropertyCaching get(Environment environment) {
+		return get(environment, null);
+	}
+
+	/**
+	 * Get for a specific configuration property source in the environment.
+	 * @param environment the spring environment
+	 * @param underlyingSource the
+	 * {@link ConfigurationPropertySource#getUnderlyingSource() underlying source} that
+	 * must match
+	 * @return a caching instance that controls the matching source
+	 */
+	static ConfigurationPropertyCaching get(Environment environment, Object underlyingSource) {
+		Iterable<ConfigurationPropertySource> sources = ConfigurationPropertySources.get(environment);
+		return get(sources, underlyingSource);
+	}
+
+	/**
+	 * Get for all specified configuration property sources.
+	 * @param sources the configuration property sources
+	 * @return a caching instance that controls the sources
+	 */
+	static ConfigurationPropertyCaching get(Iterable<ConfigurationPropertySource> sources) {
+		return get(sources, null);
+	}
+
+	/**
+	 * Get for a specific configuration property source in the specified configuration
+	 * property sources.
+	 * @param sources the configuration property sources
+	 * @param underlyingSource the
+	 * {@link ConfigurationPropertySource#getUnderlyingSource() underlying source} that
+	 * must match
+	 * @return a caching instance that controls the matching source
+	 */
+	static ConfigurationPropertyCaching get(Iterable<ConfigurationPropertySource> sources, Object underlyingSource) {
+		Assert.notNull(sources, "Sources must not be null");
+		if (underlyingSource == null) {
+			return new ConfigurationPropertySourcesCaching(sources);
+		}
+		for (ConfigurationPropertySource source : sources) {
+			if (source.getUnderlyingSource() == underlyingSource) {
+				ConfigurationPropertyCaching caching = CachingConfigurationPropertySource.find(source);
+				if (caching != null) {
+					return caching;
+				}
+			}
+		}
+		throw new IllegalStateException("Unable to find cache from configuration property sources");
+	}
+
+}

spring-boot-project/spring-boot/src/main/java/org/springframework/boot/context/properties/source/ConfigurationPropertySourcesCaching.java

@@ -0,0 +1,67 @@
+/*
+ * Copyright 2012-2020 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.boot.context.properties.source;
+
+import java.time.Duration;
+import java.util.function.Consumer;
+
+/**
+ * {@link ConfigurationPropertyCaching} for an {@link Iterable iterable} set of
+ * {@link ConfigurationPropertySource} instances.
+ *
+ * @author Phillip Webb
+ */
+class ConfigurationPropertySourcesCaching implements ConfigurationPropertyCaching {
+
+	private final Iterable<ConfigurationPropertySource> sources;
+
+	ConfigurationPropertySourcesCaching(Iterable<ConfigurationPropertySource> sources) {
+		this.sources = sources;
+	}
+
+	@Override
+	public void enable() {
+		forEach(ConfigurationPropertyCaching::enable);
+	}
+
+	@Override
+	public void disable() {
+		forEach(ConfigurationPropertyCaching::disable);
+	}
+
+	@Override
+	public void setTimeToLive(Duration timeToLive) {
+		forEach((caching) -> caching.setTimeToLive(timeToLive));
+	}
+
+	@Override
+	public void clear() {
+		forEach(ConfigurationPropertyCaching::clear);
+	}
+
+	private void forEach(Consumer<ConfigurationPropertyCaching> action) {
+		if (this.sources != null) {
+			for (ConfigurationPropertySource source : this.sources) {
+				ConfigurationPropertyCaching caching = CachingConfigurationPropertySource.find(source);
+				if (caching != null) {
+					action.accept(caching);
+				}
+			}
+		}
+	}
+
+}

spring-boot-project/spring-boot/src/main/java/org/springframework/boot/context/properties/source/DefaultPropertyMapper.java

@@ -16,6 +16,9 @@
 
 package org.springframework.boot.context.properties.source;
 
+import java.util.Collections;
+import java.util.List;
+
 import org.springframework.util.ObjectUtils;
 
 /**
@@ -32,62 +35,62 @@ final class DefaultPropertyMapper implements PropertyMapper {
 
 	public static final PropertyMapper INSTANCE = new DefaultPropertyMapper();
 
-	private LastMapping<ConfigurationPropertyName> lastMappedConfigurationPropertyName;
+	private LastMapping<ConfigurationPropertyName, List<String>> lastMappedConfigurationPropertyName;
 
-	private LastMapping<String> lastMappedPropertyName;
+	private LastMapping<String, ConfigurationPropertyName> lastMappedPropertyName;
 
 	private DefaultPropertyMapper() {
 	}
 
 	@Override
-	public PropertyMapping[] map(ConfigurationPropertyName configurationPropertyName) {
+	public List<String> map(ConfigurationPropertyName configurationPropertyName) {
 		// Use a local copy in case another thread changes things
-		LastMapping<ConfigurationPropertyName> last = this.lastMappedConfigurationPropertyName;
+		LastMapping<ConfigurationPropertyName, List<String>> last = this.lastMappedConfigurationPropertyName;
 		if (last != null && last.isFrom(configurationPropertyName)) {
 			return last.getMapping();
 		}
 		String convertedName = configurationPropertyName.toString();
-		PropertyMapping[] mapping = { new PropertyMapping(convertedName, configurationPropertyName) };
+		List<String> mapping = Collections.singletonList(convertedName);
 		this.lastMappedConfigurationPropertyName = new LastMapping<>(configurationPropertyName, mapping);
 		return mapping;
 	}
 
 	@Override
-	public PropertyMapping[] map(String propertySourceName) {
+	public ConfigurationPropertyName map(String propertySourceName) {
 		// Use a local copy in case another thread changes things
-		LastMapping<String> last = this.lastMappedPropertyName;
+		LastMapping<String, ConfigurationPropertyName> last = this.lastMappedPropertyName;
 		if (last != null && last.isFrom(propertySourceName)) {
 			return last.getMapping();
 		}
-		PropertyMapping[] mapping = tryMap(propertySourceName);
+		ConfigurationPropertyName mapping = tryMap(propertySourceName);
 		this.lastMappedPropertyName = new LastMapping<>(propertySourceName, mapping);
 		return mapping;
 	}
 
-	private PropertyMapping[] tryMap(String propertySourceName) {
+	private ConfigurationPropertyName tryMap(String propertySourceName) {
 		try {
 			ConfigurationPropertyName convertedName = ConfigurationPropertyName.adapt(propertySourceName, '.');
 			if (!convertedName.isEmpty()) {
-				return new PropertyMapping[] { new PropertyMapping(propertySourceName, convertedName) };
+				return convertedName;
 			}
 		}
 		catch (Exception ex) {
 		}
-		return NO_MAPPINGS;
+		return ConfigurationPropertyName.EMPTY;
 	}
 
 	@Override
 	public boolean isAncestorOf(ConfigurationPropertyName name, ConfigurationPropertyName candidate) {
 		return name.isAncestorOf(candidate);
 	}
 
-	private static class LastMapping<T> {
+	private static class LastMapping<T, M> {
 
 		private final T from;
 
-		private final PropertyMapping[] mapping;
+		private final M mapping;
 
-		LastMapping(T from, PropertyMapping[] mapping) {
+		LastMapping(T from, M mapping) {
 			this.from = from;
 			this.mapping = mapping;
 		}
@@ -96,7 +99,7 @@ boolean isFrom(T from) {
 			return ObjectUtils.nullSafeEquals(from, this.from);
 		}
 
-		PropertyMapping[] getMapping() {
+		M getMapping() {
 			return this.mapping;
 		}
 

spring-boot-project/spring-boot/src/main/java/org/springframework/boot/context/properties/source/MapConfigurationPropertySource.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2012-2019 the original author or authors.
+ * Copyright 2012-2020 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -35,6 +35,8 @@
  */
 public class MapConfigurationPropertySource implements IterableConfigurationPropertySource {
 
+	private static final PropertyMapper[] DEFAULT_MAPPERS = { DefaultPropertyMapper.INSTANCE };
+
 	private final Map<String, Object> source;
 
 	private final IterableConfigurationPropertySource delegate;
@@ -53,8 +55,8 @@ public MapConfigurationPropertySource() {
 	 */
 	public MapConfigurationPropertySource(Map<?, ?> map) {
 		this.source = new LinkedHashMap<>();
-		this.delegate = new SpringIterableConfigurationPropertySource(new MapPropertySource("source", this.source),
-				DefaultPropertyMapper.INSTANCE);
+		MapPropertySource mapPropertySource = new MapPropertySource("source", this.source);
+		this.delegate = new SpringIterableConfigurationPropertySource(mapPropertySource, DEFAULT_MAPPERS);
 		putAll(map);
 	}
 

spring-boot-project/spring-boot/src/main/java/org/springframework/boot/context/properties/source/PropertyMapper.java

@@ -16,6 +16,8 @@
 
 package org.springframework.boot.context.properties.source;
 
+import java.util.List;
+
 import org.springframework.core.env.EnumerablePropertySource;
 import org.springframework.core.env.PropertySource;
 
@@ -28,8 +30,7 @@
  * {@link SpringConfigurationPropertySource} to first attempt any direct mappings (i.e.
  * map the {@link ConfigurationPropertyName} directly to the {@link PropertySource} name)
  * before falling back to {@link EnumerablePropertySource enumerating} property names,
- * mapping them to a {@link ConfigurationPropertyName} and checking for
- * {@link PropertyMapping#isApplicable(ConfigurationPropertyName) applicability}. See
+ * mapping them to a {@link ConfigurationPropertyName} and checking for applicability. See
  * {@link SpringConfigurationPropertySource} for more details.
  *
  * @author Phillip Webb
@@ -38,22 +39,21 @@
  */
 interface PropertyMapper {
 
-	PropertyMapping[] NO_MAPPINGS = {};
-
 	/**
 	 * Provide mappings from a {@link ConfigurationPropertySource}
 	 * {@link ConfigurationPropertyName}.
 	 * @param configurationPropertyName the name to map
-	 * @return a stream of mappings or {@code Stream#empty()}
+	 * @return the mapped names or an empty list
 	 */
-	PropertyMapping[] map(ConfigurationPropertyName configurationPropertyName);
+	List<String> map(ConfigurationPropertyName configurationPropertyName);
 
 	/**
 	 * Provide mappings from a {@link PropertySource} property name.
 	 * @param propertySourceName the name to map
-	 * @return a stream of mappings or {@code Stream#empty()}
+	 * @return the mapped configuration property name or
+	 * {@link ConfigurationPropertyName#EMPTY}
 	 */
-	PropertyMapping[] map(String propertySourceName);
+	ConfigurationPropertyName map(String propertySourceName);
 
 	/**
 	 * Returns {@code true} if {@code name} is an ancestor (immediate or nested parent) of