Add BootstrapRegistry for long lived instances

Add a simple `BootstrapRegistry` that can be used to store and share
object instances across `EnvironmentPostProcessors`. The registry
can be injected into the constructor of any `EnvironmentPostProcessor`.

Registrations can also perform additional actions when the
`ApplicationContext` has been prepared. For example, they could register
the the bootstrap instances as beans so that they become available to
the application.

See gh-22956

Author: philwebb

spring-boot-project/spring-boot-devtools/src/main/java/org/springframework/boot/devtools/RemoteSpringApplication.java

@@ -74,7 +74,7 @@ private Collection<ApplicationListener<?>> getListeners() {
 		List<ApplicationListener<?>> listeners = new ArrayList<>();
 		listeners.add(new AnsiOutputApplicationListener());
 		listeners.add(new EnvironmentPostProcessorApplicationListener(
-				EnvironmentPostProcessorsFactory.singleton(ConfigDataEnvironmentPostProcessor::new)));
+				EnvironmentPostProcessorsFactory.of(ConfigDataEnvironmentPostProcessor.class)));
 		listeners.add(new ClasspathLoggingApplicationListener());
 		listeners.add(new LoggingApplicationListener());
 		listeners.add(new RemoteUrlPropertyExtractor());

spring-boot-project/spring-boot/src/main/java/org/springframework/boot/env/BootstrapRegistry.java

@@ -0,0 +1,123 @@
+/*
+ * 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.env;
+
+import java.util.function.BiConsumer;
+import java.util.function.Supplier;
+
+import org.springframework.boot.context.event.ApplicationPreparedEvent;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.ConfigurableApplicationContext;
+import org.springframework.core.env.Environment;
+
+/**
+ * A simple object registry that is available during {@link Environment} post-processing
+ * up to the point that the {@link ApplicationContext} is prepared. The registry can be
+ * used to store objects that may be expensive to create, or need to be shared by
+ * different {@link EnvironmentPostProcessor EnvironmentPostProcessors}.
+ * <p>
+ * The registry uses the object type as a key, meaning that only a single instance of a
+ * given class can be stored.
+ * <p>
+ * Registered instances may optionally use
+ * {@link Registration#onApplicationContextPrepared(BiConsumer)
+ * onApplicationContextPrepared(...)} to perform an action when the
+ * {@link ApplicationContext} is {@link ApplicationPreparedEvent prepared}. For example,
+ * an instance may choose to register itself as a regular Spring bean so that it is
+ * available for the application to use.
+ *
+ * @author Phillip Webb
+ * @since 2.4.0
+ * @see EnvironmentPostProcessor
+ */
+public interface BootstrapRegistry {
+
+	/**
+	 * Get an instance from the registry, creating one if it does not already exist.
+	 * @param <T> the instance type
+	 * @param type the instance type
+	 * @param instanceSupplier a supplier used to create the instance if it doesn't
+	 * already exist
+	 * @return the registered instance
+	 */
+	<T> T get(Class<T> type, Supplier<T> instanceSupplier);
+
+	/**
+	 * Get an instance from the registry, creating one if it does not already exist.
+	 * @param <T> the instance type
+	 * @param type the instance type
+	 * @param instanceSupplier a supplier used to create the instance if it doesn't
+	 * already exist
+	 * @param onApplicationContextPreparedAction the action that should be called when the
+	 * application context is prepared. This action is ignored if the registration already
+	 * exists.
+	 * @return the registered instance
+	 */
+	<T> T get(Class<T> type, Supplier<T> instanceSupplier,
+			BiConsumer<ConfigurableApplicationContext, T> onApplicationContextPreparedAction);
+
+	/**
+	 * Register an instance with the registry and return a {@link Registration} that can
+	 * be used to provide further configuration. This method will replace any existing
+	 * registration.
+	 * @param <T> the instance type
+	 * @param type the instance type
+	 * @param instanceSupplier a supplier used to create the instance if it doesn't
+	 * already exist
+	 * @return an instance registration
+	 */
+	<T> Registration<T> register(Class<T> type, Supplier<T> instanceSupplier);
+
+	/**
+	 * Return if a registration exists for the given type.
+	 * @param <T> the instance type
+	 * @param type the instance type
+	 * @return {@code true} if the type has already been registered
+	 */
+	<T> boolean isRegistered(Class<T> type);
+
+	/**
+	 * Return any existing {@link Registration} for the given type.
+	 * @param <T> the instance type
+	 * @param type the instance type
+	 * @return the existing registration or {@code null}
+	 */
+	<T> Registration<T> getRegistration(Class<T> type);
+
+	/**
+	 * A single registration contained in the registry.
+	 *
+	 * @param <T> the instance type
+	 */
+	interface Registration<T> {
+
+		/**
+		 * Get or crearte the registered object instance.
+		 * @return the object instance
+		 */
+		T get();
+
+		/**
+		 * Add an action that should run when the {@link ApplicationContext} has been
+		 * prepared.
+		 * @param action the action to run
+		 */
+		void onApplicationContextPrepared(BiConsumer<ConfigurableApplicationContext, T> action);
+
+	}
+
+}

