Polish "Use ArgFile for classpath argument on Windows"

See gh-44305

Author: snicoll

spring-boot-project/spring-boot-tools/spring-boot-maven-plugin/src/main/java/org/springframework/boot/maven/AbstractAotMojo.java

@@ -147,7 +147,7 @@ protected final void compileSourceFiles(URL[] classPath, File sourcesDirectory,
 			JavaCompilerPluginConfiguration compilerConfiguration = new JavaCompilerPluginConfiguration(this.project);
 			List<String> options = new ArrayList<>();
 			options.add("-cp");
-			options.add(ClasspathBuilder.build(classPath));
+			options.add(ClasspathBuilder.forURLs(classPath).build().argument());
 			options.add("-d");
 			options.add(outputDirectory.toPath().toAbsolutePath().toString());
 			String releaseVersion = compilerConfiguration.getReleaseVersion();

spring-boot-project/spring-boot-tools/spring-boot-maven-plugin/src/main/java/org/springframework/boot/maven/AbstractRunMojo.java

@@ -39,6 +39,7 @@
 import org.apache.maven.toolchain.ToolchainManager;
 
 import org.springframework.boot.loader.tools.FileUtils;
+import org.springframework.boot.maven.ClasspathBuilder.Classpath;
 import org.springframework.util.Assert;
 import org.springframework.util.ObjectUtils;
 
@@ -345,12 +346,13 @@ private void addActiveProfileArgument(RunArguments arguments) {
 
 	private void addClasspath(List<String> args) throws MojoExecutionException {
 		try {
-			String classpath = ClasspathBuilder.build(getClassPathUrls());
+			Classpath classpath = ClasspathBuilder.forURLs(getClassPathUrls()).build();
 			if (getLog().isDebugEnabled()) {
-				getLog().debug("Classpath for forked process: " + classpath);
+				getLog().debug("Classpath for forked process: "
+						+ classpath.elements().map(Object::toString).collect(Collectors.joining(File.separator)));
 			}
 			args.add("-cp");
-			args.add(classpath);
+			args.add(classpath.argument());
 		}
 		catch (Exception ex) {
 			throw new MojoExecutionException("Could not build classpath", ex);

spring-boot-project/spring-boot-tools/spring-boot-maven-plugin/src/main/java/org/springframework/boot/maven/ArgFile.java

@@ -20,7 +20,18 @@
 import java.io.IOException;
 import java.net.URISyntaxException;
 import java.net.URL;
+import java.nio.charset.Charset;
+import java.nio.charset.UnsupportedCharsetException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
 import java.util.Locale;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 import org.springframework.util.ObjectUtils;
 import org.springframework.util.StringUtils;
@@ -31,9 +42,23 @@
  * @author Stephane Nicoll
  * @author Dmytro Nosan
  */
-final class ClasspathBuilder {
+class ClasspathBuilder {
 
-	private ClasspathBuilder() {
+	private final List<URL> urls;
+
+	protected ClasspathBuilder(List<URL> urls) {
+		this.urls = urls;
+	}
+
+	/**
+	 * Builds a classpath string or an argument file representing the classpath, depending
+	 * on the operating system.
+	 * @param urls an array of {@link URL} representing the elements of the classpath
+	 * @return the classpath; on Windows, the path to an argument file is returned,
+	 * prefixed with '@'
+	 */
+	static ClasspathBuilder forURLs(List<URL> urls) {
+		return new ClasspathBuilder(new ArrayList<>(urls));
 	}
 
 	/**
@@ -43,47 +68,110 @@ private ClasspathBuilder() {
 	 * @return the classpath; on Windows, the path to an argument file is returned,
 	 * prefixed with '@'
 	 */
-	static String build(URL... urls) {
-		if (ObjectUtils.isEmpty(urls)) {
-			return "";
+	static ClasspathBuilder forURLs(URL... urls) {
+		return new ClasspathBuilder(Arrays.asList(urls));
+	}
+
+	Classpath build() {
+		if (ObjectUtils.isEmpty(this.urls)) {
+			return new Classpath("", Collections.emptyList());
 		}
-		if (urls.length == 1) {
-			return toFile(urls[0]).toString();
+		if (this.urls.size() == 1) {
+			Path file = toFile(this.urls.get(0));
+			return new Classpath(file.toString(), List.of(file));
 		}
-		StringBuilder builder = new StringBuilder();
-		for (URL url : urls) {
-			if (!builder.isEmpty()) {
-				builder.append(File.pathSeparator);
-			}
-			builder.append(toFile(url));
+		List<Path> files = this.urls.stream().map(ClasspathBuilder::toFile).toList();
+		String argument = files.stream().map(Object::toString).collect(Collectors.joining(File.pathSeparator));
+		if (needsClasspathArgFile()) {
+			argument = createArgFile(argument);
 		}
-		String classpath = builder.toString();
-		if (runsOnWindows()) {
-			try {
-				return "@" + ArgFile.create(classpath);
-			}
-			catch (IOException ex) {
-				return classpath;
-			}
+		return new Classpath(argument, files);
+	}
+
+	protected boolean needsClasspathArgFile() {
+		String os = System.getProperty("os.name");
+		if (!StringUtils.hasText(os)) {
+			return false;
 		}
-		return classpath;
+		// Windows limits the maximum command length, so we use an argfile
+		return os.toLowerCase(Locale.ROOT).contains("win");
 	}
 
-	private static File toFile(URL url) {
+	/**
+	 * Create a temporary file with the given {@code} classpath. Return a suitable
+	 * argument to load the file, that is the full path prefixed by {@code @}.
+	 * @param classpath the classpath to use
+	 * @return a suitable argument for the classpath using a file
+	 */
+	private String createArgFile(String classpath) {
 		try {
-			return new File(url.toURI());
+			return "@" + writeClasspathToFile(classpath);
+		}
+		catch (IOException ex) {
+			return classpath;
+		}
+	}
+
+	private Path writeClasspathToFile(CharSequence classpath) throws IOException {
+		Path tempFile = Files.createTempFile("spring-boot-", ".argfile");
+		tempFile.toFile().deleteOnExit();
+		Files.writeString(tempFile, "\"" + escape(classpath) + "\"", getCharset());
+		return tempFile;
+	}
+
+	private static Charset getCharset() {
+		String nativeEncoding = System.getProperty("native.encoding");
+		if (nativeEncoding == null) {
+			return Charset.defaultCharset();
+		}
+		try {
+			return Charset.forName(nativeEncoding);
+		}
+		catch (UnsupportedCharsetException ex) {
+			return Charset.defaultCharset();
+		}
+	}
+
+	private static String escape(CharSequence content) {
+		return content.toString().replace("\\", "\\\\");
+	}
+
+	private static Path toFile(URL url) {
+		try {
+			return Paths.get(url.toURI());
 		}
 		catch (URISyntaxException ex) {
 			throw new IllegalArgumentException(ex);
 		}
 	}
 
-	private static boolean runsOnWindows() {
-		String os = System.getProperty("os.name");
-		if (!StringUtils.hasText(os)) {
-			return false;
+	static final class Classpath {
+
+		private final String argument;
+
+		private final List<Path> elements;
+
+		private Classpath(String argument, List<Path> elements) {
+			this.argument = argument;
+			this.elements = elements;
 		}
-		return os.toLowerCase(Locale.ROOT).contains("win");
+
+		/**
+		 * Return the {@code -cp} argument value.
+		 * @return the argument to use
+		 */
+		String argument() {
+			return this.argument;
+		}
+
+		/**
+		 * Return the classpath elements.
+		 * @return the JAR files to use
+		 */
+		Stream<Path> elements() {
+			return this.elements.stream();
+		}
+
 	}
 
 }

spring-boot-project/spring-boot-tools/spring-boot-maven-plugin/src/main/java/org/springframework/boot/maven/ClasspathBuilder.java

@@ -82,7 +82,7 @@ List<String> build() {
 		}
 		if (!this.classpathElements.isEmpty()) {
 			commandLine.add("-cp");
-			commandLine.add(ClasspathBuilder.build(this.classpathElements.toArray(URL[]::new)));
+			commandLine.add(ClasspathBuilder.forURLs(this.classpathElements).build().argument());
 		}
 		commandLine.add(this.mainClass);
 		if (!this.arguments.isEmpty()) {