Use CompileClasspathClassResolver for ArchitectureCheck Gradle Task

Prior to this commit, certain rules, such as `BeanPostProcessor`,
did not work with external classes. This commit ensures that
`ArchRules` are executed using the `CompileClasspathClassResolver`,
which resolves any missing classes. This helps build a Class Graph
for external classes.

Signed-off-by: Dmytro Nosan <[email protected]>

Author: nosan

buildSrc/src/main/java/org/springframework/boot/build/architecture/ArchitectureCheck.java

@@ -26,18 +26,21 @@
 import java.util.function.Supplier;
 import java.util.stream.Stream;
 
+import com.tngtech.archunit.ArchConfiguration;
 import com.tngtech.archunit.core.domain.JavaClasses;
 import com.tngtech.archunit.core.importer.ClassFileImporter;
 import com.tngtech.archunit.lang.ArchRule;
 import com.tngtech.archunit.lang.EvaluationResult;
 import org.gradle.api.DefaultTask;
 import org.gradle.api.Task;
 import org.gradle.api.Transformer;
+import org.gradle.api.file.ConfigurableFileCollection;
 import org.gradle.api.file.DirectoryProperty;
 import org.gradle.api.file.FileCollection;
 import org.gradle.api.file.FileTree;
 import org.gradle.api.provider.ListProperty;
 import org.gradle.api.provider.Property;
+import org.gradle.api.tasks.Classpath;
 import org.gradle.api.tasks.IgnoreEmptyDirectories;
 import org.gradle.api.tasks.Input;
 import org.gradle.api.tasks.InputFiles;
@@ -58,6 +61,7 @@
  * @author Scott Frederick
  * @author Ivan Malutin
  * @author Phillip Webb