spring-boot-project/spring-boot/src/main/java/org/springframework/boot/env/DefaultBootstrapRegisty.java

@@ -0,0 +1,127 @@
+/*
+ * 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.env;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.function.BiConsumer;
+import java.util.function.Supplier;
+
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.ConfigurableApplicationContext;
+
+/**
+ * Default implementation of {@link BootstrapRegistry}.
+ *
+ * @author Phillip Webb
+ * @since 2.4.0
+ */
+public class DefaultBootstrapRegisty implements BootstrapRegistry {
+
+	private final Map<Class<?>, DefaultRegistration<?>> registrations = new HashMap<>();
+
+	@Override
+	public <T> T get(Class<T> type, Supplier<T> instanceSupplier) {
+		return get(type, instanceSupplier, null);
+	}
+
+	@Override
+	public <T> T get(Class<T> type, Supplier<T> instanceSupplier,
+			BiConsumer<ConfigurableApplicationContext, T> onApplicationContextPreparedAction) {
+		Registration<T> registration = getRegistration(type);
+		if (registration != null) {
+			return registration.get();
+		}
+		registration = register(type, instanceSupplier);
+		registration.onApplicationContextPrepared(onApplicationContextPreparedAction);
+		return registration.get();
+	}
+
+	@Override
+	public <T> Registration<T> register(Class<T> type, Supplier<T> instanceSupplier) {
+		DefaultRegistration<T> registration = new DefaultRegistration<>(instanceSupplier);
+		this.registrations.put(type, registration);
+		return registration;
+	}
+
+	@Override
+	public <T> boolean isRegistered(Class<T> type) {
+		return getRegistration(type) != null;
+	}
+
+	@Override
+	@SuppressWarnings("unchecked")
+	public <T> Registration<T> getRegistration(Class<T> type) {
+		return (Registration<T>) this.registrations.get(type);
+	}
+
+	/**
+	 * Method to be called when the {@link ApplicationContext} is prepared.
+	 * @param applicationContext the prepared context
+	 */
+	public void applicationContextPrepared(ConfigurableApplicationContext applicationContext) {
+		this.registrations.values()
+				.forEach((registration) -> registration.applicationContextPrepared(applicationContext));
+	}
+
+	/**
+	 * Default implementation of {@link Registration}.
+	 */
+	private static class DefaultRegistration<T> implements Registration<T> {
+
+		private Supplier<T> instanceSupplier;
+
+		private volatile T instance;
+
+		private List<BiConsumer<ConfigurableApplicationContext, T>> applicationContextPreparedActions = new ArrayList<>();
+
+		DefaultRegistration(Supplier<T> instanceSupplier) {
+			this.instanceSupplier = instanceSupplier;
+		}
+
+		@Override
+		public T get() {
+			T instance = this.instance;
+			if (instance == null) {
+				synchronized (this.instanceSupplier) {
+					instance = this.instanceSupplier.get();
+					this.instance = instance;
+				}
+			}
+			return instance;
+		}
+
+		@Override
+		public void onApplicationContextPrepared(BiConsumer<ConfigurableApplicationContext, T> action) {
+			if (action != null) {
+				this.applicationContextPreparedActions.add(action);
+			}
+		}
+
+		/**
+		 * Method called when the {@link ApplicationContext} is prepared.
+		 * @param applicationContext the prepared context
+		 */
+		void applicationContextPrepared(ConfigurableApplicationContext applicationContext) {
+			this.applicationContextPreparedActions.forEach((consumer) -> consumer.accept(applicationContext, get()));
+		}
+
+	}
+
+}

spring-boot-project/spring-boot/src/main/java/org/springframework/boot/env/EnvironmentPostProcessor.java

@@ -34,9 +34,16 @@
  * if they wish to be invoked in specific order.
  * <p>
  * Since Spring Boot 2.4, {@code EnvironmentPostProcessor} implementations may optionally
- * take a single {@link Log} or {@link DeferredLogFactory} instance as a constructor
- * argument. The injected {@link Log} instance will defer output until the application has
- * been full prepared to allow the environment itself to configure logging levels.
+ * take the following constructor parameters:
+ * <ul>
+ * <li>{@link DeferredLogFactory} - A factory that can be used to create loggers with
+ * output deferred until the application has been full prepared (allowing the environment
+ * itself to configure logging levels).</li>
+ * <li>{@link Log} - A log with output deferred until the application has been full
+ * prepared (allowing the environment itself to configure logging levels).</li>
+ * <li>{@link BootstrapRegistry} - A bootstrap registry that can be used to store objects
+ * that may be expensive to create, or need to be shared.</li>
+ * </ul>
  *
  * @author Andy Wilkinson
  * @author Stephane Nicoll

spring-boot-project/spring-boot/src/main/java/org/springframework/boot/env/EnvironmentPostProcessorApplicationListener.java

