Refactor BootstrapRegistry support

Refactor `BootstrapRegistry` support following initial prototype work
with the Spring Cloud team.

This update splits the `BootstrapRegistry` API into `BootstrapRegistry`,
`BootstrapContext` and  `ConfigurableBootstrapContext` interfaces and
moves it to the same package as `SpringApplication`.

A new `Bootstrapper` interface has been introduced that can be added
to the `SpringApplication` to customize the `BootstrapRegistry` before
it's used.

Closes gh-23326

Author: philwebb

spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/liquibase/LiquibaseAutoConfigurationTests.java

@@ -37,6 +37,7 @@
 
 import org.springframework.beans.factory.BeanCreationException;
 import org.springframework.beans.factory.config.BeanDefinition;
+import org.springframework.boot.DefaultBootstrapContext;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.AutoConfigurations;
 import org.springframework.boot.autoconfigure.jdbc.EmbeddedDataSourceConfiguration;
@@ -78,8 +79,8 @@ class LiquibaseAutoConfigurationTests {
 
 	@BeforeEach
 	void init() {
-		new LiquibaseServiceLocatorApplicationListener()
-				.onApplicationEvent(new ApplicationStartingEvent(new SpringApplication(Object.class), new String[0]));
+		new LiquibaseServiceLocatorApplicationListener().onApplicationEvent(new ApplicationStartingEvent(
+				new DefaultBootstrapContext(), new SpringApplication(Object.class), new String[0]));
 	}
 
 	private final ApplicationContextRunner contextRunner = new ApplicationContextRunner()

spring-boot-project/spring-boot-devtools/src/test/java/org/springframework/boot/devtools/restart/RestartApplicationListenerTests.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.
@@ -23,6 +23,7 @@
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
 
+import org.springframework.boot.DefaultBootstrapContext;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.context.event.ApplicationFailedEvent;
 import org.springframework.boot.context.event.ApplicationPreparedEvent;
@@ -90,9 +91,10 @@ void disableWithSystemProperty(CapturedOutput output) {
 	private void testInitialize(boolean failed) {
 		Restarter.clearInstance();
 		RestartApplicationListener listener = new RestartApplicationListener();
+		DefaultBootstrapContext bootstrapContext = new DefaultBootstrapContext();
 		SpringApplication application = new SpringApplication();
 		ConfigurableApplicationContext context = mock(ConfigurableApplicationContext.class);
-		listener.onApplicationEvent(new ApplicationStartingEvent(application, ARGS));
+		listener.onApplicationEvent(new ApplicationStartingEvent(bootstrapContext, application, ARGS));
 		assertThat(Restarter.getInstance()).isNotEqualTo(nullValue());
 		assertThat(Restarter.getInstance().isFinished()).isFalse();
 		listener.onApplicationEvent(new ApplicationPreparedEvent(application, ARGS, context));

spring-boot-project/spring-boot-test/src/main/java/org/springframework/boot/test/context/ConfigDataApplicationContextInitializer.java

@@ -16,10 +16,10 @@
 
 package org.springframework.boot.test.context;
 
+import org.springframework.boot.DefaultBootstrapContext;
 import org.springframework.boot.DefaultPropertiesPropertySource;
 import org.springframework.boot.context.config.ConfigData;
 import org.springframework.boot.context.config.ConfigDataEnvironmentPostProcessor;
-import org.springframework.boot.env.DefaultBootstrapRegisty;
 import org.springframework.boot.env.RandomValuePropertySource;
 import org.springframework.context.ApplicationContextInitializer;
 import org.springframework.context.ConfigurableApplicationContext;
@@ -42,9 +42,9 @@ public class ConfigDataApplicationContextInitializer
 	public void initialize(ConfigurableApplicationContext applicationContext) {
 		ConfigurableEnvironment environment = applicationContext.getEnvironment();
 		RandomValuePropertySource.addToEnvironment(environment);
-		DefaultBootstrapRegisty bootstrapRegistry = new DefaultBootstrapRegisty();
-		ConfigDataEnvironmentPostProcessor.applyTo(environment, applicationContext, bootstrapRegistry);
-		bootstrapRegistry.applicationContextPrepared(applicationContext);
+		DefaultBootstrapContext bootstrapContext = new DefaultBootstrapContext();
+		ConfigDataEnvironmentPostProcessor.applyTo(environment, applicationContext, bootstrapContext);
+		bootstrapContext.close(applicationContext);
 		DefaultPropertiesPropertySource.moveToEnd(environment);
 	}
 

spring-boot-project/spring-boot/src/main/java/org/springframework/boot/BootstrapContext.java

@@ -0,0 +1,44 @@
+/*
+ * 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;
+
+import org.springframework.context.ApplicationContext;
+import org.springframework.core.env.Environment;
+
+/**
+ * A simple bootstrap context that is available during startup and {@link Environment}
+ * post-processing up to the point that the {@link ApplicationContext} is prepared.
+ * <p>
+ * Provides lazy access to singletons that may be expensive to create, or need to be
+ * shared before the {@link ApplicationContext} is available.
+ *
+ * @author Phillip Webb
+ * @since 2.4.0
+ */
+public interface BootstrapContext {
+
+	/**
+	 * Return an instance from the context, creating it if it hasn't been accessed
+	 * previously.
+	 * @param <T> the instance type
+	 * @param type the instance type
+	 * @return the instance managed by the context
+	 * @throws IllegalStateException if the type has not been registered
+	 */
+	<T> T get(Class<T> type) throws IllegalStateException;
+
+}

spring-boot-project/spring-boot/src/main/java/org/springframework/boot/BootstrapContextClosedEvent.java

@@ -0,0 +1,54 @@
+/*
+ * 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;
+
+import org.springframework.context.ApplicationEvent;
+import org.springframework.context.ConfigurableApplicationContext;
+
+/**
+ * {@link ApplicationEvent} published by a {@link BootstrapContext} when it's closed.
+ *
+ * @author Phillip Webb
+ * @since 2.4.0
+ * @see BootstrapRegistry#addCloseListener(org.springframework.context.ApplicationListener)
+ */
+public class BootstrapContextClosedEvent extends ApplicationEvent {
+
+	private final ConfigurableApplicationContext applicationContext;
+
+	BootstrapContextClosedEvent(BootstrapContext source, ConfigurableApplicationContext applicationContext) {
+		super(source);
+		this.applicationContext = applicationContext;
+	}
+
+	/**
+	 * Return the {@link BootstrapContext} that was closed.
+	 * @return the bootstrap context
+	 */
+	public BootstrapContext getBootstrapContext() {
+		return (BootstrapContext) this.source;
+	}
+
+	/**
+	 * Return the prepared application context.
+	 * @return the application context
+	 */
+	public ConfigurableApplicationContext getApplicationContext() {
+		return this.applicationContext;
+	}
+
+}

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

@@ -0,0 +1,130 @@
+/*
+ * 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;
+
+import java.util.function.Supplier;
+
+import io.undertow.servlet.api.InstanceFactory;
+
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.ApplicationListener;
+import org.springframework.core.env.Environment;
+
+/**
+ * A simple object registry that is available during startup and {@link Environment}
+ * post-processing up to the point that the {@link ApplicationContext} is prepared.
+ * <p>
+ * Can be used to register instances that may be expensive to create, or need to be shared
+ * before the {@link ApplicationContext} is available.
+ * <p>
+ * The registry uses {@link Class} as a key, meaning that only a single instance of a
+ * given type can be stored.
+ * <p>
+ * The {@link #addCloseListener(ApplicationListener)} method can be used to add a listener
+ * that can perform actions when {@link BootstrapContext} has been closed and the
+ * {@link ApplicationContext} is fully 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 BootstrapContext
+ * @see ConfigurableBootstrapContext
+ */
+public interface BootstrapRegistry {
+
+	/**
+	 * Register a specific type with the registry. If the specified type has already been
+	 * registered, but not get obtained, it will be replaced.
+	 * @param <T> the instance type
+	 * @param type the instance type
+	 * @param instanceSupplier the instance supplier
+	 */
+	<T> void register(Class<T> type, InstanceSupplier<T> instanceSupplier);
+
+	/**
+	 * Register a specific type with the registry if one is not already present.
+	 * @param <T> the instance type
+	 * @param type the instance type
+	 * @param instanceSupplier the instance supplier
+	 */
+	<T> void registerIfAbsent(Class<T> type, InstanceSupplier<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 InstanceFactory} for the given type.
+	 * @param <T> the instance type
+	 * @param type the instance type
+	 * @return the registered {@link InstanceSupplier} or {@code null}
+	 */
+	<T> InstanceSupplier<T> getRegisteredInstanceSupplier(Class<T> type);
+
+	/**
+	 * Add an {@link ApplicationListener} that will be called with a
+	 * {@link BootstrapContextClosedEvent} when the {@link BootstrapContext} is closed and
+	 * the {@link ApplicationContext} has been prepared.
+	 * @param listener the listener to add
+	 */
+	void addCloseListener(ApplicationListener<BootstrapContextClosedEvent> listener);
+
+	/**
+	 * Supplier used to provide the actual instance the first time it is accessed.
+	 *
+	 * @param <T> the instance type
+	 */
+	public interface InstanceSupplier<T> {
+
+		/**
+		 * Factory method used to create the instance when needed.
+		 * @param context the {@link BootstrapContext} which may be used to obtain other
+		 * bootstrap instances.
+		 * @return the instance
+		 */
+		T get(BootstrapContext context);
+
+		/**
+		 * Factory method that can be used to create a {@link InstanceFactory} for a given
+		 * instance.
+		 * @param <T> the instance type
+		 * @param instance the instance
+		 * @return a new {@link InstanceFactory}
+		 */
+		static <T> InstanceSupplier<T> of(T instance) {
+			return (registry) -> instance;
+		}
+
+		/**
+		 * Factory method that can be used to create a {@link InstanceFactory} from a
+		 * {@link Supplier}.
+		 * @param <T> the instance type
+		 * @param supplier the supplier that will provide the instance
+		 * @return a new {@link InstanceFactory}
+		 */
+		static <T> InstanceSupplier<T> from(Supplier<T> supplier) {
+			return (registry) -> (supplier != null) ? supplier.get() : null;
+		}
+
+	}
+
+}

spring-boot-project/spring-boot/src/main/java/org/springframework/boot/Bootstrapper.java

@@ -0,0 +1,36 @@
+/*
+ * 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;
+
+/**
+ * Callback interface that can be used to initialize a {@link BootstrapRegistry} before it
+ * is used.
+ *
+ * @author Phillip Webb
+ * @since 2.4.0
+ * @see SpringApplication#addBootstrapper(Bootstrapper)
+ * @see BootstrapRegistry
+ */
+public interface Bootstrapper {
+
+	/**
+	 * Initialize the given {@link BootstrapRegistry} with any required registrations.
+	 * @param registry the registry to initialize
+	 */
+	void intitialize(BootstrapRegistry registry);
+
+}

spring-boot-project/spring-boot/src/main/java/org/springframework/boot/ConfigurableBootstrapContext.java

@@ -0,0 +1,31 @@
+/*
+ * 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;
+
+/**
+ * A {@link BootstrapContext} that also provides configuration methods via the
+ * {@link BootstrapRegistry} interface.
+ *
+ * @author Phillip Webb
+ * @since 2.4.0
+ * @see BootstrapRegistry
+ * @see BootstrapContext
+ * @see DefaultBootstrapContext
+ */
+public interface ConfigurableBootstrapContext extends BootstrapRegistry, BootstrapContext {
+
+}