+ * @author Dmytro Nosan
  */
 public abstract class ArchitectureCheck extends DefaultTask {
 
@@ -80,14 +84,19 @@ private List<String> asDescriptions(List<ArchRule> rules) {
 	}
 
 	@TaskAction
-	void checkArchitecture() throws IOException {
-		JavaClasses javaClasses = new ClassFileImporter().importPaths(classFilesPaths());
-		List<EvaluationResult> violations = evaluate(javaClasses).filter(EvaluationResult::hasViolation).toList();
-		File outputFile = getOutputDirectory().file("failure-report.txt").get().getAsFile();
-		writeViolationReport(violations, outputFile);
-		if (!violations.isEmpty()) {
-			throw new VerificationException("Architecture check failed. See '" + outputFile + "' for details.");
-		}
+	void checkArchitecture() {
+		ArchConfiguration.withThreadLocalScope((archConfiguration) -> {
+			archConfiguration.setClassResolver(CompileClasspathClassResolver.class);
+			archConfiguration.setClassResolverArguments(
+					getCompileClasspath().getFiles().stream().map(File::toString).toArray(String[]::new));
+			JavaClasses javaClasses = new ClassFileImporter().importPaths(classFilesPaths());
+			List<EvaluationResult> violations = evaluate(javaClasses).filter(EvaluationResult::hasViolation).toList();
+			File outputFile = getOutputDirectory().file("failure-report.txt").get().getAsFile();
+			writeViolationReport(violations, outputFile);
+			if (!violations.isEmpty()) {
+				throw new VerificationException("Architecture check failed. See '" + outputFile + "' for details.");
+			}
+		});
 	}
 
 	private List<Path> classFilesPaths() {
@@ -98,15 +107,21 @@ private Stream<EvaluationResult> evaluate(JavaClasses javaClasses) {
 		return getRules().get().stream().map((rule) -> rule.evaluate(javaClasses));
 	}
 
-	private void writeViolationReport(List<EvaluationResult> violations, File outputFile) throws IOException {
-		outputFile.getParentFile().mkdirs();
-		StringBuilder report = new StringBuilder();
-		for (EvaluationResult violation : violations) {
-			report.append(violation.getFailureReport());
-			report.append(String.format("%n"));
+	private void writeViolationReport(List<EvaluationResult> violations, File outputFile) {
+		try {
+			Files.createDirectories(outputFile.getParentFile().toPath());
+			StringBuilder report = new StringBuilder();
+			for (EvaluationResult violation : violations) {
+				report.append(violation.getFailureReport());
+				report.append(String.format("%n"));
+			}
+			Files.writeString(outputFile.toPath(), report.toString(), StandardOpenOption.CREATE,
+					StandardOpenOption.TRUNCATE_EXISTING);
+		}
+		catch (IOException ex) {
+			throw new VerificationException(
+					"Failed to write violation report to '" + outputFile + "' " + ex.getMessage());
 		}
-		Files.writeString(outputFile.toPath(), report.toString(), StandardOpenOption.CREATE,
-				StandardOpenOption.TRUNCATE_EXISTING);
 	}
 
 	public void setClasses(FileCollection classes) {
@@ -126,6 +141,10 @@ final FileTree getInputClasses() {
 		return this.classes.getAsFileTree();
 	}
 
+	@InputFiles
+	@Classpath
+	public abstract ConfigurableFileCollection getCompileClasspath();
+
 	@Optional
 	@InputFiles
 	@PathSensitive(PathSensitivity.RELATIVE)

buildSrc/src/main/java/org/springframework/boot/build/architecture/ArchitecturePlugin.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2012-2024 the original author or authors.
+ * Copyright 2012-2025 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.
@@ -49,6 +49,7 @@ private void registerTasks(Project project) {
 			TaskProvider<ArchitectureCheck> checkPackageTangles = project.getTasks()
 				.register("checkArchitecture" + StringUtils.capitalize(sourceSet.getName()), ArchitectureCheck.class,
 						(task) -> {
+							task.getCompileClasspath().from(sourceSet.getCompileClasspath());
 							task.setClasses(sourceSet.getOutput().getClassesDirs());
 							task.getResourcesDirectory().set(sourceSet.getOutput().getResourcesDir());
 							task.dependsOn(sourceSet.getProcessResourcesTaskName());

buildSrc/src/main/java/org/springframework/boot/build/architecture/CompileClasspathClassResolver.java

@@ -0,0 +1,76 @@
+/*
+ * Copyright 2012-2025 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.build.architecture;
+
+import java.io.File;
+import java.net.MalformedURLException;
+import java.net.URISyntaxException;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.util.List;
+import java.util.Optional;
+
+import com.tngtech.archunit.base.ArchUnitException;
+import com.tngtech.archunit.core.domain.JavaClass;
+import com.tngtech.archunit.core.importer.resolvers.ClassResolver;
+
+/**
+ * A {@link ClassResolver} that resolves Java classes from a provided compile classpath.
+ *
+ * @author Dmytro Nosan
+ */
+public class CompileClasspathClassResolver implements ClassResolver {
+
+	private ClassUriImporter classUriImporter;
+
+	private final URLClassLoader classLoader;
+
+	public CompileClasspathClassResolver(List<String> classpath) {
+		this.classLoader = new URLClassLoader(
+				classpath.stream().map(File::new).map(CompileClasspathClassResolver::toURL).toArray(URL[]::new));
+	}
+
+	@Override
+	public void setClassUriImporter(ClassUriImporter classUriImporter) {
+		this.classUriImporter = classUriImporter;
+	}
+
+	@Override
+	public Optional<JavaClass> tryResolve(String typeName) {
+		String typeFile = typeName.replace(".", "/") + ".class";
+		URL resource = this.classLoader.getResource(typeFile);
+		if (resource == null) {
+			return Optional.empty();
+		}
+		try {
+			return this.classUriImporter.tryImport(resource.toURI());
+		}
+		catch (URISyntaxException ex) {
+			throw new ArchUnitException.LocationException(ex);
+		}
+	}
+
+	private static URL toURL(File file) {
+		try {
+			return file.toURI().toURL();
+		}
+		catch (MalformedURLException ex) {
+			throw new ArchUnitException.LocationException(ex);
+		}
+	}
+
+}