Support ResourceLoader delegation from ApplicationResourceLoader

Update `ApplicationResourceLoader` to support delegation to another
`ResourceLoader`. The update allows customer resource loaders to be
used when loading SSL resources.

Closes gh-42835

Author: philwebb

spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/couchbase/CouchbaseAutoConfiguration.java

@@ -60,6 +60,7 @@
 import org.springframework.context.annotation.Configuration;
 import org.springframework.core.Ordered;
 import org.springframework.core.io.Resource;
+import org.springframework.core.io.ResourceLoader;
 import org.springframework.util.Assert;
 import org.springframework.util.StringUtils;
 
@@ -81,9 +82,12 @@
 @EnableConfigurationProperties(CouchbaseProperties.class)
 public class CouchbaseAutoConfiguration {
 
+	private final ResourceLoader resourceLoader;
+
 	private final CouchbaseProperties properties;
 
-	CouchbaseAutoConfiguration(CouchbaseProperties properties) {
+	CouchbaseAutoConfiguration(ResourceLoader resourceLoader, CouchbaseProperties properties) {
+		this.resourceLoader = ApplicationResourceLoader.get(resourceLoader);
 		this.properties = properties;
 	}
 
@@ -117,7 +121,7 @@ public Authenticator couchbaseAuthenticator(CouchbaseConnectionDetails connectio
 		}
 		Jks jks = this.properties.getAuthentication().getJks();
 		if (jks.getLocation() != null) {
-			Resource resource = new ApplicationResourceLoader().getResource(jks.getLocation());
+			Resource resource = this.resourceLoader.getResource(jks.getLocation());
 			String keystorePassword = jks.getPassword();
 			try (InputStream inputStream = resource.getInputStream()) {
 				KeyStore store = KeyStore.getInstance(KeyStore.getDefaultType());

spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/ssl/PropertiesSslBundle.java

@@ -99,7 +99,7 @@ public SslManagerBundle getManagers() {
 	 * @return an {@link SslBundle} instance
 	 */
 	public static SslBundle get(PemSslBundleProperties properties) {
-		return get(properties, new ApplicationResourceLoader());
+		return get(properties, ApplicationResourceLoader.get());
 	}
 
 	/**
@@ -143,7 +143,7 @@ private static PemSslStoreDetails asPemSslStoreDetails(PemSslBundleProperties.St
 	 * @return an {@link SslBundle} instance
 	 */
 	public static SslBundle get(JksSslBundleProperties properties) {
-		return get(properties, new ApplicationResourceLoader());
+		return get(properties, ApplicationResourceLoader.get());
 	}
 
 	/**

spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/ssl/SslAutoConfiguration.java

@@ -38,12 +38,12 @@
 @EnableConfigurationProperties(SslProperties.class)
 public class SslAutoConfiguration {
 
-	private final ApplicationResourceLoader resourceLoader;
+	private final ResourceLoader resourceLoader;
 
 	private final SslProperties sslProperties;
 
 	SslAutoConfiguration(ResourceLoader resourceLoader, SslProperties sslProperties) {
-		this.resourceLoader = new ApplicationResourceLoader(resourceLoader.getClassLoader());
+		this.resourceLoader = ApplicationResourceLoader.get(resourceLoader);
 		this.sslProperties = sslProperties;
 	}
 

spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/ssl/BundleContentPropertyTests.java

@@ -78,7 +78,7 @@ void hasValueWhenHasEmptyValueReturnsFalse() {
 	@Test
 	void toWatchPathWhenNotPathThrowsException() {
 		BundleContentProperty property = new BundleContentProperty("name", PEM_TEXT);
-		assertThatIllegalStateException().isThrownBy(() -> property.toWatchPath(new ApplicationResourceLoader()))
+		assertThatIllegalStateException().isThrownBy(() -> property.toWatchPath(ApplicationResourceLoader.get()))
 			.withMessage("Unable to convert value of property 'name' to a path");
 	}
 
@@ -87,15 +87,15 @@ void toWatchPathWhenPathReturnsPath() throws URISyntaxException {
 		URL resource = getClass().getResource("keystore.jks");
 		Path file = Path.of(resource.toURI()).toAbsolutePath();
 		BundleContentProperty property = new BundleContentProperty("name", file.toString());
-		assertThat(property.toWatchPath(new ApplicationResourceLoader())).isEqualTo(file);
+		assertThat(property.toWatchPath(ApplicationResourceLoader.get())).isEqualTo(file);
 	}
 
 	@Test
 	void toWatchPathUsesResourceLoader() throws URISyntaxException {
 		URL resource = getClass().getResource("keystore.jks");
 		Path file = Path.of(resource.toURI()).toAbsolutePath();
 		BundleContentProperty property = new BundleContentProperty("name", file.toString());
-		ResourceLoader resourceLoader = spy(new ApplicationResourceLoader());
+		ResourceLoader resourceLoader = spy(ApplicationResourceLoader.get());
 		assertThat(property.toWatchPath(resourceLoader)).isEqualTo(file);
 		then(resourceLoader).should(atLeastOnce()).getResource(file.toString());
 	}
@@ -104,7 +104,7 @@ void toWatchPathUsesResourceLoader() throws URISyntaxException {
 	void shouldThrowBundleContentNotWatchableExceptionIfContentIsNotWatchable() {
 		BundleContentProperty property = new BundleContentProperty("name", "https://example.com/");
 		assertThatExceptionOfType(BundleContentNotWatchableException.class)
-			.isThrownBy(() -> property.toWatchPath(new ApplicationResourceLoader()))
+			.isThrownBy(() -> property.toWatchPath(ApplicationResourceLoader.get()))
 			.withMessageContaining("Only 'file:' resources are watchable");
 	}
 

spring-boot-project/spring-boot/src/main/java/org/springframework/boot/convert/StringToFileConverter.java

@@ -34,8 +34,7 @@ class StringToFileConverter implements Converter<String, File> {
 
 	@Override
 	public File convert(String source) {
-		Resource resource = new ApplicationResourceLoader().getResource(source);
-		return getFile(resource);
+		return getFile(ApplicationResourceLoader.get().getResource(source));
 	}
 
 	private File getFile(Resource resource) {

spring-boot-project/spring-boot/src/main/java/org/springframework/boot/io/ApplicationResourceLoader.java

@@ -16,27 +16,38 @@
 
 package org.springframework.boot.io;
 
+import java.util.List;
+
 import org.springframework.core.io.ContextResource;
 import org.springframework.core.io.DefaultResourceLoader;
 import org.springframework.core.io.FileSystemResource;
 import org.springframework.core.io.ProtocolResolver;
 import org.springframework.core.io.Resource;
+import org.springframework.core.io.ResourceLoader;
 import org.springframework.core.io.support.SpringFactoriesLoader;
+import org.springframework.util.Assert;
+import org.springframework.util.StringUtils;
 
 /**
- * A {@link DefaultResourceLoader} with any {@link ProtocolResolver ProtocolResolvers}
- * registered in a {@code spring.factories} file applied to it. Plain paths without a
- * qualifier will resolve to file system resources. This is different from
+ * Class can be used to obtain {@link ResourceLoader ResourceLoaders} supporting
+ * additional {@link ProtocolResolver ProtocolResolvers} registered in
+ * {@code spring.factories}.
+ * <p>
+ * When not delegating to an existing resource loader, plain paths without a qualifier
+ * will resolve to file system resources. This is different from
  * {@code DefaultResourceLoader}, which resolves unqualified paths to classpath resources.
  *
  * @author Scott Frederick
+ * @author Phillip Webb
  * @since 3.3.0
  */
 public class ApplicationResourceLoader extends DefaultResourceLoader {
 
 	/**
 	 * Create a new {@code ApplicationResourceLoader}.
+	 * @deprecated since 3.4.0 for removal in 3.6.0 in favor of {@link #get()}
 	 */
+	@Deprecated(since = "3.4.0", forRemoval = true)
 	public ApplicationResourceLoader() {
 		this(null);
 	}
@@ -46,7 +57,9 @@ public ApplicationResourceLoader() {
 	 * @param classLoader the {@link ClassLoader} to load class path resources with, or
 	 * {@code null} for using the thread context class loader at the time of actual
 	 * resource access
+	 * @deprecated since 3.4.0 for removal in 3.6.0 in favor of {@link #get(ClassLoader)}
 	 */
+	@Deprecated(since = "3.4.0", forRemoval = true)
 	public ApplicationResourceLoader(ClassLoader classLoader) {
 		super(classLoader);
 		SpringFactoriesLoader loader = SpringFactoriesLoader.forDefaultResourceLocation(classLoader);
@@ -55,12 +68,107 @@ public ApplicationResourceLoader(ClassLoader classLoader) {
 
 	@Override
 	protected Resource getResourceByPath(String path) {
-		return new FileSystemContextResource(path);
+		return new ApplicationResource(path);
+	}
+
+	/**
+	 * Return a {@link ResourceLoader} supporting additional {@link ProtocolResolver
+	 * ProtocolResolvers} registered in {@code spring.factories}. The factories file will
+	 * be resolved using the default class loader at the time this call is made. Resources
+	 * will be resolved using the default class loader at the time they are resolved.
+	 * @return a {@link ResourceLoader} instance
+	 * @since 3.4.0
+	 */
+	public static ResourceLoader get() {
+		return get((ClassLoader) null);
+	}
+
+	/**
+	 * Return a {@link ResourceLoader} supporting additional {@link ProtocolResolver
+	 * ProtocolResolvers} registered in {@code spring.factories}. The factories files and
+	 * resources will be resolved using the specified class loader.
+	 * @param classLoader the class loader to use or {@code null} to use the default class
+	 * loader
+	 * @return a {@link ResourceLoader} instance
+	 * @since 3.4.0
+	 */
+	public static ResourceLoader get(ClassLoader classLoader) {
+		return get(classLoader, SpringFactoriesLoader.forDefaultResourceLocation(classLoader));
+	}
+
+	/**
+	 * Return a {@link ResourceLoader} supporting additional {@link ProtocolResolver
+	 * ProtocolResolvers} registered in {@code spring.factories}.
+	 * @param classLoader the class loader to use or {@code null} to use the default class
+	 * loader
+	 * @param springFactoriesLoader the {@link SpringFactoriesLoader} used to load
+	 * {@link ProtocolResolver ProtocolResolvers}
+	 * @return a {@link ResourceLoader} instance
+	 * @since 3.4.0
+	 */
+	public static ResourceLoader get(ClassLoader classLoader, SpringFactoriesLoader springFactoriesLoader) {
+		return get(ApplicationFileSystemResourceLoader.get(classLoader), springFactoriesLoader);
 	}
 
-	private static class FileSystemContextResource extends FileSystemResource implements ContextResource {
+	/**
+	 * Return a {@link ResourceLoader} delegating to the given resource loader and
+	 * supporting additional {@link ProtocolResolver ProtocolResolvers} registered in
+	 * {@code spring.factories}. The factories file will be resolved using the default
+	 * class loader at the time this call is made.
+	 * @param resourceLoader the delegate resource loader
+	 * @return a {@link ResourceLoader} instance
+	 * @since 3.4.0
+	 */
+	public static ResourceLoader get(ResourceLoader resourceLoader) {
+		Assert.notNull(resourceLoader, "'resourceLoader' must not be null");
+		return get(resourceLoader, SpringFactoriesLoader.forDefaultResourceLocation(resourceLoader.getClassLoader()));
+	}
+
+	/**
+	 * Return a {@link ResourceLoader} delegating to the given resource loader and
+	 * supporting additional {@link ProtocolResolver ProtocolResolvers} registered in
+	 * {@code spring.factories}.
+	 * @param resourceLoader the delegate resource loader
+	 * @param springFactoriesLoader the {@link SpringFactoriesLoader} used to load
+	 * {@link ProtocolResolver ProtocolResolvers}
+	 * @return a {@link ResourceLoader} instance
+	 * @since 3.4.0
+	 */
+	public static ResourceLoader get(ResourceLoader resourceLoader, SpringFactoriesLoader springFactoriesLoader) {
+		Assert.notNull(resourceLoader, "'resourceLoader' must not be null");
+		Assert.notNull(springFactoriesLoader, "'springFactoriesLoader' must not be null");
+		return new ProtocolResolvingResourceLoader(resourceLoader, springFactoriesLoader.load(ProtocolResolver.class));
+	}
+
+	/**
+	 * Internal {@link ResourceLoader} used to load {@link ApplicationResource}.
+	 */
+	private static final class ApplicationFileSystemResourceLoader extends DefaultResourceLoader {
+
+		private static final ResourceLoader shared = new ApplicationFileSystemResourceLoader(null);
+
+		private ApplicationFileSystemResourceLoader(ClassLoader classLoader) {
+			super(classLoader);
+		}
 
-		FileSystemContextResource(String path) {
+		@Override
+		protected Resource getResourceByPath(String path) {
+			return new ApplicationResource(path);
+		}
+
+		static ResourceLoader get(ClassLoader classLoader) {
+			return (classLoader != null) ? new ApplicationFileSystemResourceLoader(classLoader)
+					: ApplicationFileSystemResourceLoader.shared;
+		}
+
+	}
+
+	/**
+	 * An application {@link Resource}.
+	 */
+	private static final class ApplicationResource extends FileSystemResource implements ContextResource {
+
+		ApplicationResource(String path) {
 			super(path);
 		}
 
@@ -71,4 +179,39 @@ public String getPathWithinContext() {
 
 	}
 
+	/**
+	 * {@link ResourceLoader} decorator that adds support for additional
+	 * {@link ProtocolResolver ProtocolResolvers}.
+	 */
+	private static class ProtocolResolvingResourceLoader implements ResourceLoader {
+
+		private final ResourceLoader resourceLoader;
+
+		private final List<ProtocolResolver> protocolResolvers;
+
+		ProtocolResolvingResourceLoader(ResourceLoader resourceLoader, List<ProtocolResolver> protocolResolvers) {
+			this.resourceLoader = resourceLoader;
+			this.protocolResolvers = protocolResolvers;
+		}
+
+		@Override
+		public Resource getResource(String location) {
+			if (StringUtils.hasLength(location)) {
+				for (ProtocolResolver protocolResolver : this.protocolResolvers) {
+					Resource resource = protocolResolver.resolve(location, this);
+					if (resource != null) {
+						return resource;
+					}
+				}
+			}
+			return this.resourceLoader.getResource(location);
+		}
+
+		@Override
+		public ClassLoader getClassLoader() {
+			return this.resourceLoader.getClassLoader();
+		}
+
+	}
+
 }

spring-boot-project/spring-boot/src/main/java/org/springframework/boot/io/ProtocolResolverApplicationContextInitializer.java

@@ -24,8 +24,8 @@
 import org.springframework.core.io.support.SpringFactoriesLoader;
 
 /**
- * {@link ApplicationContextInitializer} that adds all {@link ProtocolResolver}s
- * registered in a {@code spring.factories} file.
+ * {@link ApplicationContextInitializer} that adds all {@link ProtocolResolver
+ * ProtocolResolvers} registered in a {@code spring.factories} file.
  *
  * @author Scott Frederick
  */

spring-boot-project/spring-boot/src/main/java/org/springframework/boot/logging/java/JavaLoggingSystem.java

@@ -103,7 +103,7 @@ protected void loadConfiguration(LoggingInitializationContext initializationCont
 	protected void loadConfiguration(String location, LogFile logFile) {
 		Assert.notNull(location, "Location must not be null");
 		try {
-			Resource resource = new ApplicationResourceLoader().getResource(location);
+			Resource resource = ApplicationResourceLoader.get().getResource(location);
 			String configuration = FileCopyUtils.copyToString(new InputStreamReader(resource.getInputStream()));
 			if (logFile != null) {
 				configuration = configuration.replace("${LOG_FILE}", StringUtils.cleanPath(logFile.toString()));

spring-boot-project/spring-boot/src/main/java/org/springframework/boot/logging/log4j2/Log4J2LoggingSystem.java

@@ -275,7 +275,7 @@ protected void loadConfiguration(String location, LogFile logFile, List<String>
 	}
 
 	private Configuration load(String location, LoggerContext context) throws IOException {
-		Resource resource = new ApplicationResourceLoader().getResource(location);
+		Resource resource = ApplicationResourceLoader.get().getResource(location);
 		ConfigurationSource source = getConfigurationSource(resource);
 		return ConfigurationFactory.getInstance().getConfiguration(context, source);
 	}

spring-boot-project/spring-boot/src/main/java/org/springframework/boot/logging/logback/LogbackLoggingSystem.java

@@ -258,7 +258,7 @@ protected void loadConfiguration(LoggingInitializationContext initializationCont
 				applySystemProperties(initializationContext.getEnvironment(), logFile);
 			}
 			try {
-				Resource resource = new ApplicationResourceLoader().getResource(location);
+				Resource resource = ApplicationResourceLoader.get().getResource(location);
 				configureByResourceUrl(initializationContext, loggerContext, resource.getURL());
 			}
 			catch (Exception ex) {