@@ -44,6 +44,8 @@ public class EnvironmentPostProcessorApplicationListener implements SmartApplica
 
 	private final DeferredLogs deferredLogs;
 
+	private final DefaultBootstrapRegisty bootstrapRegistry;
+
 	private int order = DEFAULT_ORDER;
 
 	private final EnvironmentPostProcessorsFactory postProcessorsFactory;
@@ -63,13 +65,14 @@ public EnvironmentPostProcessorApplicationListener() {
 	 * @param postProcessorsFactory the post processors factory
 	 */
 	public EnvironmentPostProcessorApplicationListener(EnvironmentPostProcessorsFactory postProcessorsFactory) {
-		this(postProcessorsFactory, new DeferredLogs());
+		this(postProcessorsFactory, new DeferredLogs(), new DefaultBootstrapRegisty());
 	}
 
 	EnvironmentPostProcessorApplicationListener(EnvironmentPostProcessorsFactory postProcessorsFactory,
-			DeferredLogs deferredLogs) {
+			DeferredLogs deferredLogs, DefaultBootstrapRegisty bootstrapRegistry) {
 		this.postProcessorsFactory = postProcessorsFactory;
 		this.deferredLogs = deferredLogs;
+		this.bootstrapRegistry = bootstrapRegistry;
 	}
 
 	@Override
@@ -84,8 +87,11 @@ public void onApplicationEvent(ApplicationEvent event) {
 		if (event instanceof ApplicationEnvironmentPreparedEvent) {
 			onApplicationEnvironmentPreparedEvent((ApplicationEnvironmentPreparedEvent) event);
 		}
-		if (event instanceof ApplicationPreparedEvent || event instanceof ApplicationFailedEvent) {
-			onFinish();
+		if (event instanceof ApplicationPreparedEvent) {
+			onApplicationPreparedEvent((ApplicationPreparedEvent) event);
+		}
+		if (event instanceof ApplicationFailedEvent) {
+			onApplicationFailedEvent((ApplicationFailedEvent) event);
 		}
 	}
 
@@ -97,14 +103,19 @@ private void onApplicationEnvironmentPreparedEvent(ApplicationEnvironmentPrepare
 		}
 	}
 
-	List<EnvironmentPostProcessor> getEnvironmentPostProcessors() {
-		return this.postProcessorsFactory.getEnvironmentPostProcessors(this.deferredLogs);
+	private void onApplicationPreparedEvent(ApplicationPreparedEvent event) {
+		this.deferredLogs.switchOverAll();
+		this.bootstrapRegistry.applicationContextPrepared(event.getApplicationContext());
 	}
 
-	private void onFinish() {
+	private void onApplicationFailedEvent(ApplicationFailedEvent event) {
 		this.deferredLogs.switchOverAll();
 	}
 
+	List<EnvironmentPostProcessor> getEnvironmentPostProcessors() {
+		return this.postProcessorsFactory.getEnvironmentPostProcessors(this.deferredLogs, this.bootstrapRegistry);
+	}
+
 	@Override
 	public int getOrder() {
 		return this.order;

spring-boot-project/spring-boot/src/main/java/org/springframework/boot/env/EnvironmentPostProcessorsFactory.java

@@ -16,9 +16,7 @@
 
 package org.springframework.boot.env;
 
-import java.util.Collections;
 import java.util.List;
-import java.util.function.Function;
 
 import org.springframework.boot.logging.DeferredLogFactory;
 import org.springframework.core.io.support.SpringFactoriesLoader;
@@ -36,9 +34,11 @@ public interface EnvironmentPostProcessorsFactory {
 	/**
 	 * Create all requested {@link EnvironmentPostProcessor} instances.
 	 * @param logFactory a deferred log factory
+	 * @param bootstrapRegistry a bootstrap registry
 	 * @return the post processor instances
 	 */
-	List<EnvironmentPostProcessor> getEnvironmentPostProcessors(DeferredLogFactory logFactory);
+	List<EnvironmentPostProcessor> getEnvironmentPostProcessors(DeferredLogFactory logFactory,
+			BootstrapRegistry bootstrapRegistry);
 
 	/**
 	 * Return a {@link EnvironmentPostProcessorsFactory} backed by
@@ -71,14 +71,4 @@ static EnvironmentPostProcessorsFactory of(String... classNames) {
 		return new ReflectionEnvironmentPostProcessorsFactory(classNames);
 	}
 
-	/**
-	 * Create a {@link EnvironmentPostProcessorsFactory} containing only a single post
-	 * processor.
-	 * @param factory the factory used to create the post processor
-	 * @return an {@link EnvironmentPostProcessorsFactory} instance
-	 */
-	static EnvironmentPostProcessorsFactory singleton(Function<DeferredLogFactory, EnvironmentPostProcessor> factory) {
-		return (logFactory) -> Collections.singletonList(factory.apply(logFactory));
-	}
-
 }